some != NULL checks

[wxWidgets.git] / src / common / imagbmp.cpp

diff --git a/src/common/imagbmp.cpp b/src/common/imagbmp.cpp
index 05796710b46bef413db56df10f98547f9fd40514..45169259e125bb96fb7d840a9539cfdbfc46c7f0 100644 (file)
--- a/src/common/imagbmp.cpp
+++ b/src/common/imagbmp.cpp
@@ -7,10 +7,9 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-/*
-   We don't put pragma implement in this file because it is already present in
-   src/common/image.cpp
-*/
+#ifdef __GNUG__
+#pragma implementation "imagbmp.h"
+#endif

 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"


@@ -19,7 +18,7 @@
 #pragma hdrstop
 #endif
 
 #pragma hdrstop
 #endif
 

-#include "wx/image.h"
+#include "wx/imagbmp.h"

 #include "wx/bitmap.h"
 #include "wx/debug.h"
 #include "wx/log.h"
 #include "wx/bitmap.h"
 #include "wx/debug.h"
 #include "wx/log.h"


@@ -46,9 +45,7 @@
 // wxBMPHandler
 //-----------------------------------------------------------------------------
 
 // wxBMPHandler
 //-----------------------------------------------------------------------------
 

-#if !USE_SHARED_LIBRARIES

 IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)
 IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)

-#endif

 
 #if wxUSE_STREAMS
 
 
 #if wxUSE_STREAMS
 


@@ -64,18 +61,18 @@ IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)
 
 #define poffset (line * width * 3 + column * 3)
 
 
 #define poffset (line * width * 3 + column * 3)
 

-bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
+bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) )

 {
     int             rshift = 0, gshift = 0, bshift = 0;
     wxUint8         aByte;
     wxUint16        aWord;
 {
     int             rshift = 0, gshift = 0, bshift = 0;
     wxUint8         aByte;
     wxUint16        aWord;

-    wxInt32         dbuf[4], aDword, 
+    wxInt32         dbuf[4], aDword,

                     rmask = 0, gmask = 0, bmask = 0;
     wxInt8          bbuf[4];
     struct _cmap {
         unsigned char r, g, b;
     } *cmap = NULL;
                     rmask = 0, gmask = 0, bmask = 0;
     wxInt8          bbuf[4];
     struct _cmap {
         unsigned char r, g, b;
     } *cmap = NULL;

-    
+

     off_t start_offset = stream.TellI();
 
     image->Destroy();
     off_t start_offset = stream.TellI();
 
     image->Destroy();


@@ -87,7 +84,9 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
     stream.Read( &bbuf, 2 );
     stream.Read( dbuf, 4 * 4 );
 
     stream.Read( &bbuf, 2 );
     stream.Read( dbuf, 4 * 4 );
 

+#if 0 // unused

     wxInt32 size = wxINT32_SWAP_ON_BE( dbuf[0] );
     wxInt32 size = wxINT32_SWAP_ON_BE( dbuf[0] );

+#endif

     wxInt32 offset = wxINT32_SWAP_ON_BE( dbuf[2] );
 
     stream.Read(dbuf, 4 * 2);
     wxInt32 offset = wxINT32_SWAP_ON_BE( dbuf[2] );
 
     stream.Read(dbuf, 4 * 2);


@@ -95,15 +94,17 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
     int height = (int)wxINT32_SWAP_ON_BE( dbuf[1] );
     if (width > 32767)
     {
     int height = (int)wxINT32_SWAP_ON_BE( dbuf[1] );
     if (width > 32767)
     {

-        wxLogError( _T("Image width > 32767 pixels for file.") );
+        if (verbose)
+            wxLogError( _("BMP: Image width > 32767 pixels for file.") );

         return FALSE;
     }
     if (height > 32767)
     {
         return FALSE;
     }
     if (height > 32767)
     {

-        wxLogError( _T("Image height > 32767 pixels for file.") );
+        if (verbose)
+            wxLogError( _("BMP: Image height > 32767 pixels for file.") );

         return FALSE;
     }
         return FALSE;
     }

-    
+

     stream.Read( &aWord, 2 );
 /*
     TODO
     stream.Read( &aWord, 2 );
 /*
     TODO


@@ -113,28 +114,31 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
     int bpp = (int)wxUINT16_SWAP_ON_BE( aWord );
     if (bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32)
     {
     int bpp = (int)wxUINT16_SWAP_ON_BE( aWord );
     if (bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32)
     {

-        wxLogError( _T("unknown bitdepth in file.") );
+        if (verbose)
+            wxLogError( _("BMP: Unknown bitdepth in file.") );

         return FALSE;
     }
         return FALSE;
     }

-    
+

     stream.Read( dbuf, 4 * 4 );
     int comp = (int)wxINT32_SWAP_ON_BE( dbuf[0] );
     if (comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 && comp != BI_BITFIELDS)
     {
     stream.Read( dbuf, 4 * 4 );
     int comp = (int)wxINT32_SWAP_ON_BE( dbuf[0] );
     if (comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 && comp != BI_BITFIELDS)
     {

-        wxLogError( _T("unknown encoding in Windows BMP file.") );
+        if (verbose)
+            wxLogError( _("BMP: Unknown encoding in file.") );

         return FALSE;
     }
         return FALSE;
     }

-    
+

     stream.Read( dbuf, 4 * 2 );
     int ncolors = (int)wxINT32_SWAP_ON_BE( dbuf[0] );
     if (ncolors == 0)
         ncolors = 1 << bpp;
     /* some more sanity checks */
     stream.Read( dbuf, 4 * 2 );
     int ncolors = (int)wxINT32_SWAP_ON_BE( dbuf[0] );
     if (ncolors == 0)
         ncolors = 1 << bpp;
     /* some more sanity checks */

-    if (((comp == BI_RLE4) && (bpp != 4)) || 
-        ((comp == BI_RLE8) && (bpp != 8)) || 
-       ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
+    if (((comp == BI_RLE4) && (bpp != 4)) ||
+        ((comp == BI_RLE8) && (bpp != 8)) ||
+        ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))

     {
     {

-        wxLogError( _T("encoding of BMP doesn't match bitdepth.") );
+        if (verbose)
+            wxLogError( _("BMP: Encoding doesn't match bitdepth.") );

         return FALSE;
     }
     if (bpp < 16)
         return FALSE;
     }
     if (bpp < 16)


@@ -142,7 +146,8 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
         cmap = (struct _cmap *)malloc(sizeof(struct _cmap) * ncolors);
         if (!cmap)
         {
         cmap = (struct _cmap *)malloc(sizeof(struct _cmap) * ncolors);
         if (!cmap)
         {

-            wxLogError( _T("Cannot allocate RAM for color map in BMP file.") );
+            if (verbose)
+                wxLogError( _("BMP: Couldn't allocate memory.") );

             return FALSE;
         }
     }
             return FALSE;
         }
     }


@@ -153,7 +158,8 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
     unsigned char *ptr = image->GetData();
     if (!ptr)
     {
     unsigned char *ptr = image->GetData();
     if (!ptr)
     {

-        wxLogError( _T("Cannot allocate RAM for RGB data in file.") );
+        if (verbose)
+            wxLogError( _("BMP: Couldn't allocate memory.") );

         if (cmap)
             free(cmap);
         return FALSE;
         if (cmap)
             free(cmap);
         return FALSE;


@@ -229,13 +235,13 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
         }
         ptr = data;
     }
         }
         ptr = data;
     }

-    
+

     int line = 0;
     int column = 0;
     int linesize = ((width * bpp + 31) / 32) * 4;
 
     /* BMPs are stored upside down */
     int line = 0;
     int column = 0;
     int linesize = ((width * bpp + 31) / 32) * 4;
 
     /* BMPs are stored upside down */

-    for (line = (height - 1); line >= 0; line--) 
+    for (line = (height - 1); line >= 0; line--)

     {
         int linepos = 0;
         for (column = 0; column < width;)
     {
         int linepos = 0;
         for (column = 0; column < width;)


@@ -261,7 +267,8 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
                 {
                     if (comp == BI_RLE4)
                     {
                 {
                     if (comp == BI_RLE4)
                     {

-                        wxLogError( _T("Can't deal with 4bit encoded yet.") );
+                        if (verbose)
+                            wxLogError( _("BMP: Cannot deal with 4bit encoded yet.") );

                         image->Destroy();
                         free(cmap);
                         return FALSE;
                         image->Destroy();
                         free(cmap);
                         return FALSE;


@@ -341,7 +348,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
                         ptr[poffset + 1] = cmap[aByte].g;
                         ptr[poffset + 2] = cmap[aByte].b;
                         column++;
                         ptr[poffset + 1] = cmap[aByte].g;
                         ptr[poffset + 2] = cmap[aByte].b;
                         column++;

-                        linepos += size;
+                        // linepos += size;    seems to be wrong, RR

                     }
                 }
                }
                     }
                 }
                }


@@ -358,13 +365,13 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
                {
                    unsigned char temp;
                    stream.Read( &aWord, 2 );
                {
                    unsigned char temp;
                    stream.Read( &aWord, 2 );

-                  aWord = wxUINT16_SWAP_ON_BE( aWord );
+                   aWord = wxUINT16_SWAP_ON_BE( aWord );

                    linepos += 2;
                    temp = (aWord & rmask) >> rshift;
                    ptr[poffset] = temp;
                    temp = (aWord & gmask) >> gshift;
                    ptr[poffset + 1] = temp;
                    linepos += 2;
                    temp = (aWord & rmask) >> rshift;
                    ptr[poffset] = temp;
                    temp = (aWord & gmask) >> gshift;
                    ptr[poffset + 1] = temp;

-                   temp = (aWord & bmask) >> gshift;
+                   temp = (aWord & bmask) >> bshift;

                    ptr[poffset + 2] = temp;
                    column++;
                }
                    ptr[poffset + 2] = temp;
                    column++;
                }


@@ -372,7 +379,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
                {
                    unsigned char temp;
                    stream.Read( &aDword, 4 );
                {
                    unsigned char temp;
                    stream.Read( &aDword, 4 );

-                  aDword = wxINT32_SWAP_ON_BE( aDword );
+                   aDword = wxINT32_SWAP_ON_BE( aDword );

                    linepos += 4;
                    temp = (aDword & rmask) >> rshift;
                    ptr[poffset] = temp;
                    linepos += 4;
                    temp = (aDword & rmask) >> rshift;
                    ptr[poffset] = temp;


@@ -391,7 +398,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
                   break;
           }
      }
                   break;
           }
      }

-     if (cmap) 
+     if (cmap)

        free(cmap);
 
      image->SetMask( FALSE );
        free(cmap);
 
      image->SetMask( FALSE );


@@ -399,6 +406,15 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
      return TRUE;
 }
 
      return TRUE;
 }
 

+bool wxBMPHandler::DoCanRead( wxInputStream& stream )
+{
+    unsigned char hdr[2];
+
+    stream.Read(&hdr, 2);
+    stream.SeekI(-2, wxFromCurrent);
+    return (hdr[0] == 'B' && hdr[1] == 'M');
+}
+

 #endif // wxUSE_STREAMS
 
 
 #endif // wxUSE_STREAMS