scawful/yaze
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

put png callback code back

Browse Source
This commit is contained in:
scawful
2024-05-28 23:13:41 -04:00
parent c85da49230
commit b48af5313b
1 changed files with 115 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

230
src/app/gfx/bitmap.cc
View File

@@ -26,162 +26,162 @@ void GrayscalePalette(SDL_Palette *palette) {
} }
void PngWriteCallback(png_structp png_ptr, png_bytep data, png_size_t length) { void PngWriteCallback(png_structp png_ptr, png_bytep data, png_size_t length) {
// std::vector<uint8_t> *p = (std::vector<uint8_t> *)png_get_io_ptr(png_ptr); std::vector<uint8_t> *p = (std::vector<uint8_t> *)png_get_io_ptr(png_ptr);
// p->insert(p->end(), data, data + length); p->insert(p->end(), data, data + length);
} }
void PngReadCallback(png_structp png_ptr, png_bytep outBytes, void PngReadCallback(png_structp png_ptr, png_bytep outBytes,
png_size_t byteCountToRead) { png_size_t byteCountToRead) {
// png_voidp io_ptr = png_get_io_ptr(png_ptr); png_voidp io_ptr = png_get_io_ptr(png_ptr);
// if (!io_ptr) return; if (!io_ptr) return;
// std::vector<uint8_t> *png_data = std::vector<uint8_t> *png_data =
// reinterpret_cast<std::vector<uint8_t> *>(io_ptr); reinterpret_cast<std::vector<uint8_t> *>(io_ptr);
// static size_t pos = 0; // Position to read from static size_t pos = 0; // Position to read from
// if (pos + byteCountToRead <= png_data->size()) { if (pos + byteCountToRead <= png_data->size()) {
// memcpy(outBytes, png_data->data() + pos, byteCountToRead); memcpy(outBytes, png_data->data() + pos, byteCountToRead);
// pos += byteCountToRead; pos += byteCountToRead;
// } else { } else {
// png_error(png_ptr, "Read error in PngReadCallback"); png_error(png_ptr, "Read error in PngReadCallback");
// } }
} }
} // namespace } // namespace
bool ConvertSurfaceToPNG(SDL_Surface *surface, std::vector<uint8_t> &buffer) { bool ConvertSurfaceToPNG(SDL_Surface *surface, std::vector<uint8_t> &buffer) {
// png_structp png_ptr = png_create_write_struct("1.6.40", NULL, NULL, png_structp png_ptr = png_create_write_struct("1.6.40", NULL, NULL,
// NULL); if (!png_ptr) { NULL); if (!png_ptr) {
// SDL_Log("Failed to create PNG write struct"); SDL_Log("Failed to create PNG write struct");
// return false; return false;
// } }
// png_infop info_ptr = png_create_info_struct(png_ptr); png_infop info_ptr = png_create_info_struct(png_ptr);
// if (!info_ptr) { if (!info_ptr) {
// png_destroy_write_struct(&png_ptr, (png_infopp)NULL); png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
// SDL_Log("Failed to create PNG info struct"); SDL_Log("Failed to create PNG info struct");
// return false; return false;
// } }
// if (setjmp(png_jmpbuf(png_ptr))) { if (setjmp(png_jmpbuf(png_ptr))) {
// png_destroy_write_struct(&png_ptr, &info_ptr); png_destroy_write_struct(&png_ptr, &info_ptr);
// SDL_Log("Error during PNG write"); SDL_Log("Error during PNG write");
// return false; return false;
// } }
// png_set_write_fn(png_ptr, &buffer, PngWriteCallback, NULL); png_set_write_fn(png_ptr, &buffer, PngWriteCallback, NULL);
// png_colorp pal_ptr; png_colorp pal_ptr;
// /* Prepare chunks */ /* Prepare chunks */
// int colortype = PNG_COLOR_MASK_COLOR; int colortype = PNG_COLOR_MASK_COLOR;
// int i = 0; int i = 0;
// SDL_Palette *pal; SDL_Palette *pal;
// if (surface->format->BytesPerPixel > 0 && if (surface->format->BytesPerPixel > 0 &&
// surface->format->BytesPerPixel <= 8 && (pal = surface->format->BytesPerPixel <= 8 && (pal =
// surface->format->palette)) { surface->format->palette)) {
// SDL_Log("Writing PNG image with palette"); SDL_Log("Writing PNG image with palette");
// colortype |= PNG_COLOR_MASK_PALETTE; colortype |= PNG_COLOR_MASK_PALETTE;
// pal_ptr = (png_colorp)malloc(pal->ncolors * sizeof(png_color)); pal_ptr = (png_colorp)malloc(pal->ncolors * sizeof(png_color));
// for (i = 0; i < pal->ncolors; i++) { for (i = 0; i < pal->ncolors; i++) {
// pal_ptr[i].red = pal->colors[i].r; pal_ptr[i].red = pal->colors[i].r;
// pal_ptr[i].green = pal->colors[i].g; pal_ptr[i].green = pal->colors[i].g;
// pal_ptr[i].blue = pal->colors[i].b; pal_ptr[i].blue = pal->colors[i].b;
// } }
// png_set_PLTE(png_ptr, info_ptr, pal_ptr, pal->ncolors); png_set_PLTE(png_ptr, info_ptr, pal_ptr, pal->ncolors);
// free(pal_ptr); free(pal_ptr);
// } }
// if (surface->format->Amask) { // Check for alpha channel if (surface->format->Amask) { // Check for alpha channel
// colortype |= PNG_COLOR_MASK_ALPHA; colortype |= PNG_COLOR_MASK_ALPHA;
// } }
// auto depth = surface->format->BitsPerPixel; auto depth = surface->format->BitsPerPixel;
// // Set image attributes. // Set image attributes.
// png_set_IHDR(png_ptr, info_ptr, surface->w, surface->h, depth, colortype, png_set_IHDR(png_ptr, info_ptr, surface->w, surface->h, depth, colortype,
// PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
// PNG_FILTER_TYPE_DEFAULT); PNG_FILTER_TYPE_DEFAULT);
// png_set_bgr(png_ptr); png_set_bgr(png_ptr);
// // Write the image data. // Write the image data.
// std::vector<png_bytep> row_pointers(surface->h); std::vector<png_bytep> row_pointers(surface->h);
// for (int y = 0; y < surface->h; ++y) { for (int y = 0; y < surface->h; ++y) {
// row_pointers[y] = (png_bytep)(surface->pixels) + y * surface->pitch; row_pointers[y] = (png_bytep)(surface->pixels) + y * surface->pitch;
// } }
// png_set_rows(png_ptr, info_ptr, row_pointers.data()); png_set_rows(png_ptr, info_ptr, row_pointers.data());
// SDL_Log("Writing PNG image..."); SDL_Log("Writing PNG image...");
// png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL); png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
// SDL_Log("PNG image write complete"); SDL_Log("PNG image write complete");
// png_destroy_write_struct(&png_ptr, &info_ptr); png_destroy_write_struct(&png_ptr, &info_ptr);
return true; return true;
} }
void ConvertPngToSurface(const std::vector<uint8_t> &png_data, void ConvertPngToSurface(const std::vector<uint8_t> &png_data,
SDL_Surface **outSurface) { SDL_Surface **outSurface) {
// std::vector<uint8_t> data(png_data); std::vector<uint8_t> data(png_data);
// png_structp png_ptr = png_create_read_struct("1.6.40", NULL, NULL, NULL); png_structp png_ptr = png_create_read_struct("1.6.40", NULL, NULL, NULL);
// if (!png_ptr) { if (!png_ptr) {
// throw std::runtime_error("Failed to create PNG read struct"); throw std::runtime_error("Failed to create PNG read struct");
// } }
// png_infop info_ptr = png_create_info_struct(png_ptr); png_infop info_ptr = png_create_info_struct(png_ptr);
// if (!info_ptr) { if (!info_ptr) {
// png_destroy_read_struct(&png_ptr, NULL, NULL); png_destroy_read_struct(&png_ptr, NULL, NULL);
// throw std::runtime_error("Failed to create PNG info struct"); throw std::runtime_error("Failed to create PNG info struct");
// } }
// if (setjmp(png_jmpbuf(png_ptr))) { if (setjmp(png_jmpbuf(png_ptr))) {
// png_destroy_read_struct(&png_ptr, &info_ptr, NULL); png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
// throw std::runtime_error("Error during PNG read"); throw std::runtime_error("Error during PNG read");
// } }
// // Set our custom read function // Set our custom read function
// png_set_read_fn(png_ptr, &data, PngReadCallback); png_set_read_fn(png_ptr, &data, PngReadCallback);
// // Read the PNG info // Read the PNG info
// png_read_info(png_ptr, info_ptr); png_read_info(png_ptr, info_ptr);
// uint32_t width = png_get_image_width(png_ptr, info_ptr); uint32_t width = png_get_image_width(png_ptr, info_ptr);
// uint32_t height = png_get_image_height(png_ptr, info_ptr); uint32_t height = png_get_image_height(png_ptr, info_ptr);
// png_byte color_type = png_get_color_type(png_ptr, info_ptr); png_byte color_type = png_get_color_type(png_ptr, info_ptr);
// png_byte bit_depth = png_get_bit_depth(png_ptr, info_ptr); png_byte bit_depth = png_get_bit_depth(png_ptr, info_ptr);
// // Apply necessary transformations... // Apply necessary transformations...
// // (Same as in your existing code) // (Same as in your existing code)
// // Update info structure with transformations // Update info structure with transformations
// png_read_update_info(png_ptr, info_ptr); png_read_update_info(png_ptr, info_ptr);
// // Read the file // Read the file
// std::vector<uint8_t> raw_data(width * height * std::vector<uint8_t> raw_data(width * height *
// 4); // Assuming 4 bytes per pixel (RGBA) 4); // Assuming 4 bytes per pixel (RGBA)
// std::vector<png_bytep> row_pointers(height); std::vector<png_bytep> row_pointers(height);
// for (size_t y = 0; y < height; y++) { for (size_t y = 0; y < height; y++) {
// row_pointers[y] = raw_data.data() + y * width * 4; row_pointers[y] = raw_data.data() + y * width * 4;
// } }
// png_read_image(png_ptr, row_pointers.data()); png_read_image(png_ptr, row_pointers.data());
// png_destroy_read_struct(&png_ptr, &info_ptr, NULL); png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
// // Create an SDL_Surface // Create an SDL_Surface
// *outSurface = SDL_CreateRGBSurfaceWithFormat(0, width, height, 32, *outSurface = SDL_CreateRGBSurfaceWithFormat(0, width, height, 32,
// SDL_PIXELFORMAT_RGBA32); SDL_PIXELFORMAT_RGBA32);
// if (*outSurface == nullptr) { if (*outSurface == nullptr) {
// SDL_Log("SDL_CreateRGBSurfaceWithFormat failed: %s\n", SDL_GetError()); SDL_Log("SDL_CreateRGBSurfaceWithFormat failed: %s\n", SDL_GetError());
// return; return;
// } }
// // Copy the raw data into the SDL_Surface // Copy the raw data into the SDL_Surface
// SDL_LockSurface(*outSurface); SDL_LockSurface(*outSurface);
// memcpy((*outSurface)->pixels, raw_data.data(), raw_data.size()); memcpy((*outSurface)->pixels, raw_data.data(), raw_data.size());
// SDL_UnlockSurface(*outSurface); SDL_UnlockSurface(*outSurface);
// SDL_Log("Successfully created SDL_Surface from PNG data"); SDL_Log("Successfully created SDL_Surface from PNG data");
} }
Bitmap::Bitmap(int width, int height, int depth, int data_size) { Bitmap::Bitmap(int width, int height, int depth, int data_size) {