int SOIL_save_image ( const char *filename, int image_type, int width, int height, int channels, const unsigned char *const data ) { int save_result; /* error check */ if( (width < 1) || (height < 1) || (channels < 1) || (channels > 4) || (data == NULL) || (filename == NULL) ) { return 0; } if( image_type == SOIL_SAVE_TYPE_BMP ) { save_result = stbi_write_bmp( filename, width, height, channels, (void*)data ); } else if( image_type == SOIL_SAVE_TYPE_TGA ) { save_result = stbi_write_tga( filename, width, height, channels, (void*)data ); } else if( image_type == SOIL_SAVE_TYPE_DDS ) { save_result = save_image_as_DDS( filename, width, height, channels, (const unsigned char *const)data ); } else { save_result = 0; } if( save_result == 0 ) { result_string_pointer = "Saving the image failed"; } else { result_string_pointer = "Image saved"; } return save_result; }
int image_ImageData_save(image_ImageData *dst, const char* format, const char* filename) { int succeded = 0; if (strncmp(format, "png", 3) == 0) succeded = stbi_write_png(filename, dst->w, dst->h, dst->c, (const float*)dst->pixels, 0); else if (strncmp(format, "bmp", 3) == 0) succeded = stbi_write_bmp(filename, dst->w, dst->h, dst->c, (const float*)dst->surface); else if (strncmp(format, "tga", 3) == 0) succeded = stbi_write_tga(filename, dst->w, dst->h, dst->c, (const float*)dst->pixels); else if (strncmp(format, "hdr", 3) == 0) succeded = stbi_write_hdr(filename, dst->w, dst->h, dst->c, (const float*)dst->surface); else printf("%s %s %s \n", "Error, format:", format, " is not avalabile.Only png,bmp,tga and hdr image formats are possible"); if(succeded != 0) return 1; else { printf("%s %s \n", "Error: failed to save imageData: ", filename); return 0; } }
void image::saveImageRGB(string filename){ unsigned char* bitmapData = new unsigned char[3 * xSize * ySize]; int i = 0; //read data to buffer for stb_image output for(int y = 0; y < ySize; y++) { for(int x = 0; x < xSize; x++) { if(gamma.applyGamma){ bitmapData[i] = (unsigned char)utilityCore::clamp(applyGamma(readPixelR(x,y))*255,0,255); bitmapData[i+1] = (unsigned char)utilityCore::clamp(applyGamma(readPixelG(x,y))*255,0,255); bitmapData[i+2] = (unsigned char)utilityCore::clamp(applyGamma(readPixelB(x,y))*255,0,255); }else{ bitmapData[i] = (unsigned char)utilityCore::clamp(readPixelR(x,y)*255, 0, 255); bitmapData[i+1] = (unsigned char)utilityCore::clamp(readPixelG(x,y)*255, 0, 255); bitmapData[i+2] = (unsigned char)utilityCore::clamp(readPixelB(x,y)*255, 0, 255); } i=i+3; } } //check requested output type int imagetype = 0; //0 for png, 1 for bmp if(filename[filename.size()-1]=='\r'){ //OSX Version if(filename[filename.size()-4]=='b' && filename[filename.size()-3]=='m' && filename[filename.size()-2]=='p'){ imagetype = 1; } }else{ //Windows Version if(filename[filename.size()-3]=='b' && filename[filename.size()-2]=='m' && filename[filename.size()-1]=='p'){ imagetype = 1; } } //write output file if(imagetype==1){ stbi_write_bmp(filename.c_str(), xSize, ySize, 3, bitmapData); }else{ stbi_write_png(filename.c_str(), xSize, ySize, 3, bitmapData, xSize * 3); } }
void ImageTargetFileStbImage::finalize() { if( mExtension == "png" ) { if( ! stbi_write_png( mFilePath.string().c_str(), (int)mWidth, (int)mHeight, mNumComponents, mData.get(), (int)mRowBytes ) ) throw ImageIoExceptionFailedWrite(); } else if( mExtension == "bmp" ) { if( ! stbi_write_bmp( mFilePath.string().c_str(), (int)mWidth, (int)mHeight, mNumComponents, mData.get() ) ) throw ImageIoExceptionFailedWrite(); } else if( mExtension == "tga" ) { if( ! stbi_write_tga( mFilePath.string().c_str(), (int)mWidth, (int)mHeight, mNumComponents, mData.get() ) ) throw ImageIoExceptionFailedWrite(); } else if( mExtension == "hdr" ) { if( ! stbi_write_hdr( mFilePath.string().c_str(), (int)mWidth, (int)mHeight, mNumComponents, (const float*)mData.get() ) ) throw ImageIoExceptionFailedWrite(); } }
bool Image::SaveBMP(const String& fileName) { FileSystem* fileSystem = GetSubsystem<FileSystem>(); if (fileSystem && !fileSystem->CheckAccess(GetPath(fileName))) { LOGERROR("Access denied to " + fileName); return false; } if (IsCompressed()) { LOGERROR("Can not save compressed image to BMP"); return false; } if (data_) return stbi_write_bmp(fileName.CString(), width_, height_, components_, data_.Get()) != 0; else return false; }
bool ImageLoader::saveImageToFile(const std::string& filename, const std::vector<Uint8>& pixels, unsigned int width, unsigned int height) { // Make sure the image is not empty if (!pixels.empty() && width && height) { // Deduce the image type from its extension if (filename.size() > 3) { // Extract the extension std::string extension = filename.substr(filename.size() - 3); if (toLower(extension) == "bmp") { // BMP format if (stbi_write_bmp(filename.c_str(), width, height, 4, &pixels[0])) return true; } else if (toLower(extension) == "tga") { // TGA format if (stbi_write_tga(filename.c_str(), width, height, 4, &pixels[0])) return true; } else if(toLower(extension) == "png") { // PNG format if (stbi_write_png(filename.c_str(), width, height, 4, &pixels[0], 0)) return true; } else if (toLower(extension) == "jpg") { // JPG format if (writeJpg(filename, pixels, width, height)) return true; } } } err() << "Failed to save image \"" << filename << "\"" << std::endl; return false; }
void Gosu::saveImageFile(const Gosu::Bitmap& bitmap, const std::wstring& filename) { int ok; std::string utf8 = Gosu::wstringToUTF8(filename); if (isExtension(filename.c_str(), L"bmp")) { ok = stbi_write_bmp(utf8.c_str(), bitmap.width(), bitmap.height(), 4, bitmap.data()); } else if (isExtension(filename.c_str(), L"tga")) { ok = stbi_write_tga(utf8.c_str(), bitmap.width(), bitmap.height(), 4, bitmap.data()); } else { ok = stbi_write_png(utf8.c_str(), bitmap.width(), bitmap.height(), 4, bitmap.data(), 0); } if (ok == 0) throw std::runtime_error("Could not save image data to file: " + utf8); }
bool ImageLoader::saveImageToFile(const std::string& filename, const std::vector<Uint8>& pixels, const Vector2u& size) { // Make sure the image is not empty if (!pixels.empty() && (size.x > 0) && (size.y > 0)) { // Deduce the image type from its extension // Extract the extension const std::size_t dot = filename.find_last_of('.'); const std::string extension = dot != std::string::npos ? toLower(filename.substr(dot + 1)) : ""; if (extension == "bmp") { // BMP format if (stbi_write_bmp(filename.c_str(), size.x, size.y, 4, &pixels[0])) return true; } else if (extension == "tga") { // TGA format if (stbi_write_tga(filename.c_str(), size.x, size.y, 4, &pixels[0])) return true; } else if (extension == "png") { // PNG format if (stbi_write_png(filename.c_str(), size.x, size.y, 4, &pixels[0], 0)) return true; } else if (extension == "jpg" || extension == "jpeg") { // JPG format if (writeJpg(filename, pixels, size.x, size.y)) return true; } } err() << "Failed to save image \"" << filename << "\"" << std::endl; return false; }
///\todo is there a write error message too? bool writeImage(const LDRImage& img, const std::string& filename) { if(!img) { throw std::runtime_error("Image::Write called on incomplete image"); } std::string extension = filename.substr(filename.length()-4, 4); int width =img.getDimensions()[1]; int height=img.getDimensions()[2]; int channels=img.getDimensions()[0]; //special case branching... mostly becuase jpeg doens't write with this writer. This allows autodetection of the extension regardless though. if(extension == ".png") { return stbi_write_png(filename.c_str(), width, height, channels, img.dataPtr(), width*channels); } else if(extension==".bmp") { return stbi_write_bmp(filename.c_str(), width, height, channels, img.dataPtr()); } else if(extension == ".tga") { return stbi_write_tga(filename.c_str(), width, height, channels, img.dataPtr()); } else { throw std::runtime_error("Unimplemented extension for image writer"); } return false; }
void CNormalGenerator::SaveToFile(const tchar *pszFilename) { if (!pszFilename) return; tstring sFilename = pszFilename; tvector<Color> aclrTexels; aclrTexels.resize(m_iNormal2Width*m_iNormal2Height); for (size_t i = 0; i < aclrTexels.size(); i++) aclrTexels[i] = m_avecNormal2Texels[i]; if (sFilename.endswith(".png")) stbi_write_png(sFilename.c_str(), m_iNormal2Width, m_iNormal2Height, 3, aclrTexels.data(), 0); else if (sFilename.endswith(".tga")) stbi_write_tga(sFilename.c_str(), m_iNormal2Width, m_iNormal2Height, 3, aclrTexels.data()); else if (sFilename.endswith(".bmp")) stbi_write_bmp(sFilename.c_str(), m_iNormal2Width, m_iNormal2Height, 3, aclrTexels.data()); else TUnimplemented(); }
void BitmapData::save(const char* path) const { const char* ext = strrchr(path, '.'); if (ext == NULL) { lmLogError(gGFXLogGroup, "No extension in path %s. Unable to detect file format.", path); return; } if (stricmp(ext, ".bmp") == 0) { if (stbi_write_bmp(path, w, h, DATA_BPP, data) != 1) { lmLogError(gGFXLogGroup, "Unable to write image %s", path); } return; } if (stricmp(ext, ".png") == 0) { if (stbi_write_png(path, w, h, DATA_BPP, data, w * DATA_BPP) != 1) { lmLogError(gGFXLogGroup, "Unable to write image %s", path); } return; } if (stricmp(ext, ".tga") == 0) { if (stbi_write_tga(path, w, h, DATA_BPP, data) != 1) { lmLogError(gGFXLogGroup, "Unable to write image %s", path); } return; } lmLogError(gGFXLogGroup, "Unsupported image extension in path %s.", path); }
int write_bmp(char const *filename, int x, int y, int comp, Array<unsigned char> bytes, unsigned int byteOffset, unsigned int byteLength) { return stbi_write_bmp(filename, x, y, comp, &bytes[0] + byteOffset); }
bool Image::save(core::FileSystem::Ptr fs, const std::string &filename) { if (type != TextureType::Texture2D) return false; unsigned int components = 0; if (format == TextureFormat::R8) components = 1; else if (format == TextureFormat::RG8) components = 2; else if (format == TextureFormat::RGBA8) components = 4; if (components == 0) return false; std::string extension = tolower(filename.substr(filename.rfind("."))); if (extension == ".png") { core::File::Ptr file = fs->open(filename, core::FileAccess::Write, true); if (!file) return false; unsigned int stride = TextureFormat::getSize(format, width, 1, 1); if (!stbi_write_png(file, width, height, components, imagedata, stride)) return false; } else if (extension == ".tga") { core::File::Ptr file = fs->open(filename, core::FileAccess::Write, true); if (!file) return false; if (!stbi_write_tga(file, width, height, components, imagedata)) return false; } else if (extension == ".bmp") { core::File::Ptr file = fs->open(filename, core::FileAccess::Write, true); if (!file) return false; if (!stbi_write_bmp(file, width, height, components, imagedata)) return false; } else { return false; } return true; }
int main(int argc, char **argv) { int w,h; //test_ycbcr(); #if 0 // test hdr asserts for (h=0; h < 100; h += 2) for (w=0; w < 200; ++w) hdr_data[h][w][0] = (float) rand(), hdr_data[h][w][1] = (float) rand(), hdr_data[h][w][2] = (float) rand(); stbi_write_hdr("output/test.hdr", 200,200,3,hdr_data[0][0]); #endif if (argc > 1) { int i, n; for (i=1; i < argc; ++i) { int res; int w2,h2,n2; unsigned char *data; printf("%s\n", argv[i]); res = stbi_info(argv[1], &w2, &h2, &n2); data = stbi_load(argv[i], &w, &h, &n, 4); if (data) free(data); else printf("Failed &n\n"); data = stbi_load(argv[i], &w, &h, 0, 1); if (data) free(data); else printf("Failed 1\n"); data = stbi_load(argv[i], &w, &h, 0, 2); if (data) free(data); else printf("Failed 2\n"); data = stbi_load(argv[i], &w, &h, 0, 3); if (data) free(data); else printf("Failed 3\n"); data = stbi_load(argv[i], &w, &h, &n, 4); assert(data); assert(w == w2 && h == h2 && n == n2); assert(res); if (data) { char fname[512]; stb_splitpath(fname, argv[i], STB_FILE); stbi_write_png(stb_sprintf("output/%s.png", fname), w, h, 4, data, w*4); stbi_write_bmp(stb_sprintf("output/%s.bmp", fname), w, h, 4, data); stbi_write_tga(stb_sprintf("output/%s.tga", fname), w, h, 4, data); stbi_write_png_to_func(dummy_write,0, w, h, 4, data, w*4); stbi_write_bmp_to_func(dummy_write,0, w, h, 4, data); stbi_write_tga_to_func(dummy_write,0, w, h, 4, data); free(data); } else printf("FAILED 4\n"); } } else { int i, nope=0; #ifdef PNGSUITE_PRIMARY char **files = stb_readdir_files("pngsuite/primary"); #else char **files = stb_readdir_files("images"); #endif for (i=0; i < stb_arr_len(files); ++i) { int n; char **failed = NULL; unsigned char *data; printf("."); //printf("%s\n", files[i]); data = stbi_load(files[i], &w, &h, &n, 0); if (data) free(data); else stb_arr_push(failed, "&n"); data = stbi_load(files[i], &w, &h, 0, 1); if (data) free(data); else stb_arr_push(failed, "1"); data = stbi_load(files[i], &w, &h, 0, 2); if (data) free(data); else stb_arr_push(failed, "2"); data = stbi_load(files[i], &w, &h, 0, 3); if (data) free(data); else stb_arr_push(failed, "3"); data = stbi_load(files[i], &w, &h, 0, 4); if (data) ; else stb_arr_push(failed, "4"); if (data) { char fname[512]; #ifdef PNGSUITE_PRIMARY int w2,h2; unsigned char *data2; stb_splitpath(fname, files[i], STB_FILE_EXT); data2 = stbi_load(stb_sprintf("pngsuite/primary_check/%s", fname), &w2, &h2, 0, 4); if (!data2) printf("FAILED: couldn't load 'pngsuite/primary_check/%s\n", fname); else { if (w != w2 || h != w2 || 0 != memcmp(data, data2, w*h*4)) { int x,y,c; if (w == w2 && h == h2) for (y=0; y < h; ++y) for (x=0; x < w; ++x) for (c=0; c < 4; ++c) assert(data[y*w*4+x*4+c] == data2[y*w*4+x*4+c]); printf("FAILED: %s loaded but didn't match PRIMARY_check 32-bit version\n", files[i]); } free(data2); } #else stb_splitpath(fname, files[i], STB_FILE); stbi_write_png(stb_sprintf("output/%s.png", fname), w, h, 4, data, w*4); #endif free(data); } if (failed) { int j; printf("FAILED: "); for (j=0; j < stb_arr_len(failed); ++j) printf("%s ", failed[j]); printf(" -- %s\n", files[i]); } } printf("Tested %d files.\n", i); } return 0; }
/*** Save a texture to a file. @function :save @tparam string filename path to the file to save the texture to @tparam[opt=TYPE_PNG] number type type of the image to save. Can be TYPE_PNG or TYPE_BMP @treturn[1] boolean true on success @treturn[2] boolean `false` in case of error @treturn[2] string error message */ static int texture_save(lua_State *L) { texture_userdata *texture = luaL_checkudata(L, 1, "LTexture"); const char* path = luaL_checkstring(L, 2); u8 type = luaL_optinteger(L, 3, 0); int result = 0; if (type == 0) { // PNG FILE* file = fopen(path, "wb"); if (file == NULL) { lua_pushboolean(L, false); lua_pushstring(L, "Can open file"); return 2; } png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); png_infop infos = png_create_info_struct(png); setjmp(png_jmpbuf(png)); png_init_io(png, file); png_set_IHDR(png, infos, texture->texture->width, texture->texture->height, 8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); png_write_info(png, infos); png_bytep row = malloc(4 * texture->texture->width * sizeof(png_byte)); for(int y=0;y<texture->texture->height;y++) { for (int x=0;x<texture->texture->width;x++) { ((u32*)row)[x] = __builtin_bswap32(sf2d_get_pixel(texture->texture, x, y)); } png_write_row(png, row); } png_write_end(png, NULL); fclose(file); png_free_data(png, infos, PNG_FREE_ALL, -1); png_destroy_write_struct(&png, &infos); free(row); result = 1; } else if (type == 2) { // BMP u32* buff = malloc(texture->texture->width * texture->texture->height * 4); if (buff == NULL) { lua_pushboolean(L, false); lua_pushstring(L, "Failed to allocate buffer"); return 2; } for (int y=0;y<texture->texture->height;y++) { for (int x=0;x<texture->texture->width;x++) { buff[x+(y*texture->texture->width)] = __builtin_bswap32(sf2d_get_pixel(texture->texture, x, y)); } } result = stbi_write_bmp(path, texture->texture->width, texture->texture->height, 4, buff); free(buff); } else { lua_pushboolean(L, false); lua_pushstring(L, "Not a valid type"); return 2; } if (result == 0) { lua_pushboolean(L, false); lua_pushstring(L, "Failed to save the texture"); return 2; } lua_pushboolean(L, true); return 1; }