int writeimage(char * name, int xres, int yres, unsigned char *imgdata,
int format) {
if (imgdata == NULL)
return IMAGENULLDATA;
switch (format) {
case RT_FORMAT_PPM:
return writeppm(name, xres, yres, imgdata);
case RT_FORMAT_SGIRGB:
return writergb(name, xres, yres, imgdata);
case RT_FORMAT_JPEG:
return writejpeg(name, xres, yres, imgdata);
case RT_FORMAT_PNG:
return writepng(name, xres, yres, imgdata);
case RT_FORMAT_WINBMP:
return writebmp(name, xres, yres, imgdata);
case RT_FORMAT_TARGA:
default:
return writetga(name, xres, yres, imgdata);
}
}
/**
* grx_context_save_to_png:
* @context: (nullable): Context to be saved or %NULL to use the global context
* @filename: (type filename): Name of png file
* @error: pointer to hold an error or %NULL to ignore
*
* Dump a context in a PNG file
*
* This routine works both in RGB and palette modes
*
* Returns: %TRUE on success, otherwise %FALSE
*/
gboolean grx_context_save_to_png(GrxContext *grc, char *pngfn, GError **error)
{
GrxContext grcaux;
FILE *f;
gboolean r;
f = fopen( pngfn,"wb" );
if (f == NULL) {
g_set_error(error, G_IO_ERROR, g_io_error_from_errno(errno),
"Failed to open '%s'", pngfn);
return FALSE;
}
grx_save_current_context( &grcaux );
if( grc != NULL ) grx_set_current_context( grc );
r = writepng( f,grc );
grx_set_current_context( &grcaux );
fclose( f );
if (!r) {
g_set_error(error, GRX_ERROR, GRX_ERROR_PNG_ERROR,
"Problem with PNG data in '%s'", pngfn);
}
return r;
}
int main() {
{
const char* depthfile = "/home/tfogal/data/scenedemo/D01293.png";
uint8_t* img;
uint32_t width, height;
readpng(depthfile, &img, &width, &height);
std::shared_ptr<void> id(img, free);
bstream_t info = {
UNSIGNED_INTEGER,
sizeof(uint8_t),
1,
{ width, height, 1, 1 }
};
//std::array<uint64_t,4> dims = {{ width, height, 1, 1 }};
#if 0
gv::Crop c;
c.set_axis(0);
c.set_index(320);
c.set_input(id, info);
c.execute();
#endif
gv::Cast cast;
cast.set_input(id, info);
bstream_t convert = info;
convert.width = 2;
cast.set_otype(convert);
cast.execute();
gv::stream upcasted = cast.output(0);
assert(((const uint16_t*)upcasted.data.get())[0] == 27);
writepng("test.png", (const uint16_t*)upcasted.data.get(), width, height);
}
{
gv::MinMax mm;
std::array<double, 12> arr = {{ 9,11,16,42, 19,8,-2,4, -19,86,14,8 }};
bstream_t arri = {
FLOAT,
sizeof(double),
1,
{ 12, 1, 1, 1 }
};
mm.set_input(std::shared_ptr<void>(arr.data(), nonstd::null_deleter()),
arri);
mm.execute();
gv::stream mmax = mm.output(0);
const double* dat = static_cast<const double*>(mmax.data.get());
std::cout << "minmax: (" << dat[0] << ")--(" << dat[1] << ")\n";
}
return EXIT_SUCCESS;
}
void screenshot(const char *basename)
{
if (basename == NULL)
basename = "screenshot";
char name[6 + strlen(basename) + 4 + 4 + 1];
int count = 0;
FILE *fp = NULL;
unsigned char *image;
int invert_alpha = 0;
do {
if (fp)
fclose(fp);
#if SYS
sprintf(name, "%s%03d.png", basename, count++);
#else
sprintf(name, "ms0:/%s%03d.png", basename, count++);
#endif
fp = fopen(name, "rb");
} while(fp != NULL && count < 1000);
if (count == 1000) {
if (fp)
fclose(fp);
return;
}
fp = fopen(name, "wb");
if (fp == NULL)
return;
//image = malloc(480*272*4);
image = memalign(64, 480*272*4);
glReadPixels(0,0, 480,272, GL_RGBA, GL_UNSIGNED_BYTE, image);
if (glGetError() != 0)
goto out;
/* Check to see if the opacity is 100%. */
if ((*(unsigned int *)image & 0xff000000) == 0)
invert_alpha = 1;
writepng(fp, image, 480, 272, invert_alpha);
out:
fclose(fp);
free(image);
}
int
main(int argc, char **argv)
{
FILE *in;
struct meta *imghead;
uint16_t *imgdata;
struct ares ar;
size_t want;
if(argc != 3) {
printf("Usage: %s <is2-input> <png-output>\n", argv[0]);
exit(1);
}
in = fopen(argv[1], "rb");
if(!in) {
perror("fopen");
exit(1);
}
want = 366;
imghead = readblob(in, want);
puts("Header m1");
hexdump(imghead, want);
want = 160 * 120 * 2;
imgdata = readblob(in, want);
puts("Image");
hexdump(imgdata, want);
puts("Analyzing...");
analyze(&ar, imgdata, 160, 120);
fumble(&ar, imgdata, 160, 120);
printf("min %x max %x\n", ar.min, ar.max);
writepng(argv[2], imgdata, 160, 120);
return 0;
}
int GrSaveContextToPng( GrContext *grc, char *pngfn )
{
GrContext grcaux;
FILE *f;
int r;
f = fopen( pngfn,"wb" );
if( f == NULL ) return -1;
GrSaveContext( &grcaux );
if( grc != NULL ) GrSetContext( grc );
r = writepng( f,grc );
GrSetContext( &grcaux );
fclose( f );
return r;
}
void
exec(const char* fn, const void* buf, size_t n)
{
(void)fn;
if(n == dims[0]*dims[1]*dims[2]*sizeof(float)) {
float rng[2];
range((const float*)buf, n/sizeof(float), &rng[0], &rng[1]);
TRACE(nek, "[%zu] range: [%14.7g %14.7g]", rank(), rng[0], rng[1]);
if(quant == NULL) {
quant = calloc(dims[0]*dims[1]*dims[2], sizeof(uint16_t));
}
if(fld != 4) { /* 4 is always blank, it seems. */
memset(quant, 0, dims[0]*dims[1]*dims[2]*sizeof(uint16_t));
quantize((const float*)buf, n/sizeof(float), rng[0], rng[1], quant);
char fname[256];
snprintf(fname, 256, "%zu.fld%zu.png", ts, fld);
writepng(fname, quant, dims[0], dims[1]);
}
next_field();
}
}
void do_emu_action(void)
{
int ret;
emu_action_old = emu_action;
switch (emu_action) {
case SACTION_LOAD_STATE:
ret = emu_load_state(state_slot);
snprintf(hud_msg, sizeof(hud_msg), ret == 0 ? "LOADED" : "FAIL!");
break;
case SACTION_SAVE_STATE:
ret = emu_save_state(state_slot);
snprintf(hud_msg, sizeof(hud_msg), ret == 0 ? "SAVED" : "FAIL!");
break;
#ifndef NO_FRONTEND
case SACTION_ENTER_MENU:
toggle_fast_forward(1);
menu_loop();
return;
case SACTION_NEXT_SSLOT:
state_slot++;
if (state_slot > 9)
state_slot = 0;
goto do_state_slot;
case SACTION_PREV_SSLOT:
state_slot--;
if (state_slot < 0)
state_slot = 9;
do_state_slot:
snprintf(hud_msg, sizeof(hud_msg), "STATE SLOT %d [%s]", state_slot,
emu_check_state(state_slot) == 0 ? "USED" : "FREE");
hud_new_msg = 3;
SysPrintf("* %s\n", hud_msg);
break;
case SACTION_TOGGLE_FSKIP:
pl_rearmed_cbs.fskip_advice = 0;
pl_rearmed_cbs.frameskip++;
if (pl_rearmed_cbs.frameskip > 1)
pl_rearmed_cbs.frameskip = -1;
snprintf(hud_msg, sizeof(hud_msg), "FRAMESKIP: %s",
pl_rearmed_cbs.frameskip == -1 ? "AUTO" :
pl_rearmed_cbs.frameskip == 0 ? "OFF" : "1" );
plugin_call_rearmed_cbs();
break;
case SACTION_SWITCH_DISPMODE:
pl_switch_dispmode();
plugin_call_rearmed_cbs();
if (GPU_open != NULL && GPU_close != NULL) {
GPU_close();
GPU_open(&gpuDisp, "PCSX", NULL);
}
break;
case SACTION_FAST_FORWARD:
toggle_fast_forward(0);
plugin_call_rearmed_cbs();
break;
case SACTION_TOGGLE_FPS:
if ((g_opts & (OPT_SHOWFPS|OPT_SHOWCPU))
== (OPT_SHOWFPS|OPT_SHOWCPU))
g_opts &= ~(OPT_SHOWFPS|OPT_SHOWCPU);
else if (g_opts & OPT_SHOWFPS)
g_opts |= OPT_SHOWCPU;
else
g_opts |= OPT_SHOWFPS;
break;
case SACTION_TOGGLE_FULLSCREEN:
plat_target.vout_fullscreen = !plat_target.vout_fullscreen;
if (GPU_open != NULL && GPU_close != NULL) {
GPU_close();
GPU_open(&gpuDisp, "PCSX", NULL);
}
break;
case SACTION_SCREENSHOT:
{
char buf[MAXPATHLEN];
void *scrbuf;
int w, h, bpp;
time_t t = time(NULL);
struct tm *tb = localtime(&t);
int ti = tb->tm_yday * 1000000 + tb->tm_hour * 10000 +
tb->tm_min * 100 + tb->tm_sec;
scrbuf = pl_prepare_screenshot(&w, &h, &bpp);
get_gameid_filename(buf, sizeof(buf),
"screenshots/%.32s-%.9s.%d.png", ti);
ret = -1;
if (scrbuf != 0 && bpp == 16)
ret = writepng(buf, scrbuf, w, h);
if (ret == 0)
snprintf(hud_msg, sizeof(hud_msg), "SCREENSHOT TAKEN");
break;
}
case SACTION_VOLUME_UP:
case SACTION_VOLUME_DOWN:
{
static int volume;
plat_target_step_volume(&volume,
emu_action == SACTION_VOLUME_UP ? 1 : -1);
}
return;
case SACTION_MINIMIZE:
if (GPU_close != NULL)
GPU_close();
plat_minimize();
if (GPU_open != NULL) {
ret = GPU_open(&gpuDisp, "PCSX", NULL);
if (ret)
SysMessage("GPU_open returned %d", ret);
}
return;
#endif
default:
return;
}
hud_new_msg = 3;
}
static int
xgraph(HConnect *c)
{
char *name;
Hio *hout;
Memimage *m;
int dotext;
Graph g;
Arg arg;
char *graph, *a;
name = hargstr(c, "arg", "");
if((arg.index = findname(name)) == -1 && strcmp(name, "*") != 0){
werrstr("unknown name %s", name);
goto error;
}
a = hargstr(c, "arg2", "");
if(a[0] && (arg.index2 = findname(a)) == -1){
werrstr("unknown name %s", a);
goto error;
}
g.arg = &arg;
g.t0 = hargint(c, "t0", -120);
g.t1 = hargint(c, "t1", 0);
g.min = hargint(c, "min", -1);
g.max = hargint(c, "max", -1);
g.wid = hargint(c, "wid", -1);
g.ht = hargint(c, "ht", -1);
dotext = hargstr(c, "text", "")[0] != 0;
g.fill = hargint(c, "fill", -1);
graph = hargstr(c, "graph", "raw");
if(strcmp(graph, "raw") == 0)
g.fn = rawgraph;
else if(strcmp(graph, "diskbw") == 0)
g.fn = diskgraph;
else if(strcmp(graph, "iobw") == 0)
g.fn = iograph;
else if(strcmp(graph, "netbw") == 0)
g.fn = netgraph;
else if(strcmp(graph, "diff") == 0)
g.fn = diffgraph;
else if(strcmp(graph, "pct") == 0)
g.fn = pctgraph;
else if(strcmp(graph, "pctdiff") == 0)
g.fn = pctdiffgraph;
else if(strcmp(graph, "divdiff") == 0)
g.fn = divdiffgraph;
else{
werrstr("unknown graph %s", graph);
goto error;
}
if(dotext){
hsettype(c, "text/plain");
dotextbin(&c->hout, &g);
hflush(&c->hout);
return 0;
}
m = statgraph(&g);
if(m == nil)
goto error;
if(hsettype(c, "image/png") < 0)
return -1;
hout = &c->hout;
writepng(hout, m);
qlock(&memdrawlock);
freememimage(m);
qunlock(&memdrawlock);
hflush(hout);
return 0;
error:
return herror(c);
}
