00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033 #include <sys/types.h>
00034 #include <sys/stat.h>
00035 #include <unistd.h>
00036 #include <string.h>
00037 #include "mmsgui/mmsimagemanager.h"
00038 #include "mmsgui/mmsgifloader.h"
00039 #include "mmsgui/mmsfbmanager.h"
00040
00041
00042 MMSImageManager::MMSImageManager(MMSFBLayer *layer) {
00043 if (!layer) {
00044
00045 layer = mmsfbmanager.getGraphicsLayer();
00046 }
00047
00048
00049 this->layer = layer;
00050
00051
00052 this->pixelformat = MMSFB_PF_NONE;
00053 MMSFBSurface *ts;
00054 if (this->layer->createSurface(&ts, 8, 1)) {
00055
00056 ts->getPixelFormat(&this->pixelformat);
00057 delete ts;
00058 }
00059
00060
00061 this->usetaff = false;
00062 switch (this->pixelformat) {
00063 case MMSFB_PF_ARGB:
00064 this->usetaff = true;
00065 this->taffpf = MMSTAFF_PF_ARGB;
00066 break;
00067 case MMSFB_PF_AiRGB:
00068 this->usetaff = true;
00069 this->taffpf = MMSTAFF_PF_AiRGB;
00070 break;
00071 case MMSFB_PF_AYUV:
00072 this->usetaff = true;
00073 this->taffpf = MMSTAFF_PF_AYUV;
00074 break;
00075 case MMSFB_PF_ARGB4444:
00076 this->usetaff = true;
00077 this->taffpf = MMSTAFF_PF_ARGB4444;
00078 break;
00079 case MMSFB_PF_RGB16:
00080 this->usetaff = true;
00081 this->taffpf = MMSTAFF_PF_RGB16;
00082 break;
00083 case MMSFB_PF_ABGR:
00084 this->usetaff = true;
00085 this->taffpf = MMSTAFF_PF_ABGR;
00086 break;
00087 default:
00088 break;
00089 }
00090 }
00091
00092 MMSImageManager::~MMSImageManager() {
00093
00094 for (unsigned int i = 0; i < this->images.size(); i++) {
00095 for (int j = 0; j < this->images.at(i)->sufcount; j++)
00096 if (this->images.at(i)->suf[j].surface)
00097 delete this->images.at(i)->suf[j].surface;
00098 delete this->images.at(i);
00099 }
00100 }
00101
00102
00103 MMSFBSurface *MMSImageManager::getImage(const string &path, const string &filename, MMSIM_DESC_SUF **surfdesc,
00104 int mirror_size, bool gen_taff) {
00105 string imagefile;
00106 MMSIM_DESC *im_desc = NULL;
00107 int reload_image = -1;
00108
00109
00110 imagefile = path;
00111 if (imagefile != "") imagefile+= "/";
00112 imagefile += filename;
00113 if (imagefile == "")
00114 return NULL;
00115 if (imagefile.substr(imagefile.size()-1,1)=="/")
00116 return NULL;
00117
00118 if (gen_taff) {
00119
00120 if (strToUpr(imagefile.substr(0,7)) == "HTTP://") {
00121 gen_taff = false;
00122 }
00123 else
00124 if (strToUpr(imagefile.substr(0,6)) == "FTP://") {
00125 gen_taff = false;
00126 }
00127 }
00128
00129
00130 this->lock.lock();
00131
00132 DEBUGMSG("MMSGUI", "Load request for path=%s, name=%s", path.c_str(), filename.c_str());
00133
00134
00135 for (unsigned int i = 0; i < this->images.size(); i++) {
00136 if (this->images.at(i)->imagefile == imagefile) {
00137
00138 struct stat statbuf;
00139 if (stat(imagefile.c_str(), &statbuf)==0) {
00140 if (statbuf.st_mtime != this->images.at(i)->mtime) {
00141
00142 reload_image = (int)i;
00143 this->images.at(i)->mtime = statbuf.st_mtime;
00144 break;
00145 }
00146 else {
00147
00148 DEBUGMSG("MMSGUI", "Reusing already loaded image path=%s, name=%s", path.c_str(), filename.c_str());
00149 this->images.at(i)->usecount++;
00150 if (surfdesc)
00151 *surfdesc = this->images.at(i)->suf;
00152 this->lock.unlock();
00153 return this->images.at(i)->suf[0].surface;
00154 }
00155 }
00156 else {
00157
00158 DEBUGMSG("MMSGUI", "Reusing already loaded image path=%s, name=%s", path.c_str(), filename.c_str());
00159 this->images.at(i)->usecount++;
00160 if (surfdesc)
00161 *surfdesc = this->images.at(i)->suf;
00162 this->lock.unlock();
00163 return this->images.at(i)->suf[0].surface;
00164 }
00165 }
00166 }
00167
00168
00169 im_desc = new MMSIM_DESC;
00170 memset(im_desc->suf, 0, sizeof(im_desc->suf));
00171 im_desc->suf[0].delaytime = im_desc->suf[1].delaytime = MMSIM_DESC_SUF_END;
00172 im_desc->sufcount = 0;
00173 im_desc->loading = false;
00174
00175 DEBUGMSG("MMSGUI", "Loading image path=%s, name=%s", path.c_str(), filename.c_str());
00176
00177
00178 if (isGIF(imagefile)) {
00179
00180 im_desc->imagefile = imagefile;
00181
00182 if (reload_image < 0) {
00183
00184 struct stat statbuf;
00185 if (stat(imagefile.c_str(), &statbuf)==0)
00186 im_desc->mtime = statbuf.st_mtime;
00187 else
00188 im_desc->mtime = 0;
00189 }
00190
00191 if (reload_image < 0) {
00192
00193 MMSGIFLoader *gifloader = new MMSGIFLoader(im_desc, this->layer);
00194 gifloader->start();
00195 gifloader->block();
00196
00197 if (im_desc->sufcount > 0) {
00198 DEBUGMSG("MMSGUI", "ImageManager has loaded: '%s'", imagefile.c_str());
00199
00200
00201 im_desc->usecount = 1;
00202 this->images.push_back(im_desc);
00203 if (surfdesc)
00204 *surfdesc = this->images.at(this->images.size()-1)->suf;
00205 this->lock.unlock();
00206 return im_desc->suf[0].surface;
00207 }
00208 else {
00209
00210 DEBUGMSG("MMSGUI", "cannot load image file '%s'",imagefile.c_str());
00211 delete im_desc;
00212 this->lock.unlock();
00213 return NULL;
00214 }
00215 }
00216 else {
00217
00218 this->images.at(reload_image)->usecount++;
00219
00220
00221 delete im_desc;
00222 if (surfdesc)
00223 *surfdesc = this->images.at(reload_image)->suf;
00224 this->lock.unlock();
00225 return this->images.at(reload_image)->suf[0].surface;
00226 }
00227 }
00228 else {
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238 if (this->usetaff) {
00239
00240
00241
00242
00243 bool retry = false;
00244 MMSTaffFile *tafff = NULL;
00245 do {
00246 if (retry) {
00247 retry = false;
00248 DEBUGMSG("MMSGUI", "ImageManager, retry");
00249
00250
00251 if (gen_taff) {
00252
00253 tafff = new MMSTaffFile(imagefile + ".taff", NULL,
00254 "", MMSTAFF_EXTERNAL_TYPE_IMAGE);
00255 }
00256 else {
00257
00258 tafff = new MMSTaffFile("", NULL,
00259 "", MMSTAFF_EXTERNAL_TYPE_IMAGE,
00260 false, false, false, true, false);
00261 }
00262
00263 if (tafff) {
00264
00265 tafff->setExternal(imagefile, MMSTAFF_EXTERNAL_TYPE_IMAGE);
00266 DEBUGMSG("MMSGUI", "ImageManager, taffpf = %d", taffpf);
00267
00268 if (config.getGraphicsLayer().outputtype == MMSFB_OT_OGL) {
00269
00270 tafff->setDestinationPixelFormat(taffpf, false);
00271 }
00272 else {
00273
00274 tafff->setDestinationPixelFormat(taffpf, true);
00275 }
00276
00277
00278 tafff->setMirrorEffect(mirror_size);
00279
00280
00281 tafff->rotate180(MMSFBBase_rotate180);
00282
00283
00284 if (!tafff->convertExternal2TAFF()) {
00285
00286 delete tafff;
00287 tafff = NULL;
00288 break;
00289 }
00290
00291 if (gen_taff) {
00292
00293 delete tafff;
00294 tafff = NULL;
00295 }
00296 }
00297 }
00298
00299
00300 if (gen_taff) {
00301 tafff = new MMSTaffFile(imagefile + ".taff", NULL,
00302 imagefile, MMSTAFF_EXTERNAL_TYPE_IMAGE,
00303 false, false, false, false, false);
00304 }
00305 else {
00306 if (!tafff) {
00307 retry = true;
00308 continue;
00309 }
00310 }
00311 if (tafff) {
00312 if (!tafff->isLoaded()) {
00313
00314 tafff->setMirrorEffect(mirror_size);
00315
00316
00317 tafff->rotate180(MMSFBBase_rotate180);
00318
00319
00320 if (!tafff->convertExternal2TAFF()) {
00321
00322 delete tafff;
00323 break;
00324 }
00325 delete tafff;
00326 tafff = NULL;
00327
00328
00329 tafff = new MMSTaffFile(imagefile + ".taff", NULL,
00330 "", MMSTAFF_EXTERNAL_TYPE_IMAGE);
00331 }
00332 }
00333 if (tafff) {
00334 if (tafff->isLoaded()) {
00335
00336
00337 int attrid;
00338 char *value_str;
00339 int value_int;
00340 void *img_buf = NULL;
00341 int img_width = 0;
00342 int img_height= 0;
00343 int img_pitch = 0;
00344 int img_size = 0;
00345 MMSTAFF_PF img_pixelformat = MMSTAFF_PF_ARGB;
00346 bool img_premultiplied = true;
00347 int img_mirror_size = 0;
00348 bool img_alphachannel = true;
00349 bool img_rotate_180 = false;
00350
00351 while ((attrid=tafff->getNextAttribute(&value_str, &value_int, NULL))>=0) {
00352 switch (attrid) {
00353 case MMSTAFF_IMAGE_RAWIMAGE_ATTR::MMSTAFF_IMAGE_RAWIMAGE_ATTR_IDS_width:
00354 img_width = value_int;
00355 break;
00356 case MMSTAFF_IMAGE_RAWIMAGE_ATTR::MMSTAFF_IMAGE_RAWIMAGE_ATTR_IDS_height:
00357 img_height = value_int;
00358 break;
00359 case MMSTAFF_IMAGE_RAWIMAGE_ATTR::MMSTAFF_IMAGE_RAWIMAGE_ATTR_IDS_pitch:
00360 img_pitch = value_int;
00361 break;
00362 case MMSTAFF_IMAGE_RAWIMAGE_ATTR::MMSTAFF_IMAGE_RAWIMAGE_ATTR_IDS_size:
00363 img_size = value_int;
00364 break;
00365 case MMSTAFF_IMAGE_RAWIMAGE_ATTR::MMSTAFF_IMAGE_RAWIMAGE_ATTR_IDS_data:
00366 img_buf = value_str;
00367 break;
00368 case MMSTAFF_IMAGE_RAWIMAGE_ATTR::MMSTAFF_IMAGE_RAWIMAGE_ATTR_IDS_pixelformat:
00369 img_pixelformat = (MMSTAFF_PF)value_int;
00370 break;
00371 case MMSTAFF_IMAGE_RAWIMAGE_ATTR::MMSTAFF_IMAGE_RAWIMAGE_ATTR_IDS_premultiplied:
00372 img_premultiplied = (value_int);
00373 break;
00374 case MMSTAFF_IMAGE_RAWIMAGE_ATTR::MMSTAFF_IMAGE_RAWIMAGE_ATTR_IDS_mirror_size:
00375 img_mirror_size = value_int;
00376 break;
00377 case MMSTAFF_IMAGE_RAWIMAGE_ATTR::MMSTAFF_IMAGE_RAWIMAGE_ATTR_IDS_alphachannel:
00378 img_alphachannel = (value_int);
00379 break;
00380 case MMSTAFF_IMAGE_RAWIMAGE_ATTR::MMSTAFF_IMAGE_RAWIMAGE_ATTR_IDS_rotate_180:
00381 img_rotate_180 = (value_int);
00382 break;
00383 }
00384 }
00385
00386 if (img_pixelformat != taffpf) {
00387 DEBUGMSG("MMSGUI", "ImageManager, taffpf = %d", (int)taffpf);
00388
00389 if (!retry) {
00390
00391 DEBUGMSG("MMSGUI", "ImageManager, request new pixf");
00392 retry = true;
00393 delete tafff;
00394 continue;
00395 }
00396 else
00397 retry = false;
00398 }
00399 else
00400 if (img_mirror_size != mirror_size) {
00401 DEBUGMSG("MMSGUI", "ImageManager, mirror_size = %d", (int)mirror_size);
00402
00403 if (!retry) {
00404
00405 DEBUGMSG("MMSGUI", "ImageManager, request new mirror_size");
00406 retry = true;
00407 delete tafff;
00408 continue;
00409 }
00410 else
00411 retry = false;
00412 }
00413 else
00414 if (img_premultiplied && (config.getGraphicsLayer().outputtype == MMSFB_OT_OGL)) {
00415 DEBUGMSG("MMSGUI", "ImageManager, premultiplied image");
00416
00417 if (!retry) {
00418
00419 DEBUGMSG("MMSGUI", "ImageManager, retry without pre-multiplication");
00420 retry = true;
00421 delete tafff;
00422 continue;
00423 }
00424 else
00425 retry = false;
00426 }
00427 else
00428 if (!img_premultiplied && (config.getGraphicsLayer().outputtype != MMSFB_OT_OGL)) {
00429 DEBUGMSG("MMSGUI", "ImageManager, image not premultiplied");
00430
00431 if (!retry) {
00432
00433 DEBUGMSG("MMSGUI", "ImageManager, retry with pre-multiplication");
00434 retry = true;
00435 delete tafff;
00436 continue;
00437 }
00438 else
00439 retry = false;
00440 }
00441 else
00442 if (img_rotate_180 && !MMSFBBase_rotate180) {
00443 DEBUGMSG("MMSGUI", "ImageManager, taff image is rotated by 180 degree, but NOT requested");
00444 if (!retry) {
00445
00446 DEBUGMSG("MMSGUI", "ImageManager, reset rotation");
00447 retry = true;
00448 delete tafff;
00449 continue;
00450 }
00451 else
00452 retry = false;
00453 }
00454 else
00455 if (!img_rotate_180 && MMSFBBase_rotate180) {
00456 DEBUGMSG("MMSGUI", "ImageManager, taff image is NOT rotated by 180 degree, but requested");
00457 if (!retry) {
00458
00459 DEBUGMSG("MMSGUI", "ImageManager, rotate 180 degree");
00460 retry = true;
00461 delete tafff;
00462 continue;
00463 }
00464 else
00465 retry = false;
00466 }
00467 else
00468 if ((img_width)&&(img_height)&&(img_pitch)&&(img_size)&&(img_buf)) {
00469
00470
00471 im_desc->imagefile = imagefile;
00472
00473 if (reload_image < 0) {
00474
00475 struct stat statbuf;
00476 if (stat(imagefile.c_str(), &statbuf)==0)
00477 im_desc->mtime = statbuf.st_mtime;
00478 else
00479 im_desc->mtime = 0;
00480 }
00481
00482 if (reload_image < 0) {
00483
00484
00485 if (!this->layer->createSurface(&(im_desc->suf[0].surface), img_width, img_height, this->pixelformat)) {
00486 DEBUGMSG("MMSGUI", "cannot create surface for image file '%s'", imagefile.c_str());
00487 delete im_desc;
00488 this->lock.unlock();
00489 return NULL;
00490 }
00491 im_desc->sufcount = 1;
00492
00493
00494 im_desc->suf[0].surface->blitBuffer(img_buf, img_pitch, this->pixelformat,
00495 img_width, img_height, NULL, 0, 0,
00496 !img_alphachannel);
00497
00498
00499 delete tafff;
00500 tafff = NULL;
00501
00502 DEBUGMSG("MMSGUI", "ImageManager has loaded: '%s'", imagefile.c_str());
00503
00504
00505 im_desc->usecount = 1;
00506 this->images.push_back(im_desc);
00507 if (surfdesc)
00508 *surfdesc = this->images.at(this->images.size()-1)->suf;
00509 this->lock.unlock();
00510 return im_desc->suf[0].surface;
00511 }
00512 else {
00513
00514 this->images.at(reload_image)->usecount++;
00515
00516
00517 int w, h;
00518 this->images.at(reload_image)->suf[0].surface->getSize(&w, &h);
00519 if ((w != img_width) || (h != img_height))
00520 this->images.at(reload_image)->suf[0].surface->resize(img_width, img_height);
00521
00522
00523 char *suf_ptr;
00524 int suf_pitch;
00525 im_desc->suf[0].surface->lock(MMSFB_LOCK_WRITE, (void**)&suf_ptr, &suf_pitch);
00526
00527 if (img_pitch == suf_pitch)
00528
00529 memcpy(suf_ptr, img_buf, img_pitch * img_height);
00530 else {
00531
00532 char *img_b = (char*)img_buf;
00533 for (int i = 0; i < img_height; i++) {
00534 memcpy(suf_ptr, img_b, img_pitch);
00535 suf_ptr+=suf_pitch;
00536 img_b+=img_pitch;
00537 }
00538 }
00539 im_desc->suf[0].surface->unlock();
00540
00541
00542 delete tafff;
00543 tafff = NULL;
00544
00545 DEBUGMSG("MMSGUI", "ImageManager has reloaded: '%s'", imagefile.c_str());
00546
00547
00548 delete im_desc;
00549 if (surfdesc)
00550 *surfdesc = this->images.at(reload_image)->suf;
00551 this->lock.unlock();
00552 return this->images.at(reload_image)->suf[0].surface;
00553 }
00554 }
00555 }
00556
00557
00558 delete tafff;
00559 tafff = NULL;
00560 }
00561 } while (retry);
00562 }
00563
00564
00565 #ifdef __HAVE_DIRECTFB__
00566 IDirectFBImageProvider *imageprovider = NULL;
00567 DFBSurfaceDescription surface_desc;
00568
00569
00570 if (!loadImage(&imageprovider, "", imagefile)) {
00571 DEBUGMSG("MMSGUI", "cannot load image file '%s'", imagefile.c_str());
00572 if (reload_image < 0) {
00573 delete im_desc;
00574 this->lock.unlock();
00575 return NULL;
00576 }
00577 else {
00578 this->images.at(reload_image)->usecount++;
00579 delete im_desc;
00580 if (surfdesc)
00581 *surfdesc = this->images.at(reload_image)->suf;
00582 this->lock.unlock();
00583 return this->images.at(reload_image)->suf[0].surface;
00584 }
00585 }
00586 im_desc->imagefile = imagefile;
00587
00588 if (reload_image < 0) {
00589
00590 struct stat statbuf;
00591 if (stat(imagefile.c_str(), &statbuf)==0)
00592 im_desc->mtime = statbuf.st_mtime;
00593 else
00594 im_desc->mtime = 0;
00595 }
00596
00597
00598
00599 if (imageprovider->GetSurfaceDescription(imageprovider, &surface_desc)!=DFB_OK) {
00600
00601 imageprovider->Release(imageprovider);
00602 DEBUGMSG("MMSGUI", "cannot read surface desciption from image file '%s'", imagefile.c_str());
00603 if (reload_image < 0) {
00604 delete im_desc;
00605 this->lock.unlock();
00606 return NULL;
00607 }
00608 else {
00609 this->images.at(reload_image)->usecount++;
00610 delete im_desc;
00611 if (surfdesc)
00612 *surfdesc = this->images.at(reload_image)->suf;
00613 this->lock.unlock();
00614 return this->images.at(reload_image)->suf[0].surface;
00615 }
00616 }
00617
00618 if (reload_image < 0) {
00619
00620 if (!this->layer->createSurface(&(im_desc->suf[0].surface), surface_desc.width, surface_desc.height, this->pixelformat)) {
00621
00622 imageprovider->Release(imageprovider);
00623 DEBUGMSG("MMSGUI", "cannot create surface for image file '%s'", imagefile.c_str());
00624 delete im_desc;
00625 this->lock.unlock();
00626 return NULL;
00627 }
00628 im_desc->sufcount = 1;
00629
00630
00631 if (!im_desc->suf[0].surface->getDFBSurface()) {
00632
00633 imageprovider->Release(imageprovider);
00634 delete im_desc->suf[0].surface;
00635 DEBUGMSG("MMSGUI", "cannot render image file '%s' because it is not a DFB surface", imagefile.c_str());
00636 delete im_desc;
00637 this->lock.unlock();
00638 return NULL;
00639 }
00640
00641
00642 if (imageprovider->RenderTo(imageprovider, (IDirectFBSurface *)im_desc->suf[0].surface->getDFBSurface(), NULL)!=DFB_OK) {
00643
00644 imageprovider->Release(imageprovider);
00645 delete im_desc->suf[0].surface;
00646 DEBUGMSG("MMSGUI", "cannot render image file '%s'", imagefile.c_str());
00647 delete im_desc;
00648 this->lock.unlock();
00649 return NULL;
00650 }
00651
00652
00653 imageprovider->Release(imageprovider);
00654
00655
00656
00657
00658
00659
00660 DEBUGMSG("MMSGUI", "ImageManager has loaded: '%s'", imagefile.c_str());
00661
00662
00663 im_desc->usecount = 1;
00664 this->images.push_back(im_desc);
00665 if (surfdesc)
00666 *surfdesc = this->images.at(this->images.size()-1)->suf;
00667 this->lock.unlock();
00668 return im_desc->suf[0].surface;
00669 }
00670 else {
00671
00672 this->images.at(reload_image)->usecount++;
00673
00674
00675 int w, h;
00676 this->images.at(reload_image)->suf[0].surface->getSize(&w, &h);
00677 if ((w != surface_desc.width) || (h != surface_desc.height))
00678 this->images.at(reload_image)->suf[0].surface->resize(surface_desc.width, surface_desc.height);
00679
00680
00681 if (imageprovider->RenderTo(imageprovider, (IDirectFBSurface *)this->images.at(reload_image)->suf[0].surface->getDFBSurface(), NULL)!=DFB_OK) {
00682
00683 imageprovider->Release(imageprovider);
00684 DEBUGMSG("MMSGUI", "cannot render image file '%s'", imagefile.c_str());
00685 delete im_desc;
00686 if (surfdesc)
00687 *surfdesc = this->images.at(reload_image)->suf;
00688 this->lock.unlock();
00689 return this->images.at(reload_image)->suf[0].surface;
00690 }
00691
00692
00693 imageprovider->Release(imageprovider);
00694
00695 DEBUGMSG("MMSGUI", "ImageManager has reloaded: '%s'", imagefile.c_str());
00696
00697
00698 delete im_desc;
00699 if (surfdesc)
00700 *surfdesc = this->images.at(reload_image)->suf;
00701 this->lock.unlock();
00702 return this->images.at(reload_image)->suf[0].surface;
00703 }
00704 #endif
00705 }
00706
00707 this->lock.unlock();
00708 return NULL;
00709 }
00710
00711 MMSFBSurface *MMSImageManager::newImage(const string &name, unsigned int width, unsigned int height, MMSFBSurfacePixelFormat pixelformat) {
00712
00713 MMSIM_DESC *im_desc = NULL;
00714
00715
00716
00717 this->lock.lock();
00718
00719 if (name != "") {
00720
00721 for (unsigned int i = 0; i < this->images.size(); i++) {
00722 if (this->images.at(i)->name == name) {
00723
00724 this->images.at(i)->usecount++;
00725 this->lock.unlock();
00726 return this->images.at(i)->suf[0].surface;
00727 }
00728 }
00729 }
00730
00731
00732 im_desc = new MMSIM_DESC;
00733 memset(im_desc->suf, 0, sizeof(im_desc->suf));
00734 im_desc->suf[0].delaytime = im_desc->suf[1].delaytime = MMSIM_DESC_SUF_END;
00735 im_desc->sufcount = 0;
00736 im_desc->loading = false;
00737
00738 im_desc->name = name;
00739
00740
00741
00742
00743
00744
00745
00746 if (!this->layer->createSurface(&(im_desc->suf[0].surface), width, height, (pixelformat==MMSFB_PF_NONE)?this->pixelformat:pixelformat)) {
00747 this->lock.unlock();
00748 return NULL;
00749 }
00750 im_desc->sufcount = 1;
00751 im_desc->imagefile = "";
00752
00753
00754 im_desc->usecount = 1;
00755 this->images.push_back(im_desc);
00756 this->lock.unlock();
00757 return im_desc->suf[0].surface;
00758 }
00759
00760 void MMSImageManager::releaseImage(const string &path, const string &filename) {
00761 string imagefile;
00762
00763
00764 imagefile = path;
00765 if (imagefile != "") imagefile+= "/";
00766 imagefile += filename;
00767 if (imagefile == "")
00768 return;
00769 if (imagefile.substr(imagefile.size()-1,1)=="/")
00770 return;
00771
00772
00773 this->lock.lock();
00774
00775
00776 for (unsigned int i = 0; i < this->images.size(); i++) {
00777 if (this->images.at(i)->imagefile == imagefile) {
00778
00779 this->images.at(i)->usecount--;
00780 if (this->images.at(i)->usecount <= 0) {
00781
00782 DEBUGMSG("MMSGUI", "ImageManager deletes: '%s'", this->images.at(i)->imagefile.c_str());
00783
00784 for (int j = 0; j < this->images.at(i)->sufcount; j++)
00785 if (this->images.at(i)->suf[j].surface)
00786 delete this->images.at(i)->suf[j].surface;
00787
00788 delete this->images.at(i);
00789 this->images.erase(this->images.begin()+i);
00790 break;
00791 }
00792 }
00793 }
00794
00795 this->lock.unlock();
00796 }
00797
00798 void MMSImageManager::releaseImage(MMSFBSurface *surface) {
00799
00800 if (!surface) return;
00801
00802
00803 this->lock.lock();
00804
00805
00806 for (unsigned int i = 0; i < this->images.size(); i++) {
00807 if (this->images.at(i)->suf[0].surface == surface) {
00808
00809 this->images.at(i)->usecount--;
00810 if (this->images.at(i)->usecount <= 0) {
00811
00812 DEBUGMSG("MMSGUI", "ImageManager deletes: '%s'", this->images.at(i)->imagefile.c_str());
00813
00814
00815
00816 for (int j = 0; j < this->images.at(i)->sufcount; j++)
00817 if (this->images.at(i)->suf[j].surface)
00818 delete this->images.at(i)->suf[j].surface;
00819
00820 delete this->images.at(i);
00821 this->images.erase(this->images.begin()+i);
00822 break;
00823 }
00824 }
00825 }
00826
00827 this->lock.unlock();
00828 }
00829