Shamusworld >> Repos - virtualjaguar/blob - src/gui/filethread.cpp

   1 //
   2 // filethread.cpp - File discovery thread
   3 //
   4 // by James L. Hammons
   5 // (C) 2010 Underground Software
   6 //
   7 // JLH = James L. Hammons <jlhamm@acm.org>
   8 //
   9 // Who  When        What
  10 // ---  ----------  -------------------------------------------------------------
  11 // JLH  01/28/2010  Created this file
  12 // JLH  02/16/2010  Moved RomIdentifier stuff to its own file
  13 // JLH  03/02/2010  Added .ZIP file fishing
  14 //
  15
  16 #include "filethread.h"
  17
  18 #include <QtGui>
  19 #include "crc32.h"
  20 #include "file.h"
  21 #include "filedb.h"
  22 #include "settings.h"
  23
  24 FileThread::FileThread(QObject * parent/*= 0*/): QThread(parent), abort(false)
  25 {
  26 }
  27
  28 FileThread::~FileThread()
  29 {
  30         mutex.lock();
  31         abort = true;
  32         condition.wakeOne();
  33         mutex.unlock();
  34
  35         wait();
  36 }
  37
  38 void FileThread::Go(void)
  39 {
  40         QMutexLocker locker(&mutex);
  41         start();
  42 }
  43
  44 /*
  45 Our strategy here is like so:
  46 Look at the files in the directory pointed to by ROMPath.
  47 For each file in the directory, take the CRC32 of it and compare it to the CRC
  48 in the romList[]. If there's a match, put it in a list and note it's index value
  49 in romList for future reference.
  50
  51 When constructing the list, use the index to pull up an image of the cart and
  52 put that in the list. User picks from a graphical image of the cart.
  53
  54 Ideally, the label will go into the archive along with the ROM image, but that's
  55 for the future...
  56 Maybe box art, screenshots will go as well...
  57 */
  58
  59 //
  60 // Here's the thread's actual execution path...
  61 //
  62 void FileThread::run(void)
  63 {
  64         QDir romDir(vjs.ROMPath);
  65 //      QDir romDir("../virtualjaguar/roms/rarities/");
  66         QFileInfoList list = romDir.entryInfoList();
  67
  68 /*
  69 Another thing we'll probably have to do here is check for compressed files and
  70 decompress/fish around in them to find what we need. :-P
  71 */
  72
  73         for(int i=0; i<list.size(); i++)
  74         {
  75                 if (abort)
  76 #if 1
  77 {
  78 printf("FileThread: Aborting!!!\n");
  79 #endif
  80                         return;
  81 #if 1
  82 }
  83 #endif
  84
  85                 QFileInfo fileInfo = list.at(i);
  86
  87                 // ZIP files are special: They contain more than just the software now... ;-)
  88                 // So now we fish around inside them to pull out the stuff we want.
  89                 // Probably also need more stringent error checking as well... :-O
  90                 if (fileInfo.suffix().compare("zip", Qt::CaseInsensitive) == 0)
  91                 {
  92                         uint8 * buffer = NULL;
  93                         uint32 size = GetFileFromZIP(fileInfo.canonicalFilePath().toAscii(), FT_SOFTWARE, buffer);
  94
  95                         if (size > 0)
  96                         {
  97                                 uint32_t fileSize = size;
  98 //printf("FileThread: About to calc checksum on file with size %u... (buffer=%08X)\n", size, buffer);
  99                                 uint32 crc = crc32_calcCheckSum(buffer, size);
 100                                 uint32 index = FindCRCIndexInFileList(crc);
 101 // These two are NOT interchangeable!
 102 //                              delete[] buffer;
 103                                 free(buffer);
 104
 105 // Mebbe we should pass a index AND a QImage here???
 106 /*
 107 Let's think about this... What *do* we need to send out?
 108 we need the filename for sure. image file if it exists.
 109 do we need the index? I think we're only using it to pull the label from the subdir...
 110 we might need it if we want to pull ROM flags from the fileDB...
 111 */
 112                                 if (index != 0xFFFFFFFF && !(romList[index].flags & FF_BIOS))
 113                                 {
 114 //Here's a little problem. When we create the image here and pass it off to FilePicker,
 115 //we can clobber this image before we have a chance to copy it out in the FilePicker function
 116 //because we can be back here before FilePicker can respond.
 117 //So we need to fix this so that this does not happen. :-/
 118 //And now it is. :-)
 119 /*
 120 So I guess we can create an image on the heap and pass *that* to FilePicker. But then, would
 121 it be worthwhile to just pass the pointer into the FileListModel instead of a copy of an object?
 122 Maybe. We'd do like so:
 123 QImage * imageCopy = new QImage();
 124 */
 125                                         QImage * img = NULL;
 126                                         size = GetFileFromZIP(fileInfo.canonicalFilePath().toAscii(), FT_LABEL, buffer);
 127 //printf("FT: Label size = %u bytes.\n", size);
 128
 129                                         if (size > 0)
 130                                         {
 131 //#warning "!!!"
 132 //Not sure if this will work properly... Seems to.
 133                                                 QImage label;
 134                                                 bool success = label.loadFromData(buffer, size);
 135                                                 img = new QImage();
 136                                                 *img = label.scaled(373, 172, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 137 //printf("FT: Label %s: %ux%u.\n", (success ? "succeeded" : "did not succeed"), img->width(), img->height());
 138 // These two are NOT interchangeable!
 139 //                                              delete[] buffer;
 140                                                 free(buffer);
 141                                         }
 142 //printf("FileThread: Attempted to load image. Size: %u x %u...\n", img.width(), img.height());
 143
 144 //                                      emit FoundAFile(index);
 145                                         emit FoundAFile2(index, fileInfo.canonicalFilePath(), img, fileSize);
 146                                 }
 147                         }
 148                 }
 149                 else
 150                 {
 151                         QFile file(romDir.filePath(fileInfo.fileName()));
 152
 153                         if (file.open(QIODevice::ReadOnly))
 154                         {
 155                                 uint8 * buffer = new uint8[fileInfo.size()];
 156                                 file.read((char *)buffer, fileInfo.size());
 157                                 file.close();
 158                                 uint32 crc = crc32_calcCheckSum(buffer, fileInfo.size());
 159                                 uint32 index = FindCRCIndexInFileList(crc);
 160                                 delete[] buffer;
 161
 162 // Mebbe we should pass a index AND a QImage here???
 163                                 if (index != 0xFFFFFFFF && !(romList[index].flags & FF_BIOS))
 164 //                                      emit FoundAFile(index);
 165                                         emit FoundAFile2(index, fileInfo.canonicalFilePath(), 0, fileInfo.size());
 166                         }
 167                 }
 168         }
 169 }
 170
 171 //
 172 // Find a CRC in the ROM list (simple brute force algorithm).
 173 // If it's there, return the index, otherwise return $FFFFFFFF
 174 //
 175 uint32 FileThread::FindCRCIndexInFileList(uint32 crc)
 176 {
 177         for(int i=0; romList[i].crc32!=0xFFFFFFFF; i++)
 178         {
 179                 if (romList[i].crc32 == crc)
 180                         return i;
 181         }
 182
 183         return 0xFFFFFFFF;
 184 }
 185