366 lines
10 KiB
C
366 lines
10 KiB
C
// Copyright 2011 Google Inc. All Rights Reserved.
|
|
//
|
|
// This code is licensed under the same terms as WebM:
|
|
// Software License Agreement: http://www.webmproject.org/license/software/
|
|
// Additional IP Rights Grant: http://www.webmproject.org/license/additional/
|
|
// -----------------------------------------------------------------------------
|
|
//
|
|
// Simple WebP file viewer.
|
|
//
|
|
// Compiling on linux:
|
|
// sudo apt-get install libglut3-dev mesa-common-dev
|
|
// gcc -o vwebp vwebp.c -O3 -lwebp -lwebpmux -lglut -lGL -lpthread -lm
|
|
// Compiling on Mac + XCode:
|
|
// gcc -o vwebp vwebp.c -lwebp -lwebpmux -framework GLUT -framework OpenGL
|
|
//
|
|
// Author: Skal (pascal.massimino@gmail.com)
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "webp/decode.h"
|
|
#include "webp/demux.h"
|
|
|
|
#ifdef __APPLE__
|
|
#include <GLUT/glut.h>
|
|
#else
|
|
#include <GL/glut.h>
|
|
#ifdef FREEGLUT
|
|
#include <GL/freeglut.h>
|
|
#endif
|
|
#endif
|
|
|
|
#include "./example_util.h"
|
|
|
|
#ifdef _MSC_VER
|
|
#define snprintf _snprintf
|
|
#endif
|
|
|
|
static void Help(void);
|
|
|
|
// Unfortunate global variables. Gathered into a struct for comfort.
|
|
static struct {
|
|
int has_animation;
|
|
int done;
|
|
int decoding_error;
|
|
int print_info;
|
|
|
|
int canvas_width, canvas_height;
|
|
int loop_count;
|
|
uint32_t bg_color;
|
|
|
|
const char* file_name;
|
|
WebPData data;
|
|
WebPDecoderConfig* config;
|
|
const WebPDecBuffer* pic;
|
|
WebPDemuxer* dmux;
|
|
WebPIterator frameiter;
|
|
} kParams;
|
|
|
|
static void ClearPreviousPic(void) {
|
|
WebPFreeDecBuffer((WebPDecBuffer*)kParams.pic);
|
|
kParams.pic = NULL;
|
|
}
|
|
|
|
static void ClearParams(void) {
|
|
ClearPreviousPic();
|
|
WebPDataClear(&kParams.data);
|
|
WebPDemuxReleaseIterator(&kParams.frameiter);
|
|
WebPDemuxDelete(kParams.dmux);
|
|
kParams.dmux = NULL;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Callbacks
|
|
|
|
static void HandleKey(unsigned char key, int pos_x, int pos_y) {
|
|
(void)pos_x;
|
|
(void)pos_y;
|
|
if (key == 'q' || key == 'Q' || key == 27 /* Esc */) {
|
|
#ifdef FREEGLUT
|
|
glutLeaveMainLoop();
|
|
#else
|
|
ClearParams();
|
|
exit(0);
|
|
#endif
|
|
} else if (key == 'i') {
|
|
kParams.print_info = 1 - kParams.print_info;
|
|
glutPostRedisplay();
|
|
}
|
|
}
|
|
|
|
static void HandleReshape(int width, int height) {
|
|
// TODO(skal): proper handling of resize, esp. for large pictures.
|
|
// + key control of the zoom.
|
|
glViewport(0, 0, width, height);
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
}
|
|
|
|
static void PrintString(const char* const text) {
|
|
void* const font = GLUT_BITMAP_9_BY_15;
|
|
int i;
|
|
for (i = 0; text[i]; ++i) {
|
|
glutBitmapCharacter(font, text[i]);
|
|
}
|
|
}
|
|
|
|
static float GetColorf(uint32_t color, int shift) {
|
|
return (color >> shift) / 255.f;
|
|
}
|
|
|
|
static void DrawCheckerBoard(void) {
|
|
const int square_size = 8; // must be a power of 2
|
|
int x, y;
|
|
GLint viewport[4]; // x, y, width, height
|
|
|
|
glPushMatrix();
|
|
|
|
glGetIntegerv(GL_VIEWPORT, viewport);
|
|
// shift to integer coordinates with (0,0) being top-left.
|
|
glOrtho(0, viewport[2], viewport[3], 0, -1, 1);
|
|
for (y = 0; y < viewport[3]; y += square_size) {
|
|
for (x = 0; x < viewport[2]; x += square_size) {
|
|
const GLubyte color = 128 + 64 * (!((x + y) & square_size));
|
|
glColor3ub(color, color, color);
|
|
glRecti(x, y, x + square_size, y + square_size);
|
|
}
|
|
}
|
|
glPopMatrix();
|
|
}
|
|
|
|
static void HandleDisplay(void) {
|
|
const WebPDecBuffer* const pic = kParams.pic;
|
|
const WebPIterator* const iter = &kParams.frameiter;
|
|
GLfloat xoff, yoff;
|
|
if (pic == NULL) return;
|
|
glPushMatrix();
|
|
glPixelZoom(1, -1);
|
|
xoff = (GLfloat)(2. * iter->x_offset / kParams.canvas_width);
|
|
yoff = (GLfloat)(2. * iter->y_offset / kParams.canvas_height);
|
|
glRasterPos2f(-1. + xoff, 1. - yoff);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, pic->u.RGBA.stride / 4);
|
|
if (iter->dispose_method == WEBP_MUX_DISPOSE_BACKGROUND) {
|
|
glClear(GL_COLOR_BUFFER_BIT); // use clear color
|
|
}
|
|
glDrawPixels(pic->width, pic->height,
|
|
GL_RGBA, GL_UNSIGNED_BYTE,
|
|
(GLvoid*)pic->u.RGBA.rgba);
|
|
if (kParams.print_info) {
|
|
char tmp[32];
|
|
|
|
glColor4f(0.90, 0.0, 0.90, 1.0);
|
|
glRasterPos2f(-0.95f, 0.90f);
|
|
PrintString(kParams.file_name);
|
|
|
|
snprintf(tmp, sizeof(tmp), "Dimension:%d x %d", pic->width, pic->height);
|
|
glColor4f(0.90, 0.0, 0.90, 1.0);
|
|
glRasterPos2f(-0.95f, 0.80f);
|
|
PrintString(tmp);
|
|
if (iter->x_offset != 0 || iter->y_offset != 0) {
|
|
snprintf(tmp, sizeof(tmp), " (offset:%d,%d)",
|
|
iter->x_offset, iter->y_offset);
|
|
glRasterPos2f(-0.95f, 0.70f);
|
|
PrintString(tmp);
|
|
}
|
|
}
|
|
glPopMatrix();
|
|
glFlush();
|
|
}
|
|
|
|
static void StartDisplay(void) {
|
|
const int width = kParams.canvas_width;
|
|
const int height = kParams.canvas_height;
|
|
glutInitDisplayMode(GLUT_RGBA);
|
|
glutInitWindowSize(width, height);
|
|
glutCreateWindow("WebP viewer");
|
|
glutDisplayFunc(HandleDisplay);
|
|
glutIdleFunc(NULL);
|
|
glutKeyboardFunc(HandleKey);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glEnable(GL_BLEND);
|
|
glClearColor(GetColorf(kParams.bg_color, 0),
|
|
GetColorf(kParams.bg_color, 8),
|
|
GetColorf(kParams.bg_color, 16),
|
|
GetColorf(kParams.bg_color, 24));
|
|
HandleReshape(width, height);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
DrawCheckerBoard();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// File decoding
|
|
|
|
static int Decode(void) { // Fills kParams.frameiter
|
|
const WebPIterator* const iter = &kParams.frameiter;
|
|
WebPDecoderConfig* const config = kParams.config;
|
|
WebPDecBuffer* const output_buffer = &config->output;
|
|
int ok = 0;
|
|
|
|
ClearPreviousPic();
|
|
output_buffer->colorspace = MODE_RGBA;
|
|
ok = (WebPDecode(iter->fragment.bytes, iter->fragment.size,
|
|
config) == VP8_STATUS_OK);
|
|
if (!ok) {
|
|
fprintf(stderr, "Decoding of frame #%d failed!\n", iter->frame_num);
|
|
} else {
|
|
kParams.pic = output_buffer;
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
static void decode_callback(int what) {
|
|
if (what == 0 && !kParams.done) {
|
|
int duration = 0;
|
|
if (kParams.dmux != NULL) {
|
|
WebPIterator* const iter = &kParams.frameiter;
|
|
if (!WebPDemuxNextFrame(iter)) {
|
|
WebPDemuxReleaseIterator(iter);
|
|
if (WebPDemuxGetFrame(kParams.dmux, 1, iter)) {
|
|
--kParams.loop_count;
|
|
kParams.done = (kParams.loop_count == 0);
|
|
} else {
|
|
kParams.decoding_error = 1;
|
|
kParams.done = 1;
|
|
return;
|
|
}
|
|
}
|
|
duration = iter->duration;
|
|
}
|
|
if (!Decode()) {
|
|
kParams.decoding_error = 1;
|
|
kParams.done = 1;
|
|
} else {
|
|
glutPostRedisplay();
|
|
glutTimerFunc(duration, decode_callback, what);
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Main
|
|
|
|
static void Help(void) {
|
|
printf("Usage: vwebp in_file [options]\n\n"
|
|
"Decodes the WebP image file and visualize it using OpenGL\n"
|
|
"Options are:\n"
|
|
" -version .... print version number and exit.\n"
|
|
" -nofancy ..... don't use the fancy YUV420 upscaler.\n"
|
|
" -nofilter .... disable in-loop filtering.\n"
|
|
" -mt .......... use multi-threading.\n"
|
|
" -info ........ print info.\n"
|
|
" -h ....... this help message.\n"
|
|
"\n"
|
|
"Keyboard shortcuts:\n"
|
|
" 'i' ................ overlay file information.\n"
|
|
" 'q' / 'Q' / ESC .... quit.\n"
|
|
);
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
WebPDecoderConfig config;
|
|
int c;
|
|
|
|
if (!WebPInitDecoderConfig(&config)) {
|
|
fprintf(stderr, "Library version mismatch!\n");
|
|
return -1;
|
|
}
|
|
kParams.config = &config;
|
|
|
|
for (c = 1; c < argc; ++c) {
|
|
if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
|
|
Help();
|
|
return 0;
|
|
} else if (!strcmp(argv[c], "-nofancy")) {
|
|
config.options.no_fancy_upsampling = 1;
|
|
} else if (!strcmp(argv[c], "-nofilter")) {
|
|
config.options.bypass_filtering = 1;
|
|
} else if (!strcmp(argv[c], "-info")) {
|
|
kParams.print_info = 1;
|
|
} else if (!strcmp(argv[c], "-version")) {
|
|
const int dec_version = WebPGetDecoderVersion();
|
|
const int dmux_version = WebPGetDemuxVersion();
|
|
printf("WebP Decoder version: %d.%d.%d\nWebP Demux version: %d.%d.%d\n",
|
|
(dec_version >> 16) & 0xff, (dec_version >> 8) & 0xff,
|
|
dec_version & 0xff, (dmux_version >> 16) & 0xff,
|
|
(dmux_version >> 8) & 0xff, dmux_version & 0xff);
|
|
return 0;
|
|
} else if (!strcmp(argv[c], "-mt")) {
|
|
config.options.use_threads = 1;
|
|
} else if (argv[c][0] == '-') {
|
|
printf("Unknown option '%s'\n", argv[c]);
|
|
Help();
|
|
return -1;
|
|
} else {
|
|
kParams.file_name = argv[c];
|
|
}
|
|
}
|
|
|
|
if (kParams.file_name == NULL) {
|
|
printf("missing input file!!\n");
|
|
Help();
|
|
return 0;
|
|
}
|
|
|
|
if (!ExUtilReadFile(kParams.file_name,
|
|
&kParams.data.bytes, &kParams.data.size)) {
|
|
goto Error;
|
|
}
|
|
|
|
kParams.dmux = WebPDemux(&kParams.data);
|
|
if (kParams.dmux == NULL) {
|
|
fprintf(stderr, "Could not create demuxing object!\n");
|
|
goto Error;
|
|
}
|
|
|
|
if (WebPDemuxGetI(kParams.dmux, WEBP_FF_FORMAT_FLAGS) & FRAGMENTS_FLAG) {
|
|
fprintf(stderr, "Image fragments are not supported for now!\n");
|
|
goto Error;
|
|
}
|
|
kParams.canvas_width = WebPDemuxGetI(kParams.dmux, WEBP_FF_CANVAS_WIDTH);
|
|
kParams.canvas_height = WebPDemuxGetI(kParams.dmux, WEBP_FF_CANVAS_HEIGHT);
|
|
if (kParams.print_info) {
|
|
printf("Canvas: %d x %d\n", kParams.canvas_width, kParams.canvas_height);
|
|
}
|
|
|
|
if (!WebPDemuxGetFrame(kParams.dmux, 1, &kParams.frameiter)) goto Error;
|
|
|
|
kParams.has_animation = (kParams.frameiter.num_frames > 1);
|
|
kParams.loop_count = (int)WebPDemuxGetI(kParams.dmux, WEBP_FF_LOOP_COUNT);
|
|
kParams.bg_color = WebPDemuxGetI(kParams.dmux, WEBP_FF_BACKGROUND_COLOR);
|
|
printf("VP8X: Found %d images in file (loop count = %d)\n",
|
|
kParams.frameiter.num_frames, kParams.loop_count);
|
|
|
|
// Decode first frame
|
|
if (!Decode()) goto Error;
|
|
|
|
// Position iterator to last frame. Next call to HandleDisplay will wrap over.
|
|
// We take this into account by bumping up loop_count.
|
|
WebPDemuxGetFrame(kParams.dmux, 0, &kParams.frameiter);
|
|
if (kParams.loop_count) ++kParams.loop_count;
|
|
|
|
// Start display (and timer)
|
|
glutInit(&argc, argv);
|
|
#ifdef FREEGLUT
|
|
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
|
|
#endif
|
|
StartDisplay();
|
|
|
|
if (kParams.has_animation) glutTimerFunc(0, decode_callback, 0);
|
|
glutMainLoop();
|
|
|
|
// Should only be reached when using FREEGLUT:
|
|
ClearParams();
|
|
return 0;
|
|
|
|
Error:
|
|
ClearParams();
|
|
return -1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|