void load_sokoban_images(void) {
/* load all sokoban images */
read_image_data("crate.bmp", &box_image[0][0],16,16);
read_image_data("player.bmp", &player_image[0][0],16,16);
read_image_data("wall.bmp", &wall_image[0][0],16,16);
read_image_data("blank.bmp", &blank_image[0][0],16,16);
read_image_data("target.bmp", &target_image[0][0],16,16);
read_image_data("playertarget.bmp", &player_on_target_image[0][0],16,16);
read_image_data("cratetarget.bmp", &box_on_target_image[0][0],16,16);
read_image_data("win.bmp", &win_image[0][0], MAX_HEIGHT, MAX_WIDTH);
read_image_data("splash.bmp", &splash_image[0][0], MAX_HEIGHT, MAX_WIDTH);
read_image_data("end.bmp", &end_image[0][0], MAX_HEIGHT, MAX_WIDTH);
printf("Sokoban images loaded.\n");
}
TargaLoader::TargaLoader(const IODevicePtr &iodevice, bool srgb)
: file(iodevice), srgb(srgb)
{
read_header();
read_image_id();
read_color_map();
read_image_data();
decode_palette();
decode_image();
}
static int
uncompress_image(Gif_Context *gfc, Gif_Image *gfi, Gif_Reader *grr)
{
if (!Gif_CreateUncompressedImage(gfi)) return 0;
gfc->width = gfi->width;
gfc->height = gfi->height;
gfc->image = gfi->image_data;
gfc->maximage = gfi->image_data + gfi->width * gfi->height;
read_image_data(gfc, grr);
return 1;
}
Image TGAReader::read_stream(std::istream &stream, const std::string &error_prefix)
{
this->stream = &stream;
this->error_prefix = error_prefix;
read_header();
skip(header.id_field_length);
if (header.color_map_type == ColorMapType::PRESENT)
read_color_map();
return read_image_data();
}
void ggscfg_ColorEditSheet::on_init(wxInitDialogEvent& event) {
if (strcmp(GET_APP->get_title_label(), "SLPS_251.84") == 0) {
kCharaCount = kCharaCount_251_84;
kCharaInfo = kCharaInfo_251_84;
kPaletteCount= kPaletteCount_251_84;
kPaletteLabel = kPaletteLabel_251_84;
} else if (strcmp(GET_APP->get_title_label(), "SLPS_252.61") == 0) {
kCharaCount = kCharaCount_252_61;
kCharaInfo = kCharaInfo_252_61;
kPaletteCount= kPaletteCount_252_61;
kPaletteLabel = kPaletteLabel_252_61;
} else if (strcmp(GET_APP->get_title_label(), "SLPM_663.33") == 0) {
kCharaCount = kCharaCount_663_33;
kCharaInfo = kCharaInfo_663_33;
kPaletteCount= kPaletteCount_663_33;
kPaletteLabel = kPaletteLabel_663_33;
} else if (strcmp(GET_APP->get_title_label(), "SLPM_669.65") == 0) {
kCharaCount = kCharaCount_669_65;
kCharaInfo = kCharaInfo_669_65;
kPaletteCount= kPaletteCount_669_65;
kPaletteLabel = kPaletteLabel_669_65;
}
// キャラコンボの初期化
for (int i = 0; i < kCharaCount; i++) {
m_choice_chara->Append(kCharaInfo[i].name);
}
m_choice_chara->Select(0);
// カラーコンボの初期化
for (int i = 0; i < kPaletteCount; i++) {
m_choice_color->Append(kPaletteLabel[i]);
}
m_choice_color->Select(0);
change_color_edit_chara(0); // sol
read_image_data(0, 0);
// 20msに１回描画
m_timer.SetOwner(this, wxID_ANY);
m_timer.Start(20, wxTIMER_CONTINUOUS);
DragAcceptFiles(true);
}
void ggscfg_ColorEditSheet::on_choice_color(wxCommandEvent& event) {
int imgidx = m_choice_id->GetSelection();
int palidx = m_choice_color->GetSelection();
if (palidx != m_cur_palette) {
int ret = check_save_palette();
if (ret == 1) {
// yes
write_palette();
m_palette_changed = false;
} else if (ret == 0) {
// cancel
m_choice_color->SetSelection(m_cur_palette);
return;
}
read_image_data(imgidx, palidx);
update_ggxx_palette(false);
}
}
void ggscfg_ColorEditSheet::on_choice_chara(wxCommandEvent& event) {
int cid = m_choice_chara->GetSelection();
int palidx = m_choice_color->GetSelection();
if (cid != m_cur_cid) {
int ret = check_save_palette();
if (ret == 1) {
// yes
write_palette();
m_palette_changed = false;
} else if (ret == 0) {
// cancel
m_choice_chara->SetSelection(m_cur_cid);
return;
}
change_color_edit_chara(cid);
read_image_data(0, palidx);
update_ggxx_palette(false);
}
}
static int __init read_suspend_image(void)
{
int error = 0;
if ((error = check_sig()))
return error;
if ((error = check_header()))
return error;
if ((error = read_pagedir()))
return error;
if ((error = relocate_pagedir()))
goto FreePagedir;
if ((error = check_pagedir()))
goto FreePagedir;
if ((error = read_image_data()))
goto FreePagedir;
Done:
return error;
FreePagedir:
free_pages((unsigned long)pm_pagedir_nosave,pagedir_order);
goto Done;
}
int main(int argc, char **argv) {
/* Host/device data structures */
cl_device_id device;
cl_context context;
cl_command_queue queue;
cl_program program;
cl_kernel kernel;
cl_int err;
size_t global_size[2];
/* Image data */
png_bytep pixels;
cl_image_format png_format;
cl_mem input_image, output_image;
size_t origin[3], region[3];
size_t width, height;
/* Open input file and read image data */
read_image_data(INPUT_FILE, &pixels, &width, &height);
/* Create a device and context */
device = create_device();
context = clCreateContext(NULL, 1, &device, NULL, NULL, &err);
if(err < 0) {
perror("Couldn't create a context");
exit(1);
}
/* Build the program and create a kernel */
program = build_program(context, device, PROGRAM_FILE);
kernel = clCreateKernel(program, KERNEL_FUNC, &err);
if(err < 0) {
printf("Couldn't create a kernel: %d", err);
exit(1);
};
/* Create image object */
png_format.image_channel_order = CL_LUMINANCE;
png_format.image_channel_data_type = CL_UNORM_INT16;
input_image = clCreateImage2D(context,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
&png_format, width, height, 0, (void*)pixels, &err);
output_image = clCreateImage2D(context,
CL_MEM_WRITE_ONLY, &png_format, width, height, 0, NULL, &err);
if(err < 0) {
perror("Couldn't create the image object");
exit(1);
};
/* Create kernel arguments */
err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &input_image);
err |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &output_image);
if(err < 0) {
printf("Couldn't set a kernel argument");
exit(1);
};
/* Create a command queue */
queue = clCreateCommandQueue(context, device, 0, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
};
/* Enqueue kernel */
global_size[0] = height; global_size[1] = width;
err = clEnqueueNDRangeKernel(queue, kernel, 2, NULL, global_size,
NULL, 0, NULL, NULL);
if(err < 0) {
perror("Couldn't enqueue the kernel");
exit(1);
}
/* Read the image object */
origin[0] = 0; origin[1] = 0; origin[2] = 0;
region[0] = width; region[1] = height; region[2] = 1;
err = clEnqueueReadImage(queue, output_image, CL_TRUE, origin,
region, 0, 0, (void*)pixels, 0, NULL, NULL);
if(err < 0) {
perror("Couldn't read from the image object");
exit(1);
}
/* Create output PNG file and write data */
write_image_data(OUTPUT_FILE, pixels, width, height);
/* Deallocate resources */
free(pixels);
clReleaseMemObject(input_image);
clReleaseMemObject(output_image);
clReleaseKernel(kernel);
clReleaseCommandQueue(queue);
clReleaseProgram(program);
clReleaseContext(context);
return 0;
}
/* Initialize OpenCL processing */
void init_cl() {
char *program_buffer, *program_log;
size_t program_size, log_size;
cl_image_format png_format;
int err;
/* Identify a platform */
err = clGetPlatformIDs(1, &platform, NULL);
if(err < 0) {
perror("Couldn't identify a platform");
exit(1);
}
/* Access a device */
err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL);
if(err == CL_DEVICE_NOT_FOUND) {
err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU, 1, &device, NULL);
}
if(err < 0) {
perror("Couldn't access any devices");
exit(1);
}
/* Create OpenCL context properties */
#ifdef MAC
CGLContextObj mac_context = CGLGetCurrentContext();
CGLShareGroupObj group = CGLGetShareGroup(mac_context);
cl_context_properties properties[] = {
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE,
(cl_context_properties)group, 0};
#else
#ifdef UNIX
cl_context_properties properties[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),
CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(),
CL_CONTEXT_PLATFORM, (cl_context_properties)platform, 0};
#else
cl_context_properties properties[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties)wglGetCurrentContext(),
CL_WGL_HDC_KHR, (cl_context_properties)wglGetCurrentDC(),
CL_CONTEXT_PLATFORM, (cl_context_properties)platform, 0};
#endif
#endif
/* Create context */
context = clCreateContext(properties, 1, &device, NULL, NULL, &err);
if(err < 0) {
perror("Couldn't create a context");
exit(1);
}
/* Create program from file */
program_buffer = read_file(PROGRAM_FILE, &program_size);
program = clCreateProgramWithSource(context, 1,
(const char**)&program_buffer, &program_size, &err);
if(err < 0) {
perror("Couldn't create the program");
exit(1);
}
free(program_buffer);
/* Build program */
err = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
if(err < 0) {
/* Find size of log and print to std output */
clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,
0, NULL, &log_size);
program_log = (char*) malloc(log_size + 1);
program_log[log_size] = '\0';
clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,
log_size + 1, program_log, NULL);
printf("%s\n", program_log);
free(program_log);
exit(1);
}
/* Create a command queue */
queue = clCreateCommandQueue(context, device, 0, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
};
/* Create kernel */
kernel = clCreateKernel(program, KERNEL_FUNC, &err);
if(err < 0) {
printf("Couldn't create a kernel: %d", err);
exit(1);
};
/* Read pixel data */
read_image_data(TEXTURE_FILE, &tex_pixels, &width, &height);
/* Create the input image object from the PNG data */
png_format.image_channel_order = CL_R;
png_format.image_channel_data_type = CL_UNSIGNED_INT8;
in_texture = clCreateImage2D(context,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
&png_format, width, height, 0, (void*)tex_pixels, &err);
if(err < 0) {
perror("Couldn't create the image object");
exit(1);
};
/* Create kernel arguments */
err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &in_texture);
if(err < 0) {
printf("Couldn't set a kernel argument");
exit(1);
};
}
int
png_include_image (pdf_ximage *ximage, FILE *png_file)
{
pdf_obj *stream;
pdf_obj *stream_dict;
pdf_obj *colorspace, *mask, *intent;
png_bytep stream_data_ptr;
int trans_type;
ximage_info info;
/* Libpng stuff */
png_structp png_ptr;
png_infop png_info_ptr;
png_byte bpc, color_type;
png_uint_32 width, height, rowbytes;
pdf_ximage_init_image_info(&info);
stream = NULL;
stream_dict = NULL;
colorspace = mask = intent = NULL;
rewind (png_file);
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, warn);
if (png_ptr == NULL ||
(png_info_ptr = png_create_info_struct (png_ptr)) == NULL) {
WARN("%s: Creating Libpng read/info struct failed.", PNG_DEBUG_STR);
if (png_ptr)
png_destroy_read_struct(&png_ptr, NULL, NULL);
return -1;
}
#if PNG_LIBPNG_VER >= 10603
/* ignore possibly incorrect CMF bytes */
png_set_option(png_ptr, PNG_MAXIMUM_INFLATE_WINDOW, PNG_OPTION_ON);
#endif
/* Inititializing file IO. */
png_init_io (png_ptr, png_file);
/* Read PNG info-header and get some info. */
png_read_info(png_ptr, png_info_ptr);
color_type = png_get_color_type (png_ptr, png_info_ptr);
width = png_get_image_width (png_ptr, png_info_ptr);
height = png_get_image_height(png_ptr, png_info_ptr);
bpc = png_get_bit_depth (png_ptr, png_info_ptr);
/* Ask libpng to convert down to 8-bpc. */
if (bpc > 8) {
if (pdf_get_version() < 5) {
WARN("%s: 16-bpc PNG requires PDF version 1.5.", PNG_DEBUG_STR);
png_set_strip_16(png_ptr);
bpc = 8;
}
}
/* Ask libpng to gamma-correct.
* It is wrong to assume screen gamma value 2.2 but...
* We do gamma correction here only when uncalibrated color space is used.
*/
if (!png_get_valid(png_ptr, png_info_ptr, PNG_INFO_iCCP) &&
!png_get_valid(png_ptr, png_info_ptr, PNG_INFO_sRGB) &&
!png_get_valid(png_ptr, png_info_ptr, PNG_INFO_cHRM) &&
png_get_valid(png_ptr, png_info_ptr, PNG_INFO_gAMA)) {
double G = 1.0;
png_get_gAMA (png_ptr, png_info_ptr, &G);
png_set_gamma(png_ptr, 2.2, G);
}
trans_type = check_transparency(png_ptr, png_info_ptr);
/* check_transparency() does not do updata_info() */
png_read_update_info(png_ptr, png_info_ptr);
rowbytes = png_get_rowbytes(png_ptr, png_info_ptr);
/* Values listed below will not be modified in the remaining process. */
info.width = width;
info.height = height;
info.bits_per_component = bpc;
if (compat_mode)
info.xdensity = info.ydensity = 72.0 / 100.0;
else
{
png_uint_32 xppm = png_get_x_pixels_per_meter(png_ptr, png_info_ptr);
png_uint_32 yppm = png_get_y_pixels_per_meter(png_ptr, png_info_ptr);
if (xppm > 0)
info.xdensity = 72.0 / 0.0254 / xppm;
if (yppm > 0)
info.ydensity = 72.0 / 0.0254 / yppm;
}
stream = pdf_new_stream (STREAM_COMPRESS);
stream_dict = pdf_stream_dict(stream);
stream_data_ptr = (png_bytep) NEW(rowbytes*height, png_byte);
read_image_data(png_ptr, stream_data_ptr, height, rowbytes);
/* Non-NULL intent means there is valid sRGB chunk. */
intent = get_rendering_intent(png_ptr, png_info_ptr);
if (intent)
pdf_add_dict(stream_dict, pdf_new_name("Intent"), intent);
switch (color_type) {
case PNG_COLOR_TYPE_PALETTE:
colorspace = create_cspace_Indexed(png_ptr, png_info_ptr);
switch (trans_type) {
case PDF_TRANS_TYPE_BINARY:
/* Color-key masking */
mask = create_ckey_mask(png_ptr, png_info_ptr);
break;
case PDF_TRANS_TYPE_ALPHA:
/* Soft mask */
mask = create_soft_mask(png_ptr, png_info_ptr, stream_data_ptr, width, height);
break;
default:
/* Nothing to be done here.
* No tRNS chunk or image already composited with background color.
*/
break;
}
info.num_components = 1;
break;
case PNG_COLOR_TYPE_RGB:
case PNG_COLOR_TYPE_RGB_ALPHA:
if (png_get_valid(png_ptr, png_info_ptr, PNG_INFO_iCCP))
colorspace = create_cspace_ICCBased(png_ptr, png_info_ptr);
else if (intent) {
colorspace = create_cspace_sRGB(png_ptr, png_info_ptr);
} else {
colorspace = create_cspace_CalRGB(png_ptr, png_info_ptr);
}
if (!colorspace)
colorspace = pdf_new_name("DeviceRGB");
switch (trans_type) {
case PDF_TRANS_TYPE_BINARY:
mask = create_ckey_mask(png_ptr, png_info_ptr);
break;
/* rowbytes changes 4 to 3 at here */
case PDF_TRANS_TYPE_ALPHA:
mask = strip_soft_mask(png_ptr, png_info_ptr,
stream_data_ptr, &rowbytes, width, height);
break;
default:
mask = NULL;
}
info.num_components = 3;
break;
case PNG_COLOR_TYPE_GRAY:
case PNG_COLOR_TYPE_GRAY_ALPHA:
if (png_get_valid(png_ptr, png_info_ptr, PNG_INFO_iCCP))
colorspace = create_cspace_ICCBased(png_ptr, png_info_ptr);
else if (intent) {
colorspace = create_cspace_sRGB(png_ptr, png_info_ptr);
} else {
colorspace = create_cspace_CalGray(png_ptr, png_info_ptr);
}
if (!colorspace)
colorspace = pdf_new_name("DeviceGray");
switch (trans_type) {
case PDF_TRANS_TYPE_BINARY:
mask = create_ckey_mask(png_ptr, png_info_ptr);
break;
case PDF_TRANS_TYPE_ALPHA:
mask = strip_soft_mask(png_ptr, png_info_ptr,
stream_data_ptr, &rowbytes, width, height);
break;
default:
mask = NULL;
}
info.num_components = 1;
break;
default:
WARN("%s: Unknown PNG colortype %d.", PNG_DEBUG_STR, color_type);
}
pdf_add_dict(stream_dict, pdf_new_name("ColorSpace"), colorspace);
pdf_add_stream(stream, stream_data_ptr, rowbytes*height);
RELEASE(stream_data_ptr);
if (mask) {
if (trans_type == PDF_TRANS_TYPE_BINARY)
pdf_add_dict(stream_dict, pdf_new_name("Mask"), mask);
else if (trans_type == PDF_TRANS_TYPE_ALPHA) {
if (info.bits_per_component >= 8 && info.width > 64) {
pdf_stream_set_predictor(mask, 2, info.width,
info.bits_per_component, 1);
}
pdf_add_dict(stream_dict, pdf_new_name("SMask"), pdf_ref_obj(mask));
pdf_release_obj(mask);
} else {
WARN("%s: Unknown transparency type...???", PNG_DEBUG_STR);
pdf_release_obj(mask);
}
}
/* Finally read XMP Metadata
* See, XMP Specification Part 3, Storage in Files
* http://www.adobe.com/jp/devnet/xmp.html
*
* We require libpng version >= 1.6.14 since prior versions
* of libpng had a bug that incorrectly treat the compression
* flag of iTxt chunks.
*/
#if PNG_LIBPNG_VER >= 10614
if (pdf_get_version() >= 4) {
png_textp text_ptr;
pdf_obj *XMP_stream, *XMP_stream_dict;
int i, num_text;
int have_XMP = 0;
num_text = png_get_text(png_ptr, png_info_ptr, &text_ptr, NULL);
for (i = 0; i < num_text; i++) {
if (!memcmp(text_ptr[i].key, "XML:com.adobe.xmp", 17)) {
/* XMP found */
if (text_ptr[i].compression != PNG_ITXT_COMPRESSION_NONE ||
text_ptr[i].itxt_length == 0)
WARN("%s: Invalid value(s) in iTXt chunk for XMP Metadata.", PNG_DEBUG_STR);
else if (have_XMP)
WARN("%s: Multiple XMP Metadata. Don't know how to treat it.", PNG_DEBUG_STR);
else {
/* We compress XMP metadata for included images here.
* It is not recommended to compress XMP metadata for PDF documents but
* we compress XMP metadata for included images here to avoid confusing
* application programs that only want PDF document global XMP metadata
* and scan for that.
*/
XMP_stream = pdf_new_stream(STREAM_COMPRESS);
XMP_stream_dict = pdf_stream_dict(XMP_stream);
pdf_add_dict(XMP_stream_dict,
pdf_new_name("Type"), pdf_new_name("Metadata"));
pdf_add_dict(XMP_stream_dict,
pdf_new_name("Subtype"), pdf_new_name("XML"));
pdf_add_stream(XMP_stream, text_ptr[i].text, text_ptr[i].itxt_length);
pdf_add_dict(stream_dict,
pdf_new_name("Metadata"), pdf_ref_obj(XMP_stream));
pdf_release_obj(XMP_stream);
have_XMP = 1;
}
}
}
}
#endif /* PNG_LIBPNG_VER */
png_read_end(png_ptr, NULL);
/* Cleanup */
if (png_info_ptr)
png_destroy_info_struct(png_ptr, &png_info_ptr);
if (png_ptr)
png_destroy_read_struct(&png_ptr, NULL, NULL);
if (color_type != PNG_COLOR_TYPE_PALETTE &&
info.bits_per_component >= 8 &&
info.height > 64) {
pdf_stream_set_predictor(stream, 15, info.width,
info.bits_per_component, info.num_components);
}
pdf_ximage_set_image(ximage, &info, stream);
return 0;
}
void ggscfg_ColorEditSheet::on_choice_id(wxCommandEvent& event) {
int imgidx = m_choice_id->GetSelection();
read_image_data(imgidx, -1);
}