stb_image_write: support for 16 bit png #1726
Open
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
For single channel 16 bit png
lyd405121
changed the title
lyd405121
changed the title
lyd405121
changed the title
What's left
Why not fix it
This fix is still valuable
|
|
Releasing this wouldn't make any sense in practice because of the width=height restriction. It may be true that gamedev textures are this way, but (a) a more common use for this library is screenshots, which aren't square, and (b) more importantly it's too weird a restriction. End users won't read the documentation and notice the limitation and would report it as a bug, and we'd have to say it's not a bug, and they'd be annoyed. We either fully support 16-bit writing, or not at all. |
Two solution
|
|
It should definitely be a separate function so it can be typesafe (take |
Conclusion
Proveint main()
{
char name[32];
for (int i = 8; i < 1000; )
{
for (int j = 8; j < 1000;)
{
sprintf_s(name, "my_16bit_%dx%d.png", i,j);
unsigned short* us_pixel = new unsigned short[i * j];
DrawJuliaSet(us_pixel, 255,i,j);
stbi_write_png(name, i, j, 1, us_pixel, i * sizeof(unsigned short));
sprintf_s(name, "my_8bit_%dx%d.png", i, j);
unsigned char* uc_pixel = new unsigned char[i * j];
DrawJuliaSet(uc_pixel, 255, i, j);
stbi_write_png(name, i, j, 1, uc_pixel, i * sizeof(unsigned char));
sprintf_s(name, "my_16bit_n3_%dx%d.png", i, j);
unsigned short* us_pixel3 = new unsigned short[i * j * 3];
DrawColor(us_pixel3, 255, i, j);
stbi_write_png(name, i, j, 3, us_pixel3, i * sizeof(unsigned short) * 3);
sprintf_s(name, "my_8bit_n3_%dx%d.png", i, j);
unsigned char* uc_pixel3 = new unsigned char[i * j * 3];
DrawColor(uc_pixel3, 255, i, j);
stbi_write_png(name, i, j, 3, uc_pixel3, i * sizeof(unsigned char) * 3);
i = i + 15;
j = j + 15;
}
}
return 0;
}
16bit-channel3.mp4
Why does they support
Overthrow my assumption
|
|
Ok, that's good, but you can't change the API the way you have to infer the size of the pixels from the stride. Stride already has a different meaning. The stride describes the number of bytes between successive rows of an image, sometimes called the pitch; it's not the length of a row. For example, if you have a 1024x1024 1-channel 1-byte image and you want to write out a 512x512 subregion of it, you call the writer with a pointer to the top left corner of the subregion, and you specify the stride as 1024, because that's the distance between rows of the 512x512 subimage in memory. So you still need a separate interface for writing out 16-bit. |
|
Also, you can test the 16-bit output by using stb_image to read the 16-bit PNGs and verify they're the same pixels that you wrote out. |
Solid prove
At last
|
I have tested images file from 8*8 to 1280 *1280
Seperate Function Done
final-test.mp4More info
FYI
#define STB_IMAGE_WRITE_IMPLEMENTATION
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image_write.h"
#include "stb_image.h"
#include "stdio.h"
#include "png.h"
#define PNG_BYTES_TO_CHECK 4 //libpng检查文件是否为png所需要BYTE数目
//https://www.shadertoy.com/view/wtBBWd
template<typename T>
void DrawJuliaSet(T* pImage, int nMax, int WID, int HGT){
float cx = -0.8f, cy = 0.2f;
for (int i = 0; i < WID; i++) {
for (int j = 0; j < HGT; j++) {
float zx = float(i) / float(HGT) - 1.0f, zy = float(j) / float(HGT) - 0.5f;
pImage[(i + j * WID)] = 0;
while (sqrtf(zx * zx + zy * zy) < float(HGT) && pImage[(i + j * WID)] < nMax){
float temp = zx * zx - zy * zy + cx;
zy = 2.0f * zx * zy + cy;
zx = temp;
pImage[(i + j * WID)]++;
}
}
}
}
template<typename T>
void DrawColor(T* pImage, int nMax, int WID, int HGT) {
for (int i = 0; i < HGT; i++) {
for (int j = 0; j < WID; j++) {
pImage[(j + i * WID) * 3 + 0] = T(float(j) / float(WID - 1) * float(nMax));
pImage[(j + i * WID) * 3 + 1] = T(float(i) / float(HGT - 1) * float(nMax));
pImage[(j + i * WID) * 3 + 2] = 0;
}
}
}
void ReadPng(const char* pFileName)
{
//初始化各种结构
png_structp png_ptr = { 0 };
png_infop info_ptr = { 0 };
char buf[PNG_BYTES_TO_CHECK] = { 0 };
int temp0 = 0;
//创建png数据结构体
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
//创建png文件信息结构体
info_ptr = png_create_info_struct(png_ptr);
setjmp(png_jmpbuf(png_ptr));
//检测是否为png文件
FILE* m_pFile = fopen(pFileName, "rb");
if (NULL == m_pFile)
{
return;
}
temp0 = (int)fread(buf, 1, PNG_BYTES_TO_CHECK, m_pFile); //读取四个字节判断是否为Png文件
temp0 = png_sig_cmp((png_const_bytep)buf, (png_size_t)0, PNG_BYTES_TO_CHECK);
if (temp0 != 0)
{
return;
}
//开始读文件
rewind(m_pFile); //重置文件指针
png_init_io(png_ptr, m_pFile); //初始化png数据结构体
png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_EXPAND, 0); //初始化png文件信息结构体
//获取宽度，高度，位深，颜色类型
int color_type;
int nChannel = png_get_channels(png_ptr, info_ptr); //获取通道数
color_type = png_get_color_type(png_ptr, info_ptr); //颜色类型
int nPicWid = png_get_image_width(png_ptr, info_ptr);
int nPicHgt = png_get_image_height(png_ptr, info_ptr);
int nPicPitch = png_get_rowbytes(png_ptr, info_ptr);
int nPicDepth = png_get_bit_depth(png_ptr, info_ptr) / 8;
int nSize = static_cast<long long>(nPicPitch) * static_cast<long long>(nPicHgt); // 计算图片的总像素点数量
png_bytepp row_pointers;// row_pointers里边就是rgba数据
row_pointers = png_get_rows(png_ptr, info_ptr);
long long temp = 0;
if (nChannel == 3 || color_type == PNG_COLOR_TYPE_RGB)//每个像素点占3个字节内存
{
//由于png文件解析之后的数据按照RGB排列，所以这里直接赋值即可
for (int i = 0; i < nPicHgt; i++)
{
for (int j = 0; j < nPicWid * 3; j = j + 3)
{
unsigned short* pData = (unsigned short*)(row_pointers[i] + j * nPicDepth); //存储解析后的数据
printf("%d %d %d|", pData[0], pData[1], pData[2]);
}
printf("\n");
printf("--------------next line-------------\n");
}
}
//删除数据占用的内存
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
fclose(m_pFile);
}
int main()
{
char name[32];
for (int i = 8; i <= 1280; )
{
for (int j = 8; j <= 1280;)
{
sprintf_s(name, "my_16bit_%dx%d.png", i,j);
unsigned short* us_pixel = new unsigned short[i * j];
DrawJuliaSet(us_pixel, 65535,i,j);
stbi_write_png_16(name, i, j, 1, us_pixel, i * sizeof(unsigned short));
sprintf_s(name, "my_8bit_%dx%d.png", i, j);
unsigned char* uc_pixel = new unsigned char[i * j];
DrawJuliaSet(uc_pixel, 255, i, j);
stbi_write_png(name, i, j, 1, uc_pixel, i * sizeof(unsigned char));
sprintf_s(name, "my_16bit_n3_%dx%d.png", i, j);
unsigned short* us_pixel3 = new unsigned short[i * j * 3];
DrawColor(us_pixel3, 255, i, j);
stbi_write_png_16(name, i, j, 3, us_pixel3, i * sizeof(unsigned short) * 3);
sprintf_s(name, "my_8bit_n3_%dx%d.png", i, j);
unsigned char* uc_pixel3 = new unsigned char[i * j * 3];
DrawColor(uc_pixel3, 255, i, j);
stbi_write_png(name, i, j, 3, uc_pixel3, i * sizeof(unsigned char) * 3);
i = i + 15;
j = j + 15;
printf("--------------%dX%d Done-------------\n", i,j);
}
}
printf("****************test for stb*********************\n");
int w, h, n;
auto pData = stbi_load_16("my_16bit_n3_8x8.png", &w, &h, &n, 3);
for (int i = 0; i < h; i++)
{
for (int j = 0; j < w; j++)
{
printf("%d %d %d|", pData[3 * (j + i * w) + 0], pData[3 * (j + i * w) + 1], pData[3 * (j + i * w) + 2]);
}
printf("\n");
printf("--------------next line-------------\n");
}
printf("****************test for libpng*********************\n");
ReadPng("my_16bit_n3_8x8.png");
return 0;
}
|
Final Prove
Find a Competitors
The mistake in stb reader
How to solve it
Your opinion
|
|
Well, there are two problems with the conclusion that the 16-bit png stb_image reader code is wrong: if the current code reverses the bytes in 16-bit PNGs, it is a bit surprising that nobody else has ever noticed or complained The specification explicitly say the bytes in 16-bit samples are in big-endian order: The correct way to decode a 16-bit big-endian number is with So it seems like the most likely issue is that something is wrong with your testing methodology, although nothing jumps out at me. Another possibility is that something somewhere else in the stb_image pipeline is also byte-swapping the 16-bit pixels, but I'm not aware of anything that would do that. But the fix you suggest seems specifically wrong, given the specification. |
|
|
No worries, I understand you're making a good faith effort here, I'm just not sure what to do with the info you're supplied about the reading problem. |
|
Well if it can help, this stb_image_write fork does implement 16-bit PNG support https://github.com/AuburnSounds/gamut/blob/main/source/gamut/codecs/stb_image_write.d |
Thanks for p0nce 🤗
More info
|
|
Another Competitor
import numpy as np
import cv2
#image = cv2.imread('libpng_16bit_n3_8x8.png', cv2.IMREAD_UNCHANGED)
image = cv2.imread('my_16bit_n3_8x8.png', cv2.IMREAD_UNCHANGED)
# 确保图像是16位深度
assert image.dtype == np.uint16, "图像不是16位深度"
# 输出每个像素的值
for i in range(image.shape[0]):
for j in range(image.shape[1]):
print(f"Pixel ({i},{j}): {image[i, j]}")Amazing result
|
Final fix done
Good news
Conclusion
|
|
For reference: it looks like the libpng API requires the user to explicitly request Our assumption that libpng was correct--which seemed pretty reasonable!--absolutely fucked us. |
Wake up
Conlusion
Resolution.mp4
Just in case
void ReadByLIBPng(const char* pFileName)
{
//初始化各种结构
png_structp png_ptr = { 0 };
png_infop info_ptr = { 0 };
char buf[PNG_BYTES_TO_CHECK] = { 0 };
int temp0 = 0;
//创建png数据结构体
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
//创建png文件信息结构体
info_ptr = png_create_info_struct(png_ptr);
setjmp(png_jmpbuf(png_ptr));
//检测是否为png文件
FILE* m_pFile = fopen(pFileName, "rb");
if (nullptr == m_pFile)
{
return;
}
temp0 = (int)fread(buf, 1, PNG_BYTES_TO_CHECK, m_pFile); //读取四个字节判断是否为Png文件
temp0 = png_sig_cmp((png_const_bytep)buf, (png_size_t)0, PNG_BYTES_TO_CHECK);
if (temp0 != 0)
{
return;
}
//开始读文件
rewind(m_pFile); //重置文件指针
png_init_io(png_ptr, m_pFile); //初始化png数据结构体
png_read_info(png_ptr, info_ptr);
if (png_get_bit_depth(png_ptr, info_ptr) == 16 && png_get_channels(png_ptr, info_ptr) > 1) {
png_set_swap(png_ptr); // This is equivalent to using PNG_TRANSFORM_SWAP_ENDIAN
}
png_read_update_info(png_ptr, info_ptr);
int color_type;
int nChannel = png_get_channels(png_ptr, info_ptr);
color_type = png_get_color_type(png_ptr, info_ptr);
int nPicWid = png_get_image_width(png_ptr, info_ptr);
int nPicHgt = png_get_image_height(png_ptr, info_ptr);
int nPicDepth = png_get_bit_depth(png_ptr, info_ptr) / 8;
png_bytep* row_pointers = (png_bytep*)malloc(sizeof(png_bytep) * png_get_image_height(png_ptr, info_ptr));
for (size_t y = 0; y < png_get_image_height(png_ptr, info_ptr); y++) {
row_pointers[y] = (png_byte*)malloc(png_get_rowbytes(png_ptr, info_ptr));
}
png_read_image(png_ptr, row_pointers);
// Process the image data here
for (size_t y = 0; y < png_get_image_height(png_ptr, info_ptr); y++) {
free(row_pointers[y]);
}
free(row_pointers);
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
fclose(m_pFile);
}
void WriteByLIBPng(const char* pFileName, int nWid, int nHgt, int nChannel,void* p, int nByteForChannel)
{
void* pPixel = p;
int width = nWid;
int height = nHgt;
int nBitDepth = 8 * nByteForChannel;
//检测是否为png文件
FILE* m_pFile = fopen(pFileName, "wb");
if (nullptr == m_pFile)
{
return;
}
unsigned char* pData = (unsigned char*)pPixel;
png_structp png_ptr;
png_infop info_ptr;
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
if (png_ptr == nullptr)
{
fclose(m_pFile);
m_pFile = nullptr;
return;
}
info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == nullptr)
{
png_destroy_write_struct(&png_ptr, nullptr);
return;
}
png_init_io(png_ptr, m_pFile);
switch (nChannel)
{
case 1:
png_set_IHDR(png_ptr, info_ptr, width, height, nBitDepth, PNG_COLOR_TYPE_GRAY, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
break;
case 2:
png_set_IHDR(png_ptr, info_ptr, width, height, nBitDepth, PNG_COLOR_TYPE_GRAY_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
break;
case 3:
png_set_IHDR(png_ptr, info_ptr, width, height, nBitDepth, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
break;
case 4:
png_set_IHDR(png_ptr, info_ptr, width, height, nBitDepth, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
break;
default:
return;
}
png_colorp palette = (png_colorp)png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH * sizeof(png_color));
if (!palette)
{
fclose(m_pFile);
png_destroy_write_struct(&png_ptr, &info_ptr);
return;
}
png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH);
png_write_info(png_ptr, info_ptr);
if (nBitDepth == 16 && nChannel > 1)
{
png_set_swap(png_ptr); // This is equivalent to using PNG_TRANSFORM_SWAP_ENDIAN
}
png_bytepp rows = (png_bytepp)png_malloc(png_ptr, height * sizeof(png_bytep));
if (nullptr == rows)
{
png_write_end(png_ptr, info_ptr);
png_free(png_ptr, palette);
palette = nullptr;
png_destroy_write_struct(&png_ptr, &info_ptr);
fclose(m_pFile);
return;
}
for (int i = 0; i < height; ++i)
{
rows[i] = (png_bytep)(pData + static_cast<long long>(i) * static_cast<long long>(width) * nChannel * nByteForChannel);
}
png_write_image(png_ptr, rows);
delete[] rows;
png_write_end(png_ptr, info_ptr);
png_free(png_ptr, palette);
palette = nullptr;
png_destroy_write_struct(&png_ptr, &info_ptr);
fclose(m_pFile);
}
|
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Background
Why is this neccessary
1.mp4
Bug reproduce
More test