// Copyright 2021 The Wuffs Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // ---------------- /* sdl-imageviewer is a simple GUI program for viewing an image. To run: $CXX sdl-imageviewer.cc -lSDL2 -lSDL2_image && \ ./a.out ../../test/data/bricks-color.png; rm -f a.out for a C++ compiler $CXX, such as clang++ or g++. The Tab key switches between decoding the image via Wuffs or via SDL2_image. There should be no difference unless you uncomment the § line of code below. The Escape key quits. ---- This program (in Wuffs' example directory) is like example/imageviewer but with fewer features. It focuses on showing how to integrate the Wuffs image decoders with SDL (as an alternative to the SDL_image extension). While SDL is cross-platform, this program is not as good as example/imageviewer for general use. SDL (which is designed for full-screen games) uses a noticable amount of CPU (and therefore power) polling for events even when the program isn't otherwise doing anything. */ #include #include #include // Wuffs ships as a "single file C library" or "header file library" as per // https://github.com/nothings/stb/blob/master/docs/stb_howto.txt // // To use that single file as a "foo.c"-like implementation, instead of a // "foo.h"-like header, #define WUFFS_IMPLEMENTATION before #include'ing or // compiling it. #define WUFFS_IMPLEMENTATION // Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when // combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs' // functions have static storage. // // This can help the compiler ignore or discard unused code, which can produce // faster compiles and smaller binaries. Other motivations are discussed in the // "ALLOW STATIC IMPLEMENTATION" section of // https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt #define WUFFS_CONFIG__STATIC_FUNCTIONS // Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of // release/c/etc.c choose which parts of Wuffs to build. That file contains the // entire Wuffs standard library, implementing a variety of codecs and file // formats. Without this macro definition, an optimizing compiler or linker may // very well discard Wuffs code for unused codecs, but listing the Wuffs // modules we use makes that process explicit. Preprocessing means that such // code simply isn't compiled. #define WUFFS_CONFIG__MODULES #define WUFFS_CONFIG__MODULE__ADLER32 #define WUFFS_CONFIG__MODULE__AUX__BASE #define WUFFS_CONFIG__MODULE__AUX__IMAGE #define WUFFS_CONFIG__MODULE__BASE #define WUFFS_CONFIG__MODULE__BMP #define WUFFS_CONFIG__MODULE__CRC32 #define WUFFS_CONFIG__MODULE__DEFLATE #define WUFFS_CONFIG__MODULE__GIF #define WUFFS_CONFIG__MODULE__JPEG #define WUFFS_CONFIG__MODULE__LZW #define WUFFS_CONFIG__MODULE__NETPBM #define WUFFS_CONFIG__MODULE__NIE #define WUFFS_CONFIG__MODULE__PNG #define WUFFS_CONFIG__MODULE__TGA #define WUFFS_CONFIG__MODULE__WBMP #define WUFFS_CONFIG__MODULE__ZLIB // If building this program in an environment that doesn't easily accommodate // relative includes, you can use the script/inline-c-relative-includes.go // program to generate a stand-alone C file. #include "../../release/c/wuffs-unsupported-snapshot.c" // ---------------- #include #include #include // -------- class Wuffs_Load_RW_Callbacks : public wuffs_aux::DecodeImageCallbacks { public: Wuffs_Load_RW_Callbacks() : m_surface(NULL) {} ~Wuffs_Load_RW_Callbacks() { if (m_surface) { SDL_UnlockSurface(m_surface); SDL_FreeSurface(m_surface); m_surface = NULL; } } SDL_Surface* // TakeSurface() { if (!m_surface) { return NULL; } SDL_UnlockSurface(m_surface); SDL_Surface* ret = m_surface; m_surface = NULL; return ret; } private: wuffs_base__pixel_format // SelectPixfmt(const wuffs_base__image_config& image_config) override { // Regardless of endianness, SDL_PIXELFORMAT_BGRA32 (from a few lines // below) is equivalent to WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL. return wuffs_base__make_pixel_format( WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL); } AllocPixbufResult // AllocPixbuf(const wuffs_base__image_config& image_config, bool allow_uninitialized_memory) override { if (m_surface) { SDL_UnlockSurface(m_surface); SDL_FreeSurface(m_surface); m_surface = NULL; } uint32_t w = image_config.pixcfg.width(); uint32_t h = image_config.pixcfg.height(); if ((w > 0xFFFFFF) || (h > 0xFFFFFF)) { return AllocPixbufResult("Wuffs_Load_RW_Callbacks: image is too large"); } uint32_t sdl_pixelformat = SDL_PIXELFORMAT_BGRA32; // (§) Uncomment this line of code to invert the BGRA/RGBA color order. // This isn't a generally useful feature for an image viewer, but it should // make it obvious, when pressing the TAB key, whether you're using the // Wuffs (inverted) or SDL_image (correct) decoder. // // sdl_pixelformat = SDL_PIXELFORMAT_RGBA32; m_surface = SDL_CreateRGBSurfaceWithFormat( 0, static_cast(w), static_cast(h), 32, sdl_pixelformat); if (!m_surface) { return AllocPixbufResult( "Wuffs_Load_RW_Callbacks: SDL_CreateRGBSurface failed"); } SDL_LockSurface(m_surface); wuffs_base__pixel_buffer pixbuf; wuffs_base__status status = pixbuf.set_interleaved( &image_config.pixcfg, wuffs_base__make_table_u8(static_cast(m_surface->pixels), m_surface->w * 4, m_surface->h, m_surface->pitch), wuffs_base__empty_slice_u8()); if (!status.is_ok()) { SDL_UnlockSurface(m_surface); SDL_FreeSurface(m_surface); m_surface = NULL; return AllocPixbufResult(status.message()); } return AllocPixbufResult(wuffs_aux::MemOwner(NULL, &free), pixbuf); } SDL_Surface* m_surface; }; // -------- class Wuffs_Load_RW_Input : public wuffs_aux::sync_io::Input { public: Wuffs_Load_RW_Input(SDL_RWops* rw, bool take_ownership_of_rw) : m_rw(rw), m_ownership(take_ownership_of_rw) {} ~Wuffs_Load_RW_Input() { if (m_rw && m_ownership) { m_rw->close(m_rw); } } private: std::string // CopyIn(wuffs_aux::IOBuffer* dst) override { if (!m_rw) { return "Wuffs_Load_RW_Input: NULL SDL_RWops"; } else if (!dst) { return "Wuffs_Load_RW_Input: NULL IOBuffer"; } else if (dst->meta.closed) { return "Wuffs_Load_RW_Input: end of file"; } dst->compact(); if (dst->writer_length() == 0) { return "Wuffs_Load_RW_Input: full IOBuffer"; } size_t n = m_rw->read(m_rw, dst->writer_pointer(), 1, dst->writer_length()); dst->meta.wi += n; return std::string(); } SDL_RWops* m_rw; const bool m_ownership; }; // -------- // Wuffs_Load_RW loads the image from the input rw. It is like SDL_image's // IMG_Load_RW function but it returns any error in-band (as a std::string) // instead of separately (global state accessible via SDL_GetError). // // On success, the SDL_Surface* returned will be non-NULL and the caller owns // it. Ownership means that they are responsible for calling SDL_FreeSurface on // it when done. std::pair // Wuffs_Load_RW(SDL_RWops* rw, bool take_ownership_of_rw) { Wuffs_Load_RW_Callbacks callbacks; Wuffs_Load_RW_Input input(rw, take_ownership_of_rw); wuffs_aux::DecodeImageResult res = wuffs_aux::DecodeImage(callbacks, input); if (!res.error_message.empty()) { return std::make_pair( NULL, std::move(res.error_message)); } return std::make_pair(callbacks.TakeSurface(), std::string()); } // ---------------- SDL_Surface* g_image = NULL; bool g_load_via_sdl_image = false; bool // draw(SDL_Window* window) { SDL_Surface* ws = SDL_GetWindowSurface(window); if (!ws) { // Use an indirect approach, for exotic window pixel formats (e.g. X.org 10 // bits per RGB channel), when we can't get the window surface directly. // // See https://github.com/google/wuffs/issues/51 SDL_Renderer* r = SDL_CreateRenderer(window, -1, 0); if (!r) { fprintf(stderr, "main: SDL_CreateRenderer: %s\n", SDL_GetError()); return false; } SDL_RenderClear(r); if (g_image) { SDL_Texture* texture = SDL_CreateTextureFromSurface(r, g_image); SDL_RenderCopy(r, texture, NULL, &g_image->clip_rect); SDL_DestroyTexture(texture); } SDL_RenderPresent(r); SDL_DestroyRenderer(r); return true; } // Use a direct approach. SDL_FillRect(ws, NULL, SDL_MapRGB(ws->format, 0x00, 0x00, 0x00)); if (g_image) { SDL_BlitSurface(g_image, NULL, ws, NULL); } SDL_UpdateWindowSurface(window); return true; } bool // load_image(const char* filename) { if (g_image) { SDL_FreeSurface(g_image); g_image = NULL; } SDL_RWops* rw = SDL_RWFromFile(filename, "rb"); if (!rw) { fprintf(stderr, "main: SDL_RWFromFile(\"%s\"): %s\n", filename, SDL_GetError()); return false; } constexpr bool take_ownership_of_rw = true; if (g_load_via_sdl_image) { g_image = IMG_Load_RW(rw, take_ownership_of_rw); if (!g_image) { fprintf(stderr, "main: IMG_Load_RW(\"%s\"): %s\n", filename, SDL_GetError()); return false; } } else { std::pair p = Wuffs_Load_RW(rw, take_ownership_of_rw); if (!p.second.empty()) { fprintf(stderr, "main: Wuffs_Load_RW(\"%s\"): %s\n", filename, p.second.c_str()); return false; } g_image = p.first; } return true; } int // main(int argc, char** argv) { if (argc != 2) { fprintf(stderr, "usage: %s filename\n", argv[0]); return 1; } if (SDL_Init(SDL_INIT_VIDEO) < 0) { fprintf(stderr, "main: SDL_Init: %s\n", SDL_GetError()); return 1; } SDL_Window* window = SDL_CreateWindow("sdl-imageviewer", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 1024, 768, SDL_WINDOW_SHOWN); if (!window) { fprintf(stderr, "main: SDL_CreateWindow: %s\n", SDL_GetError()); return 1; } if (!load_image(argv[1])) { return 1; } while (true) { SDL_Event event; if (!SDL_WaitEvent(&event)) { fprintf(stderr, "main: SDL_WaitEvent: %s\n", SDL_GetError()); return 1; } switch (event.type) { case SDL_QUIT: goto cleanup; case SDL_WINDOWEVENT: switch (event.window.event) { case SDL_WINDOWEVENT_EXPOSED: if (!draw(window)) { return 1; } break; } break; case SDL_KEYDOWN: switch (event.key.keysym.sym) { case SDLK_ESCAPE: goto cleanup; case SDLK_TAB: g_load_via_sdl_image = !g_load_via_sdl_image; printf("Switched to %s.\n", g_load_via_sdl_image ? "SDL_image" : "Wuffs"); if (!load_image(argv[1]) || !draw(window)) { return 1; } break; } break; } } cleanup: if (g_image) { SDL_FreeSurface(g_image); g_image = NULL; } SDL_DestroyWindow(window); SDL_Quit(); return 0; }