suppress (harmless) unused parameter warnings

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

diff --git a/src/common/imagbmp.cpp b/src/common/imagbmp.cpp
index a500a84a9774a47fbc600c3e20a3798b92fc1cf8..72398fcda17cd73753b9f0e7f9019380bb2b1068 100644 (file)
--- a/src/common/imagbmp.cpp
+++ b/src/common/imagbmp.cpp
@@ -16,32 +16,29 @@
 
 #if wxUSE_IMAGE
 
 
 #if wxUSE_IMAGE
 

+#include "wx/imagbmp.h"
+

 #ifndef WX_PRECOMP
 #ifndef WX_PRECOMP

+    #ifdef __WXMSW__
+        #include "wx/msw/wrapwin.h"
+    #endif

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

-    #include "wx/module.h"
+    #include "wx/palette.h"
+    #include "wx/intl.h"
+    #include "wx/math.h"

 #endif
 
 #endif
 

-#include "wx/imagbmp.h"

 #include "wx/filefn.h"
 #include "wx/wfstream.h"
 #include "wx/filefn.h"
 #include "wx/wfstream.h"

-#include "wx/intl.h"

 #include "wx/quantize.h"
 #include "wx/quantize.h"

+#include "wx/scopeguard.h"
+#include "wx/anidecod.h"

 
 // For memcpy
 #include <string.h>
 
 
 // For memcpy
 #include <string.h>
 

-#ifdef __SALFORDC__
-#ifdef FAR
-#undef FAR
-#endif
-#endif
-
-#ifdef __WXMSW__
-#include "wx/msw/wrapwin.h"
-#endif
-

 //-----------------------------------------------------------------------------
 // wxBMPHandler
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxBMPHandler
 //-----------------------------------------------------------------------------


@@ -153,7 +150,7 @@ bool wxBMPHandler::SaveDib(wxImage *image,
         wxUint16  bpp;            // bits per pixel
         wxUint32  compression;    // compression method
         wxUint32  size_of_bmp;    // size of the bitmap
         wxUint16  bpp;            // bits per pixel
         wxUint32  compression;    // compression method
         wxUint32  size_of_bmp;    // size of the bitmap

-        wxUint32  h_res, v_res;   // image resolution in dpi
+        wxUint32  h_res, v_res;   // image resolution in pixels-per-meter

         wxUint32  num_clrs;       // number of colors used
         wxUint32  num_signif_clrs;// number of significant colors
     } hdr;
         wxUint32  num_clrs;       // number of colors used
         wxUint32  num_signif_clrs;// number of significant colors
     } hdr;


@@ -180,7 +177,36 @@ bool wxBMPHandler::SaveDib(wxImage *image,
     hdr.bpp = wxUINT16_SWAP_ON_BE(bpp);
     hdr.compression = 0; // RGB uncompressed
     hdr.size_of_bmp = wxUINT32_SWAP_ON_BE(row_width * image->GetHeight());
     hdr.bpp = wxUINT16_SWAP_ON_BE(bpp);
     hdr.compression = 0; // RGB uncompressed
     hdr.size_of_bmp = wxUINT32_SWAP_ON_BE(row_width * image->GetHeight());

-    hdr.h_res = hdr.v_res = wxUINT32_SWAP_ON_BE(72);  // 72dpi is standard
+
+    // get the resolution from the image options  or fall back to 72dpi standard
+    // for the BMP format if not specified
+    int hres, vres;
+    switch ( GetResolutionFromOptions(*image, &hres, &vres) )
+    {
+        default:
+            wxFAIL_MSG( _T("unexpected image resolution units") );
+            // fall through
+
+        case wxIMAGE_RESOLUTION_NONE:
+            hres =
+            vres = 72;
+            // fall through to convert it to correct units
+
+        case wxIMAGE_RESOLUTION_INCHES:
+            // convert resolution in inches to resolution in centimeters
+            hres = (int)(10*mm2inches*hres);
+            vres = (int)(10*mm2inches*vres);
+            // fall through to convert it to resolution in meters
+
+        case wxIMAGE_RESOLUTION_CM:
+            // convert resolution in centimeters to resolution in meters
+            hres *= 100;
+            vres *= 100;
+            break;
+    }
+
+    hdr.h_res = wxUINT32_SWAP_ON_BE(hres);
+    hdr.v_res = wxUINT32_SWAP_ON_BE(vres);

     hdr.num_clrs = wxUINT32_SWAP_ON_BE(palette_size); // # colors in colormap
     hdr.num_signif_clrs = 0;     // all colors are significant
 
     hdr.num_clrs = wxUINT32_SWAP_ON_BE(palette_size); // # colors in colormap
     hdr.num_signif_clrs = 0;     // all colors are significant
 


@@ -443,18 +469,20 @@ bool wxBMPHandler::SaveDib(wxImage *image,
 }
 
 
 }
 
 

-typedef struct
+struct BMPPalette

 {
 {

+    static void Free(BMPPalette* pal) { delete [] pal; }
+

     unsigned char r, g, b;
     unsigned char r, g, b;

-}  _cmap;
+};

 
 bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
                              int bpp, int ncolors, int comp,
                              wxFileOffset bmpOffset, wxInputStream& stream,
                              bool verbose, bool IsBmp, bool hasPalette)
 {
 
 bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
                              int bpp, int ncolors, int comp,
                              wxFileOffset bmpOffset, wxInputStream& stream,
                              bool verbose, bool IsBmp, bool hasPalette)
 {

-    wxInt32         aDword, rmask = 0, gmask = 0, bmask = 0;
-    int             rshift = 0, gshift = 0, bshift = 0;
+    wxInt32         aDword, rmask = 0, gmask = 0, bmask = 0, amask = 0;
+    int             rshift = 0, gshift = 0, bshift = 0, ashift = 0;

     int             rbits = 0, gbits = 0, bbits = 0;
     wxInt32         dbuf[4];
     wxInt8          bbuf[4];
     int             rbits = 0, gbits = 0, bbits = 0;
     wxInt32         dbuf[4];
     wxInt8          bbuf[4];


@@ -462,11 +490,11 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
     wxUint16        aWord;
 
     // allocate space for palette if needed:
     wxUint16        aWord;
 
     // allocate space for palette if needed:

-    _cmap *cmap;
+    BMPPalette *cmap;

 
     if ( bpp < 16 )
     {
 
     if ( bpp < 16 )
     {

-        cmap = new _cmap[ncolors];
+        cmap = new BMPPalette[ncolors];

         if ( !cmap )
         {
             if (verbose)
         if ( !cmap )
         {
             if (verbose)


@@ -474,8 +502,12 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
             return false;
         }
     }
             return false;
         }
     }

-    else
+    else // no palette
+    {

         cmap = NULL;
         cmap = NULL;

+    }
+
+    wxON_BLOCK_EXIT1(&BMPPalette::Free, cmap);

 
     // destroy existing here instead of:
     image->Destroy();
 
     // destroy existing here instead of:
     image->Destroy();


@@ -487,11 +519,27 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
     {
         if ( verbose )
             wxLogError( _("BMP: Couldn't allocate memory.") );
     {
         if ( verbose )
             wxLogError( _("BMP: Couldn't allocate memory.") );

-        if ( cmap )
-            delete[] cmap;

         return false;
     }
 
         return false;
     }
 

+    unsigned char *alpha;
+    if ( bpp == 32 )
+    {
+        // tell the image to allocate an alpha buffer
+        image->SetAlpha();
+        alpha = image->GetAlpha();
+        if ( !alpha )
+        {
+            if ( verbose )
+                wxLogError(_("BMP: Couldn't allocate memory."));
+            return false;
+        }
+    }
+    else // no alpha
+    {
+        alpha = NULL;
+    }
+

     // Reading the palette, if it exists:
     if ( bpp < 16 && ncolors != 0 )
     {
     // Reading the palette, if it exists:
     if ( bpp < 16 && ncolors != 0 )
     {


@@ -576,6 +624,9 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
             rmask = 0x00FF0000;
             gmask = 0x0000FF00;
             bmask = 0x000000FF;
             rmask = 0x00FF0000;
             gmask = 0x0000FF00;
             bmask = 0x000000FF;

+            amask = 0xFF000000;
+
+            ashift = 24;

             rshift = 16;
             gshift = 8;
             bshift = 0;
             rshift = 16;
             gshift = 8;
             bshift = 0;


@@ -814,6 +865,11 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
                 ptr[poffset + 1] = temp;
                 temp = (unsigned char)((aDword & bmask) >> bshift);
                 ptr[poffset + 2] = temp;
                 ptr[poffset + 1] = temp;
                 temp = (unsigned char)((aDword & bmask) >> bshift);
                 ptr[poffset + 2] = temp;

+                if ( alpha )
+                {
+                    temp = (unsigned char)((aDword & amask) >> ashift);
+                    alpha[line * width + column] = temp;
+                }

                 column++;
             }
         }
                 column++;
             }
         }


@@ -826,8 +882,6 @@ bool wxBMPHandler::DoLoadDib(wxImage * image, int width, int height,
         }
     }
 
         }
     }
 

-    delete[] cmap;
-

     image->SetMask(false);
 
     const wxStreamError err = stream.GetLastError();
     image->SetMask(false);
 
     const wxStreamError err = stream.GetLastError();


@@ -905,6 +959,7 @@ bool wxBMPHandler::LoadDib(wxImage *image, wxInputStream& stream,
     }
 
     stream.Read(dbuf, 4 * 2);
     }
 
     stream.Read(dbuf, 4 * 2);

+

     int ncolors = wxINT32_SWAP_ON_BE( (int)dbuf[0] );
     if (ncolors == 0)
         ncolors = 1 << bpp;
     int ncolors = wxINT32_SWAP_ON_BE( (int)dbuf[0] );
     if (ncolors == 0)
         ncolors = 1 << bpp;


@@ -943,6 +998,11 @@ bool wxBMPHandler::LoadDib(wxImage *image, wxInputStream& stream,
 
     }
 
 
     }
 

+    // the resolution in the bitmap header is in meters, convert to centimeters
+    image->SetOption(wxIMAGE_OPTION_RESOLUTIONUNIT, wxIMAGE_RESOLUTION_CM);
+    image->SetOption(wxIMAGE_OPTION_RESOLUTIONX, dbuf[2]/100);
+    image->SetOption(wxIMAGE_OPTION_RESOLUTIONY, dbuf[3]/100);
+

     return true;
 }
 
     return true;
 }
 


@@ -1114,7 +1174,7 @@ bool wxICOHandler::SaveFile(wxImage *image,
         }
         wxUint32 Size = cStream.GetSize();
 
         }
         wxUint32 Size = cStream.GetSize();
 

-        // wxCountingOutputStream::Ok() always returns true for now and this
+        // wxCountingOutputStream::IsOk() always returns true for now and this

         // "if" provokes VC++ warnings in optimized build
 #if 0
         if ( !cStream.Ok() )
         // "if" provokes VC++ warnings in optimized build
 #if 0
         if ( !cStream.Ok() )


@@ -1324,160 +1384,28 @@ IMPLEMENT_DYNAMIC_CLASS(wxANIHandler, wxCURHandler)
 #if wxUSE_STREAMS
 
 bool wxANIHandler::LoadFile(wxImage *image, wxInputStream& stream,
 #if wxUSE_STREAMS
 
 bool wxANIHandler::LoadFile(wxImage *image, wxInputStream& stream,

-                            bool verbose, int index)
+                            bool WXUNUSED(verbose), int index)

 {
 {

-    wxInt32 FCC1, FCC2;
-    wxUint32 datalen;
-
-    wxInt32 riff32;
-    memcpy( &riff32, "RIFF", 4 );
-    wxInt32 list32;
-    memcpy( &list32, "LIST", 4 );
-    wxInt32 ico32;
-    memcpy( &ico32, "icon", 4 );
-    int iIcon = 0;
-
-    stream.SeekI(0);
-    stream.Read(&FCC1, 4);
-    if ( FCC1 != riff32 )
+    wxANIDecoder decoder;
+    if (!decoder.Load(stream))

         return false;
 
         return false;
 

-    // we have a riff file:
-    while (stream.IsOk())
-    {
-        // we always have a data size
-        stream.Read(&datalen, 4);
-        datalen = wxINT32_SWAP_ON_BE(datalen) ;
-        //data should be padded to make even number of bytes
-        if (datalen % 2 == 1) datalen ++ ;
-        //now either data or a FCC
-        if ( (FCC1 == riff32) || (FCC1 == list32) )
-        {
-            stream.Read(&FCC2, 4);
-        }
-        else
-        {
-            if (FCC1 == ico32 && iIcon >= index)
-            {
-                return DoLoadFile(image, stream, verbose, -1);
-            }
-            else
-            {
-                stream.SeekI(stream.TellI() + datalen);
-                if ( FCC1 == ico32 )
-                    iIcon ++;
-            }
-        }
-
-        // try to read next data chunk:
-        stream.Read(&FCC1, 4);
-    }
-    return false;
+    return decoder.ConvertToImage(index != -1 ? (size_t)index : 0, image);

 }
 
 bool wxANIHandler::DoCanRead(wxInputStream& stream)
 {
 }
 
 bool wxANIHandler::DoCanRead(wxInputStream& stream)
 {

-    wxInt32 FCC1, FCC2;
-    wxUint32 datalen ;
-
-    wxInt32 riff32;
-    memcpy( &riff32, "RIFF", 4 );
-    wxInt32 list32;
-    memcpy( &list32, "LIST", 4 );
-    wxInt32 ico32;
-    memcpy( &ico32, "icon", 4 );
-    wxInt32 anih32;
-    memcpy( &anih32, "anih", 4 );
-
-    stream.SeekI(0);
-    if ( !stream.Read(&FCC1, 4) )
-        return false;
-
-    if ( FCC1 != riff32 )
-        return false;
-
-    // we have a riff file:
-    while ( stream.IsOk() )
-    {
-        if ( FCC1 == anih32 )
-            return true;
-        // we always have a data size:
-        stream.Read(&datalen, 4);
-        datalen = wxINT32_SWAP_ON_BE(datalen) ;
-        //data should be padded to make even number of bytes
-        if (datalen % 2 == 1) datalen ++ ;
-        // now either data or a FCC:
-        if ( (FCC1 == riff32) || (FCC1 == list32) )
-        {
-            stream.Read(&FCC2, 4);
-        }
-        else
-        {
-            stream.SeekI(stream.TellI() + datalen);
-        }
-
-        // try to read next data chunk:
-        if ( !stream.Read(&FCC1, 4) )
-        {
-            // reading failed -- either EOF or IO error, bail out anyhow
-            return false;
-        }
-    }
-
-    return false;
+    wxANIDecoder decod;
+    return decod.CanRead(stream);

 }
 
 int wxANIHandler::GetImageCount(wxInputStream& stream)
 {
 }
 
 int wxANIHandler::GetImageCount(wxInputStream& stream)
 {

-    wxInt32 FCC1, FCC2;
-    wxUint32 datalen ;
-
-    wxInt32 riff32;
-    memcpy( &riff32, "RIFF", 4 );
-    wxInt32 list32;
-    memcpy( &list32, "LIST", 4 );
-    wxInt32 ico32;
-    memcpy( &ico32, "icon", 4 );
-    wxInt32 anih32;
-    memcpy( &anih32, "anih", 4 );
-
-    stream.SeekI(0);
-    stream.Read(&FCC1, 4);
-    if ( FCC1 != riff32 )
+    wxANIDecoder decoder;
+    if (!decoder.Load(stream))

         return wxNOT_FOUND;
 
         return wxNOT_FOUND;
 

-    // we have a riff file:
-    while ( stream.IsOk() )
-    {
-        // we always have a data size:
-        stream.Read(&datalen, 4);
-        datalen = wxINT32_SWAP_ON_BE(datalen) ;
-        //data should be padded to make even number of bytes
-        if (datalen % 2 == 1) datalen ++ ;
-        // now either data or a FCC:
-        if ( (FCC1 == riff32) || (FCC1 == list32) )
-        {
-            stream.Read(&FCC2, 4);
-        }
-        else
-        {
-            if ( FCC1 == anih32 )
-            {
-                wxUint32 *pData = new wxUint32[datalen/4];
-                stream.Read(pData, datalen);
-                int nIcons = wxINT32_SWAP_ON_BE(*(pData + 1));
-                delete[] pData;
-                return nIcons;
-            }
-            else
-                stream.SeekI(stream.TellI() + datalen);
-        }
-
-        // try to read next data chunk:
-        stream.Read(&FCC1, 4);
-    }
-
-    return wxNOT_FOUND;
+    return decoder.GetFrameCount();

 }
 
 #endif // wxUSE_STREAMS
 }
 
 #endif // wxUSE_STREAMS