static int write(struct img_pixmap *img, struct img_io *io)
{
struct img_pixmap fimg;
img_init(&fimg);
if(img_copy(&fimg, img) == -1) {
img_destroy(&fimg);
return -1;
}
if(img_convert(&fimg, IMG_FMT_RGBF) == -1) {
img_destroy(&fimg);
return -1;
}
if(rgbe_write_header(io, fimg.width, fimg.height, 0) == -1) {
img_destroy(&fimg);
return -1;
}
if(rgbe_write_pixels_rle(io, fimg.pixels, fimg.width, fimg.height) == -1) {
img_destroy(&fimg);
return -1;
}
img_destroy(&fimg);
return 0;
}
int img_convert(struct img_pixmap *img, enum img_fmt tofmt)
{
struct pixel pbuf[8];
int bufsz = (img->width & 7) == 0 ? 8 : ((img->width & 3) == 0 ? 4 : 1);
int i, num_pix = img->width * img->height;
int num_iter = num_pix / bufsz;
char *sptr, *dptr;
struct img_pixmap nimg;
if(img->fmt == tofmt) {
return 0; /* nothing to do */
}
img_init(&nimg);
if(img_set_pixels(&nimg, img->width, img->height, tofmt, 0) == -1) {
img_destroy(&nimg);
return -1;
}
sptr = img->pixels;
dptr = nimg.pixels;
for(i=0; i<num_iter; i++) {
unpack[img->fmt](pbuf, sptr, bufsz);
pack[tofmt](dptr, pbuf, bufsz);
sptr += bufsz * img->pixelsz;
dptr += bufsz * nimg.pixelsz;
}
img_copy(img, &nimg);
img_destroy(&nimg);
return 0;
}
static int write(struct img_pixmap *img, struct img_io *io)
{
int i, nlines = 0;
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
struct dst_mgr dest;
struct img_pixmap tmpimg;
unsigned char **scanlines;
img_init(&tmpimg);
if(img->fmt != IMG_FMT_RGB24) {
if(img_copy(&tmpimg, img) == -1) {
return -1;
}
if(img_convert(&tmpimg, IMG_FMT_RGB24) == -1) {
img_destroy(&tmpimg);
return -1;
}
img = &tmpimg;
}
if(!(scanlines = malloc(img->height * sizeof *scanlines))) {
img_destroy(&tmpimg);
return -1;
}
scanlines[0] = img->pixels;
for(i=1; i<img->height; i++) {
scanlines[i] = scanlines[i - 1] + img->width * img->pixelsz;
}
cinfo.err = jpeg_std_error(&jerr); /* XXX */
jpeg_create_compress(&cinfo);
dest.pub.init_destination = init_destination;
dest.pub.empty_output_buffer = empty_output_buffer;
dest.pub.term_destination = term_destination;
dest.io = io;
cinfo.dest = (struct jpeg_destination_mgr*)&dest;
cinfo.image_width = img->width;
cinfo.image_height = img->height;
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&cinfo);
jpeg_start_compress(&cinfo, 1);
while(nlines < img->height) {
int res = jpeg_write_scanlines(&cinfo, scanlines + nlines, img->height - nlines);
nlines += res;
}
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
free(scanlines);
img_destroy(&tmpimg);
return 0;
}
unsigned int img_gltexture_read(struct img_io *io)
{
struct img_pixmap img;
unsigned int tex;
img_init(&img);
if(img_read(&img, io) == -1) {
img_destroy(&img);
return 0;
}
tex = img_gltexture(&img);
img_destroy(&img);
return tex;
}
unsigned int img_gltexture_read_file(FILE *fp)
{
struct img_pixmap img;
unsigned int tex;
img_init(&img);
if(img_read_file(&img, fp) == -1) {
img_destroy(&img);
return 0;
}
tex = img_gltexture(&img);
img_destroy(&img);
return tex;
}
unsigned int img_gltexture_load(const char *fname)
{
struct img_pixmap img;
unsigned int tex;
img_init(&img);
if(img_load(&img, fname) == -1) {
img_destroy(&img);
return 0;
}
tex = img_gltexture(&img);
img_destroy(&img);
return tex;
}
int main(int argc, char *argv[])
{
image_t *img, *dst;
if (argc < 3) {
printf("Usage : <src_path> <dst_path>.\n");
}
img = load_bmp(argv[1]);
dst = gauss_filter(img, 10);
save_as_bmp(dst, argv[2]);
img_destroy(img);
img_destroy(dst);
return 0;
}
int main(int argc, char *argv[])
{
image_t *img;
img = load_jpeg(argv[1]);
save_as_bmp(img, argv[2]);
img_destroy(img);
return 0;
}
GGPROTO::~GGPROTO()
{
#ifdef DEBUGMODE
debugLogA("~GGPROTO(): destroying protocol interface");
#endif
// Destroy modules
block_uninit();
img_destroy();
keepalive_destroy();
gc_destroy();
Popup_UnregisterClass(hPopupError);
Popup_UnregisterClass(hPopupNotify);
if (hMenuRoot)
CallService(MS_CLIST_REMOVEMAINMENUITEM, (WPARAM)hMenuRoot, 0);
// Close handles
Netlib_CloseHandle(m_hNetlibUser);
// Destroy mutexes
DeleteCriticalSection(&sess_mutex);
DeleteCriticalSection(&ft_mutex);
DeleteCriticalSection(&img_mutex);
DeleteCriticalSection(&modemsg_mutex);
DeleteCriticalSection(&avatar_mutex);
DeleteCriticalSection(&sessions_mutex);
#ifdef DEBUGMODE
debugLogA("~GGPROTO(): DeleteCriticalSections. OK");
#endif
// Free status messages
if (modemsg.online) mir_free(modemsg.online);
if (modemsg.away) mir_free(modemsg.away);
if (modemsg.dnd) mir_free(modemsg.dnd);
if (modemsg.freechat) mir_free(modemsg.freechat);
if (modemsg.invisible) mir_free(modemsg.invisible);
if (modemsg.offline) mir_free(modemsg.offline);
}
int parse_args(int argc, char **argv)
{
int i;
char *endp;
struct list_node *head = 0, *tail = 0;
for(i=1; i<argc; i++) {
if(argv[i][0] == '-' && argv[i][2] == 0) {
switch(argv[i][1]) {
case 'f':
fullscreen = !fullscreen;
break;
case 's':
stereo = !stereo;
break;
case 't':
threshold = strtod(argv[++i], &endp);
if(endp == argv[i]) {
fprintf(stderr, "-t must be followed by a number\n");
return -1;
}
break;
case 'h':
printf("usage: %s [opt]\n", argv[0]);
printf("options:\n");
printf(" -f start in fullscreen\n");
printf(" -s enable stereoscopic rendering\n");
printf(" -h print usage and exit\n");
exit(0);
default:
fprintf(stderr, "unrecognized option: %s\n", argv[i]);
return -1;
}
} else {
struct list_node *slice;
if(!(slice = malloc(sizeof *slice))) {
fprintf(stderr, "failed to allocate volume slice: %d\n", num_slices);
return -1;
}
slice->next = 0;
img_init(&slice->img);
if(img_load(&slice->img, argv[i]) == -1) {
fprintf(stderr, "failed to load volume slice %d: %s\n", num_slices, argv[i]);
free(slice);
return -1;
}
img_convert(&slice->img, IMG_FMT_GREY8);
if(num_slices > 0 && (xres != slice->img.width || yres != slice->img.height)) {
fprintf(stderr, "error: slice %d (%s) is %dx%d, up to now we had %dx%d images\n", num_slices, argv[i],
slice->img.width, slice->img.height, xres, yres);
img_destroy(&slice->img);
free(slice);
return -1;
}
xres = slice->img.width;
yres = slice->img.height;
if(head) {
tail->next = slice;
tail = slice;
} else {
head = tail = slice;
}
printf("loaded volume slice %d: %s\n", num_slices++, argv[i]);
}
}
if(!head) {
fprintf(stderr, "you must specify a list of images for the volume data slices\n");
return -1;
}
if(!(volume = malloc(num_slices * sizeof *volume))) {
fprintf(stderr, "failed to allocate volume data (%d slices)\n", num_slices);
return -1;
}
for(i=0; i<num_slices; i++) {
void *tmp;
assert(head);
volume[i] = head->img;
tmp = head;
head = head->next;
free(tmp);
}
return 0;
}
static int write_file(struct img_pixmap *img, struct img_io *io)
{
png_struct *png;
png_info *info;
png_text txt;
struct img_pixmap tmpimg;
unsigned char **rows;
unsigned char *pixptr;
int i, coltype;
img_init(&tmpimg);
if(!(png = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) {
return -1;
}
if(!(info = png_create_info_struct(png))) {
png_destroy_write_struct(&png, 0);
return -1;
}
/* if the input image is floating-point, we need to convert it to integer */
if(img_is_float(img)) {
if(img_copy(&tmpimg, img) == -1) {
return -1;
}
if(img_to_integer(&tmpimg) == -1) {
img_destroy(&tmpimg);
return -1;
}
img = &tmpimg;
}
txt.compression = PNG_TEXT_COMPRESSION_NONE;
txt.key = "Software";
txt.text = "libimago2";
txt.text_length = 0;
if(setjmp(png_jmpbuf(png))) {
png_destroy_write_struct(&png, &info);
img_destroy(&tmpimg);
return -1;
}
png_set_write_fn(png, io, write_func, flush_func);
coltype = fmt_to_png_type(img->fmt);
png_set_IHDR(png, info, img->width, img->height, 8, coltype, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
png_set_text(png, info, &txt, 1);
if(!(rows = malloc(img->height * sizeof *rows))) {
png_destroy_write_struct(&png, &info);
img_destroy(&tmpimg);
return -1;
}
pixptr = img->pixels;
for(i=0; i<img->height; i++) {
rows[i] = pixptr;
pixptr += img->width * img->pixelsz;
}
png_set_rows(png, info, rows);
png_write_png(png, info, 0, 0);
png_write_end(png, info);
png_destroy_write_struct(&png, &info);
free(rows);
img_destroy(&tmpimg);
return 0;
}
int export_img(struct play_s *play)
{
/*
Export img uses following pipeline:
file -(uncompressed_buffer)-> reads data from stream file
unpack -(uncompressed_buffer)-> decompresses lzo/quicklz packets
rgb -(rgb)-> does conversion to BGR
scale -(scale)-> does rescaling
color -(color)-> applies color correction
img writes separate image files for each frame
*/
ps_bufferattr_t attr;
ps_buffer_t uncompressed_buffer, compressed_buffer,
rgb_buffer, color_buffer, scale_buffer;
img_t img;
color_t color;
scale_t scale;
unpack_t unpack;
rgb_t rgb;
int ret = 0;
if ((ret = ps_bufferattr_init(&attr)))
goto err;
/* buffers */
if ((ret = ps_bufferattr_setsize(&attr, play->compressed_size)))
goto err;
if ((ret = ps_buffer_init(&compressed_buffer, &attr)))
goto err;
if ((ret = ps_bufferattr_setsize(&attr, play->uncompressed_size)))
goto err;
if ((ret = ps_buffer_init(&uncompressed_buffer, &attr)))
goto err;
if ((ret = ps_buffer_init(&color_buffer, &attr)))
goto err;
if ((ret = ps_buffer_init(&rgb_buffer, &attr)))
goto err;
if ((ret = ps_buffer_init(&scale_buffer, &attr)))
goto err;
if ((ret = ps_bufferattr_destroy(&attr)))
goto err;
/* filters */
if ((ret = unpack_init(&unpack, &play->glc)))
goto err;
if ((ret = rgb_init(&rgb, &play->glc)))
goto err;
if ((ret = scale_init(&scale, &play->glc)))
goto err;
if (play->scale_width && play->scale_height)
scale_set_size(scale, play->scale_width, play->scale_height);
else
scale_set_scale(scale, play->scale_factor);
if ((ret = color_init(&color, &play->glc)))
goto err;
if (play->override_color_correction)
color_override(color, play->brightness, play->contrast,
play->red_gamma, play->green_gamma, play->blue_gamma);
if ((ret = img_init(&img, &play->glc)))
goto err;
img_set_filename(img, play->export_filename_format);
img_set_stream_id(img, play->export_video_id);
img_set_format(img, play->img_format);
img_set_fps(img, play->fps);
/* pipeline... */
if ((ret = unpack_process_start(unpack, &compressed_buffer, &uncompressed_buffer)))
goto err;
if ((ret = rgb_process_start(rgb, &uncompressed_buffer, &rgb_buffer)))
goto err;
if ((ret = scale_process_start(scale, &rgb_buffer, &scale_buffer)))
goto err;
if ((ret = color_process_start(color, &scale_buffer, &color_buffer)))
goto err;
if ((ret = img_process_start(img, &color_buffer)))
goto err;
/* ok, read the file */
if ((ret = file_read(play->file, &compressed_buffer)))
goto err;
/* wait 'till its done and clean up the mess... */
if ((ret = img_process_wait(img)))
goto err;
if ((ret = color_process_wait(color)))
goto err;
if ((ret = scale_process_wait(scale)))
goto err;
if ((ret = rgb_process_wait(rgb)))
goto err;
if ((ret = unpack_process_wait(unpack)))
goto err;
unpack_destroy(unpack);
rgb_destroy(rgb);
scale_destroy(scale);
color_destroy(color);
img_destroy(img);
ps_buffer_destroy(&compressed_buffer);
ps_buffer_destroy(&uncompressed_buffer);
ps_buffer_destroy(&color_buffer);
ps_buffer_destroy(&scale_buffer);
ps_buffer_destroy(&rgb_buffer);
return 0;
err:
fprintf(stderr, "exporting images failed: %s (%d)\n", strerror(ret), ret);
return ret;
}