c++ - 高级 Win32 图像文件 I/O？

Question

我想在 Windows C++ 应用程序中将图像文件读入内存。什么是相当简单的解决方案，也许类似于 IOS 在 UIImage 中提供的解决方案？

我希望支持合理数量的文件格式。

我需要为位图提供一些低级访问权限以进行图像处理。

我在 Internet 上阅读了很多内容，看起来 Windows DIB 可能是一种合理的内存表示形式。除此之外，我找不到示例代码来将 JPEG 或 PNG 读入内存中的 DIB。

感谢任何建议。

Answer 1

我刚刚查了一下 LoadImage 确实支持通过标志从文件加载 LR_LOADFROMFILE .

所以那将是我的第一选择。

次要选择，GDI+(请注意，它需要相当多的 init 东西才能获得普通的良好质量，至少在几年前它仍然依赖于 min 和 max 宏 来自 <windows.h> )。第三选择，Windows Imaging Component在对该问题的评论中提到。第四选择， OleLoadPicturePath 和家人。

---

附录:如评论中所述LoadImage仅限于加载图像文件的“位图”。在我的系统上，下面的测试程序报告 .bmp 文件加载正常，但 .gif、.png 和 .jpg 文件加载失败。

#undef UNICODE
#define UNICODE
#include <windows.h>

#include <assert.h>         // assert
#include <iostream>         // std::wcout
#include <string>           // std::wstring
using namespace std;

auto get_exe_path()
    -> wstring
{
    int const buffer_size = MAX_PATH;
    wstring result( buffer_size, L'#' );
    int const n_characters = GetModuleFileName( 0, &result[0], buffer_size );
    assert( 0 < n_characters && n_characters < buffer_size );
    result.resize( n_characters );
    return result;
}

auto get_exe_folder_path()
    -> wstring
{
    wstring const exe_path = get_exe_path();
    int const i = exe_path.rfind( L'\\' );
    return exe_path.substr( 0, i + 1 );
}

void test( wstring const& image_name )
{
    wstring const image_file_name = get_exe_folder_path() + image_name;
    wcout << image_file_name << endl;
    HANDLE const image = ::LoadImage(
        0,              // HINSTANCE hinst,
        image_file_name.c_str(),
        IMAGE_BITMAP,
        0, 0,   // int cxDesired, int cyDesired,
        LR_LOADFROMFILE
        );
    wcout << image << endl;
    DeleteObject( image );
}

auto main()
    -> int
{
    test( L"test.bmp" );  wcout << endl;
    test( L"test.png" );  wcout << endl;
    test( L"test.gif" );  wcout << endl;
    test( L"test.jpg" );
}

---

附录 2:为了检查一下，我还测试了 Windows 成像组件功能，它确实可以处理上述所有四种图像类型。下面代码的大部分大小是由于对 COM 的可重用一次写入支持(我只是再次从头开始编写它，所以它有点粗略，只有这里需要的)。不过，此代码不会显示图像或对其执行任何其他操作，并且对于同样复杂的 WIC……

虽然这段代码有部分 g++ 支持，但我已经用 g++ 测试过它。我记得 g++ 只支持 Windows API，就像 Windows XP 一样。我不确定 WIC 是何时引入的(尽管它可以与 Windows XP 一起使用)。

#undef UNICODE
#define UNICODE
#include <windows.h>
#include <wincodec.h>       // IWICImagingFactory

#include <algorithm>        // std::swap
#include <assert.h>         // assert
#include <iostream>         // std::wcout
#include <stdlib.h>         // EXIT_FAILURE, EXIT_SUCCESS
#include <string>           // std::string, std::wstring
#include <utility>          // std::move

#ifndef CPPX_NOEXCEPT
#   if defined( _MSC_VER )
#       define CPPX_NOEXCEPT   throw()
#   else
#       define  CPPX_NOEXCEPT   noexcept
#   endif
#endif

#ifndef CPPX_NORETURN
#   if defined( _MSC_VER )
#       define CPPX_NORETURN   __declspec( noreturn )
#       pragma warning( disable: 4646 )     // "has non-void return type"
#   elif defined( __GNUC__ )
#       define CPPX_NORETURN    __attribute__((noreturn))
#   else
#       define CPPX_NORETURN    [[noreturn]]
#   endif
#endif

namespace cppx {
    using std::string;
    using std::runtime_error;

    auto hopefully( bool const condition )
        CPPX_NOEXCEPT
        -> bool
    { return condition; }

    CPPX_NORETURN
    auto fail( string const& s )
        -> bool
    { throw runtime_error( s ); }
}  // namespace cppx

namespace process {
    using std::wstring;

    auto get_exe_path()
        -> wstring
    {
        int const buffer_size = MAX_PATH;
        wstring result( buffer_size, L'#' );
        int const n_characters = GetModuleFileName( 0, &result[0], buffer_size );
        assert( 0 < n_characters && n_characters < buffer_size );
        result.resize( n_characters );
        return result;
    }

    auto get_exe_folder_path()
        -> wstring
    {
        wstring const exe_path = get_exe_path();
        int const i = exe_path.rfind( L'\\' );
        return exe_path.substr( 0, i + 1 );
    }
}  // namespace process

namespace com {
    using cppx::fail;
    using std::move;

    enum Success { success };

    auto operator>>( HRESULT const hr, Success )
        -> bool
    { return SUCCEEDED( hr ); }

    struct Library
    {
        ~Library()
        { CoUninitialize(); }

        Library()
        { CoInitialize( nullptr ); }
    };

    template< class Interface >
    class Ptr
    {
    private:
        Interface*  p_;

    public:
        auto raw() -> Interface* { return p_; }
        auto operator->() -> Interface* { return p_; }

        void clear() { Ptr null; swap( *this, null ); }

        auto as_value_receiver()
            -> Interface**
        {
            clear();
            return &p_;
        }

        auto as_untyped_value_receiver()
            -> void**
        { return reinterpret_cast<void**>( as_value_receiver() ); }

        friend void swap( Ptr& a, Ptr& b )
            CPPX_NOEXCEPT
        { std::swap( a.p_, b.p_ ); }

        void operator=( Ptr other )
        { swap( *this, other ); }

        void operator=( Ptr&& other )
        {
            Ptr temp( move( other ) );
            swap( temp, *this );
        }

        ~Ptr()
        { if( p_ != nullptr ) { p_->Release(); } }

        explicit Ptr( Interface* p = nullptr )
            CPPX_NOEXCEPT
            : p_( p )
        {}

        Ptr( Ptr const& other )
            : p_( other.p_ )
        { if( p != nullptr ) { p_->AddRef(); } }

        Ptr( Ptr&& other )
            CPPX_NOEXCEPT
            : p_( other.p_ )
        { other.p_ = nullptr; }

        static
        auto create_local( CLSID const& class_id )
            -> Ptr<Interface>
        {
            Ptr<Interface>  result;
            ::CoCreateInstance(
                class_id, nullptr, CLSCTX_INPROC_SERVER,
                __uuidof( Interface ),
                result.as_untyped_value_receiver()
                )
                >> success
                || fail( "CoCreateInstance" );
            return move( result );
        }
    };

}  // namespace com

namespace app {
    using cppx::fail;
    using std::wstring;
    using std::wcout; using std::endl;

    void test( wstring const& image_name )
    {
        wstring const image_file_name =
            process::get_exe_folder_path() + image_name;
        wcout << image_file_name << endl;

        auto                            p_factory   =
            com::Ptr<IWICImagingFactory>::create_local( CLSID_WICImagingFactory );

        com::Ptr< IWICBitmapDecoder>    p_decoder;
        p_factory->CreateDecoderFromFilename(
            image_file_name.c_str(),
            nullptr,
            GENERIC_READ,
            WICDecodeMetadataCacheOnDemand, // Cache metadata when needed
            p_decoder.as_value_receiver()
            )
            >> com::success
            || fail( "IWICImagingFactory::CreateDecoderFromFilename" );

        com::Ptr<IWICBitmapFrameDecode> p_frame;
        p_decoder->GetFrame( 0, p_frame.as_value_receiver() )
            >> com::success
            || fail( "IWICBitmapFrameDecode::GetFrame");

        UINT w, h;
        p_frame->GetSize( &w, &h )
            >> com::success
            || fail( "IWICBitmapFrameDecode::GetSize" );

        wcout << "(w, h) = (" << w << ", " << h << ")" << endl;
    }

    void cpp_main()
    {
        com::Library const  com_usage;

        test( L"test.bmp" );  wcout << endl;
        test( L"test.png" );  wcout << endl;
        test( L"test.gif" );  wcout << endl;
        test( L"test.jpg" );  wcout << endl;
        test( L"test.bogus" );
    }
}  // namespace app

auto main()
    -> int
{
    using namespace std;
    try
    {
        app::cpp_main();
        return EXIT_SUCCESS;
    }
    catch( exception const& x )
    {
        wcout << "!" << x.what() << endl;
    }
    return EXIT_FAILURE;
}