provider_bmp.cpp Source File

00001 /*
00002         $Id: provider_bmp.cpp,v 1.2 2001/03/13 21:43:01 sphair Exp $
00003 
00004         ------------------------------------------------------------------------
00005         ClanLib, the platform independent game SDK.
00006 
00007         This library is distributed under the GNU LIBRARY GENERAL PUBLIC LICENSE
00008         version 2. See COPYING for details.
00009 
00010         For a total list of contributers see CREDITS.
00011 
00012         ------------------------------------------------------------------------
00013 
00014         File purpose:
00015                 BMP SurfaceProvider
00016 */
00017 #include "Core/precomp.h"
00018 #include <iostream>
00019 #ifdef WIN32
00020         #define WIN32_LEAN_AND_MEAN
00021         #include <windows.h>
00022 #endif
00023 #include "API/Display/Display/pixelformat.h"
00024 #include "API/Display/Display/palette.h"
00025 #include "API/Core/IOData/inputsource.h"
00026 #include "API/Core/IOData/inputsource_provider.h"
00027 #include "API/Display/SurfaceProviders/provider_bmp.h"
00028 #include "API/Core/System/error.h" 
00029 #include "API/Core/System/cl_assert.h"
00030 #include "API/Display/Display/res_surface.h"
00031 #include "API/Core/Resources/resourceoptions.h"
00032 
00033 CL_Surface *CL_BMPProvider::create(
00034         std::string handle, 
00035         CL_InputSourceProvider *provider, 
00036         bool transparent, 
00037         short trans_col)
00038 {
00039         return CL_Surface::create(new CL_BMPProvider(
00040                 handle, 
00041                 provider, 
00042                 transparent, 
00043                 trans_col), true);
00044 }
00045 
00046 CL_BMPProvider::CL_BMPProvider(
00047         std::string _name, 
00048         CL_InputSourceProvider *_provider, 
00049         bool _transparent, 
00050         short _trans_col)
00051 {
00052         provider = _provider != NULL ? _provider->clone() : 
00053                                                                 CL_InputSourceProvider::create_file_provider(".");
00054 //      width = height = 0;
00055         //bounding_left = bounding_top = bounding_right = bounding_bottom = 0;
00056         
00057         transparent = _transparent;
00058         if (!transparent) trans_col = -1;
00059         else trans_col = _trans_col;
00060         
00061         name = _name;
00062         palette = NULL;
00063         image = NULL;
00064 //      pixelformat = PAL8;
00065 }
00066 
00067 CL_BMPProvider::~CL_BMPProvider()
00068 {
00069         perform_unlock();
00070         delete provider;
00071 }
00072 /*
00073 EPixelFormat CL_BMPProvider::get_pixel_format() const
00074 {
00075         return pixelformat;
00076 }
00077 */
00078 
00079 unsigned int CL_BMPProvider::get_depth() const
00080 {
00081         if (biBitCount==24)
00082                 return 32;
00083         else if (biBitCount==8)
00084                 return 8;
00085         else
00086                 return ~0;
00087 }
00088 
00089 unsigned int CL_BMPProvider::get_pitch() const
00090 {       
00091         if (biBitCount==24)
00092                 return 4*get_width();
00093         
00094         else if (biBitCount==8)
00095                 return get_width();
00096 
00097         else
00098                 return ~0;
00099 
00100 }
00101 
00102 unsigned int CL_BMPProvider::get_red_mask() const
00103 {
00104 
00105         return 0xff000000;
00106         //return Rmask;
00107 }
00108 
00109 unsigned int CL_BMPProvider::get_green_mask() const
00110 {
00111         return 0x00ff0000;
00112         //return Gmask;
00113 }
00114 
00115 unsigned int CL_BMPProvider::get_blue_mask() const
00116 {
00117         return 0x0000ff00;
00118         //return Bmask;
00119 }
00120 
00121 unsigned int CL_BMPProvider::get_alpha_mask() const
00122 {
00123         return 0x000000ff;
00124 }
00125 
00126 void CL_BMPProvider::perform_lock()
00127 {
00128         if (image != NULL) return;
00129 
00130         cl_assert(provider != NULL);
00131         CL_InputSource *datafile = provider->open_source(name.c_str());
00132         cl_assert(datafile != NULL);
00133 
00134 
00135 // ---------------- read the bmp headers ---------
00136         magic[0] = datafile->read_char8();
00137         magic[1] = datafile->read_char8();
00138 
00139         if ( (magic[0] != 'B') && (magic[1] != 'M') )
00140                 std::cout << std::endl << "File is not a Windows BMP file(DIB)" << std::endl;
00141 
00142         bfSize          = datafile->read_uint32();//SDL_ReadLE32(src);
00143         bfReserved1     = datafile->read_ushort16();//SDL_ReadLE16(src);
00144         bfReserved2     = datafile->read_ushort16();//SDL_ReadLE16(src);
00145         bfOffBits       = datafile->read_uint32();//SDL_ReadLE32(src);
00146 
00147         /* Read the Win32 BITMAPINFOHEADER */
00148         biSize          = datafile->read_uint32();//SDL_ReadLE32(src);
00149         biWidth                 = datafile->read_int32();//SDL_ReadLE32(src);
00150         biHeight                = datafile->read_int32();//SDL_ReadLE32(src);
00151         biPlanes                = datafile->read_ushort16();//SDL_ReadLE16(src);
00152         biBitCount              = datafile->read_ushort16();//SDL_ReadLE16(src);
00153         biCompression   = datafile->read_uint32();//SDL_ReadLE32(src);
00154         biSizeImage             = datafile->read_uint32();//SDL_ReadLE32(src);
00155         biXPelsPerMeter = datafile->read_int32();//SDL_ReadLE32(src);
00156         biYPelsPerMeter = datafile->read_int32();//SDL_ReadLE32(src);
00157         biClrUsed               = datafile->read_uint32();//SDL_ReadLE32(src);
00158         biClrImportant  = datafile->read_uint32();//SDL_ReadLE32(src);
00159         
00160         if(biSize!=40)
00161                 std::cout << std::endl << "This BMP file are in a old format. Please update this BMP file to BMP(DIB) version 3.0,";
00162 
00163         std::cout << std::endl
00164                 << "bfSize = " << bfSize << std::endl
00165                 << "bfReserved1 = " << bfReserved1 << std::endl
00166                 << "bfReserved2 = " << bfReserved2 << std::endl
00167                 << "bfOffBits = " << bfOffBits << std::endl
00168                 << "biWidth = " << biWidth << std::endl
00169                 << "biHeight = " << biHeight << std::endl
00170                 << "biPlanes = " << biPlanes << std::endl
00171                 << "biBitCount = " << biBitCount << std::endl
00172                 << "biCompression = " << biCompression << std::endl
00173                 << "biSizeImage = " << biSizeImage << std::endl
00174                 << "biXPelsPerMeter = " << biXPelsPerMeter << std::endl
00175                 << "biYPelsPerMeter = " << biYPelsPerMeter << std::endl
00176                 << "biClrUsed = " << biClrUsed << std::endl
00177                 << "biClrImportant = " << biClrImportant << std::endl;
00178 // --(end)--------- read the bmp headers ---------              
00179 
00180 
00181 
00182         if ( (biBitCount==8) || (biBitCount==16) || (biBitCount==24) )
00183                 //this is supported
00184                 ;
00185 
00186         else
00187         {
00188                 throw CL_Error("We only support 8, 16 or 24 bpp.");
00189         }
00190 
00191 
00192 
00193 
00194 
00195 
00196         /* Load the palette, if any */
00197         if (biBitCount==8)
00198         {
00199                 if(biClrUsed==0)//ofcouse there is some colors use !! ;-)
00200                         biClrUsed=256;
00201                 
00202                 unsigned char *pal = new unsigned char[(biClrUsed*3)];
00203                 
00204                 int i = 0;
00205 
00206                 for (;;)
00207                 {
00208                         //std::cout << "pal[i] = " << i;
00209                         
00210                         pal[i+2] = datafile->read_uchar8();
00211                                                 
00212                         //std::cout << "pal[i] = " << i;
00213                         
00214                         pal[i+1] = datafile->read_uchar8();
00215                         
00216                         //std::cout << "pal[i] = " << i;
00217                         
00218                         pal[i] = datafile->read_uchar8();
00219 
00220                         i+=3;
00221                         //std::cout << std::endl;
00222                         
00223                         
00224                         // read the unused space in palette
00225                         datafile->read_uchar8();
00226                         
00227                         // Break if finish reading palette.
00228                         if ( ((int)biClrUsed*3) <= i)
00229                                 break;
00230                 }
00231         
00232                 //set new palette
00233                 palette = new CL_Palette(pal, biClrUsed);       
00234         
00235         }
00236 
00237         else
00238         {
00239                 palette = NULL;
00240         }
00241         
00242 
00243 
00244 //---------- load 8bpp - BI_RGB encoding ----------------------
00245 
00246         
00247         if ( (biBitCount==8) && (biCompression==BI_RGB) )
00248         {
00249                 image = new unsigned char[biSizeImage];
00250         
00251                 cl_assert(image != NULL);
00252 
00253                 for (int y=biHeight-1; y>-1; y--)
00254                 //for (int y=0; y<biHeight; y++)
00255                 {
00256                         //for (int x=biWidth-1; x>-1; x--)
00257                         for (int x=0; x<biWidth; x++)
00258                         {
00259                                 image[(x+y*biHeight)] = datafile->read_uchar8(); 
00260                         }
00261                 }
00262         
00263 
00264         }
00265 //--(end)--- load 8bpp - BI_RGB encoding ----------------------
00266 
00267 
00268 //---------- load 8bpp - BI_RLE8 encoding ----------------------
00269         
00270         if ( (biBitCount==8) && (biCompression==BI_RLE8) )
00271         {
00272                 image = new unsigned char[biWidth*biHeight];
00273 
00274                 cl_assert(image != NULL);
00275                 
00276                 //unsigned char value1=0;
00277                 //unsigned char value2=0;
00278 /*
00279                 int byte1=0;
00280                 int byte2=0;
00281 
00282                 unsigned char color=5;
00283                 int num_pixels=0;
00284 
00285                 //bool need_input = true;
00286                 //byte1 = datafile->read_uchar8();
00287                 //byte2 = datafile->read_uchar8();
00288                 int mode=0;//1= encode, 2= absolute
00289                 
00290                 for (int y=biHeight-1; y>-1; y--)
00291                 {
00292                         for (int x=0; x<biWidth; x++)
00293                         {
00294                                 std::cout << std::endl << "num_pixels = " << num_pixels; 
00295                                 std::cout << std::endl << "color = " << (int)color; 
00296 
00297                                 //are we finish writing pixels we know ?, if so lets get some more.
00298                                 if(num_pixels<=0)
00299                                 {
00300                                         if(mode ==2)//read out the unuse byte
00301                                                 datafile->read_uchar8();
00302 
00303                                         byte1 = (int)datafile->read_uchar8();
00304                                         byte2 = (int)datafile->read_uchar8();
00305                                 
00306                                         // Absolute mode.
00307                                         if( (byte1 == 0) && ( !(byte2==0) || !(byte2==1) || !(byte2==2) ) )
00308                                         {
00309                                                 num_pixels = byte2;
00310                                                 mode = 2;
00311                                         
00312                                         }// end -- Absolute mode.
00313                                         // Encoded mode
00314                                         else
00315                                         {
00316                                                 mode = 1;
00317 
00318                                                 if(byte1 == 0)
00319                                                 {
00320                                                         switch(byte2)
00321                                                         {
00322                                                         case 0://End of line.
00323                                                                 num_pixels = (biWidth-x);
00324                                                                 break;
00325                                                                         
00326                                                         case 1://End of bitmap.
00327                                                                 num_pixels = (biWidth-x)*(y-biHeight);
00328                                                                 break;
00329 
00330                                                         case 2://Delta. The two bytes following the escape contain unsigned values indicating the horizontal and vertical offsets of the next pixel from the current position.
00331                                                                 int dummy_x = (int)datafile->read_uchar8();
00332                                                                 int dummy_y = (int)datafile->read_uchar8();
00333                                                                 
00334                                                                 num_pixels = (int)((biWidth+dummy_x)*(biHeight-dummy_y));
00335                                                                 break;
00336                                                         }
00337                                                 }
00338                                                 else
00339                                                 {
00340                                                         num_pixels = byte1;
00341                                                         color      = (unsigned char)byte2;
00342                                                 }
00343 
00344 
00345                                         }// end -- Encoded mode
00346 
00347                                 
00348                                         //write pixel
00349                                         if(mode==1)//encoded
00350                                         {
00351                                                 //color = datafile->read_uchar8();
00352                                                 image[(x+y*biHeight)] = color;
00353 
00354                                                 num_pixels--;
00355                                         }
00356                                         else if(mode==2)//absolute
00357                                         {
00358                                                 color = datafile->read_uchar8();
00359                                                 image[(x+y*biHeight)] = color;
00360 
00361                                                 num_pixels--;
00362 
00363                                         }
00364                                 
00365                                 }
00366                                 
00367                                 
00368 
00369                                 
00370                                 
00371                         }
00372                 }
00373         }
00374 */      
00375 
00376                 unsigned char value1=0;
00377                 unsigned char value2=0;
00378 
00379                 unsigned char color=5;
00380                 unsigned char num_pixels=0;
00381 
00382                 //bool need_input = true;
00383                 //byte1 = datafile->read_uchar8();
00384                 //byte2 = datafile->read_uchar8();
00385 //              int mode=0;//1= encode, 2= absolute
00386         
00387                 int x=0;
00388                 int y=0/*biHeight*/;
00389 
00390 
00391                 for (;;)
00392                 {
00393                 
00394 
00395                         // Absolute mode.
00396                         if( (value1 == 0) && !(value2==0 || value2==1 || value2==2) )
00397                         {
00398                                 for     (int i=0; i < value2; i++)
00399                                 {
00400                                         if(x >= biWidth)
00401                                         {
00402                                                 x=0;
00403                                                 //y--;
00404                                                 y++;
00405                                         }
00406                                         color = datafile->read_uchar8();
00407                                                                                 
00408                                         image[(x+y*biWidth)] = color;
00409                                         x++;            
00410                                         
00411                                 }
00412                                 //read out the unuse byte
00413                                 datafile->read_uchar8();
00414                                 //datafile->read_ushort16();
00415 
00416                         }// end -- Absolute mode.
00417                         // Encoded mode
00418                         else
00419                         {
00420                                 if(value1 == 0)
00421                                 {
00422                                         switch(value2)
00423                                         {
00424                                         case 0://End of line.
00425                                                 for (; x<biWidth; x++)
00426                                                         image[(x+y*biWidth)] = color;
00427                                                 break;
00428                                                         
00429                                         case 1://End of bitmap.
00430                                                 //for (;  y>-1; y--)
00431                                                 for (; y<biHeight; y++)
00432                                                         for (; x<biWidth; x++)
00433                                                                 image[(x+y*biWidth)] = color;
00434                                                 break;
00435 
00436                                         case 2://Delta. The two bytes following the escape contain unsigned values indicating the horizontal and vertical offsets of the next pixel from the current position.
00437                                                 value1 = datafile->read_uchar8();
00438                                                 value2 = datafile->read_uchar8();
00439 
00440                                                 x += value1;
00441                                                 y += value2;
00442                                         break;
00443                                         }
00444                                 }
00445                                 
00446                                 else
00447                                 {
00448                                         num_pixels = value1;
00449                                         color      = value2;
00450 
00451                                         for(int i = 0; i < num_pixels;i++)
00452                                         {
00453                                                 if(x >= biWidth)
00454                                                 {
00455                                                         x=0;
00456                                                         y++;
00457                                                 }
00458                                                 image[(x+y*biWidth)] = color;
00459                                                 x++;    
00460                                                                                                 
00461                                         }
00462                                 }
00463 
00464 
00465                         }// end -- Encoded mode
00466 
00467         
00468 
00469                         
00470                         // If we are finish reading the bitmap, then exit.
00471                         //if( (x+y*biWidth) >= (biWidth*biHeight) )
00472                         if ( (y==biHeight)/*(y==-1)*/ && (x==biWidth) )
00473                                 break;
00474 
00475                         if(x >= biWidth)
00476                         {
00477                                 x=0;
00478                                 y++;
00479                         }
00480         
00481                         
00482                 }
00483 
00484         }
00485 
00486 //--(end)--- load 8bpp - BI_RLE8 encoding ----------------------
00487 
00488 
00489 //---------- load 24bpp - BI_RGB encoding ----------------------
00490 
00491         //stored in BGR
00492         if ( (biBitCount==24) && (biCompression==BI_RGB) )
00493         {
00494                 image = new unsigned char[biWidth*biHeight*4];
00495         
00496                 cl_assert(image != NULL);
00497 
00498                 for (int y=biHeight-1; y>-1; y--)
00499                 //for (int y=0; y<biHeight; y++)
00500                 {
00501                         //for (int x=biWidth-1; x>-1; x--)
00502                         for (int x=0; x<biWidth; x++)
00503                         {
00504                                 image[(x+y*biWidth)*4 + 0] = 255;/*datafile->read_uchar8();*/ // alpha component of pixel
00505                                 image[(x+y*biWidth)*4 + 1] = datafile->read_uchar8(); // blue component
00506                                 image[(x+y*biWidth)*4 + 2] = datafile->read_uchar8(); // green component
00507                                 image[(x+y*biWidth)*4 + 3] = datafile->read_uchar8(); // red component
00508                         }
00509                 }
00510         
00511         }
00512 //--(end)--- load 24bpp - BI_RGB encoding ----------------------
00513 
00514 
00515 
00516 
00517                 /* If there are no masks, use the defaults */
00518         //      if ( bfOffBits == (2+biSize) )
00519         //      {
00520                 /* Default values for the BMP format */
00521 /*              switch (biBitCount)
00522                 {
00523                         case 15:
00524                         case 16:
00525                                 Rmask = 0x7C00;
00526                                 Gmask = 0x03E0;
00527                                 Bmask = 0x001F;
00528                                 break;
00529                         case 24:
00530                         case 32:
00531                                 Bmask = 0x00FF0000;
00532                                 Gmask = 0x0000FF00;
00533                                 Rmask = 0x000000FF;
00534                                 break;
00535                         default:
00536                                 break;
00537                 }
00538                 break;
00539         //      }
00540         }
00541                         
00542 */
00543                 /* Fall through -- read the RGB masks */
00544 /*              case BI_BITFIELDS:
00545                         switch (biBitCount)
00546                         {
00547                                 case 15:
00548                                 case 16:
00549                                 case 24:
00550                                 case 32:
00551                                         Rmask = datafile->read_uint32();//SDL_ReadLE32(src);
00552                                         Gmask = datafile->read_uint32();//SDL_ReadLE32(src);
00553                                         Bmask = datafile->read_uint32();//SDL_ReadLE32(src);
00554                                         break;
00555                                 default:
00556                                         break;
00557                         }
00558                         break;
00559                 default:
00560                         std::cout << "Compressed BMP files not supported";
00561                         break;
00562         
00563         }
00564 
00565 
00566                         std::cout << std::endl << "Rmask = " << Rmask;
00567 
00568                         std::cout << std::endl << "Gmask = " << Gmask;
00569 
00570                         std::cout << std::endl << "Bmask = " << Bmask;
00571 
00572                         std::cout << std::endl << "biSize = " << biSize;
00573 
00574         // Create a compatible surface, note that the colors are RGB ordered
00575         surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
00576                         biWidth, biHeight, biBitCount, Rmask, Gmask, Bmask, 0);
00577         if ( surface == NULL )
00578         {
00579                 was_error = 1;
00580                 goto done;
00581         }
00582 */
00583 
00584 //---------- load 8bpp ------------------------------
00585         
00586 
00587 
00588 
00589 //---------- load 8bpp ------------------------------
00590 /*
00591                 std::cout << std::endl
00592                 << "bfSize = " << bfSize << std::endl
00593                 << "bfReserved1 = " << bfReserved1 << std::endl
00594                 << "bfReserved2 = " << bfReserved2 << std::endl
00595                 << "bfOffBits = " << bfOffBits << std::endl
00596                 << "biWidth = " << biWidth << std::endl
00597                 << "biHeight = " << biHeight << std::endl
00598                 << "biPlanes = " << biPlanes << std::endl
00599                 << "biBitCount = " << biBitCount << std::endl
00600                 << "biCompression = " << biCompression << std::endl
00601                 << "biSizeImage = " << biSizeImage << std::endl
00602                 << "biXPelsPerMeter = " << biXPelsPerMeter << std::endl
00603                 << "biYPelsPerMeter = " << biYPelsPerMeter << std::endl
00604                 << "biClrUsed = " << biClrUsed << std::endl
00605                 << "biClrImportant = " << biClrImportant << std::endl;
00606                 
00607 */
00608         /* Read the surface pixels.  Note that the bmp image is upside down */
00609 /*      if ( SDL_RWseek(src, fp_offset+bfOffBits, SEEK_SET) < 0 )
00610         {
00611                 SDL_Error(SDL_EFSEEK);
00612                 was_error = 1;
00613                 goto done;
00614         }
00615         bits = (Uint8 *)surface->pixels+(surface->h*surface->pitch);
00616         switch (ExpandBMP)
00617         {
00618                 case 1:
00619                 case 4:
00620                         pad  = (((surface->pitch/(8/ExpandBMP))%4) ?
00621                                 (4-((surface->pitch/(8/ExpandBMP))%4)) : 0);
00622                         break;
00623                 default:
00624                         pad  = ((surface->pitch%4) ?
00625                                         (4-(surface->pitch%4)) : 0);
00626                         break;
00627         }
00628         while ( bits > (Uint8 *)surface->pixels )
00629         {
00630                 bits -= surface->pitch;
00631                 switch (ExpandBMP) {
00632                         case 1:
00633                         case 4: {
00634                         Uint8 pixel = 0;
00635                         int   shift = (8-ExpandBMP);
00636                         for ( i=0; i<surface->w; ++i )
00637                         {
00638                                 if ( i%(8/ExpandBMP) == 0 ) {
00639                                         if ( !SDL_RWread(src, &pixel, 1, 1) ) {
00640                                                 SDL_SetError(
00641                                         "Error reading from BMP");
00642                                                 was_error = 1;
00643                                                 goto done;
00644                                         }
00645                                 }
00646                                 *(bits+i) = (pixel>>shift);
00647                                 pixel <<= ExpandBMP;
00648                         } }
00649                         break;
00650 
00651                         default:
00652                         if ( SDL_RWread(src, bits, 1, surface->pitch)
00653                                                          != surface->pitch ) {
00654                                 SDL_Error(SDL_EFREAD);
00655                                 was_error = 1;
00656                                 goto done;
00657                         }
00658                         break;
00659                 }
00660 */              /* Skip padding bytes, ugh */
00661 /*              if ( pad ) {
00662                         Uint8 padbyte;
00663                         for ( i=0; i<pad; ++i ) {
00664                                 SDL_RWread(src, &padbyte, 1, 1);
00665                         }
00666                 }
00667         }
00668 done:
00669         if ( was_error ) {
00670                 if ( surface ) {
00671                         SDL_FreeSurface(surface);
00672                 }
00673                 surface = NULL;
00674         }
00675         if ( freesrc && src ) {
00676                 SDL_RWclose(src);
00677         }
00678         return(surface);
00679 */
00681         
00683         
00684         
00685 //      pitch = width = biWidth;
00686 //      height = biHeight;
00687 
00688         //datafile->seek(4, CL_InputSource::seek_set);
00689         
00690 //      int bit_per_pixel = datafile->read_char8();
00691 //      int dest_num_planes = num_planes;
00692 /*
00693         switch (bit_per_pixel)
00694         {
00695         case 1: //1bit  (monochrome colors)
00696                 //pixelformat = ;
00697                 break;
00698         case 4: //4bit (16 colors)
00699                 //pixelformat = ;
00700                 break;
00701         case 8: //8bit (256 colors)
00702                 pixelformat = PAL8;
00703                 break;
00704         case 24: //24bit (2^24 colors)
00705                 //pixelformat = RGBA8888;
00706         //      dest_num_planes = 4;
00707                 break;
00708         default:
00709                 cl_assert(false);
00710                 break;
00711         }
00712 */
00713 //      image = new unsigned char[pitch*height/* *dest_num_planes */];
00714         
00715 
00716 
00717         
00718 /*      
00719         //swap the data
00720         for(int j=0;j<biSizeImage;j++)
00721         {
00722                 image[j] = swap[biSizeImage-j];
00723         }
00724 */
00725 //      int read = datafile->read(swap, biSizeImage);
00726 //      if (read != biSizeImage)
00727 //              throw CL_Error("Invalid BMP file!?");
00728 //      cl_assert(read == biSizeImage);
00729         
00730 
00731 
00732 
00733 //      for (int y=0;y<height;y++)
00734 //      {
00735 //              for (int x=0;x<get_width();x++)
00736 //              {
00737 //                              image[(x+y*height/*get_width()*/)/**4*/ + 0] = datafile->read_uchar8(); // alpha component of pixel
00738                         //      image[(x+y*get_width())/**4*/ + 1] =   x; // blue component
00739                         //      image[(x+y*get_width())/**4*/ + 2] =   y; // green component
00740                         //      image[(x+y*get_width())/**4*/ + 3] = x+y; // red component
00741 
00742 
00743 //              }
00744 //      }
00745 
00746         /*if (dest_num_planes == 4)
00747         {
00748                 memset(image, 255, pitch*height*dest_num_planes);
00749         }
00750 */
00751 //      datafile->seek(bfOffBits, CL_InputSource::seek_set);
00752 
00753         //int size_data = bfSize - bfOffBits;//datafile->size() - size_of_the_structure;
00754         
00755 //      unsigned char *temp = new unsigned char[biSizeImage];
00756         //int read = datafile->read(image, biSizeImage);
00757         //if (read != biSizeImage)
00758         //      throw CL_Error("Invalid BMP file!?");
00759         //cl_assert(read == biSizeImage);
00760         
00761         //delete datafile;
00762         
00763 //      unsigned char *p = temp;
00764 
00765 //      unsigned char *cur_line = image;
00766         /*
00767         for (int y=0;y<height;y++)
00768         {
00769                 for (int plane=0;plane<num_planes;plane++)
00770                 {
00771                         int x = 0;
00772                         while (x < pitch)
00773                         {
00774                                 unsigned char packed_byte = *(p++);
00775                                 if (packed_byte<192)
00776                                 {
00777                                         cur_line[(x*dest_num_planes)+plane] = packed_byte;
00778 
00779                                         if (transparent && packed_byte != trans_col)
00780                                         {
00781                                                 if (x < bounding_left) bounding_left = x;
00782                                                 if (y < bounding_top) bounding_top = y;
00783                                                 if (x > bounding_right) bounding_right = x;
00784                                                 if (y > bounding_bottom) bounding_bottom = y;
00785                                         }
00786                                         x++;
00787                                 }
00788                                 else 
00789                                 { 
00790                                         unsigned char counter = packed_byte&0x3f;
00791                                         packed_byte = *(p++);
00792                                         for(unsigned char j=0;j<counter;j++)
00793                                         {
00794                                                 cur_line[(x+j)*dest_num_planes+plane] = packed_byte;
00795                                                 if (transparent && packed_byte != trans_col)
00796                                                 {
00797                                                         if ((x+j) < bounding_left) bounding_left = x+j;
00798                                                         if (y < bounding_top) bounding_top = y;
00799                                                         if ((x+j) > bounding_right) bounding_right = x+j;
00800                                                         if (y > bounding_bottom) bounding_bottom = y;
00801                                                 }
00802                                         }
00803                                         x += counter;
00804                                 }
00805                         }
00806                 }
00807                 cur_line += dest_num_planes * pitch;
00808         }
00809 */
00810         
00811 //      if (bit_per_pixel == 8)
00812 //      {
00813         //      palette = new CL_Palette((image+biSizeImage-768));
00814 //      }
00815 
00816 //      else
00817 //      {
00818 //              palette = NULL;
00819 //      }
00820 
00821 //      delete[] temp;
00822 //      delete[] image;
00823         delete datafile;
00824 }
00825 
00826 void CL_BMPProvider::perform_unlock()
00827 {
00828         delete[] image;
00829         delete palette;
00830 
00831         image = NULL;
00832         palette = NULL;
00833 }