static void ShootAndSave(int left, int top, int width, int height)
{
uint8_t* buffer = xmalloc(width * height * 4);
ShootArea(left, top, width, height, buffer);
SavePNG(buffer, width, height);
free(buffer);
}
/*
==================
R_TakeScreenshotPNG
==================
*/
static void R_TakeScreenshotPNG( int x, int y, int width, int height, char *fileName )
{
byte *buffer = RB_ReadPixels( x, y, width, height, 0 );
if ( tr.overbrightBits > 0 && glConfig.deviceSupportsGamma )
{
R_GammaCorrect( buffer, 3 * width * height );
}
SavePNG( fileName, buffer, width, height, 3, qfalse );
ri.Hunk_FreeTempMemory( buffer );
}
//
// Save the image to a file (PPM, JPEG and PNG
// formats are supported).
// Returns a non-zero value on error.
//
STStatus STImage::Save(const std::string& filename) const
{
// Determine the right routine based on the file's extension.
// The format-specific subroutines are each implemented in
// a different file.
std::string ext = STGetExtension( filename );
if (ext.compare("PPM") == 0 ) {
return SavePPM(filename);
}
else if (ext.compare("PNG") == 0) {
return SavePNG(filename);
}
else if (ext.compare("JPG") == 0) {
return SaveJPG(filename);
}
else {
fprintf(stderr,
"STImage::Save() - Unknown image file type \"%s\".\n",
filename.c_str());
assert(false);
return ST_ERROR;
}
}
//ウィンドウプロシージャ
LRESULT __stdcall WndProc(HWND WindowHandle,UINT Message,WPARAM WParam,LPARAM LParam)
{
static bool CaptureStarted=false;
static RECT CaptureRect={0};
switch(Message){
case WM_RBUTTONDOWN:
//キャンセル
DestroyWindow(WindowHandle);
return DefWindowProc(WindowHandle,Message,WParam,LParam);
break;
case WM_TIMER:
//ESCキー押下の検知
if(GetKeyState(VK_ESCAPE)&0x8000){
DestroyWindow(WindowHandle);
return DefWindowProc(WindowHandle,Message,WParam,LParam);
}
break;
case WM_MOUSEMOVE:
if(CaptureStarted){
//新しい座標をセット
CaptureRect.right=LOWORD(LParam)+OffsetX;
CaptureRect.bottom=HIWORD(LParam)+OffsetY;
DrawRubberband(CaptureRect);
}
break;
case WM_LBUTTONDOWN:
//クリップ開始
CaptureStarted=true;
ShowWindow(LayerWindowHandle,SW_SHOW);
//初期位置をセット
CaptureRect.left=LOWORD(LParam)+OffsetX;
CaptureRect.top=HIWORD(LParam)+OffsetY;
//マウスをキャプチャ
SetCapture(WindowHandle);
break;
case WM_LBUTTONUP:
{
//クリップ終了
CaptureStarted=false;
ShowWindow(LayerWindowHandle,SW_HIDE);
//マウスのキャプチャを解除
ReleaseCapture();
//新しい座標をセット
CaptureRect.right=LOWORD(LParam)+OffsetX;
CaptureRect.bottom=HIWORD(LParam)+OffsetY;
HDC Hdc,NewHdc;
HBITMAP NewBitmap;
Hdc=GetDC(nullptr);
//画像のキャプチャ
int Width,Height;
Width=std::abs(CaptureRect.right-CaptureRect.left+1);
Height=std::abs(CaptureRect.bottom-CaptureRect.top+1);
if(!Width||!Height) {
//画像になってないので何もしない
ReleaseDC(nullptr,Hdc);
DestroyWindow(WindowHandle);
break;
}
// ビットマップバッファを作成
NewBitmap=CreateCompatibleBitmap(Hdc,Width,Height);
NewHdc=CreateCompatibleDC(Hdc);
//関連づけ
SelectObject(NewHdc,NewBitmap);
//画像を取得
BitBlt(NewHdc,0,0,Width,Height,Hdc,
CaptureRect.left<CaptureRect.right?CaptureRect.left:CaptureRect.right,
CaptureRect.top<CaptureRect.bottom?CaptureRect.top:CaptureRect.bottom,SRCCOPY);
//ウィンドウを隠す
ShowWindow(WindowHandle,SW_HIDE);
//テンポラリファイル名を決定
std::vector<wchar_t> TempDirectory(MAX_PATH,0),TempFile(MAX_PATH,0);
GetTempPath(MAX_PATH,TempDirectory.data());
GetTempFileName(TempDirectory.data(),TempPrefix,0,TempFile.data());
if(SavePNG(TempFile.data(),NewBitmap)) UploadFile(TempFile.data(),ShowBrowser);
else MessageBox(WindowHandle,L"一時ファイルの保存に失敗しました。",Title,MB_OK|MB_ICONERROR);
//後始末
DeleteFile(TempFile.data());
DeleteDC(NewHdc);
DeleteObject(NewBitmap);
ReleaseDC(nullptr,Hdc);
DestroyWindow(WindowHandle);
}
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(WindowHandle,Message,WParam,LParam);
}
return 0;
}
int main(int argc, char** argv)
{
if (argc != 5 && argc != 6 && argc != 7)
{
printf("Usage: program SourceJPEG DestJPEG DestWidth DestHeight [bpp] [rotation]\r\n");
return -1;
}
RawImage_t* myImage;
int bpp = 32;
int rotation = 0;
if (argc > 5)
bpp = atoi(argv[5]);
if (argc > 6)
rotation = atoi(argv[6]);
char* lastDot = strrchr(argv[1], '.');
if (lastDot && !strcasecmp(lastDot, ".png"))
{
FILE* fp = fopen(argv[1], "rb");
myImage = LoadPNG(fp, atoi(argv[3]), atoi(argv[4]));
fclose(fp);
}
else if (lastDot && !strcasecmp(lastDot, ".gif"))
{
int fp = open(argv[1], O_RDONLY | O_BINARY);
myImage = LoadGIF(fp, atoi(argv[3]), atoi(argv[4]));
close(fp);
}
else if (lastDot && (!strcasecmp(lastDot, ".tif") || !strcasecmp(lastDot, ".tiff")))
{
int fp = open(argv[1], O_RDONLY | O_BINARY);
myImage = LoadTIFF(fp, argv[1], atoi(argv[3]), atoi(argv[4]));
close(fp);
}
else
{
FILE* fp = fopen(argv[1], "rb");
myImage = LoadJPEG(fp, atoi(argv[3]), atoi(argv[4]), bpp, rotation);
fclose(fp);
}
printf("Finished loading image\r\n");fflush(stdout);
if (!myImage)
{
printf("FAILED loading image\r\n");
return -1;
}
FILE* fp = fopen(argv[2], "wb");
if (strstr(argv[2], ".png"))
{
if (SavePNG(myImage, fp))
printf("FAILED saving PNG image\r\n");
}
else if (SaveJPEG(myImage, fp))
{
printf("FAILED saving JPEG image\r\n");
}
fclose(fp);
free(myImage->pPlane);
free(myImage);
return 0;
}
int main(int argc, char *argv[])
{
int wid,hgt;
png_byte type, bits;
png_bytep *ppData;
char input[1024];
char output[1024];
int result;
int black_partial = 0;
int i,j;
png_byte r,g,b,a;
png_bytep row;
// Process the command line
if (argc < 3) {
puts("Usage: png_premultiply_alpha {-b} <infile> <outfile>");
puts(" -b Set a pixel with partial transparency to be fully opaque, so it looks like a black outline");
return -1;
}
strncpy(input,argv[argc-2],1024);
strncpy(output,argv[argc-1],1024);
if (argc > 3) {
if (strncmp(argv[argc-3],"-b",2) == 0) {
black_partial = 1;
}
}
// load the input
result = LoadPNG(input, &wid,&hgt, &type,&bits, &ppData);
if (result < 0) {
puts("Failed to load input file... Aborting");
return result;
} else {
puts("Load successful. Processing...");
}
if (type != PNG_COLOR_TYPE_RGB_ALPHA) {
puts("Could not convert input file to RGBA... Aborting");
FreePNG(&ppData, hgt);
return -5;
}
// process the file
for (j = 0; j < hgt; ++j) {
row = ppData[j];
for (i = 0; i < wid; ++i) {
//b = *(row + i*4 + 0);
//g = *(row + i*4 + 1);
//r = *(row + i*4 + 2);
a = *(row + i*4 + 3);
if (a && (a != 255)) {
float rf,gf,bf,af;
//blend the color value based on this value
r = *(row + i*4 + 0);
g = *(row + i*4 + 1);
b = *(row + i*4 + 2);
rf = ((float)r) / 255.f;
gf = ((float)g) / 255.f;
bf = ((float)b) / 255.f;
af = ((float)a) / 255.f;
r = (png_byte)((rf/af)*255.f);
g = (png_byte)((gf/af)*255.f);
b = (png_byte)((bf/af)*255.f);
if (r > 255) r = 255;
if (g > 255) r = 255;
if (b > 255) r = 255;
*(row + i*4 + 0) = r;
*(row + i*4 + 1) = g;
*(row + i*4 + 2) = b;
}
}
}
// write the output
result = SavePNG(output, wid,hgt, type,bits, ppData);
if (result < 0) {
puts("Failed to save output file... Aborting");
} else {
puts("Finished... Closing");
}
FreePNG(&ppData, hgt);
return result;
}
bool SavePNG(File* file, Image* image) {
COR_GUARD("SavePNG");
if (!image) {
return false;
}
// If the image format isn't supported directly by this function,
// clone to a supported format and try to save with that.
switch (image->getFormat()) {
case PF_R8G8B8A8:
case PF_R8G8B8:
case PF_I8:
break;
default: {
COR_LOG("Unsupported pixel format... cloning");
std::auto_ptr<Image> cloned(CloneImage(image, PF_R8G8B8A8));
return SavePNG(file, cloned.get());
}
}
// create write struct
png_structp png_ptr = png_create_write_struct(
PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
return false;
}
// error handling!
if (setjmp(png_jmpbuf(png_ptr))) {
png_destroy_write_struct(&png_ptr, NULL);
return false;
}
// create info struct
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr, NULL);
return false;
}
int width = image->getWidth();
int height = image->getHeight();
// set image characteristics
png_set_write_fn(png_ptr, file, PNG_write, PNG_flush);
int color_format = 0; // png output format
int color_format_bpp = 0; // png bytes per pixel
bool color_format_paletted = false; // png palette needed flag
// figure out output format
switch (image->getFormat()) {
case PF_R8G8B8A8:
color_format = PNG_COLOR_TYPE_RGB_ALPHA;
color_format_bpp = 4;
break;
case PF_R8G8B8:
color_format = PNG_COLOR_TYPE_RGB;
color_format_bpp = 3;
break;
case PF_I8:
color_format = PNG_COLOR_TYPE_PALETTE;
color_format_bpp = 1;
color_format_paletted = true;
break;
default:
// Unsupported format. This should already be taken care of
// by the test at the beginning of this function.
return false;
}
png_set_IHDR(
png_ptr, info_ptr,
width, height,
8,
color_format,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
if (color_format_paletted) {
COR_LOG("Saving palettized image...");
int image_palette_format = image->getPaletteFormat(); // palette format
int image_palette_size = image->getPaletteSize(); // palette size
// allocate png palette and get pointer to image palette
png_color* png_palette = (png_color*)png_malloc(
png_ptr, sizeof(png_color) * image_palette_size);
byte* image_palette = (byte*)image->getPalette();
if (image_palette_format == PF_R8G8B8) {
// 24 bit source palette
for (int i = 0; i < image_palette_size; i++) {
// copy entry directly
png_palette[i].red = *image_palette++;
png_palette[i].green = *image_palette++;
png_palette[i].blue = *image_palette++;
}
} else if (image_palette_format == PF_R8G8B8A8) {
// 32 bit source palette
for (int i = 0; i < image_palette_size; i++) {
// copy entry, skip alpha
png_palette[i].red = *image_palette++;
png_palette[i].green = *image_palette++;
png_palette[i].blue = *image_palette++;
image_palette++;
}
}
// write palette
png_set_PLTE(png_ptr, info_ptr, png_palette, image_palette_size);
}
byte* pixels = (byte*)image->getPixels();
// build rows
void** rows = (void**)png_malloc(png_ptr, sizeof(void*) * height);
for (int i = 0; i < height; ++i) {
rows[i] = png_malloc(png_ptr, color_format_bpp * width);
memcpy(rows[i], pixels, color_format_bpp * width);
pixels += width * color_format_bpp;
}
png_set_rows(png_ptr, info_ptr, (png_bytepp)rows);
info_ptr->valid |= PNG_INFO_IDAT;
// actually write the image
png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
png_destroy_write_struct(&png_ptr, &info_ptr);
return true;
}
