| | 1 | + | /* |
| | 2 | + | rdesktop: A Remote Desktop Protocol client. |
| | 3 | + | Bitmap decompression routines |
| | 4 | + | Copyright (C) Matthew Chapman <matthewc.unsw.edu.au> 1999-2008 |
| | 5 | + | |
| | 6 | + | This program is free software: you can redistribute it and/or modify |
| | 7 | + | it under the terms of the GNU General Public License as published by |
| | 8 | + | the Free Software Foundation, either version 3 of the License, or |
| | 9 | + | (at your option) any later version. |
| | 10 | + | |
| | 11 | + | This program is distributed in the hope that it will be useful, |
| | 12 | + | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| | 13 | + | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| | 14 | + | GNU General Public License for more details. |
| | 15 | + | |
| | 16 | + | You should have received a copy of the GNU General Public License |
| | 17 | + | along with this program. If not, see <http://www.gnu.org/licenses/>. |
| | 18 | + | |
| | 19 | + | */ |
| | 20 | + | |
| | 21 | + | /* |
| | 22 | + | Added few modifications: |
| | 23 | + | The code now ALWAYS returns RGB32 format regardless of input bpp. Makes life easier on upper levels. |
| | 24 | + | The code also takes non-compressed input (and a flag that indicates wether it's compressed or not.) |
| | 25 | + | Non-compressed data will be only converted to RGB32. |
| | 26 | + | There are some out-of-bounds write possibilities in the RRE decoder. |
| | 27 | + | |
| | 28 | + | Mod author: Tamas Jos @skelsec |
| | 29 | + | */ |
| | 30 | + | |
| | 31 | + | /* |
| | 32 | + | Portation to Rust: |
| | 33 | + | The original C code is now ported to Rust code. |
| | 34 | + | The functions bitmap_decompress2, mask_rgbx, decode_rre, their wrapper and all the functions that |
| | 35 | + | get called by those one are tested and are working. |
| | 36 | + | The rest is not tested yet so that it may contain any logical bugs. |
| | 37 | + | However, all functions are syntactically correct and do compile. |
| | 38 | + | |
| | 39 | + | I am the author and tester of this code. I am not the sole owner or the algorithm developer. |
| | 40 | + | The sole owner is Tamas Jos @skelsec. |
| | 41 | + | |
| | 42 | + | Mod author: Julien Schminke @ProgrammerSkill |
| | 43 | + | Fiverr: ProgrammerSkill |
| | 44 | + | */ |
| | 45 | + | |
| | 46 | + | use std::ffi::CString; |
| | 47 | + | use std::slice; |
| | 48 | + | |
| | 49 | + | use pyo3::prelude::*; |
| | 50 | + | use pyo3::exceptions::PyTypeError; |
| | 51 | + | use pyo3::types::PyByteArray; |
| | 52 | + | |
| | 53 | + | use pyo3::ffi::{Py_buffer, PyArg_ParseTuple, PyErr_SetString, PyExc_TypeError, Py_None, PyObject}; |
| | 54 | + | use pyo3::{exceptions, pyfunction, pymodule, PyResult, Python, wrap_pyfunction}; |
| | 55 | + | use pyo3::buffer::PyBuffer; |
| | 56 | + | use pyo3::types::PyModule; |
| | 57 | + | |
| | 58 | + | #[macro_use] extern crate lazy_static; |
| | 59 | + | |
| | 60 | + | macro_rules! cval { |
| | 61 | + | ($p:expr, $p_index:expr) => ({ |
| | 62 | + | let c = $p[$p_index]; |
| | 63 | + | $p_index += 1; |
| | 64 | + | c |
| | 65 | + | }) |
| | 66 | + | } |
| | 67 | + | |
| | 68 | + | macro_rules! cval2 { |
| | 69 | + | ($p:expr, $p_index:expr, $v:expr) => ({ |
| | 70 | + | if cfg!(need_align) && cfg!(l_endian) { // NEED_ALIGN & L_ENDIAN |
| | 71 | + | $v = $p[$p_index] as u16; |
| | 72 | + | $p_index += 1; |
| | 73 | + | $v |= ($p[$p_index] as u16) << 8; |
| | 74 | + | $p_index += 1; |
| | 75 | + | } else if cfg!(need_align) { // NEED_ALIGN & !L_ENDIAN |
| | 76 | + | $v = ($p[$p_index] as u16) << 8; |
| | 77 | + | $p_index += 1; |
| | 78 | + | $v |= $p[$p_index] as u16; |
| | 79 | + | $p_index += 1; |
| | 80 | + | } else { // !NEED_ALIGN |
| | 81 | + | $v = (($p[$p_index] as u16) << 8) + $p[$p_index+1] as u16; |
| | 82 | + | $p_index += 2; |
| | 83 | + | } |
| | 84 | + | }) |
| | 85 | + | } |
| | 86 | + | |
| | 87 | + | macro_rules! unroll8 { |
| | 88 | + | ($exp:block) => ($exp $exp $exp $exp $exp $exp $exp $exp) |
| | 89 | + | } |
| | 90 | + | |
| | 91 | + | macro_rules! repeat { |
| | 92 | + | ($statement:block, $count:expr, $x:expr, $width:expr) => ( |
| | 93 | + | while ($count & !0x7) != 0 && ($x + 8 < $width) { |
| | 94 | + | unroll8!({$statement; $count -= 1; $x += 1;}); |
| | 95 | + | } |
| | 96 | + | |
| | 97 | + | while ($count > 0) && ($x < $width) { |
| | 98 | + | $statement; |
| | 99 | + | $count -= 1; |
| | 100 | + | $x += 1; |
| | 101 | + | } |
| | 102 | + | ); |
| | 103 | + | } |
| | 104 | + | |
| | 105 | + | macro_rules! mask_update { |
| | 106 | + | ($mixmask:expr, $fom_mask:expr, $input_index:expr, $input:expr, $mask:expr) => { |
| | 107 | + | $mixmask <<= 1; |
| | 108 | + | if $mixmask == 0 { |
| | 109 | + | $mask = if $fom_mask != 0 { |
| | 110 | + | $fom_mask |
| | 111 | + | } else { |
| | 112 | + | cval!($input, $input_index) |
| | 113 | + | }; |
| | 114 | + | $mixmask = 1; |
| | 115 | + | } |
| | 116 | + | } |
| | 117 | + | } |
| | 118 | + | |
| | 119 | + | |
| | 120 | + | // 1 byte bitmap decompress |
| | 121 | + | fn bitmap_decompress1(mut output: &mut Vec<u8>, width: i16, mut height: i16, input: &mut Vec<u8>, _size: usize) -> bool { |
| | 122 | + | let mut prevline_index = None; |
| | 123 | + | let mut line_index = None; |
| | 124 | + | let mut opcode: i16; |
| | 125 | + | let mut count: i16; |
| | 126 | + | let mut offset: i16 = 0; |
| | 127 | + | let mut isfillormix: bool; |
| | 128 | + | let mut x = width; |
| | 129 | + | let mut lastopcode = -1; |
| | 130 | + | let mut insertmix = false; |
| | 131 | + | let mut bicolour = false; |
| | 132 | + | let mut code: u8; |
| | 133 | + | let mut colour1 = 0u8; |
| | 134 | + | let mut colour2 = 0u8; |
| | 135 | + | let mut mixmask: u8; |
| | 136 | + | let mut mask = 0u8; |
| | 137 | + | let mut mix = 0xffu8; |
| | 138 | + | let mut fom_mask = 0; |
| | 139 | + | |
| | 140 | + | let mut input_index = 0; |
| | 141 | + | while input_index < input.len() { |
| | 142 | + | fom_mask = 0; |
| | 143 | + | code = cval!(input, input_index); |
| | 144 | + | opcode = (code >> 4) as i16; |
| | 145 | + | |
| | 146 | + | // Handle different opcode forms |
| | 147 | + | match opcode { |
| | 148 | + | 0xc | 0xd | 0xe => { |
| | 149 | + | opcode -= 6; |
| | 150 | + | count = (code & 0xf) as i16; |
| | 151 | + | offset = 16; |
| | 152 | + | }, |
| | 153 | + | 0xf => { |
| | 154 | + | opcode = (code & 0xf) as i16; |
| | 155 | + | if opcode < 9 { |
| | 156 | + | count = cval!(input, input_index) as i16; |
| | 157 | + | count |= (cval!(input, input_index) as i16) << 8 |
| | 158 | + | } else { |
| | 159 | + | count = if opcode < 0xb { 8 } else { 1 }; |
| | 160 | + | } |
| | 161 | + | offset = 0; |
| | 162 | + | } |
| | 163 | + | _ => { |
| | 164 | + | opcode >>= 1; |
| | 165 | + | count = (code & 0x1f) as i16; |
| | 166 | + | offset = 32; |
| | 167 | + | }, |
| | 168 | + | } |
| | 169 | + | // Handle strange cases for counts |
| | 170 | + | if offset != 0 { |
| | 171 | + | isfillormix = opcode == 2 || opcode == 7; |
| | 172 | + | if count == 0 { |
| | 173 | + | count = if isfillormix { |
| | 174 | + | cval!(input, input_index) as i16 + 1 |
| | 175 | + | } else { |
| | 176 | + | cval!(input, input_index) as i16 + offset |
| | 177 | + | } |
| | 178 | + | } else if isfillormix { |
| | 179 | + | count <<= 3; |
| | 180 | + | } |
| | 181 | + | } |
| | 182 | + | |
| | 183 | + | // Read preliminary data |
| | 184 | + | |
| | 185 | + | // Bicolour |
| | 186 | + | if opcode == 8 { |
| | 187 | + | colour1 = cval!(input, input_index); |
| | 188 | + | } |
| | 189 | + | |
| | 190 | + | match opcode { |
| | 191 | + | 0 => { |
| | 192 | + | // Fill |
| | 193 | + | if lastopcode == opcode && !(x == width && prevline_index.is_none()) { |
| | 194 | + | insertmix = true; |
| | 195 | + | } |
| | 196 | + | }, |
| | 197 | + | 3 => { |
| | 198 | + | // Colour |
| | 199 | + | colour2 = cval!(input, input_index); |
| | 200 | + | }, |
| | 201 | + | 6 | 7 => { |
| | 202 | + | // 6 = SetMix/Mix |
| | 203 | + | // 7 = SetMix/FillOrMix |
| | 204 | + | mix = cval!(input, input_index); |
| | 205 | + | opcode -= 5; |
| | 206 | + | }, |
| | 207 | + | 9 => { |
| | 208 | + | // FillOrMix_1 |
| | 209 | + | mask = 0x03; |
| | 210 | + | opcode = 0x02; |
| | 211 | + | fom_mask = 3; |
| | 212 | + | }, |
| | 213 | + | 0x0a => { |
| | 214 | + | // FillOrMix_2 |
| | 215 | + | mask = 0x05; |
| | 216 | + | opcode = 0x02; |
| | 217 | + | fom_mask = 5; |
| | 218 | + | }, |
| | 219 | + | _ => (), |
| | 220 | + | } |
| | 221 | + | lastopcode = opcode; |
| | 222 | + | mixmask = 0; |
| | 223 | + | // Output body |
| | 224 | + | while count > 0 { |
| | 225 | + | if x >= width { |
| | 226 | + | if height <= 0 { |
| | 227 | + | return false; |
| | 228 | + | } |
| | 229 | + | x = 0; |
| | 230 | + | height -= 1; |
| | 231 | + | prevline_index = line_index; |
| | 232 | + | line_index = Some(height * width); |
| | 233 | + | } |
| | 234 | + | match opcode { |
| | 235 | + | 0 => { |
| | 236 | + | // Fill |
| | 237 | + | if insertmix { |
| | 238 | + | if prevline_index.is_none() { |
| | 239 | + | output[(line_index.unwrap()+x) as usize] = mix; |
| | 240 | + | } else { |
| | 241 | + | output[(line_index.unwrap()+x) as usize] = output[prevline_index.unwrap() as usize]^mix; |
| | 242 | + | } |
| | 243 | + | insertmix = false; |
| | 244 | + | count -= 1; |
| | 245 | + | x += 1; |
| | 246 | + | } |
| | 247 | + | if prevline_index.is_none() { |
| | 248 | + | repeat!({output[(line_index.unwrap()+x) as usize] = 0;}, count, x, width); |
| | 249 | + | } else { |
| | 250 | + | repeat!({output[(line_index.unwrap()+x) as usize] = output[(prevline_index.unwrap() + x) as usize];}, count, x, width); |
| | 251 | + | } |
| | 252 | + | }, |
| | 253 | + | 1 => { |
| | 254 | + | // Mix |
| | 255 | + | if prevline_index.is_none() { |
| | 256 | + | repeat!({output[(line_index.unwrap()+x) as usize] = mix;}, count, x, width); |
| | 257 | + | } else { |
| | 258 | + | repeat!({output[(line_index.unwrap()+x) as usize] = output[(((prevline_index.unwrap()) + x) ^ mix as i16) as usize];}, count, x, width); |
| | 259 | + | } |
| | 260 | + | }, |
| | 261 | + | 2 => { |
| | 262 | + | //Fill or Mix |
| | 263 | + | if prevline_index.is_none() { |
| | 264 | + | repeat!({ |
| | 265 | + | mask_update!(mixmask, fom_mask, input_index, input, mask); |
| | 266 | + | if (mask & mixmask) != 0 { |
| | 267 | + | output[(line_index.unwrap()+x) as usize] = mix |
| | 268 | + | } else { |
| | 269 | + | output[(line_index.unwrap()+x) as usize] = 0; |
| | 270 | + | } |
| | 271 | + | }, count, x, width); |
| | 272 | + | } else { |
| | 273 | + | repeat!({ |
| | 274 | + | mask_update!(mixmask, fom_mask, input_index, input, mask); |
| | 275 | + | if (mask & mixmask) != 0 { |
| | 276 | + | output[(line_index.unwrap()+x) as usize] = output[((prevline_index.unwrap()+x) ^ mix as i16) as usize]; |
| | 277 | + | } else { |
| | 278 | + | output[(line_index.unwrap()+x) as usize] = output[(prevline_index.unwrap()+x) as usize] |
| | 279 | + | } |
| | 280 | + | }, count, x, width); |
| | 281 | + | } |
| | 282 | + | }, |
| | 283 | + | 3 => { // Colour |
| | 284 | + | repeat!({output[(line_index.unwrap()+x) as usize] = colour2;}, count, x, width); |
| | 285 | + | }, |
| | 286 | + | 4 => { // Copy |
| | 287 | + | repeat!({output[(line_index.unwrap()+x) as usize] = cval!(input, input_index);}, count, x, width); |
| | 288 | + | }, |
| | 289 | + | 8 => { // Bicolour |
| | 290 | + | repeat!({ |
| | 291 | + | if bicolour { |
| | 292 | + | output[(line_index.unwrap()+x) as usize] = colour2; |
| | 293 | + | bicolour = false; |
| | 294 | + | } else { |
| | 295 | + | output[(line_index.unwrap()+x) as usize] = colour1; |
| | 296 | + | bicolour = true; |
| | 297 | + | count += 1; |
| | 298 | + | } |
| | 299 | + | }, count, x, width); |
| | 300 | + | }, |
| | 301 | + | 0xd => { // White |
| | 302 | + | repeat!({output[(line_index.unwrap()+x) as usize] = 0xff;}, count, x, width); |
| | 303 | + | }, |
| | 304 | + | 0xe => { // Black |
| | 305 | + | repeat!({output[(line_index.unwrap()+x) as usize] = 0;} , count, x, width); |
| | 306 | + | }, |
| | 307 | + | _ => { |
| | 308 | + | return false; |
| | 309 | + | }, |
| | 310 | + | } |
| | 311 | + | } |
| | 312 | + | } |
| | 313 | + | true |
| | 314 | + | } |
| | 315 | + | |
| | 316 | + | |
| | 317 | + | // 2 byte bitmap decompress |
| | 318 | + | fn bitmap_decompress2(mut output: &mut Vec<u8>, width: i16, mut height: i16, input: &mut Vec<u8>, _size: usize) -> bool { |
| | 319 | + | let mut prevline_index = None; |
| | 320 | + | let mut line_index = None; |
| | 321 | + | let mut opcode: i16; |
| | 322 | + | let mut count: i16; |
| | 323 | + | let mut offset: i16 = 0; |
| | 324 | + | let mut isfillormix: bool; |
| | 325 | + | let mut x = width; |
| | 326 | + | let mut lastopcode = -1; |
| | 327 | + | let mut insertmix = false; |
| | 328 | + | let mut bicolour = false; |
| | 329 | + | let mut code: u8; |
| | 330 | + | let mut colour1 = 0u16; |
| | 331 | + | let mut colour2 = 0u16; |
| | 332 | + | let mut mixmask: u8; |
| | 333 | + | let mut mask = 0u8; |
| | 334 | + | let mut mix = 0xffffu16; |
| | 335 | + | let mut fom_mask = 0; |
| | 336 | + | |
| | 337 | + | let mut input_index = 0; |
| | 338 | + | let mut output_u16_clone: Vec<u16> = output |
| | 339 | + | .chunks_exact(2) |
| | 340 | + | .into_iter() |
| | 341 | + | .map(|a| u16::from_ne_bytes([a[0], a[1]])) |
| | 342 | + | .collect(); |
| | 343 | + | |
| | 344 | + | while input_index < input.len() { |
| | 345 | + | fom_mask = 0; |
| | 346 | + | code = cval!(input, input_index); |
| | 347 | + | opcode = (code >> 4) as i16; |
| | 348 | + | |
| | 349 | + | // Handle different opcode forms |
| | 350 | + | match opcode { |
| | 351 | + | 0xc | 0xd | 0xe => { |
| | 352 | + | opcode -= 6; |
| | 353 | + | count = (code & 0xf) as i16; |
| | 354 | + | offset = 16; |
| | 355 | + | }, |
| | 356 | + | 0xf => { |
| | 357 | + | opcode = (code & 0xf) as i16; |
| | 358 | + | if opcode < 9 { |
| | 359 | + | count = cval!(input, input_index) as i16; |
| | 360 | + | count |= (cval!(input, input_index) as i16) << 8 |
| | 361 | + | } else { |
| | 362 | + | count = if opcode < 0xb { 8 } else { 1 }; |
| | 363 | + | } |
| | 364 | + | offset = 0; |
| | 365 | + | } |
| | 366 | + | _ => { |
| | 367 | + | opcode >>= 1; |
| | 368 | + | count = (code & 0x1f) as i16; |
| | 369 | + | offset = 32; |
| | 370 | + | }, |
| | 371 | + | } |
| | 372 | + | // Handle strange cases for counts |
| | 373 | + | if offset != 0 { |
| | 374 | + | isfillormix = opcode == 2 || opcode == 7; |
| | 375 | + | if count == 0 { |
| | 376 | + | count = if isfillormix { |
| | 377 | + | cval!(input, input_index) as i16 + 1 |
| | 378 | + | } else { |
| | 379 | + | cval!(input, input_index) as i16 + offset |
| | 380 | + | }; |
| | 381 | + | |
| | 382 | + | } else if isfillormix { |
| | 383 | + | count <<= 3; |
| | 384 | + | } |
| | 385 | + | } |
| | 386 | + | |
| | 387 | + | // Read preliminary data |
| | 388 | + | |
| | 389 | + | // Bicolour |
| | 390 | + | if opcode == 8 { |
| | 391 | + | cval2!(input, input_index, colour1); |
| | 392 | + | } |
| | 393 | + | |
| | 394 | + | match opcode { |
| | 395 | + | 0 => { |
| | 396 | + | // Fill |
| | 397 | + | if lastopcode == opcode && !(x == width && prevline_index.is_none()) { |
| | 398 | + | insertmix = true; |
| | 399 | + | } |
| | 400 | + | }, |
| | 401 | + | 3 => { |
| | 402 | + | // Colour |
| | 403 | + | cval2!(input, input_index, colour2); |
| | 404 | + | }, |
| | 405 | + | 6 | 7 => { |
| | 406 | + | // 6 = SetMix/Mix |
| | 407 | + | // 7 = SetMix/FillOrMix |
| | 408 | + | cval2!(input, input_index, mix); |
| | 409 | + | opcode = -5; |
| | 410 | + | }, |
| | 411 | + | 9 => { |
| | 412 | + | // FillOrMix_1 |
| | 413 | + | mask = 0x03; |
| | 414 | + | opcode = 0x02; |
| | 415 | + | fom_mask = 3; |
| | 416 | + | }, |
| | 417 | + | 0x0a => { |
| | 418 | + | // FillOrMix_2 |
| | 419 | + | mask = 0x05; |
| | 420 | + | opcode = 0x02; |
| | 421 | + | fom_mask = 5; |
| | 422 | + | }, |
| | 423 | + | _ => (), |
| | 424 | + | } |
| | 425 | + | lastopcode = opcode; |
| | 426 | + | mixmask = 0; |
| | 427 | + | |
| | 428 | + | // Output body |
| | 429 | + | while count > 0 { |
| | 430 | + | if x >= width { |
| | 431 | + | if height <= 0 { |
| | 432 | + | for i in 0..output_u16_clone.len() { |
| | 433 | + | output[i*2 ] = (output_u16_clone[i] >> 8 ) as u8; |
| | 434 | + | output[i*2+1] = (output_u16_clone[i] | 0x00ff) as u8; |
| | 435 | + | |
| | 436 | + | } |
| | 437 | + | return false; |
| | 438 | + | } |
| | 439 | + | x = 0; |
| | 440 | + | height -= 1; |
| | 441 | + | prevline_index = line_index; |
| | 442 | + | line_index = Some(height * width); |
| | 443 | + | } |
| | 444 | + | |
| | 445 | + | match opcode { |
| | 446 | + | 0 => { |
| | 447 | + | // Fill |
| | 448 | + | if insertmix { |
| | 449 | + | |
| | 450 | + | if prevline_index.is_none() { |
| | 451 | + | output_u16_clone[(line_index.unwrap()+x) as usize] = mix; |
| | 452 | + | } else { |
| | 453 | + | output_u16_clone[(line_index.unwrap()+x) as usize] = output_u16_clone[(prevline_index.unwrap()+x) as usize] ^ mix; |
| | 454 | + | } |
| | 455 | + | insertmix = false; |
| | 456 | + | count -= 1; |
| | 457 | + | x += 1; |
| | 458 | + | } |
| | 459 | + | if prevline_index.is_none() { |
| | 460 | + | repeat!({output_u16_clone[(line_index.unwrap()+x) as usize] = 0}, count, x, width); |
| | 461 | + | } else { |
| | 462 | + | repeat!({output_u16_clone[(line_index.unwrap()+x) as usize] = output_u16_clone[(prevline_index.unwrap() + x) as usize];}, count, x, width); |
| | 463 | + | } |
| | 464 | + | }, |
| | 465 | + | 1 => { |
| | 466 | + | // Mix |
| | 467 | + | if prevline_index.is_none() { |
| | 468 | + | repeat!({output_u16_clone[(line_index.unwrap()+x) as usize] = mix}, count, x, width); |
| | 469 | + | } else { |
| | 470 | + | repeat!({output_u16_clone[(line_index.unwrap()+x) as usize] = output_u16_clone[(prevline_index.unwrap()+x) as usize] ^ mix}, count, x, width); |
| | 471 | + | } |
| | 472 | + | }, |
| | 473 | + | 2 => { |
| | 474 | + | //Fill or Mix |
| | 475 | + | if prevline_index.is_none() { |
| | 476 | + | repeat!({ |
| | 477 | + | mask_update!(mixmask, fom_mask, input_index, input, mask); |
| | 478 | + | if (mask & mixmask) != 0 { |
| | 479 | + | output_u16_clone[(line_index.unwrap()+x) as usize] = mix; |
| | 480 | + | } else { |
| | 481 | + | output_u16_clone[(line_index.unwrap()+x) as usize] = 0; |
| | 482 | + | } |
| | 483 | + | }, count, x, width); |
| | 484 | + | } else { |
| | 485 | + | repeat!({ |
| | 486 | + | mask_update!(mixmask, fom_mask, input_index, input, mask); |
| | 487 | + | if (mask & mixmask) != 0 { |
| | 488 | + | output_u16_clone[(line_index.unwrap()+x) as usize] = output_u16_clone[(prevline_index.unwrap()+x) as usize] ^ mix; |
| | 489 | + | } else { |
| | 490 | + | output_u16_clone[(line_index.unwrap()+x) as usize] = output_u16_clone[(prevline_index.unwrap()+x) as usize]; |
| | 491 | + | } |
| | 492 | + | }, count, x, width); |
| | 493 | + | } |
| | 494 | + | }, |
| | 495 | + | 3 => { // Colour |
| | 496 | + | repeat!({output_u16_clone[(line_index.unwrap()+x) as usize] = colour2}, count, x, width); //TODO unsicher mit colour2 |
| | 497 | + | }, |
| | 498 | + | 4 => { // Copy |
| | 499 | + | repeat!({cval2!(input, input_index, output_u16_clone[(line_index.unwrap()+x) as usize])}, count, x, width); |
| | 500 | + | }, |
| | 501 | + | 8 => { // Bicolour |
| | 502 | + | repeat!({ |
| | 503 | + | if bicolour { |
| | 504 | + | output_u16_clone[(line_index.unwrap()+x) as usize] = colour2; |
| | 505 | + | bicolour = false; |
| | 506 | + | } else { |
| | 507 | + | output_u16_clone[(line_index.unwrap()+x) as usize] = colour1; |
| | 508 | + | bicolour = true; |
| | 509 | + | count += 1; |
| | 510 | + | } |
| | 511 | + | }, count, x, width); |
| | 512 | + | }, |
| | 513 | + | 0xd => { // White |
| | 514 | + | repeat!({output_u16_clone[(line_index.unwrap()+x) as usize] = 0xffff;}, count, x, width); |
| | 515 | + | }, |
| | 516 | + | 0xe => { // Black |
| | 517 | + | repeat!({output_u16_clone[(line_index.unwrap()+x) as usize] = 0;} , count, x, width); |
| | 518 | + | }, |
| | 519 | + | _ => { |
| | 520 | + | for i in 0..output_u16_clone.len() { |
| | 521 | + | output[i*2 ] = (output_u16_clone[i] >> 8 ) as u8; |
| | 522 | + | output[i*2+1] = (output_u16_clone[i] & 0x00ff) as u8; |
| | 523 | + | |
| | 524 | + | } |
| | 525 | + | return false; |
| | 526 | + | }, |
| | 527 | + | } |
| | 528 | + | } |
| | 529 | + | } |
| | 530 | + | for i in 0..output_u16_clone.len() { |
| | 531 | + | output[i*2 ] = (output_u16_clone[i] >> 8 ) as u8; |
| | 532 | + | output[i*2+1] = (output_u16_clone[i] & 0x00ff) as u8; |
| | 533 | + | |
| | 534 | + | } |
| | 535 | + | true |
| | 536 | + | } |
| | 537 | + | |
| | 538 | + | // 3 byte bitmap decompress |
| | 539 | + | fn bitmap_decompress3(mut output: &mut Vec<u8>, width: i16, mut height: i16, input: &mut Vec<u8>, _size: usize) -> bool { |
| | 540 | + | let mut prevline_index = None; |
| | 541 | + | let mut line_index = None; |
| | 542 | + | let mut opcode: i16; |
| | 543 | + | let mut count: i16; |
| | 544 | + | let mut offset: i16 = 0; |
| | 545 | + | let mut isfillormix: bool; |
| | 546 | + | let mut x = width; |
| | 547 | + | let mut lastopcode = -1; |
| | 548 | + | let mut insertmix = false; |
| | 549 | + | let mut bicolour = false; |
| | 550 | + | let mut code: u8; |
| | 551 | + | let mut colour1 = [0u8, 0, 0]; |
| | 552 | + | let mut colour2 = [0u8, 0, 0]; |
| | 553 | + | let mut mixmask: u8; |
| | 554 | + | let mut mask = 0u8; |
| | 555 | + | let mut mix = [0xffu8, 0xff, 0xff]; |
| | 556 | + | let mut fom_mask = 0; |
| | 557 | + | |
| | 558 | + | let mut input_index = 0; |
| | 559 | + | while input_index < input.len() { |
| | 560 | + | fom_mask = 0; |
| | 561 | + | code = cval!(input, input_index); |
| | 562 | + | opcode = (code >> 4) as i16; |
| | 563 | + | |
| | 564 | + | match opcode { |
| | 565 | + | 0xc | 0xd | 0xe => { |
| | 566 | + | opcode -= 6; |
| | 567 | + | count = (code & 0xf) as i16; |
| | 568 | + | offset = 16; |
| | 569 | + | }, |
| | 570 | + | 0xf => { |
| | 571 | + | opcode = (code & 0xf) as i16; |
| | 572 | + | if opcode < 9 { |
| | 573 | + | count = cval!(input, input_index) as i16; |
| | 574 | + | count |= (cval!(input, input_index) as i16) << 8 |
| | 575 | + | } else { |
| | 576 | + | count = if opcode < 0xb { 8 } else { 1 }; |
| | 577 | + | } |
| | 578 | + | offset = 0; |
| | 579 | + | } |
| | 580 | + | _ => { |
| | 581 | + | opcode >>= 1; |
| | 582 | + | count = (code & 0x1f) as i16; |
| | 583 | + | offset = 32; |
| | 584 | + | }, |
| | 585 | + | } |
| | 586 | + | // Handle strange cases for counts |
| | 587 | + | if offset != 0 { |
| | 588 | + | isfillormix = opcode == 2 || opcode == 7; |
| | 589 | + | if count == 0 { |
| | 590 | + | count = if isfillormix { |
| | 591 | + | cval!(input, input_index) as i16 + 1 |
| | 592 | + | } else { |
| | 593 | + | cval!(input, input_index) as i16 + offset |
| | 594 | + | } |
| | 595 | + | } else if isfillormix { |
| | 596 | + | count <<= 3; |
| | 597 | + | } |
| | 598 | + | } |
| | 599 | + | |
| | 600 | + | // Read preliminary data |
| | 601 | + | |
| | 602 | + | // Bicolour |
| | 603 | + | if opcode == 8 { |
| | 604 | + | colour1[0] = cval!(input, input_index); |
| | 605 | + | colour1[1] = cval!(input, input_index); |
| | 606 | + | colour1[2] = cval!(input, input_index); |
| | 607 | + | } |
| | 608 | + | |
| | 609 | + | match opcode { |
| | 610 | + | 0 => { |
| | 611 | + | // Fill |
| | 612 | + | if lastopcode == opcode && !(x == width && prevline_index.is_none()) { |
| | 613 | + | insertmix = true; |
| | 614 | + | } |
| | 615 | + | }, |
| | 616 | + | 3 => { |
| | 617 | + | // Colour |
| | 618 | + | colour2[0] = cval!(input, input_index); |
| | 619 | + | colour2[1] = cval!(input, input_index); |
| | 620 | + | colour2[2] = cval!(input, input_index); |
| | 621 | + | }, |
| | 622 | + | 6 | 7 => { |
| | 623 | + | // 6 = SetMix/Mix |
| | 624 | + | // 7 = SetMix/FillOrMix |
| | 625 | + | mix[0] = cval!(input, input_index); |
| | 626 | + | mix[1] = cval!(input, input_index); |
| | 627 | + | mix[2] = cval!(input, input_index); |
| | 628 | + | opcode = -5; |
| | 629 | + | }, |
| | 630 | + | 9 => { |
| | 631 | + | // FillOrMix_1 |
| | 632 | + | mask = 0x03; |
| | 633 | + | opcode = 0x02; |
| | 634 | + | fom_mask = 3; |
| | 635 | + | }, |
| | 636 | + | 0x0a => { |
| | 637 | + | // FillOrMix_2 |
| | 638 | + | mask = 0x05; |
| | 639 | + | opcode = 0x02; |
| | 640 | + | fom_mask = 5; |
| | 641 | + | }, |
| | 642 | + | _ => (), |
| | 643 | + | } |
| | 644 | + | lastopcode = opcode; |
| | 645 | + | mixmask = 0; |
| | 646 | + | // Output body |
| | 647 | + | while count > 0 { |
| | 648 | + | if x >= width { |
| | 649 | + | if height <= 0 { |
| | 650 | + | return false; |
| | 651 | + | } |
| | 652 | + | x = 0; |
| | 653 | + | height -= 1; |
| | 654 | + | prevline_index = line_index; |
| | 655 | + | line_index = Some(height * width * 3); |
| | 656 | + | } |
| | 657 | + | match opcode { |
| | 658 | + | 0 => { |
| | 659 | + | // Fill |
| | 660 | + | if insertmix { |
| | 661 | + | if prevline_index.is_none() { |
| | 662 | + | output[(line_index.unwrap()+x*3 ) as usize] = mix[0]; |
| | 663 | + | output[(line_index.unwrap()+x*3+1) as usize] = mix[1]; |
| | 664 | + | output[(line_index.unwrap()+x*3+2) as usize] = mix[2]; |
| | 665 | + | } else { |
| | 666 | + | output[(line_index.unwrap()+x*3 ) as usize] = output[(prevline_index.unwrap()+x*3 ) as usize] ^ mix[0]; |
| | 667 | + | output[(line_index.unwrap()+x*3+1) as usize] = output[(prevline_index.unwrap()+x*3+1) as usize] ^ mix[1]; |
| | 668 | + | output[(line_index.unwrap()+x*3+2) as usize] = output[(prevline_index.unwrap()+x*3+2) as usize] ^ mix[2]; |
| | 669 | + | } |
| | 670 | + | insertmix = false; |
| | 671 | + | count -= 1; |
| | 672 | + | x += 1; |
| | 673 | + | } |
| | 674 | + | if prevline_index.is_none() { |
| | 675 | + | repeat!({ |
| | 676 | + | output[(line_index.unwrap()+x*3 ) as usize] = 0; |
| | 677 | + | output[(line_index.unwrap()+x*3+1) as usize] = 0; |
| | 678 | + | output[(line_index.unwrap()+x*3+2) as usize] = 0; |
| | 679 | + | }, count, x, width); |
| | 680 | + | } else { |
| | 681 | + | repeat!({ |
| | 682 | + | output[(line_index.unwrap()+x*3 ) as usize] = output[(prevline_index.unwrap()+x*3 ) as usize]; |
| | 683 | + | output[(line_index.unwrap()+x*3+1) as usize] = output[(prevline_index.unwrap()+x*3+1) as usize]; |
| | 684 | + | output[(line_index.unwrap()+x*3+2) as usize] = output[(prevline_index.unwrap()+x*3+2) as usize]; |
| | 685 | + | }, count, x, width); |
| | 686 | + | } |
| | 687 | + | }, |
| | 688 | + | 1 => { |
| | 689 | + | // Mix |
| | 690 | + | if prevline_index.is_none() { |
| | 691 | + | repeat!({ |
| | 692 | + | output[(line_index.unwrap()+x*3 ) as usize] = mix[0]; |
| | 693 | + | output[(line_index.unwrap()+x*3+1) as usize] = mix[1]; |
| | 694 | + | output[(line_index.unwrap()+x*3+2) as usize] = mix[2]; |
| | 695 | + | }, count, x, width); |
| | 696 | + | } else { |
| | 697 | + | repeat!({ |
| | 698 | + | output[(line_index.unwrap()+x*3 ) as usize] = output[(prevline_index.unwrap()+x*3 ) as usize] ^ mix[0]; |
| | 699 | + | output[(line_index.unwrap()+x*3+1) as usize] = output[(prevline_index.unwrap()+x*3+1) as usize] ^ mix[1]; |
| | 700 | + | output[(line_index.unwrap()+x*3+2) as usize] = output[(prevline_index.unwrap()+x*3+2) as usize] ^ mix[2]; |
| | 701 | + | }, count, x, width); |
| | 702 | + | } |
| | 703 | + | }, |
| | 704 | + | 2 => { |
| | 705 | + | //Fill or Mix |
| | 706 | + | if prevline_index.is_none() { |
| | 707 | + | repeat!({ |
| | 708 | + | mask_update!(mixmask, fom_mask, input_index, input, mask); |
| | 709 | + | if (mask & mixmask) != 0 { |
| | 710 | + | output[(line_index.unwrap()+x*3 ) as usize] = mix[0]; |
| | 711 | + | output[(line_index.unwrap()+x*3+1) as usize] = mix[1]; |
| | 712 | + | output[(line_index.unwrap()+x*3+2) as usize] = mix[2]; |
| | 713 | + | } else { |
| | 714 | + | output[(line_index.unwrap()+x*3 ) as usize] = 0; |
| | 715 | + | output[(line_index.unwrap()+x*3+1) as usize] = 0; |
| | 716 | + | output[(line_index.unwrap()+x*3+2) as usize] = 0; |
| | 717 | + | } |
| | 718 | + | }, count, x, width); |
| | 719 | + | } else { |
| | 720 | + | repeat!({ |
| | 721 | + | mask_update!(mixmask, fom_mask, input_index, input, mask); |
| | 722 | + | if (mask & mixmask) != 0 { |
| | 723 | + | output[(line_index.unwrap()+x*3 ) as usize] = output[(prevline_index.unwrap()+x*3 ) as usize] ^ mix[0]; |
| | 724 | + | output[(line_index.unwrap()+x*3+1) as usize] = output[(prevline_index.unwrap()+x*3+1) as usize] ^ mix[1]; |
| | 725 | + | output[(line_index.unwrap()+x*3+2) as usize] = output[(prevline_index.unwrap()+x*3+2) as usize] ^ mix[2]; |
| | 726 | + | } else { |
| | 727 | + | output[(line_index.unwrap()+x*3 ) as usize] = output[(prevline_index.unwrap()+x*3 ) as usize]; |
| | 728 | + | output[(line_index.unwrap()+x*3+1) as usize] = output[(prevline_index.unwrap()+x*3+1) as usize]; |
| | 729 | + | output[(line_index.unwrap()+x*3+2) as usize] = output[(prevline_index.unwrap()+x*3+2) as usize]; |
| | 730 | + | } |
| | 731 | + | }, count, x, width); |
| | 732 | + | } |
| | 733 | + | }, |
| | 734 | + | 3 => { // Colour |
| | 735 | + | repeat!({ |
| | 736 | + | output[(line_index.unwrap()+x*3 ) as usize] = colour2[0]; |
| | 737 | + | output[(line_index.unwrap()+x*3+1) as usize] = colour2[1]; |
| | 738 | + | output[(line_index.unwrap()+x*3+2) as usize] = colour2[2]; |
| | 739 | + | }, count, x, width); |
| | 740 | + | }, |
| | 741 | + | 4 => { // Copy |
| | 742 | + | repeat!({ |
| | 743 | + | output[(line_index.unwrap()+x*3 ) as usize] = cval!(input, input_index); |
| | 744 | + | output[(line_index.unwrap()+x*3+1) as usize] = cval!(input, input_index); |
| | 745 | + | output[(line_index.unwrap()+x*3+2) as usize] = cval!(input, input_index); |
| | 746 | + | }, count, x, width); |
| | 747 | + | }, |
| | 748 | + | 8 => { // Bicolour |
| | 749 | + | repeat!({ |
| | 750 | + | if bicolour { |
| | 751 | + | output[(line_index.unwrap()+x*3 ) as usize] = colour2[0]; |
| | 752 | + | output[(line_index.unwrap()+x*3+1) as usize] = colour2[1]; |
| | 753 | + | output[(line_index.unwrap()+x*3+2) as usize] = colour2[2]; |
| | 754 | + | bicolour = false; |
| | 755 | + | } else { |
| | 756 | + | output[(line_index.unwrap()+x*3 ) as usize] = colour1[0]; |
| | 757 | + | output[(line_index.unwrap()+x*3+1) as usize] = colour1[1]; |
| | 758 | + | output[(line_index.unwrap()+x*3+2) as usize] = colour1[2]; |
| | 759 | + | bicolour = true; |
| | 760 | + | count += 1; |
| | 761 | + | } |
| | 762 | + | }, count, x, width); |
| | 763 | + | }, |
| | 764 | + | 0xd => { // White |
| | 765 | + | repeat!({ |
| | 766 | + | output[(line_index.unwrap()+x*3 ) as usize] = 0xff; |
| | 767 | + | output[(line_index.unwrap()+x*3+1) as usize] = 0xff; |
| | 768 | + | output[(line_index.unwrap()+x*3+2) as usize] = 0xff; |
| | 769 | + | }, count, x, width); |
| | 770 | + | }, |
| | 771 | + | 0xe => { // Black |
| | 772 | + | repeat!({ |
| | 773 | + | output[(line_index.unwrap()+x*3 ) as usize] = 0; |
| | 774 | + | output[(line_index.unwrap()+x*3+1) as usize] = 0; |
| | 775 | + | output[(line_index.unwrap()+x*3+2) as usize] = 0; |
| | 776 | + | }, count, x, width); |
| | 777 | + | }, |
| | 778 | + | _ => { |
| | 779 | + | return false; |
| | 780 | + | }, |
| | 781 | + | } |
| | 782 | + | } |
| | 783 | + | } |
| | 784 | + | true |
| | 785 | + | } |
| | 786 | + | |
| | 787 | + | fn process_plane(input: &Vec<u8>, width: i16, height: i16, mut output: &mut Vec<u8>, _size: usize) -> usize { |
| | 788 | + | let mut indexw; |
| | 789 | + | let mut indexh = 0; |
| | 790 | + | let mut code; |
| | 791 | + | let mut collen; |
| | 792 | + | let mut replen; |
| | 793 | + | let mut color; |
| | 794 | + | let mut x: u8; |
| | 795 | + | let mut revcode; |
| | 796 | + | let mut last_line_index = 0; |
| | 797 | + | let mut this_line_index = 0; |
| | 798 | + | let mut org_output_index = 0; |
| | 799 | + | let mut output_index = 0; |
| | 800 | + | let mut input_index = 0; |
| | 801 | + | |
| | 802 | + | while indexh < height { |
| | 803 | + | output_index = ((org_output_index + width * height * 4) - ((indexh + 1) * width * 4)) as usize; |
| | 804 | + | color = 0; |
| | 805 | + | this_line_index = output_index; |
| | 806 | + | indexw = 0; |
| | 807 | + | if last_line_index == 0 { |
| | 808 | + | while indexw < width { |
| | 809 | + | code = cval!(input, input_index); |
| | 810 | + | replen = code & 0xf; |
| | 811 | + | collen = (code >> 4) & 0xf; |
| | 812 | + | revcode = (replen << 4) | collen; |
| | 813 | + | if revcode <= 47 && revcode >= 16 { |
| | 814 | + | replen = revcode; |
| | 815 | + | collen = 0; |
| | 816 | + | } |
| | 817 | + | while collen > 0 { |
| | 818 | + | color = cval!(input, input_index); |
| | 819 | + | output[output_index] = color; |
| | 820 | + | output_index += 4; |
| | 821 | + | indexw += 1; |
| | 822 | + | collen -= 1; |
| | 823 | + | } |
| | 824 | + | while replen > 0 { |
| | 825 | + | output[output_index] = color; |
| | 826 | + | output_index += 4; |
| | 827 | + | indexw += 1; |
| | 828 | + | collen -= 1; |
| | 829 | + | } |
| | 830 | + | } |
| | 831 | + | } else { |
| | 832 | + | while indexw < width { |
| | 833 | + | code = cval!(input, input_index); |
| | 834 | + | replen = code & 0xf; |
| | 835 | + | collen = (code >> 4) & 0xf; |
| | 836 | + | revcode = (replen << 4) | collen; |
| | 837 | + | if revcode <= 47 && revcode >= 16 { |
| | 838 | + | replen = revcode; |
| | 839 | + | collen = 0; |
| | 840 | + | } |
| | 841 | + | while collen > 0 { |
| | 842 | + | x = cval!(input, input_index); |
| | 843 | + | if x & 1 != 0 { |
| | 844 | + | x >>= 1; |
| | 845 | + | x += 1; |
| | 846 | + | color -= x; |
| | 847 | + | } else { |
| | 848 | + | x >>= 1; |
| | 849 | + | color = x; |
| | 850 | + | } |
| | 851 | + | x = output[last_line_index * 4] + color; |
| | 852 | + | output[output_index] = x; |
| | 853 | + | output_index += 4; |
| | 854 | + | indexw += 1; |
| | 855 | + | collen -= 1; |
| | 856 | + | } |
| | 857 | + | while replen > 0 { |
| | 858 | + | x = output[last_line_index * 4] + color; |
| | 859 | + | output[output_index] = x; |
| | 860 | + | output_index += 4; |
| | 861 | + | indexw += 1; |
| | 862 | + | replen -= 1; |
| | 863 | + | } |
| | 864 | + | } |
| | 865 | + | } |
| | 866 | + | indexh += 1; |
| | 867 | + | last_line_index = this_line_index; |
| | 868 | + | } |
| | 869 | + | return input_index; |
| | 870 | + | |
| | 871 | + | } |
| | 872 | + | |
| | 873 | + | fn bitmap_decompress4(output: &mut Vec<u8>, width: i16, height: i16, input: &mut Vec<u8>, size: usize) -> bool { |
| | 874 | + | let code; |
| | 875 | + | let mut bytes_pro; |
| | 876 | + | let mut total_pro; |
| | 877 | + | let mut input_index = 0; |
| | 878 | + | |
| | 879 | + | code = cval!(input, input_index); |
| | 880 | + | if code != 0x10 { |
| | 881 | + | return false; |
| | 882 | + | } |
| | 883 | + | total_pro = 1; |
| | 884 | + | bytes_pro = process_plane(&input, width, height, &mut output[3..].to_vec(), size - total_pro); |
| | 885 | + | total_pro += bytes_pro; |
| | 886 | + | input[0] += bytes_pro as u8; |
| | 887 | + | bytes_pro = process_plane(&input, width, height, &mut output[2..].to_vec(), size - total_pro); |
| | 888 | + | total_pro += bytes_pro; |
| | 889 | + | input[0] += bytes_pro as u8; |
| | 890 | + | bytes_pro = process_plane(&input, width, height, &mut output[1..].to_vec(), size - total_pro); |
| | 891 | + | total_pro += bytes_pro; |
| | 892 | + | input[0] += bytes_pro as u8; |
| | 893 | + | bytes_pro = process_plane(&input, width, height, &mut output[0..].to_vec(), size - total_pro); |
| | 894 | + | total_pro += bytes_pro; |
| | 895 | + | size == total_pro |
| | 896 | + | } |
| | 897 | + | |
| | 898 | + | fn bitmap_decompress(output: &mut Vec<u8>, width: i16, height: i16, input: &mut Vec<u8>, size: usize, bpp: usize) -> bool { |
| | 899 | + | let mut rv = false; |
| | 900 | + | match bpp { |
| | 901 | + | 1 => rv = bitmap_decompress1(output, width, height, input, size), |
| | 902 | + | 2 => rv = bitmap_decompress2(output, width, height, input, size), |
| | 903 | + | 3 => rv = bitmap_decompress3(output, width, height, input, size), |
| | 904 | + | 4 => rv = bitmap_decompress4(output, width, height, input, size), |
| | 905 | + | _ => () |
| | 906 | + | } |
| | 907 | + | rv |
| | 908 | + | } |
| | 909 | + | |
| | 910 | + | fn convert_rgb555_rgb32(decomp_buff: Vec<u8>, decomp_buff_size: usize, dst: &mut Vec<u8>, _dst_size: usize) { |
| | 911 | + | let mut j = 0; |
| | 912 | + | for i in (0..decomp_buff_size).step_by(2) { |
| | 913 | + | let t = ((decomp_buff[i+1] as u16) << 8) + decomp_buff[i] as u16; |
| | 914 | + | dst[j] = (t >> 8) as u8; |
| | 915 | + | dst[j+1] = (((t >> 5) & 0b11111) << 3) as u8; |
| | 916 | + | dst[j+2] = ((t & 0x1F) as u8) << 3; |
| | 917 | + | dst[j+3] = 0xff; |
| | 918 | + | j += 4; |
| | 919 | + | } |
| | 920 | + | } |
| | 921 | + | |
| | 922 | + | fn convert_rgb565_rgb32(decomp_buff: Vec<u8>, decomp_buff_size: usize, dst: &mut Vec<u8>, _dst_size: usize) { |
| | 923 | + | let mut j = 0; |
| | 924 | + | for i in (0..decomp_buff_size).step_by(2) { |
| | 925 | + | let t = ((decomp_buff[i+1] as u16) << 8) + decomp_buff[i] as u16; |
| | 926 | + | dst[j] = (t >> 8) as u8; |
| | 927 | + | dst[j+1] = (((t >> 5) & 0b111111) << 2) as u8; |
| | 928 | + | dst[j+2] = ((t & 0x1F) as u8) << 3; |
| | 929 | + | dst[j+3] = 0xff; |
| | 930 | + | j += 4; |
| | 931 | + | } |
| | 932 | + | } |
| | 933 | + | |
| | 934 | + | fn convert_rgb24_rgb32(decomp_buff: Vec<u8>, decomp_buff_size: usize, dst: &mut Vec<u8>, _dst_size: usize) { |
| | 935 | + | let mut j = 0; |
| | 936 | + | for i in (0..decomp_buff_size).step_by(3) { |
| | 937 | + | dst[j] = decomp_buff[i]; |
| | 938 | + | dst[j+1] = decomp_buff[i+1]; |
| | 939 | + | dst[j+2] = decomp_buff[i+2]; |
| | 940 | + | dst[i+3] = 0xff; |
| | 941 | + | j += 4; |
| | 942 | + | } |
| | 943 | + | } |
| | 944 | + | |
| | 945 | + | fn convert_rgbx_rgba(decomp_buff: Vec<u8>, decomp_buff_size: usize, dst: &mut Vec<u8>, _dst_size: usize) { |
| | 946 | + | for i in (0..decomp_buff_size).step_by(4) { |
| | 947 | + | dst[i] = decomp_buff[i]; |
| | 948 | + | dst[i+1] = decomp_buff[i+1]; |
| | 949 | + | dst[i+2] = decomp_buff[i+2]; |
| | 950 | + | dst[i+3] = 0xff; |
| | 951 | + | } |
| | 952 | + | } |
| | 953 | + | |
| | 954 | + | fn decode_rre(rre_buff: Vec<u8>, rre_buff_size: usize, dst: &mut Vec<u8>, dst_size: usize, bypp: u16, width: u16, height: u16) -> i16 { |
| | 955 | + | let sub_rect_num = ((rre_buff[0] as u32) << 24) + ((rre_buff[1] as u32) << 16) + ((rre_buff[2] as u32) << 8) + rre_buff[3] as u32; |
| | 956 | + | let sub_rect_num_bytes = sub_rect_num*12; |
| | 957 | + | let rectangle_pixel_count = width * height; |
| | 958 | + | let rectangle_size = rectangle_pixel_count * bypp; |
| | 959 | + | let mut sub_rectangle_pixel_count = 0; |
| | 960 | + | let mut subrect_color_offset = 0; |
| | 961 | + | let mut subwidth_bytes = 0; |
| | 962 | + | let mut subx = 0u16; |
| | 963 | + | let mut suby = 0u16; |
| | 964 | + | let mut subwidth = 0u16; |
| | 965 | + | let mut subheight = 0u16; |
| | 966 | + | let mut substart = 0u16; |
| | 967 | + | |
| | 968 | + | if rectangle_size as usize > dst_size { |
| | 969 | + | return 1; |
| | 970 | + | } |
| | 971 | + | |
| | 972 | + | // filling rectangle with default pattern |
| | 973 | + | for i in (0..rectangle_size).step_by(bypp as usize) { |
| | 974 | + | dst[i as usize] = rre_buff[4]; |
| | 975 | + | dst[(i+1) as usize] = rre_buff[5]; |
| | 976 | + | dst[(i+2) as usize] = rre_buff[6]; |
| | 977 | + | dst[(i+3) as usize] = 0xff; // alpha channel |
| | 978 | + | } |
| | 979 | + | |
| | 980 | + | //println!("rs dst: {:?}", dst); |
| | 981 | + | |
| | 982 | + | if sub_rect_num*12+8 != rre_buff_size as u32 { |
| | 983 | + | println!("sub_rect_num {}", sub_rect_num); |
| | 984 | + | println!("boundary: {}", sub_rect_num*12+8); |
| | 985 | + | println!("rre_buff_size: {}", rre_buff_size); |
| | 986 | + | return 1; |
| | 987 | + | } |
| | 988 | + | |
| | 989 | + | for i in (0..sub_rect_num_bytes).step_by(12) { |
| | 990 | + | //memo: 12 = 4(RGBX) + subx, suby, subwidth, subheight |
| | 991 | + | subx = ((rre_buff[(8+4+i) as usize] as u16) << 8) + rre_buff[(8+5+i) as usize] as u16; |
| | 992 | + | suby = ((rre_buff[(8+6+i) as usize] as u16) << 8) + rre_buff[(8+7+i) as usize] as u16; |
| | 993 | + | subwidth = ((rre_buff[(8+8+i) as usize] as u16) << 8) + rre_buff[(8+9+i) as usize] as u16; |
| | 994 | + | subwidth_bytes = subwidth * 4; |
| | 995 | + | subheight = ((rre_buff[(8+10+i) as usize] as u16) << 8) + rre_buff[(8+11+i) as usize] as u16; |
| | 996 | + | sub_rectangle_pixel_count = subwidth * subheight; |
| | 997 | + | subrect_color_offset = 8+i; |
| | 998 | + | |
| | 999 | + | for j in 0..sub_rectangle_pixel_count { |
| | 1000 | + | for y in 0..subheight { |
| | 1001 | + | substart = (subx + (suby+y) * width) * bypp; |
| | 1002 | + | if substart > dst_size as u16 || substart + subwidth_bytes > dst_size as u16 { |
| | 1003 | + | return 1; |
| | 1004 | + | } |
| | 1005 | + | |
| | 1006 | + | for x in (0..subwidth_bytes).step_by(4) { |
| | 1007 | + | dst[(substart+x ) as usize] = rre_buff[(subrect_color_offset ) as usize]; |
| | 1008 | + | dst[(substart+x+1) as usize] = rre_buff[(subrect_color_offset+1) as usize]; |
| | 1009 | + | dst[(substart+x+2) as usize] = rre_buff[(subrect_color_offset+2) as usize]; |
| | 1010 | + | dst[(substart+x+3) as usize] = 0xff; // alpha channel |
| | 1011 | + | } |
| | 1012 | + | } |
| | 1013 | + | } |
| | 1014 | + | } |
| | 1015 | + | return 0; |
| | 1016 | + | } |
| | 1017 | + | |
| | 1018 | + | // *INDENT-ON* |
| | 1019 | + | #[pyfunction] |
| | 1020 | + | #[pyo3(name = "bitmap_decompress")] |
| | 1021 | + | fn bitmap_decompress_wrapper(py: Python<'_>, output: PyBuffer<u8>, width: usize, height: usize, input: PyBuffer<u8>, bitsperpixel: usize, bpp: usize, is_compressed: usize) -> PyResult<&PyByteArray> { |
| | 1022 | + | let mut decomp_size = 0usize; |
| | 1023 | + | let mut decomp_buffer; |
| | 1024 | + | |
| | 1025 | + | if is_compressed != 0 { |
| | 1026 | + | decomp_size = width * height * bpp; |
| | 1027 | + | decomp_buffer = vec![0; decomp_size]; |
| | 1028 | + | |
| | 1029 | + | if !bitmap_decompress(&mut decomp_buffer, width as i16, height as i16, &mut input.to_vec(py).unwrap(), input.len_bytes(), bpp) { |
| | 1030 | + | return Err(PyTypeError::new_err("Decompression Error")); |
| | 1031 | + | } |
| | 1032 | + | } else { |
| | 1033 | + | decomp_size = input.len_bytes(); |
| | 1034 | + | decomp_buffer = input.to_vec(py).unwrap(); |
| | 1035 | + | } |
| | 1036 | + | |
| | 1037 | + | let mut output_buffer = output.to_vec(py).unwrap(); |
| | 1038 | + | |
| | 1039 | + | match bitsperpixel { |
| | 1040 | + | 15 => convert_rgb555_rgb32(decomp_buffer, decomp_size, &mut output_buffer, output.len_bytes()), |
| | 1041 | + | 16 => convert_rgb565_rgb32(decomp_buffer, decomp_size, &mut output_buffer, output.len_bytes()), |
| | 1042 | + | 24 => convert_rgb24_rgb32(decomp_buffer, decomp_size, &mut output_buffer, output.len_bytes()), |
| | 1043 | + | 32 | _ => (), |
| | 1044 | + | } |
| | 1045 | + | |
| | 1046 | + | let output_as_bytes = PyByteArray::new(py, &output_buffer); |
| | 1047 | + | return Ok(output_as_bytes); |
| | 1048 | + | } |
| | 1049 | + | |
| | 1050 | + | #[pyfunction] |
| | 1051 | + | #[pyo3(name = "mask_rgbx")] |
| | 1052 | + | fn mask_rgbx_wrapper(py: Python<'_>, output: PyBuffer<u8>, input: PyBuffer<u8>) -> PyResult<&PyByteArray> { |
| | 1053 | + | let mut output_buffer = output.to_vec(py).unwrap(); |
| | 1054 | + | convert_rgbx_rgba(input.to_vec(py).unwrap(), input.len_bytes(), &mut output_buffer, output.len_bytes()); |
| | 1055 | + | return Ok(PyByteArray::new(py, &output_buffer)); |
| | 1056 | + | } |
| | 1057 | + | |
| | 1058 | + | #[pyfunction] |
| | 1059 | + | #[pyo3(name = "decode_rre")] |
| | 1060 | + | fn decode_rre_wrapper(py: Python<'_>, output: PyBuffer<u8>, input: PyBuffer<u8>, width: u16, height: u16, bypp: u16) -> PyResult<&PyByteArray> { |
| | 1061 | + | let mut output_buffer = output.to_vec(py).unwrap(); |
| | 1062 | + | if decode_rre(input.to_vec(py).unwrap(), input.len_bytes(), &mut output_buffer, output.len_bytes(), bypp, width, height) != 0 { |
| | 1063 | + | return Err(PyTypeError::new_err("Decode failed!")); |
| | 1064 | + | } |
| | 1065 | + | return Ok(PyByteArray::new(py, &output_buffer)); |
| | 1066 | + | } |
| | 1067 | + | |
| | 1068 | + | #[pymodule] |
| | 1069 | + | fn rle(py: Python<'_>, m: &PyModule) -> PyResult<()> { |
| | 1070 | + | m.add_function(wrap_pyfunction!(bitmap_decompress_wrapper, m)?)?; |
| | 1071 | + | m.add_function(wrap_pyfunction!(mask_rgbx_wrapper, m)?)?; |
| | 1072 | + | m.add_function(wrap_pyfunction!(decode_rre_wrapper, m)?)?; |
| | 1073 | + | Ok(()) |
| | 1074 | + | } |
| | 1075 | + | |
| | 1076 | + | |
| | 1077 | + | |
