R-PAGE
Resistance's Portable-Adventure-Game-Engine
bitmap.c
Go to the documentation of this file.
1 /* Resistance's Portable-Adventure-Game-Engine (R-PAGE), Copyright (C) 2019 François Gutherz, Resistance.no
2  Released under MIT License, see license.txt for details.
3 */
4 
5 #ifdef LATTICE
6 /*
7  Misc bitmap routines
8 */
9 
10 #include "rpage/aos/inc.prl"
11 #include "rpage/aos/debug.h"
12 #include "rpage/aos/color.h"
13 #include "ext/tinfl.h"
14 #include "ext/aos/shrinkler.h"
15 #include "ext/aos/nrv2.h"
16 #include "rpage/frwk.h"
17 #include "rpage/err.h"
18 
19 extern struct DosLibrary *DOSBase;
20 extern struct GfxBase *GfxBase;
21 
22 struct BitMap *allocate_new_bitmap(short width, short height, short depth)
23 {
24  short i, size;
25  struct BitMap *new_bitmap;
26  PLANEPTR plane_prt;
27 
28  size = RASSIZE(width, height);
29  new_bitmap = (struct BitMap *)AllocMem((LONG)sizeof(struct BitMap), MEMF_CLEAR);
30  InitBitMap(new_bitmap, depth, width, height);
31 
32 #ifdef DEBUG_MACROS
33  printf("allocate_new_bitmap(), size = %d", size * depth);
34 #endif
35  plane_prt = (PLANEPTR)AllocMem(size * depth, MEMF_CHIP | MEMF_CLEAR);
36  for (i = 0; i < depth; i++)
37  {
38  new_bitmap->Planes[i] = plane_prt + (i * size);
39 #ifdef DEBUG_MACROS
40  printf(", allocated plane #%d", i);
41 #endif
42  }
43 
44  return new_bitmap;
45 }
46 
47 BOOL load_pak_img_to_bitmap(struct BitMap **bitmap, amiga_color **palette, BYTE *packed_block, UBYTE *name)
48 {
49  BPTR fileHandle;
50  char tag[4];
51  UWORD w, h, d, pal_size, packed_block_size;
52  // PLANEPTR plane_prt;
53 
54  UWORD i;
55  // UBYTE *read_ptr;
56 
57 #ifdef DEBUG_MACROS
58  printf("load_pak_img_to_bitmap(): '%s',", name);
59 #endif
60  if ((fileHandle = Open(name, MODE_OLDFILE)))
61  {
62  Read(fileHandle, &tag, 4);
63  if (strncmp(tag, "IMPK", 4) != 0)
64  {
65  printf(err_no_impk_found);
66  }
67  else
68  {
69  /* Read image geometry */
70  ULONG size;
71  Read(fileHandle, &w, 2); /* image width in pixels */
72  Read(fileHandle, &h, 2); /* image height in pixels */
73  Read(fileHandle, &d, 2); /* image depth */
74  size = RASSIZE(w, h); /* size of a single bitplane, in bytes */
75  pal_size = 1 << d;
76 #ifdef DEBUG_MACROS
77  printf("w=%d, h=%d, d=%d, palette_size=%d, plane_size=%d,", w, h, d, pal_size, (int)size);
78 #endif
79  /* Read color palette (if available) */
80  Read(fileHandle, &tag, 4);
81  if (strncmp(tag, "PAL4", 4) == 0)
82  {
83 #ifdef DEBUG_MACROS
84  printf("PAL4\n");
85 #endif
86  if (palette != NULL)
87  {
88  color444 fcolor; // Color from file
89  for (i = 0; i < pal_size; i++)
90  {
91  Read(fileHandle, &fcolor, 2);
92 #ifdef DEBUG_MACROS
93  printf("%X,", fcolor);
94 #endif
95  #ifdef VGA_CAPABLE
96  (*palette)[i] = rgb4_to_rgb8(fcolor); // from RGB444 to RGB888
97  #else
98  (*palette)[i] = fcolor; // from RGB444 to RGB444
99  #endif
100  }
101  // printf("\n");
102  }
103  else
104  Seek(fileHandle, pal_size * 2, OFFSET_CURRENT);
105 
106  }
107  else
108  {
109  if (strncmp(tag, "PAL8", 4) == 0)
110  {
111 #ifdef DEBUG_MACROS
112  printf("PAL8\n");
113 #endif
114  if (palette != NULL)
115  {
116  color888 fcolor; // Color from file
117  for (i = 0; i < pal_size; i++)
118  {
119  Read(fileHandle, &fcolor, 4);
120 #ifdef DEBUG_MACROS
121  printf("%X,", fcolor);
122 #endif
123  #ifdef VGA_CAPABLE
124  (*palette)[i] = fcolor; // from RGB888 to RGB888
125  #else
126  (*palette)[i] = rgb8_to_rgb4(fcolor); // from RGB888to RGB444
127  #endif
128  }
129  // printf("\n");
130  }
131  else
132  Seek(fileHandle, pal_size * 4, OFFSET_CURRENT);
133 
134  }
135  }
136 
137  Read(fileHandle, &tag, 4);
138  if (strncmp(tag, "DATA", 4) == 0)
139  {
140 #ifdef DEBUG_MACROS
141  printf(", found raw 'DATA'!");
142 #endif
143  Read(fileHandle, (**bitmap).Planes[0], size * d);
144 #ifdef DEBUG_MACROS
145  printf(", loaded plane #%d", i);
146 #endif
147  }
148  else if (strncmp(tag, "MINZ", 4) == 0)
149  {
150 #ifdef DEBUG_MACROS
151  printf(", found 'MINIZ' data!");
152 #endif
153  Read(fileHandle, &tag, 4);
154  if (strncmp(tag, "SIZE", 4) == 0)
155  {
156  Read(fileHandle, &packed_block_size, 2);
157 #ifdef DEBUG_MACROS
158  printf(", MINIZ block size: %d", packed_block_size);
159 #endif
160  Read(fileHandle, packed_block, packed_block_size);
161  // printf("!!!!MINIZ block size: %d\n", packed_block_size);
162  tinfl_decompress_mem_to_mem((**bitmap).Planes[0], size * d, packed_block, packed_block_size, 1);
163 #ifdef DEBUG_MACROS
164  printf(", loaded packed plane #%d", i);
165 #endif
166  }
167  else
168  printf(err_no_size_found);
169  }
170  else if (strncmp(tag, "SHRK", 4) == 0)
171  {
172 #ifdef DEBUG_MACROS
173  printf(", found 'Shrinkler' data!");
174 #endif
175  Read(fileHandle, &tag, 4);
176  if (strncmp(tag, "SIZE", 4) == 0)
177  {
178  Read(fileHandle, &packed_block_size, 2);
179 #ifdef DEBUG_MACROS
180  printf(", Shrinkler block size: %d", packed_block_size);
181 #endif
182  Read(fileHandle, packed_block, packed_block_size);
183  ShrinklerDecompress(packed_block, (**bitmap).Planes[0], NULL, NULL);
184 #ifdef DEBUG_MACROS
185  printf(", loaded packed plane #%d", i);
186 #endif
187  }
188  else
189  printf(err_no_size_found);
190  }
191  else if (strncmp(tag, "NRV2", 4) == 0)
192  {
193 #ifdef DEBUG_MACROS
194  printf(", found 'nrv2x' data!");
195 #endif
196  Read(fileHandle, &tag, 4);
197  if (strncmp(tag, "SIZE", 4) == 0)
198  {
199  UBYTE *Destination;
200  Read(fileHandle, &packed_block_size, 2);
201 #ifdef DEBUG_MACROS
202  printf(", nrv2x block size: %d", packed_block_size);
203 #endif
204  Read(fileHandle, packed_block, packed_block_size);
205  Destination = (**bitmap).Planes[0];
206  nrv2s_unpack(packed_block, Destination);
207 #ifdef DEBUG_MACROS
208  printf(", loaded packed plane #%d", i);
209 #endif
210  }
211  else
212  printf(err_no_size_found);
213  }
214 #ifdef DEBUG_MACROS
215  printf("\n");
216 #endif
217  // return FALSE;
218  }
219  }
220  else
221  {
222  // char _err_msg[128];
223  // memset(_err_msg, 0, 128);
224  // strcpy(_err_msg, "Cannot load '");
225  // strcat(_err_msg, name); // fixme!
226  // strcat(_err_msg, "'!");
227  // rpage_system_alert(_err_msg);
228  printf(err_cannot_open_file, name);
229  return FALSE;
230  }
231 
232  return TRUE;
233 }
234 
235 BOOL load_pak_img_to_new_bitmap(struct BitMap **new_bitmap, amiga_color **new_palette, BYTE *packed_block, UBYTE *name)
236 {
237  BPTR fileHandle;
238  char tag[4];
239  UWORD w, h, d, pal_size, packed_block_size;
240  BOOL self_alloc_unpack_buffer = FALSE;
241  // BYTE *packed_block;
242  // PLANEPTR plane_prt;
243 
244  UWORD i;
245  // UBYTE *read_ptr;
246 
247  if (packed_block == NULL)
248  self_alloc_unpack_buffer = TRUE;
249 
250 #ifdef DEBUG_MACROS
251  printf("load_pak_img_to_new_bitmap(): '%s',", name);
252 #endif
253  if ((fileHandle = Open(name, MODE_OLDFILE)))
254  {
255  Read(fileHandle, &tag, 4);
256  if (strncmp(tag, "IMPK", 4) != 0)
257  {
258  printf(err_no_impk_found);
259  }
260  else
261  {
262  /* Read image geometry */
263  ULONG size;
264  Read(fileHandle, &w, 2); /* image width in pixels */
265  Read(fileHandle, &h, 2); /* image height in pixels */
266  Read(fileHandle, &d, 2); /* image depth */
267  size = RASSIZE(w, h); /* size of a single bitplane, in bytes */
268  pal_size = 1 << d;
269 #ifdef DEBUG_MACROS
270  printf("w=%d, h=%d, d=%d, palette_size=%d, plane_size=%d,", w, h, d, pal_size, (int)size);
271 #endif
272  /* Read color palette (if available) */
273  Read(fileHandle, &tag, 4);
274  if (strncmp(tag, "PAL4", 4) == 0)
275  {
276  if (new_palette != NULL)
277  {
278  color444 fcolor; // Color from file
279  *new_palette = (amiga_color *)AllocMem(pal_size * sizeof(amiga_color), 0L);
280  for (i = 0; i < pal_size; i++)
281  {
282  Read(fileHandle, &fcolor, 2);
283  #ifdef VGA_CAPABLE
284  (*new_palette)[i] = rgb4_to_rgb8(fcolor); // from RGB444 to RGB888
285  #else
286  (*new_palette)[i] = fcolor; // from RGB444 to RGB444
287  #endif
288  }
289  }
290  else
291  Seek(fileHandle, pal_size * 2, OFFSET_CURRENT);
292  }
293  else
294  {
295  if (strncmp(tag, "PAL8", 4) == 0)
296  {
297  if (new_palette != NULL)
298  {
299  color888 fcolor; // Color from file
300  *new_palette = (amiga_color *)AllocMem(pal_size * sizeof(amiga_color), 0L);
301  for (i = 0; i < pal_size; i++)
302  {
303  Read(fileHandle, &fcolor, 4);
304  #ifdef VGA_CAPABLE
305  (*new_palette)[i] = fcolor; // from RGB888 to RGB888
306  #else
307  (*new_palette)[i] = rgb8_to_rgb4(fcolor); // from RGB888to RGB444
308  #endif
309  }
310  }
311  else
312  Seek(fileHandle, pal_size * 4, OFFSET_CURRENT);
313  }
314  }
315 
316 
317  /* Allocate each plane */
318  *new_bitmap = allocate_new_bitmap(w, h, d);
319 
320  Read(fileHandle, &tag, 4);
321  if (strncmp(tag, "DATA", 4) == 0)
322  {
323 #ifdef DEBUG_MACROS
324  printf(", found raw 'DATA'!");
325 #endif
326  Read(fileHandle, (**new_bitmap).Planes[0], size * d);
327 #ifdef DEBUG_MACROS
328  printf(", loaded plane #%d", i);
329 #endif
330  }
331  else if (strncmp(tag, "MINZ", 4) == 0)
332  {
333 #ifdef DEBUG_MACROS
334  printf(", found 'MINIZ' data!");
335 #endif
336  Read(fileHandle, &tag, 4);
337  if (strncmp(tag, "SIZE", 4) == 0)
338  {
339  Read(fileHandle, &packed_block_size, 2);
340  if (self_alloc_unpack_buffer)
341  packed_block = AllocMem(packed_block_size * sizeof(BYTE), MEMF_CLEAR);
342 #ifdef DEBUG_MACROS
343  printf(", MINIZ block size: %d", packed_block_size);
344 #endif
345  Read(fileHandle, packed_block, packed_block_size);
346  // printf("!!!!MINIZ block size: %d\n", packed_block_size);
347  tinfl_decompress_mem_to_mem((**new_bitmap).Planes[0], size * d, packed_block, packed_block_size, 1);
348  if (self_alloc_unpack_buffer && packed_block != NULL)
349  {
350  FreeMem(packed_block, packed_block_size);
351  packed_block = NULL;
352  }
353 #ifdef DEBUG_MACROS
354  printf(", loaded packed plane #%d", i);
355 #endif
356  }
357  else
358  printf(err_no_size_found);
359  }
360  else if (strncmp(tag, "SHRK", 4) == 0)
361  {
362 #ifdef DEBUG_MACROS
363  printf(", found 'Shrinkler' data!");
364 #endif
365  Read(fileHandle, &tag, 4);
366  if (strncmp(tag, "SIZE", 4) == 0)
367  {
368  Read(fileHandle, &packed_block_size, 2);
369  if (self_alloc_unpack_buffer)
370  packed_block = AllocMem(packed_block_size * sizeof(BYTE), MEMF_CLEAR);
371 #ifdef DEBUG_MACROS
372  printf(", Shrinkler block size: %d", packed_block_size);
373 #endif
374  Read(fileHandle, packed_block, packed_block_size);
375  ShrinklerDecompress(packed_block, (**new_bitmap).Planes[0], NULL, NULL);
376  if (self_alloc_unpack_buffer && packed_block != NULL)
377  {
378  FreeMem(packed_block, packed_block_size);
379  packed_block = NULL;
380  }
381 #ifdef DEBUG_MACROS
382  printf(", loaded packed plane #%d", i);
383 #endif
384  }
385  else
386  printf(err_no_size_found);
387  }
388  else if (strncmp(tag, "NRV2", 4) == 0)
389  {
390 #ifdef DEBUG_MACROS
391  printf(", found 'nrv2x' data!");
392 #endif
393  Read(fileHandle, &tag, 4);
394  if (strncmp(tag, "SIZE", 4) == 0)
395  {
396  UBYTE *Destination;
397 
398  Read(fileHandle, &packed_block_size, 2);
399  if (self_alloc_unpack_buffer)
400  packed_block = AllocMem(packed_block_size * sizeof(BYTE), MEMF_CLEAR);
401 #ifdef DEBUG_MACROS
402  printf(", nrv2x block size: %d", packed_block_size);
403 #endif
404  Read(fileHandle, packed_block, packed_block_size);
405  Destination = (**new_bitmap).Planes[0];
406  nrv2s_unpack(packed_block, Destination);
407  if (self_alloc_unpack_buffer && packed_block != NULL)
408  {
409  FreeMem(packed_block, packed_block_size);
410  packed_block = NULL;
411  }
412 #ifdef DEBUG_MACROS
413  printf(", loaded packed plane #%d", i);
414 #endif
415  }
416  else
417  printf(err_no_size_found);
418  }
419 #ifdef DEBUG_MACROS
420  printf("\n");
421 #endif
422  return TRUE;
423  }
424  }
425  else
426  {
427  printf(err_cannot_open_file, name);
428  }
429 
430  return FALSE;
431 }
432 
433 void clear_bitmap(struct BitMap *bitmap)
434 {
435  int i;
436  for (i = 0; i < bitmap->Depth; i++)
437  {
438  BltClear(bitmap->Planes[i], RASSIZE(bitmap->BytesPerRow << 3, bitmap->Rows), 0);
439  WaitBlit();
440  }
441 }
442 
443 PLANEPTR load_raw_to_mem(UBYTE *name, ULONG size, BOOL allocate_into_chipmem)
444 {
445  BPTR fileHandle;
446  PLANEPTR mem;
447 
448  if (!(fileHandle = Open(name, MODE_OLDFILE)))
449  {
450  printf(err_cannot_open_file, name);
451  rpage_system_alert("load_raw_to_mem() : cannot open file!");
452  return (NULL);
453  }
454 
455  if (!(mem = AllocMem(size, allocate_into_chipmem?MEMF_CHIP:0L)))
456  {
457  rpage_system_alert("load_raw_to_mem() : cannot AllocMem()!");
458  Close(fileHandle);
459  return (NULL);
460  }
461 
462  Read(fileHandle, mem, size);
463  Close(fileHandle);
464 
465  return (mem);
466 }
467 
468 void free_allocated_bitmap(struct BitMap *allocated_bitmap)
469 {
470  if (allocated_bitmap)
471  {
472  UWORD i;
473 
474 #ifdef DEBUG_MACROS
475  printf("free_allocated_bitmap() allocated_bitmap = %x\n", (int)allocated_bitmap);
476  printf("allocated_bitmap, BytesPerRow = %d, Rows = %d, Depth = %d, pad = %d\n",
477  (*allocated_bitmap).BytesPerRow,
478  (*allocated_bitmap).Rows,
479  (*allocated_bitmap).Depth,
480  (int)(*allocated_bitmap).pad);
481 #endif
482  if (allocated_bitmap->Planes[0] != NULL)
483  FreeMem(allocated_bitmap->Planes[0], RASSIZE(allocated_bitmap->BytesPerRow << 3, allocated_bitmap->Rows) * allocated_bitmap->Depth);
484  else
485  printf("free_allocated_bitmap() error, plane ptr should not be NULL!\n");
486 
487  for (i = 0; i < allocated_bitmap->Depth; i++)
488  {
489 #ifdef DEBUG_MACROS
490  printf("FreeMem() plane[%i], adr = %x, block_len = %i\n", i, allocated_bitmap->Planes[i], (int)block_len);
491 #endif
492  if (allocated_bitmap->Planes[i] != NULL)
493  allocated_bitmap->Planes[i] = NULL;
494  }
495 
496  if (allocated_bitmap != NULL)
497  {
498  FreeMem(allocated_bitmap, (LONG)sizeof(struct BitMap));
499  allocated_bitmap = NULL;
500  }
501  }
502 }
503 
504 #endif
FALSE
#define FALSE
Definition: utils.h:41
err_cannot_open_file
const char * err_cannot_open_file
Definition: err.c:4
err_no_size_found
const char * err_no_size_found
Definition: err.c:2
err_no_impk_found
const char * err_no_impk_found
Definition: err.c:3
BOOL
int BOOL
Definition: utils.h:32
rpage_system_alert
void rpage_system_alert(char *alert_message)
Opens a GURU MEDITATION message.
UBYTE
unsigned char UBYTE
Definition: utils.h:20
UWORD
unsigned short UWORD
Definition: utils.h:28
DOSBase
struct DosLibrary * DOSBase
tinfl_decompress_mem_to_mem
size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
Definition: tinfl.c:544
BYTE
unsigned char BYTE
Definition: utils.h:16
ULONG
unsigned long ULONG
Definition: utils.h:24
TRUE
#define TRUE
Definition: utils.h:37
Generated by   doxygen 1.8.11