King_DuckZ
/
libbpg
forked from mirror/libbpg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
libbpg/bpgview.c

539 lines
14 KiB
C
Raw Permalink Blame History

/*
* BPG viewer
*
* Copyright (c) 2014-2015 Fabrice Bellard
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <getopt.h>
#include <inttypes.h>
#ifdef WIN32
#include <windows.h>
#endif
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include "libbpg.h"
typedef enum {
BG_BLACK,
BG_TILED,
} BackgroundTypeEnum;
typedef struct {
SDL_Surface *img;
int delay; /* in ms */
} Frame;
typedef struct {
int screen_w, screen_h;
int win_w, win_h;
SDL_Surface *screen;
int img_w, img_h;
int frame_count;
Frame *frames;
int frame_index; /* index of the current frame */
int loop_counter;
int loop_count;
SDL_TimerID frame_timer_id;
int is_full_screen;
int pos_x, pos_y;
BackgroundTypeEnum background_type;
} DispContext;
static uint32_t timer_cb(uint32_t interval, void *param);
static inline int clamp_int(int val, int min_val, int max_val)
{
if (val < min_val)
return min_val;
else if (val > max_val)
return max_val;
else
return val;
}
Frame *bpg_load(FILE *f, int *pframe_count, int *ploop_count)
{
BPGDecoderContext *s;
BPGImageInfo bi_s, *bi = &bi_s;
uint8_t *buf;
int len, y;
SDL_Surface *img;
Frame *frames;
uint32_t rmask, gmask, bmask, amask;
int frame_count, i, delay_num, delay_den;
fseek(f, 0, SEEK_END);
len = ftell(f);
fseek(f, 0, SEEK_SET);
if (len < 0)
return NULL;
buf = malloc(len);
if (!buf)
return NULL;
if (fread(buf, 1, len, f) != len)
return NULL;
frames = NULL;
frame_count = 0;
s = bpg_decoder_open();
if (bpg_decoder_decode(s, buf, len) < 0)
goto fail;
bpg_decoder_get_info(s, bi);
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
#else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
#endif
for(;;) {
if (bpg_decoder_start(s, BPG_OUTPUT_FORMAT_RGBA32) < 0)
break;
bpg_decoder_get_frame_duration(s, &delay_num, &delay_den);
frames = realloc(frames, sizeof(frames[0]) * (frame_count + 1));
img = SDL_CreateRGBSurface(SDL_HWSURFACE, bi->width, bi->height, 32,
rmask, gmask, bmask, amask);
if (!img)
goto fail;
SDL_LockSurface(img);
for(y = 0; y < bi->height; y++) {
bpg_decoder_get_line(s, (uint8_t *)img->pixels + y * img->pitch);
}
SDL_UnlockSurface(img);
frames[frame_count].img = img;
frames[frame_count].delay = (delay_num * 1000) / delay_den;
frame_count++;
}
bpg_decoder_close(s);
*pframe_count = frame_count;
*ploop_count = bi->loop_count;
return frames;
fail:
bpg_decoder_close(s);
for(i = 0; i < frame_count; i++) {
SDL_FreeSurface(frames[i].img);
}
free(frames);
*pframe_count = 0;
return NULL;
}
static void restart_frame_timer(DispContext *dc)
{
if (dc->frame_timer_id) {
/* XXX: the SDL timer API is not safe, so we remove the timer even if it already expired */
SDL_RemoveTimer(dc->frame_timer_id);
dc->frame_timer_id = 0;
}
dc->frame_timer_id =
SDL_AddTimer(dc->frames[dc->frame_index].delay, timer_cb, NULL);
}
int load_image(DispContext *dc, const char *filename)
{
SDL_Surface *img;
Frame *frames;
FILE *f;
uint8_t buf[BPG_DECODER_INFO_BUF_SIZE];
int len, i, frame_count, loop_count;
BPGImageInfo bi;
f = fopen(filename, "rb");
if (!f)
goto fail;
len = fread(buf, 1, sizeof(buf), f);
if (bpg_decoder_get_info_from_buf(&bi, NULL, buf, len) >= 0) {
fseek(f, 0, SEEK_SET);
frames = bpg_load(f, &frame_count, &loop_count);
if (!frames)
goto fail;
fclose(f);
} else {
/* use SDL image loader */
img = IMG_Load(filename);
if (!img) {
fail:
fprintf(stderr, "Could not load '%s'\n", filename);
return -1;
}
frame_count = 1;
frames = malloc(sizeof(dc->frames[0]) * frame_count);
frames[0].img = img;
frames[0].delay = 0;
loop_count = 1;
}
for(i = 0; i < dc->frame_count; i++) {
SDL_FreeSurface(dc->frames[i].img);
}
free(dc->frames);
if (dc->frame_timer_id) {
SDL_RemoveTimer(dc->frame_timer_id);
dc->frame_timer_id = 0;
}
dc->frame_count = frame_count;
dc->frames = frames;
dc->frame_index = 0;
dc->loop_counter = 0;
dc->loop_count = loop_count;
dc->img_w = dc->frames[0].img->w;
dc->img_h = dc->frames[0].img->h;
/* start the animation timer if needed */
if (dc->frame_count > 1) {
restart_frame_timer(dc);
}
return 0;
}
void center_image(DispContext *dc)
{
dc->pos_x = clamp_int((dc->screen->w - dc->img_w) / 2, -32767, 32768);
dc->pos_y = clamp_int((dc->screen->h - dc->img_h) / 2, -32767, 32768);
}
void draw_image(DispContext *dc)
{
SDL_Rect r;
r.x = 0;
r.y = 0;
r.w = dc->screen->w;
r.h = dc->screen->h;
SDL_FillRect(dc->screen, &r, SDL_MapRGB(dc->screen->format, 0x00, 0x00, 0x00));
if (dc->background_type == BG_TILED) {
int x, y, tw, w, h, x2, y2, w1, h1, x1, y1;
uint32_t bgcolors[2];
tw = 16;
w = dc->img_w;
h = dc->img_h;
w1 = (w + tw - 1) / tw;
h1 = (h + tw - 1) / tw;
bgcolors[0] = SDL_MapRGB(dc->screen->format, 100, 100, 100);
bgcolors[1] = SDL_MapRGB(dc->screen->format, 150, 150, 150);
for(y = 0; y < h1; y++) {
for(x = 0; x < w1; x++) {
x1 = x * tw;
y1 = y * tw;
x2 = x1 + tw;
y2 = y1 + tw;
if (x2 > w)
x2 = w;
if (y2 > h)
y2 = h;
r.x = x1 + dc->pos_x;
r.y = y1 + dc->pos_y;
r.w = x2 - x1;
r.h = y2 - y1;
SDL_FillRect(dc->screen, &r, bgcolors[(x ^ y) & 1]);
}
}
}
r.x = dc->pos_x;
r.y = dc->pos_y;
r.w = 0;
r.h = 0;
SDL_BlitSurface (dc->frames[dc->frame_index].img, NULL, dc->screen, &r);
SDL_Flip(dc->screen);
}
void pan_image(DispContext *dc, int dx, int dy)
{
int dw, dh;
dw = dc->img_w - dc->screen->w;
dh = dc->img_h - dc->screen->h;
if (dw > 0) {
dc->pos_x += dx;
if (dc->pos_x < -dw)
dc->pos_x = -dw;
else if (dc->pos_x > 0)
dc->pos_x = 0;
}
if (dh > 0) {
dc->pos_y += dy;
if (dc->pos_y < -dh)
dc->pos_y = -dh;
else if (dc->pos_y > 0)
dc->pos_y = 0;
}
draw_image(dc);
}
static void set_caption(DispContext *dc, char **argv,
int image_index, int image_count)
{
char buf[1024];
const char *filename;
filename = argv[image_index];
snprintf(buf, sizeof(buf), "bpgview [%d of %d] - %s",
image_index + 1, image_count, filename);
SDL_WM_SetCaption(buf, buf);
}
static void open_window(DispContext *dc, int w, int h, int is_full_screen)
{
int flags;
flags = SDL_DOUBLEBUF | SDL_HWSURFACE | SDL_HWACCEL;
if (is_full_screen)
flags |= SDL_FULLSCREEN;
else
flags |= SDL_RESIZABLE;
dc->screen = SDL_SetVideoMode(w, h, 32, flags);
if (!dc->screen) {
fprintf(stderr, "Could not init screen\n");
exit(1);
}
}
static uint32_t timer_cb(uint32_t interval, void *param)
{
SDL_Event event;
SDL_UserEvent userevent;
userevent.type = SDL_USEREVENT;
userevent.code = 0;
userevent.data1 = NULL;
userevent.data2 = NULL;
event.type = SDL_USEREVENT;
event.user = userevent;
SDL_PushEvent(&event);
return 0;
}
#define DEFAULT_W 640
#define DEFAULT_H 480
static void help(void)
{
const char *str;
str = "BPG Image Viewer version " CONFIG_BPG_VERSION "\n"
"usage: bpgview infile...\n"
"\n"
"Keys:\n"
"q, ESC quit\n"
"n, SPACE next image\n"
"p previous image\n"
"arrows pan\n"
"c center\n"
"b toggle background type\n";
#ifdef WIN32
MessageBox(NULL, str, "Error", MB_ICONERROR | MB_OK);
exit(1);
#else
printf("%s", str);
exit(1);
#endif
}
int main(int argc, char **argv)
{
int c, image_index, image_count, incr, i;
SDL_Event event;
DispContext dc_s, *dc = &dc_s;
const SDL_VideoInfo *vi;
for(;;) {
c = getopt(argc, argv, "h");
if (c == -1)
break;
switch(c) {
case 'h':
show_help:
help();
break;
default:
exit(1);
}
}
if (optind >= argc)
goto show_help;
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0) {
fprintf(stderr, "Could not init SDL\n");
exit(1);
}
memset(dc, 0, sizeof(*dc));
vi = SDL_GetVideoInfo();
dc->screen_w = vi->current_w;
dc->screen_h = vi->current_h;
dc->is_full_screen = 0;
image_count = argc - optind;
image_index = 0;
if (load_image(dc, argv[optind + image_index]) < 0)
exit(1);
dc->background_type = BG_TILED;
{
int w, h;
if (image_count > 1 || (dc->img_w < 256 || dc->img_h < 256)) {
w = DEFAULT_W;
h = DEFAULT_H;
} else {
w = clamp_int(dc->img_w, 32, dc->screen_w);
h = clamp_int(dc->img_h, 32, dc->screen_h);
}
open_window(dc, w, h, 0);
set_caption(dc, argv + optind, image_index, image_count);
}
center_image(dc);
draw_image(dc);
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
for(;;) {
if (!SDL_WaitEvent(&event))
continue;
switch(event.type) {
case SDL_KEYDOWN:
switch (event.key.keysym.sym) {
case SDLK_ESCAPE:
case SDLK_q:
goto done;
case SDLK_SPACE: /* next image */
case SDLK_n:
incr = 1;
goto prev_next;
case SDLK_p: /* previous image */
incr = -1;
prev_next:
if (image_count > 1) {
for(i = 0; i < image_count; i++) {
image_index += incr;
if (image_index < 0)
image_index = image_count - 1;
else if (image_index >= image_count)
image_index = 0;
if (load_image(dc, argv[optind + image_index]) == 0)
break;
}
if (i == image_count)
exit(1);
set_caption(dc, argv + optind, image_index, image_count);
center_image(dc);
draw_image(dc);
}
break;
case SDLK_LEFT:
pan_image(dc, 32, 0);
break;
case SDLK_RIGHT:
pan_image(dc, -32, 0);
break;
case SDLK_UP:
pan_image(dc, 0, 32);
break;
case SDLK_DOWN:
pan_image(dc, 0, -32);
break;
case SDLK_c:
center_image(dc);
draw_image(dc);
break;
case SDLK_b:
dc->background_type ^= 1;
draw_image(dc);
break;
case SDLK_f:
dc->is_full_screen ^= 1;
if (dc->is_full_screen) {
/* save old windows size */
dc->win_w = dc->screen->w;
dc->win_h = dc->screen->h;
open_window(dc, dc->screen_w, dc->screen_h, 1);
} else {
open_window(dc, dc->win_w, dc->win_h, 0);
}
center_image(dc);
draw_image(dc);
break;
default:
break;
}
break;
case SDL_VIDEORESIZE:
{
open_window(dc, event.resize.w, event.resize.h, 0);
center_image(dc);
draw_image(dc);
}
break;
case SDL_QUIT:
goto done;
case SDL_MOUSEMOTION:
if (event.motion.state) {
pan_image(dc, event.motion.xrel, event.motion.yrel);
}
break;
case SDL_USEREVENT:
if (dc->frame_count > 1) {
/* show next frame */
if (dc->frame_index == (dc->frame_count - 1)) {
if (dc->loop_count == 0 ||
dc->loop_counter < (dc->loop_count - 1)) {
dc->frame_index = 0;
dc->loop_counter++;
} else {
break;
}
} else {
dc->frame_index++;
}
draw_image(dc);
restart_frame_timer(dc);
}
break;
default:
break;
}
}
done:
SDL_FreeSurface(dc->screen);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink