src/Util.cpp

   1 // VisualBoyAdvance - Nintendo Gameboy/GameboyAdvance (TM) emulator.
   2 // Copyright (C) 1999-2003 Forgotten
   3 // Copyright (C) 2004-2006 Forgotten and the VBA development team
   4
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2, or(at your option)
   8 // any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <zlib.h>
  23
  24 extern "C" {
  25 #include <png.h>
  26 }
  27
  28 #if 0
  29 #include "unrarlib.h"
  30 #endif
  31
  32 #include "System.h"
  33 #include "NLS.h"
  34 #include "Util.h"
  35 #include "Flash.h"
  36 #include "GBA.h"
  37 #include "Globals.h"
  38 #include "RTC.h"
  39 #include "Port.h"
  40
  41
  42 extern "C" {
  43 #include "memgzio.h"
  44 }
  45
  46 #ifndef _MSC_VER
  47 #define _stricmp strcasecmp
  48 #endif // ! _MSC_VER
  49
  50 extern int systemColorDepth;
  51 extern int systemRedShift;
  52 extern int systemGreenShift;
  53 extern int systemBlueShift;
  54
  55 extern u16 systemColorMap16[0x10000];
  56 extern u32 systemColorMap32[0x10000];
  57
  58 static int (ZEXPORT *utilGzWriteFunc)(gzFile, const voidp, unsigned int) = NULL;
  59 static int (ZEXPORT *utilGzReadFunc)(gzFile, voidp, unsigned int) = NULL;
  60 static int (ZEXPORT *utilGzCloseFunc)(gzFile) = NULL;
  61
  62 bool utilWritePNGFile(const char *fileName, int w, int h, u8 *pix)
  63 {
  64   u8 writeBuffer[512 * 3];
  65
  66   FILE *fp = fopen(fileName,"wb");
  67
  68   if(!fp) {
  69     systemMessage(MSG_ERROR_CREATING_FILE, N_("Error creating file %s"), fileName);
  70     return false;
  71   }
  72
  73   png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
  74                                                 NULL,
  75                                                 NULL,
  76                                                 NULL);
  77   if(!png_ptr) {
  78     fclose(fp);
  79     return false;
  80   }
  81
  82   png_infop info_ptr = png_create_info_struct(png_ptr);
  83
  84   if(!info_ptr) {
  85     png_destroy_write_struct(&png_ptr,NULL);
  86     fclose(fp);
  87     return false;
  88   }
  89
  90   if(setjmp(png_jmpbuf(png_ptr))) {
  91     png_destroy_write_struct(&png_ptr,NULL);
  92     fclose(fp);
  93     return false;
  94   }
  95
  96   png_init_io(png_ptr,fp);
  97
  98   png_set_IHDR(png_ptr,
  99                info_ptr,
 100                w,
 101                h,
 102                8,
 103                PNG_COLOR_TYPE_RGB,
 104                PNG_INTERLACE_NONE,
 105                PNG_COMPRESSION_TYPE_DEFAULT,
 106                PNG_FILTER_TYPE_DEFAULT);
 107
 108   png_write_info(png_ptr,info_ptr);
 109
 110   u8 *b = writeBuffer;
 111
 112   int sizeX = w;
 113   int sizeY = h;
 114
 115   switch(systemColorDepth) {
 116   case 16:
 117     {
 118       u16 *p = (u16 *)(pix+(w+2)*2); // skip first black line
 119       for(int y = 0; y < sizeY; y++) {
 120          for(int x = 0; x < sizeX; x++) {
 121           u16 v = *p++;
 122
 123           *b++ = ((v >> systemRedShift) & 0x001f) << 3; // R
 124           *b++ = ((v >> systemGreenShift) & 0x001f) << 3; // G
 125           *b++ = ((v >> systemBlueShift) & 0x01f) << 3; // B
 126         }
 127         p++; // skip black pixel for filters
 128         p++; // skip black pixel for filters
 129         png_write_row(png_ptr,writeBuffer);
 130
 131         b = writeBuffer;
 132       }
 133     }
 134     break;
 135   case 24:
 136     {
 137       u8 *pixU8 = (u8 *)pix;
 138       for(int y = 0; y < sizeY; y++) {
 139         for(int x = 0; x < sizeX; x++) {
 140           if(systemRedShift < systemBlueShift) {
 141             *b++ = *pixU8++; // R
 142             *b++ = *pixU8++; // G
 143             *b++ = *pixU8++; // B
 144           } else {
 145             int blue = *pixU8++;
 146             int green = *pixU8++;
 147             int red = *pixU8++;
 148
 149             *b++ = red;
 150             *b++ = green;
 151             *b++ = blue;
 152           }
 153         }
 154         png_write_row(png_ptr,writeBuffer);
 155
 156         b = writeBuffer;
 157       }
 158     }
 159     break;
 160   case 32:
 161     {
 162       u32 *pixU32 = (u32 *)(pix+4*(w+1));
 163       for(int y = 0; y < sizeY; y++) {
 164         for(int x = 0; x < sizeX; x++) {
 165           u32 v = *pixU32++;
 166
 167           *b++ = ((v >> systemRedShift) & 0x001f) << 3; // R
 168           *b++ = ((v >> systemGreenShift) & 0x001f) << 3; // G
 169           *b++ = ((v >> systemBlueShift) & 0x001f) << 3; // B
 170         }
 171         pixU32++;
 172
 173         png_write_row(png_ptr,writeBuffer);
 174
 175         b = writeBuffer;
 176       }
 177     }
 178     break;
 179   }
 180
 181   png_write_end(png_ptr, info_ptr);
 182
 183   png_destroy_write_struct(&png_ptr, &info_ptr);
 184
 185   fclose(fp);
 186
 187   return true;
 188 }
 189
 190 void utilPutDword(u8 *p, u32 value)
 191 {
 192   *p++ = value & 255;
 193   *p++ = (value >> 8) & 255;
 194   *p++ = (value >> 16) & 255;
 195   *p = (value >> 24) & 255;
 196 }
 197
 198 void utilPutWord(u8 *p, u16 value)
 199 {
 200   *p++ = value & 255;
 201   *p = (value >> 8) & 255;
 202 }
 203
 204 void utilWriteBMP(char *buf, int w, int h, u8 *pix)
 205 {
 206   u8 *b = (u8 *)buf;
 207
 208   int sizeX = w;
 209   int sizeY = h;
 210
 211   switch(systemColorDepth) {
 212   case 16:
 213     {
 214       u16 *p = (u16 *)(pix+(w+2)*(h)*2); // skip first black line
 215       for(int y = 0; y < sizeY; y++) {
 216         for(int x = 0; x < sizeX; x++) {
 217           u16 v = *p++;
 218
 219           *b++ = ((v >> systemBlueShift) & 0x01f) << 3; // B
 220           *b++ = ((v >> systemGreenShift) & 0x001f) << 3; // G
 221           *b++ = ((v >> systemRedShift) & 0x001f) << 3; // R
 222         }
 223         p++; // skip black pixel for filters
 224         p++; // skip black pixel for filters
 225         p -= 2*(w+2);
 226       }
 227     }
 228     break;
 229   case 24:
 230     {
 231       u8 *pixU8 = (u8 *)pix+3*w*(h-1);
 232       for(int y = 0; y < sizeY; y++) {
 233         for(int x = 0; x < sizeX; x++) {
 234           if(systemRedShift > systemBlueShift) {
 235             *b++ = *pixU8++; // B
 236             *b++ = *pixU8++; // G
 237             *b++ = *pixU8++; // R
 238           } else {
 239             int red = *pixU8++;
 240             int green = *pixU8++;
 241             int blue = *pixU8++;
 242
 243             *b++ = blue;
 244             *b++ = green;
 245             *b++ = red;
 246           }
 247         }
 248         pixU8 -= 2*3*w;
 249       }
 250     }
 251     break;
 252   case 32:
 253     {
 254       u32 *pixU32 = (u32 *)(pix+4*(w+1)*(h));
 255       for(int y = 0; y < sizeY; y++) {
 256         for(int x = 0; x < sizeX; x++) {
 257           u32 v = *pixU32++;
 258
 259           *b++ = ((v >> systemBlueShift) & 0x001f) << 3; // B
 260           *b++ = ((v >> systemGreenShift) & 0x001f) << 3; // G
 261           *b++ = ((v >> systemRedShift) & 0x001f) << 3; // R
 262         }
 263         pixU32++;
 264         pixU32 -= 2*(w+1);
 265       }
 266     }
 267     break;
 268   }
 269 }
 270
 271 bool utilWriteBMPFile(const char *fileName, int w, int h, u8 *pix)
 272 {
 273   u8 writeBuffer[512 * 3];
 274
 275   FILE *fp = fopen(fileName,"wb");
 276
 277   if(!fp) {
 278     systemMessage(MSG_ERROR_CREATING_FILE, N_("Error creating file %s"), fileName);
 279     return false;
 280   }
 281
 282   struct {
 283     u8 ident[2];
 284     u8 filesize[4];
 285     u8 reserved[4];
 286     u8 dataoffset[4];
 287     u8 headersize[4];
 288     u8 width[4];
 289     u8 height[4];
 290     u8 planes[2];
 291     u8 bitsperpixel[2];
 292     u8 compression[4];
 293     u8 datasize[4];
 294     u8 hres[4];
 295     u8 vres[4];
 296     u8 colors[4];
 297     u8 importantcolors[4];
 298     //    u8 pad[2];
 299   } bmpheader;
 300   memset(&bmpheader, 0, sizeof(bmpheader));
 301
 302   bmpheader.ident[0] = 'B';
 303   bmpheader.ident[1] = 'M';
 304
 305   u32 fsz = sizeof(bmpheader) + w*h*3;
 306   utilPutDword(bmpheader.filesize, fsz);
 307   utilPutDword(bmpheader.dataoffset, 0x36);
 308   utilPutDword(bmpheader.headersize, 0x28);
 309   utilPutDword(bmpheader.width, w);
 310   utilPutDword(bmpheader.height, h);
 311   utilPutDword(bmpheader.planes, 1);
 312   utilPutDword(bmpheader.bitsperpixel, 24);
 313   utilPutDword(bmpheader.datasize, 3*w*h);
 314
 315   fwrite(&bmpheader, 1, sizeof(bmpheader), fp);
 316
 317   u8 *b = writeBuffer;
 318
 319   int sizeX = w;
 320   int sizeY = h;
 321
 322   switch(systemColorDepth) {
 323   case 16:
 324     {
 325       u16 *p = (u16 *)(pix+(w+2)*(h)*2); // skip first black line
 326       for(int y = 0; y < sizeY; y++) {
 327         for(int x = 0; x < sizeX; x++) {
 328           u16 v = *p++;
 329
 330           *b++ = ((v >> systemBlueShift) & 0x01f) << 3; // B
 331           *b++ = ((v >> systemGreenShift) & 0x001f) << 3; // G
 332           *b++ = ((v >> systemRedShift) & 0x001f) << 3; // R
 333         }
 334         p++; // skip black pixel for filters
 335         p++; // skip black pixel for filters
 336         p -= 2*(w+2);
 337         fwrite(writeBuffer, 1, 3*w, fp);
 338
 339         b = writeBuffer;
 340       }
 341     }
 342     break;
 343   case 24:
 344     {
 345       u8 *pixU8 = (u8 *)pix+3*w*(h-1);
 346       for(int y = 0; y < sizeY; y++) {
 347         for(int x = 0; x < sizeX; x++) {
 348           if(systemRedShift > systemBlueShift) {
 349             *b++ = *pixU8++; // B
 350             *b++ = *pixU8++; // G
 351             *b++ = *pixU8++; // R
 352           } else {
 353             int red = *pixU8++;
 354             int green = *pixU8++;
 355             int blue = *pixU8++;
 356
 357             *b++ = blue;
 358             *b++ = green;
 359             *b++ = red;
 360           }
 361         }
 362         pixU8 -= 2*3*w;
 363         fwrite(writeBuffer, 1, 3*w, fp);
 364
 365         b = writeBuffer;
 366       }
 367     }
 368     break;
 369   case 32:
 370     {
 371       u32 *pixU32 = (u32 *)(pix+4*(w+1)*(h));
 372       for(int y = 0; y < sizeY; y++) {
 373         for(int x = 0; x < sizeX; x++) {
 374           u32 v = *pixU32++;
 375
 376           *b++ = ((v >> systemBlueShift) & 0x001f) << 3; // B
 377           *b++ = ((v >> systemGreenShift) & 0x001f) << 3; // G
 378           *b++ = ((v >> systemRedShift) & 0x001f) << 3; // R
 379         }
 380         pixU32++;
 381         pixU32 -= 2*(w+1);
 382
 383         fwrite(writeBuffer, 1, 3*w, fp);
 384
 385         b = writeBuffer;
 386       }
 387     }
 388     break;
 389   }
 390
 391   fclose(fp);
 392
 393   return true;
 394 }
 395
 396 static int utilReadInt2(FILE *f)
 397 {
 398   int res = 0;
 399   int c = fgetc(f);
 400   if(c == EOF)
 401     return -1;
 402   res = c;
 403   c = fgetc(f);
 404   if(c == EOF)
 405     return -1;
 406   return c + (res<<8);
 407 }
 408
 409 static int utilReadInt3(FILE *f)
 410 {
 411   int res = 0;
 412   int c = fgetc(f);
 413   if(c == EOF)
 414     return -1;
 415   res = c;
 416   c = fgetc(f);
 417   if(c == EOF)
 418     return -1;
 419   res = c + (res<<8);
 420   c = fgetc(f);
 421   if(c == EOF)
 422     return -1;
 423   return c + (res<<8);
 424 }
 425
 426 void utilApplyIPS(const char *ips, u8 **r, int *s)
 427 {
 428   // from the IPS spec at http://zerosoft.zophar.net/ips.htm
 429   FILE *f = fopen(ips, "rb");
 430   if(!f)
 431     return;
 432   u8 *rom = *r;
 433   int size = *s;
 434   if(fgetc(f) == 'P' &&
 435      fgetc(f) == 'A' &&
 436      fgetc(f) == 'T' &&
 437      fgetc(f) == 'C' &&
 438      fgetc(f) == 'H') {
 439     int b;
 440     int offset;
 441     int len;
 442     for(;;) {
 443       // read offset
 444       offset = utilReadInt3(f);
 445       // if offset == EOF, end of patch
 446       if(offset == 0x454f46)
 447         break;
 448       // read length
 449       len = utilReadInt2(f);
 450       if(!len) {
 451         // len == 0, RLE block
 452         len = utilReadInt2(f);
 453         // byte to fill
 454         int c = fgetc(f);
 455         if(c == -1)
 456           break;
 457         b = (u8)c;
 458       } else
 459         b= -1;
 460       // check if we need to reallocate our ROM
 461       if((offset + len) >= size) {
 462         size *= 2;
 463         rom = (u8 *)realloc(rom, size);
 464         *r = rom;
 465         *s = size;
 466       }
 467       if(b == -1) {
 468         // normal block, just read the data
 469         if(fread(&rom[offset], 1, len, f) != (size_t)len)
 470           break;
 471       } else {
 472         // fill the region with the given byte
 473         while(len--) {
 474           rom[offset++] = b;
 475         }
 476       }
 477     }
 478   }
 479   // close the file
 480   fclose(f);
 481 }
 482
 483 extern bool cpuIsMultiBoot;
 484
 485 bool utilIsGBAImage(const char * file)
 486 {
 487   cpuIsMultiBoot = false;
 488   if(strlen(file) > 4) {
 489     const char * p = strrchr(file,'.');
 490
 491     if(p != NULL) {
 492       if(_stricmp(p, ".gba") == 0)
 493         return true;
 494       if(_stricmp(p, ".agb") == 0)
 495         return true;
 496       if(_stricmp(p, ".bin") == 0)
 497         return true;
 498       if(_stricmp(p, ".elf") == 0)
 499         return true;
 500       if(_stricmp(p, ".mb") == 0) {
 501         cpuIsMultiBoot = true;
 502         return true;
 503       }
 504     }
 505   }
 506
 507   return false;
 508 }
 509
 510 bool utilIsGBImage(const char * file)
 511 {
 512   if(strlen(file) > 4) {
 513     const char * p = strrchr(file,'.');
 514
 515     if(p != NULL) {
 516       if(_stricmp(p, ".gb") == 0)
 517         return true;
 518       if(_stricmp(p, ".gbc") == 0)
 519         return true;
 520       if(_stricmp(p, ".cgb") == 0)
 521         return true;
 522       if(_stricmp(p, ".sgb") == 0)
 523         return true;
 524     }
 525   }
 526
 527   return false;
 528 }
 529
 530 bool utilIsZipFile(const char *file)
 531 {
 532   if(strlen(file) > 4) {
 533     const char * p = strrchr(file,'.');
 534
 535     if(p != NULL) {
 536       if(_stricmp(p, ".zip") == 0)
 537         return true;
 538     }
 539   }
 540
 541   return false;
 542 }
 543
 544 #if 0
 545 bool utilIsRarFile(const char *file)
 546 {
 547   if(strlen(file) > 4) {
 548     char * p = strrchr(file,'.');
 549
 550     if(p != NULL) {
 551       if(_stricmp(p, ".rar") == 0)
 552         return true;
 553     }
 554   }
 555
 556   return false;
 557 }
 558 #endif
 559
 560 bool utilIsGzipFile(const char *file)
 561 {
 562   if(strlen(file) > 3) {
 563     const char * p = strrchr(file,'.');
 564
 565     if(p != NULL) {
 566       if(_stricmp(p, ".gz") == 0)
 567         return true;
 568       if(_stricmp(p, ".z") == 0)
 569         return true;
 570     }
 571   }
 572
 573   return false;
 574 }
 575
 576 void utilGetBaseName(const char *file, char *buffer)
 577 {
 578   strcpy(buffer, file);
 579
 580   if(utilIsGzipFile(file)) {
 581     char *p = strrchr(buffer, '.');
 582
 583     if(p)
 584       *p = 0;
 585   }
 586 }
 587
 588 IMAGE_TYPE utilFindType(const char *file)
 589 {
 590   char buffer[2048];
 591
 592   if(utilIsZipFile(file)) {
 593     unzFile unz = unzOpen(file);
 594
 595     if(unz == NULL) {
 596       systemMessage(MSG_CANNOT_OPEN_FILE, N_("Cannot open file %s"), file);
 597       return IMAGE_UNKNOWN;
 598     }
 599
 600     int r = unzGoToFirstFile(unz);
 601
 602     if(r != UNZ_OK) {
 603       unzClose(unz);
 604       systemMessage(MSG_BAD_ZIP_FILE, N_("Bad ZIP file %s"), file);
 605       return IMAGE_UNKNOWN;
 606     }
 607
 608     IMAGE_TYPE found = IMAGE_UNKNOWN;
 609
 610     unz_file_info info;
 611
 612     while(true) {
 613       r = unzGetCurrentFileInfo(unz,
 614                                 &info,
 615                                 buffer,
 616                                 sizeof(buffer),
 617                                 NULL,
 618                                 0,
 619                                 NULL,
 620                                 0);
 621
 622       if(r != UNZ_OK) {
 623         unzClose(unz);
 624         systemMessage(MSG_BAD_ZIP_FILE, N_("Bad ZIP file %s"), file);
 625         return IMAGE_UNKNOWN;
 626       }
 627
 628       if(utilIsGBAImage(buffer)) {
 629         found = IMAGE_GBA;
 630         break;
 631       }
 632
 633       if(utilIsGBImage(buffer)) {
 634         found = IMAGE_GB;
 635         break;
 636       }
 637
 638       r = unzGoToNextFile(unz);
 639
 640       if(r != UNZ_OK)
 641         break;
 642     }
 643     unzClose(unz);
 644
 645     if(found == IMAGE_UNKNOWN) {
 646       systemMessage(MSG_NO_IMAGE_ON_ZIP,
 647                     N_("No image found on ZIP file %s"), file);
 648       return found;
 649     }
 650     return found;
 651 #if 0
 652   } else if(utilIsRarFile(file)) {
 653     IMAGE_TYPE found = IMAGE_UNKNOWN;
 654
 655     ArchiveList_struct *rarList = NULL;
 656     if(urarlib_list((void *)file, (ArchiveList_struct *)&rarList)) {
 657       ArchiveList_struct *p = rarList;
 658
 659       while(p) {
 660         if(utilIsGBAImage(p->item.Name)) {
 661           found = IMAGE_GBA;
 662           break;
 663         }
 664
 665         if(utilIsGBImage(p->item.Name)) {
 666           found = IMAGE_GB;
 667           break;
 668         }
 669         p = p->next;
 670       }
 671
 672       urarlib_freelist(rarList);
 673     }
 674     return found;
 675 #endif
 676   } else {
 677     if(utilIsGzipFile(file))
 678       utilGetBaseName(file, buffer);
 679     else
 680       strcpy(buffer, file);
 681
 682     if(utilIsGBAImage(buffer))
 683       return IMAGE_GBA;
 684     if(utilIsGBImage(buffer))
 685       return IMAGE_GB;
 686   }
 687   return IMAGE_UNKNOWN;
 688 }
 689
 690 static int utilGetSize(int size)
 691 {
 692   int res = 1;
 693   while(res < size)
 694     res <<= 1;
 695   return res;
 696 }
 697
 698 static u8 *utilLoadFromZip(const char *file,
 699                            bool (*accept)(const char *),
 700                            u8 *data,
 701                            int &size)
 702 {
 703   char buffer[2048];
 704
 705   unzFile unz = unzOpen(file);
 706
 707   if(unz == NULL) {
 708     systemMessage(MSG_CANNOT_OPEN_FILE, N_("Cannot open file %s"), file);
 709     return NULL;
 710   }
 711   int r = unzGoToFirstFile(unz);
 712
 713   if(r != UNZ_OK) {
 714     unzClose(unz);
 715     systemMessage(MSG_BAD_ZIP_FILE, N_("Bad ZIP file %s"), file);
 716     return NULL;
 717   }
 718
 719   bool found = false;
 720
 721   unz_file_info info;
 722
 723   while(true) {
 724     r = unzGetCurrentFileInfo(unz,
 725                               &info,
 726                               buffer,
 727                               sizeof(buffer),
 728                               NULL,
 729                               0,
 730                               NULL,
 731                               0);
 732
 733     if(r != UNZ_OK) {
 734       unzClose(unz);
 735       systemMessage(MSG_BAD_ZIP_FILE, N_("Bad ZIP file %s"), file);
 736       return NULL;
 737     }
 738
 739     if(accept(buffer)) {
 740       found = true;
 741       break;
 742     }
 743
 744     r = unzGoToNextFile(unz);
 745
 746     if(r != UNZ_OK)
 747       break;
 748   }
 749
 750   if(!found) {
 751     unzClose(unz);
 752     systemMessage(MSG_NO_IMAGE_ON_ZIP,
 753                   N_("No image found on ZIP file %s"), file);
 754     return NULL;
 755   }
 756
 757   int fileSize = info.uncompressed_size;
 758   if(size == 0)
 759     size = fileSize;
 760   r = unzOpenCurrentFile(unz);
 761
 762   if(r != UNZ_OK) {
 763     unzClose(unz);
 764     systemMessage(MSG_ERROR_OPENING_IMAGE, N_("Error opening image %s"), buffer);
 765     return NULL;
 766   }
 767
 768   u8 *image = data;
 769
 770   if(image == NULL) {
 771     image = (u8 *)malloc(utilGetSize(size));
 772     if(image == NULL) {
 773       unzCloseCurrentFile(unz);
 774       unzClose(unz);
 775       systemMessage(MSG_OUT_OF_MEMORY, N_("Failed to allocate memory for %s"),
 776                     "data");
 777       return NULL;
 778     }
 779     size = fileSize;
 780   }
 781   int read = fileSize <= size ? fileSize : size;
 782   r = unzReadCurrentFile(unz,
 783                          image,
 784                          read);
 785
 786   unzCloseCurrentFile(unz);
 787   unzClose(unz);
 788
 789   if(r != (int)read) {
 790     systemMessage(MSG_ERROR_READING_IMAGE,
 791                   N_("Error reading image %s"), buffer);
 792     if(data == NULL)
 793       free(image);
 794     return NULL;
 795   }
 796
 797   size = fileSize;
 798
 799   return image;
 800 }
 801
 802 static u8 *utilLoadGzipFile(const char *file,
 803                             bool (*accept)(const char *),
 804                             u8 *data,
 805                             int &size)
 806 {
 807   FILE *f = fopen(file, "rb");
 808
 809   if(f == NULL) {
 810     systemMessage(MSG_ERROR_OPENING_IMAGE, N_("Error opening image %s"), file);
 811     return NULL;
 812   }
 813
 814   fseek(f, -4, SEEK_END);
 815   int fileSize = fgetc(f) | (fgetc(f) << 8) | (fgetc(f) << 16) | (fgetc(f) << 24);
 816   fclose(f);
 817   if(size == 0)
 818     size = fileSize;
 819
 820   gzFile gz = gzopen(file, "rb");
 821
 822   if(gz == NULL) {
 823     // should not happen, but who knows?
 824     systemMessage(MSG_ERROR_OPENING_IMAGE, N_("Error opening image %s"), file);
 825     return NULL;
 826   }
 827
 828   u8 *image = data;
 829
 830   if(image == NULL) {
 831     image = (u8 *)malloc(utilGetSize(size));
 832     if(image == NULL) {
 833       systemMessage(MSG_OUT_OF_MEMORY, N_("Failed to allocate memory for %s"),
 834                     "data");
 835       fclose(f);
 836       return NULL;
 837     }
 838     size = fileSize;
 839   }
 840   int read = fileSize <= size ? fileSize : size;
 841   int r = gzread(gz, image, read);
 842   gzclose(gz);
 843
 844   if(r != (int)read) {
 845     systemMessage(MSG_ERROR_READING_IMAGE,
 846                   N_("Error reading image %s"), file);
 847     if(data == NULL)
 848       free(image);
 849     return NULL;
 850   }
 851
 852   size = fileSize;
 853
 854   return image;
 855 }
 856
 857 #if 0
 858 static u8 *utilLoadRarFile(const char *file,
 859                            bool (*accept)(const char *),
 860                            u8 *data,
 861                            int &size)
 862 {
 863   char buffer[2048];
 864
 865   ArchiveList_struct *rarList = NULL;
 866   if(urarlib_list((void *)file, (ArchiveList_struct *)&rarList)) {
 867     ArchiveList_struct *p = rarList;
 868
 869     bool found = false;
 870     while(p) {
 871       if(accept(p->item.Name)) {
 872         strcpy(buffer, p->item.Name);
 873         found = true;
 874         break;
 875       }
 876       p = p->next;
 877     }
 878     if(found) {
 879       void *memory = NULL;
 880       unsigned long lsize = 0;
 881       size = p->item.UnpSize;
 882       int r = urarlib_get((void *)&memory, &lsize, buffer, (void *)file, "");
 883       if(!r) {
 884         systemMessage(MSG_ERROR_READING_IMAGE,
 885                       N_("Error reading image %s"), buffer);
 886         urarlib_freelist(rarList);
 887         return NULL;
 888       }
 889       u8 *image = (u8 *)memory;
 890       if(data != NULL) {
 891         memcpy(image, data, size);
 892       }
 893       urarlib_freelist(rarList);
 894       return image;
 895     }
 896     systemMessage(MSG_NO_IMAGE_ON_ZIP,
 897                   N_("No image found on RAR file %s"), file);
 898     urarlib_freelist(rarList);
 899     return NULL;
 900   }
 901   // nothing found
 902   return NULL;
 903 }
 904 #endif
 905
 906 u8 *utilLoad(const char *file,
 907              bool (*accept)(const char *),
 908              u8 *data,
 909              int &size)
 910 {
 911   if(utilIsZipFile(file)) {
 912     return utilLoadFromZip(file, accept, data, size);
 913   }
 914   if(utilIsGzipFile(file)) {
 915     return utilLoadGzipFile(file, accept, data, size);
 916   }
 917 #if 0
 918   if(utilIsRarFile(file)) {
 919     return utilLoadRarFile(file, accept, data, size);
 920   }
 921 #endif
 922
 923   u8 *image = data;
 924
 925   FILE *f = fopen(file, "rb");
 926
 927   if(!f) {
 928     systemMessage(MSG_ERROR_OPENING_IMAGE, N_("Error opening image %s"), file);
 929     return NULL;
 930   }
 931
 932   fseek(f,0,SEEK_END);
 933   int fileSize = ftell(f);
 934   fseek(f,0,SEEK_SET);
 935   if(size == 0)
 936     size = fileSize;
 937
 938   if(image == NULL) {
 939     image = (u8 *)malloc(utilGetSize(size));
 940     if(image == NULL) {
 941       systemMessage(MSG_OUT_OF_MEMORY, N_("Failed to allocate memory for %s"),
 942                     "data");
 943       fclose(f);
 944       return NULL;
 945     }
 946     size = fileSize;
 947   }
 948   size_t read = fileSize <= size ? fileSize : size;
 949   size_t r = fread(image, 1, read, f);
 950   fclose(f);
 951
 952   if(r != read) {
 953     systemMessage(MSG_ERROR_READING_IMAGE,
 954                   N_("Error reading image %s"), file);
 955     if(data == NULL)
 956       free(image);
 957     return NULL;
 958   }
 959
 960   size = fileSize;
 961
 962   return image;
 963 }
 964
 965 void utilWriteInt(gzFile gzFile, int i)
 966 {
 967   utilGzWrite(gzFile, &i, sizeof(int));
 968 }
 969
 970 int utilReadInt(gzFile gzFile)
 971 {
 972   int i = 0;
 973   utilGzRead(gzFile, &i, sizeof(int));
 974   return i;
 975 }
 976
 977 void utilReadData(gzFile gzFile, variable_desc* data)
 978 {
 979   while(data->address) {
 980     utilGzRead(gzFile, data->address, data->size);
 981     data++;
 982   }
 983 }
 984
 985 void utilWriteData(gzFile gzFile, variable_desc *data)
 986 {
 987   while(data->address) {
 988     utilGzWrite(gzFile, data->address, data->size);
 989     data++;
 990   }
 991 }
 992
 993 gzFile utilGzOpen(const char *file, const char *mode)
 994 {
 995   utilGzWriteFunc = (int (ZEXPORT *)(gzFile,void * const, unsigned int))gzwrite;
 996   utilGzReadFunc = gzread;
 997   utilGzCloseFunc = gzclose;
 998
 999   return gzopen(file, mode);
1000 }
1001
1002 gzFile utilMemGzOpen(char *memory, int available, char *mode)
1003 {
1004   utilGzWriteFunc = memgzwrite;
1005   utilGzReadFunc = memgzread;
1006   utilGzCloseFunc = memgzclose;
1007
1008   return memgzopen(memory, available, mode);
1009 }
1010
1011 int utilGzWrite(gzFile file, const voidp buffer, unsigned int len)
1012 {
1013   return utilGzWriteFunc(file, buffer, len);
1014 }
1015
1016 int utilGzRead(gzFile file, voidp buffer, unsigned int len)
1017 {
1018   return utilGzReadFunc(file, buffer, len);
1019 }
1020
1021 int utilGzClose(gzFile file)
1022 {
1023   return utilGzCloseFunc(file);
1024 }
1025
1026 long utilGzMemTell(gzFile file)
1027 {
1028   return memtell(file);
1029 }
1030
1031 void utilGBAFindSave(const u8 *data, const int size)
1032 {
1033   u32 *p = (u32 *)data;
1034   u32 *end = (u32 *)(data + size);
1035   int saveType = 0;
1036   int flashSize = 0x10000;
1037   bool rtcFound = false;
1038
1039   while(p  < end) {
1040     u32 d = READ32LE(p);
1041
1042     if(d == 0x52504545) {
1043       if(memcmp(p, "EEPROM_", 7) == 0) {
1044         if(saveType == 0)
1045           saveType = 3;
1046       }
1047     } else if (d == 0x4D415253) {
1048       if(memcmp(p, "SRAM_", 5) == 0) {
1049         if(saveType == 0)
1050           saveType = 1;
1051       }
1052     } else if (d == 0x53414C46) {
1053       if(memcmp(p, "FLASH1M_", 8) == 0) {
1054         if(saveType == 0) {
1055           saveType = 2;
1056           flashSize = 0x20000;
1057         }
1058       } else if(memcmp(p, "FLASH", 5) == 0) {
1059         if(saveType == 0) {
1060           saveType = 2;
1061           flashSize = 0x10000;
1062         }
1063       }
1064     } else if (d == 0x52494953) {
1065       if(memcmp(p, "SIIRTC_V", 8) == 0)
1066         rtcFound = true;
1067     }
1068     p++;
1069   }
1070   // if no matches found, then set it to NONE
1071   if(saveType == 0) {
1072     saveType = 5;
1073   }
1074   rtcEnable(rtcFound);
1075   cpuSaveType = saveType;
1076   flashSetSize(flashSize);
1077 }
1078
1079 void utilUpdateSystemColorMaps()
1080 {
1081   switch(systemColorDepth) {
1082   case 16:
1083     {
1084       for(int i = 0; i < 0x10000; i++) {
1085         systemColorMap16[i] = ((i & 0x1f) << systemRedShift) |
1086           (((i & 0x3e0) >> 5) << systemGreenShift) |
1087           (((i & 0x7c00) >> 10) << systemBlueShift);
1088       }
1089     }
1090     break;
1091   case 24:
1092   case 32:
1093     {
1094       for(int i = 0; i < 0x10000; i++) {
1095         systemColorMap32[i] = ((i & 0x1f) << systemRedShift) |
1096           (((i & 0x3e0) >> 5) << systemGreenShift) |
1097           (((i & 0x7c00) >> 10) << systemBlueShift);
1098       }
1099     }
1100     break;
1101   }
1102 }