Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

* WPS editor: set eol-style

Browse source 
* Add CLI-only screenshot utility (using libwps)


git-svn-id: svn://svn.rockbox.org/rockbox/trunk@18402 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Maurus Cuelenaere 2008-09-03 20:51:13 +00:00
parent 4f26222a9f
commit c1c1383e23
9 changed files with 1378 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
utils/wpseditor/buildall.bat
View file

@ -1,9 +1,9 @@
@echo off
echo qmake...
qmake
echo Building gui...
mingw32-make 1>nul
echo Building libs...
cd libwps
call buildall.bat 2>nul
cd ..
@echo off
echo qmake...
qmake
echo Building gui...
mingw32-make 1>nul
echo Building libs...
cd libwps
call buildall.bat 2>nul
cd ..

8
utils/wpseditor/buildall.sh
View file

@ -1,4 +1,4 @@
#!/bin/sh
qmake && make
cd libwps
./buildall.sh 2> /dev/null
#!/bin/sh
qmake && make
cd libwps
./buildall.sh 2> /dev/null

88
utils/wpseditor/gui/src/qsyntaxer.cpp
View file

@ -1,44 +1,44 @@
#include <QTextCharFormat>
#include "qsyntaxer.h"
QSyntaxer::QSyntaxer(QTextDocument *parent)
: QSyntaxHighlighter(parent) {
HighlightingRule rule;
hrules["operator"].pattern = QRegExp("%[^\\| \n<\\?%]{1,2}");
hrules["operator"].format.setFontWeight(QFont::Bold);
hrules["operator"].format.setForeground(Qt::darkBlue);
hrules["question"].pattern = QRegExp("%[\\?]{1}[^<]{1,2}");
hrules["question"].format.setForeground(Qt::darkMagenta);
hrules["question2"].pattern = QRegExp("(<|>)");
hrules["question2"].format.setForeground(Qt::red);
hrules["limiter"].pattern = QRegExp("\\|");
hrules["limiter"].format.setForeground(Qt::darkRed);
hrules["comment"].pattern = QRegExp("#[^\n]*");
hrules["comment"].format.setForeground(Qt::darkGreen);
hrules["comment"].format.setFontItalic(true);
}
//
void QSyntaxer::highlightBlock(const QString &text) {
QTextCharFormat wholeText;
wholeText.setFont(QFont("arial",11,QFont::Normal));
setFormat(0,text.length(),wholeText);
foreach (HighlightingRule rule, hrules) {
QRegExp expression(rule.pattern);
int index = text.indexOf(expression);
while (index >= 0) {
int length = expression.matchedLength();
setFormat(index, length, rule.format);
index = text.indexOf(expression, index + length);
}
}
}
#include <QTextCharFormat>
#include "qsyntaxer.h"
QSyntaxer::QSyntaxer(QTextDocument *parent)
: QSyntaxHighlighter(parent) {
HighlightingRule rule;
hrules["operator"].pattern = QRegExp("%[^\\| \n<\\?%]{1,2}");
hrules["operator"].format.setFontWeight(QFont::Bold);
hrules["operator"].format.setForeground(Qt::darkBlue);
hrules["question"].pattern = QRegExp("%[\\?]{1}[^<]{1,2}");
hrules["question"].format.setForeground(Qt::darkMagenta);
hrules["question2"].pattern = QRegExp("(<|>)");
hrules["question2"].format.setForeground(Qt::red);
hrules["limiter"].pattern = QRegExp("\\|");
hrules["limiter"].format.setForeground(Qt::darkRed);
hrules["comment"].pattern = QRegExp("#[^\n]*");
hrules["comment"].format.setForeground(Qt::darkGreen);
hrules["comment"].format.setFontItalic(true);
}
//
void QSyntaxer::highlightBlock(const QString &text) {
QTextCharFormat wholeText;
wholeText.setFont(QFont("arial",11,QFont::Normal));
setFormat(0,text.length(),wholeText);
foreach (HighlightingRule rule, hrules) {
QRegExp expression(rule.pattern);
int index = text.indexOf(expression);
while (index >= 0) {
int length = expression.matchedLength();
setFormat(index, length, rule.format);
index = text.indexOf(expression, index + length);
}
}
}

42
utils/wpseditor/gui/src/qsyntaxer.h
View file

@ -1,21 +1,21 @@
#ifndef QSYNTAXER_H
#define QSYNTAXER_H
//
#include <QSyntaxHighlighter>
class QTextCharFormat;
class QSyntaxer : public QSyntaxHighlighter {
Q_OBJECT
struct HighlightingRule {
QRegExp pattern;
QTextCharFormat format;
};
QMap<QString,HighlightingRule> hrules;
public:
QSyntaxer(QTextDocument *parent = 0);
protected:
void highlightBlock(const QString &text);
};
#endif
#ifndef QSYNTAXER_H
#define QSYNTAXER_H
//
#include <QSyntaxHighlighter>
class QTextCharFormat;
class QSyntaxer : public QSyntaxHighlighter {
Q_OBJECT
struct HighlightingRule {
QRegExp pattern;
QTextCharFormat format;
};
QMap<QString,HighlightingRule> hrules;
public:
QSyntaxer(QTextDocument *parent = 0);
protected:
void highlightBlock(const QString &text);
};
#endif

8
utils/wpseditor/libwps/buildall.bat
View file

@ -1,4 +1,4 @@
@echo off
FOR /F "tokens=1,2* delims=, " %%i in (targets.txt) do @mingw32-make MODEL=%%j TARGET=%%i build 2>nul
echo Copying files...
xcopy /I /Y *.dll ..\gui\bin
@echo off
FOR /F "tokens=1,2* delims=, " %%i in (targets.txt) do @mingw32-make MODEL=%%j TARGET=%%i build 2>nul
echo Copying files...
xcopy /I /Y *.dll ..\gui\bin

43
utils/wpseditor/screenshot/Makefile Normal file
View file

@ -0,0 +1,43 @@
# __________ __ ___.
# Open \______ \ ____ ____ | | _\_ |__ _______ ___
# Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
# Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
# Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
# \/ \/ \/ \/ \/
# $Id$
#
ROOT=../../..
OS = w32
CC = gcc
ifeq ($(findstring MINGW,$(shell uname)),MINGW)
OS = w32
CC = mingw32-gcc
RM = rm
endif
ifeq ($(findstring Linux,$(shell uname)),Linux)
OS = linux
CC = gcc
RM = rm -f
endif
COMMON= main.c gd_bmp.c
INCLUDE=-I ../libwps/src \
-I $(ROOT)/apps/gui \
-I $(ROOT)/firmware/export \
-I $(ROOT)/apps/recorder \
-I $(ROOT)/apps \
-I .
CFLAGS = -g -Wall
all:
$(CC) $(INCLUDE) $(CFLAGS) $(COMMON) -rdynamic -ldl -lgd -lpng -o screenshot
clean:
$(RM) screenshot

114
utils/wpseditor/screenshot/bmp.h Normal file
View file

@ -0,0 +1,114 @@
/* $Id$ */
#ifdef __cplusplus
extern "C" {
#endif
/*
gd_bmp.c
Bitmap format support for libgd
* Written 2007, Scott MacVicar
---------------------------------------------------------------------------
Todo:
RLE4, RLE8 and Bitfield encoding
Add full support for Windows v4 and Windows v5 header formats
----------------------------------------------------------------------------
*/
#ifndef BMP_H
#define BMP_H 1
#define BMP_PALETTE_3 1
#define BMP_PALETTE_4 2
#define BMP_WINDOWS_V3 40
#define BMP_OS2_V1 12
#define BMP_OS2_V2 64
#define BMP_WINDOWS_V4 108
#define BMP_WINDOWS_V5 124
#define BMP_BI_RGB 0
#define BMP_BI_RLE8 1
#define BMP_BI_RLE4 2
#define BMP_BI_BITFIELDS 3
#define BMP_BI_JPEG 4
#define BMP_BI_PNG 5
#define BMP_RLE_COMMAND 0
#define BMP_RLE_ENDOFLINE 0
#define BMP_RLE_ENDOFBITMAP 1
#define BMP_RLE_DELTA 2
#define BMP_RLE_TYPE_RAW 0
#define BMP_RLE_TYPE_RLE 1
/* BMP header. */
typedef struct
{
/* 16 bit - header identifying the type */
signed short int magic;
/* 32bit - size of the file */
int size;
/* 16bit - these two are in the spec but "reserved" */
signed short int reserved1;
signed short int reserved2;
/* 32 bit - offset of the bitmap header from data in bytes */
signed int off;
} bmp_hdr_t;
/* BMP info. */
typedef struct
{
/* 16bit - Type, ie Windows or OS/2 for the palette info */
signed short int type;
/* 32bit - The length of the bitmap information header in bytes. */
signed int len;
/* 32bit - The width of the bitmap in pixels. */
signed int width;
/* 32bit - The height of the bitmap in pixels. */
signed int height;
/* 8 bit - The bitmap data is specified in top-down order. */
signed char topdown;
/* 16 bit - The number of planes. This must be set to a value of one. */
signed short int numplanes;
/* 16 bit - The number of bits per pixel. */
signed short int depth;
/* 32bit - The type of compression used. */
signed int enctype;
/* 32bit - The size of the image in bytes. */
signed int size;
/* 32bit - The horizontal resolution in pixels/metre. */
signed int hres;
/* 32bit - The vertical resolution in pixels/metre. */
signed int vres;
/* 32bit - The number of color indices used by the bitmap. */
signed int numcolors;
/* 32bit - The number of color indices important for displaying the bitmap. */
signed int mincolors;
} bmp_info_t;
#endif
#ifdef __cplusplus
}
#endif

778
utils/wpseditor/screenshot/gd_bmp.c Normal file
View file

@ -0,0 +1,778 @@
/*
Stolen from http://cvs.php.net/viewcvs.cgi/gd/playground/gdbmp/
*/
/*
gd_bmp.c
Bitmap format support for libgd
* Written 2007, Scott MacVicar
---------------------------------------------------------------------------
Todo:
Bitfield encoding
----------------------------------------------------------------------------
*/
/* $Id$ */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "gd.h"
#include "bmp.h"
extern void* gdCalloc (size_t nmemb, size_t size);
static int bmp_read_header(gdIOCtxPtr infile, bmp_hdr_t *hdr);
static int bmp_read_info(gdIOCtxPtr infile, bmp_info_t *info);
static int bmp_read_windows_v3_info(gdIOCtxPtr infile, bmp_info_t *info);
static int bmp_read_os2_v1_info(gdIOCtxPtr infile, bmp_info_t *info);
static int bmp_read_os2_v2_info(gdIOCtxPtr infile, bmp_info_t *info);
static int bmp_read_direct(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header);
static int bmp_read_1bit(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header);
static int bmp_read_4bit(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header);
static int bmp_read_8bit(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header);
static int bmp_read_rle(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info);
#if GD_MAJOR_VERSION == 2 && GD_MINOR_VERSION < 1
/* Byte helper functions, since added to GD 2.1 */
static int gdGetIntLSB(signed int *result, gdIOCtx * ctx);
static int gdGetWordLSB(signed short int *result, gdIOCtx * ctx);
#endif
#define BMP_DEBUG(s)
gdImagePtr gdImageCreateFromBmpCtx(gdIOCtxPtr infile);
gdImagePtr gdImageCreateFromBmp(FILE * inFile)
{
gdImagePtr im = 0;
gdIOCtx *in = gdNewFileCtx(inFile);
im = gdImageCreateFromBmpCtx(in);
in->gd_free(in);
return im;
}
gdImagePtr gdImageCreateFromBmpPtr(int size, void *data)
{
gdImagePtr im;
gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0);
im = gdImageCreateFromBmpCtx(in);
in->gd_free(in);
return im;
}
gdImagePtr gdImageCreateFromBmpCtx(gdIOCtxPtr infile)
{
bmp_hdr_t *hdr;
bmp_info_t *info;
gdImagePtr im = NULL;
int error = 0;
if (!(hdr= (bmp_hdr_t *)gdCalloc(1, sizeof(bmp_hdr_t)))) {
return NULL;
}
if (bmp_read_header(infile, hdr)) {
gdFree(hdr);
return NULL;
}
if (hdr->magic != 0x4d42) {
gdFree(hdr);
return NULL;
}
if (!(info = (bmp_info_t *)gdCalloc(1, sizeof(bmp_info_t)))) {
gdFree(hdr);
return NULL;
}
if (bmp_read_info(infile, info)) {
gdFree(hdr);
gdFree(info);
return NULL;
}
BMP_DEBUG(printf("Numcolours: %d\n", info->numcolors));
BMP_DEBUG(printf("Width: %d\n", info->width));
BMP_DEBUG(printf("Height: %d\n", info->height));
BMP_DEBUG(printf("Planes: %d\n", info->numplanes));
BMP_DEBUG(printf("Depth: %d\n", info->depth));
BMP_DEBUG(printf("Offset: %d\n", hdr->off));
if (info->depth >= 16) {
im = gdImageCreateTrueColor(info->width, info->height);
} else {
im = gdImageCreate(info->width, info->height);
}
if (!im) {
gdFree(hdr);
gdFree(info);
return NULL;
}
switch (info->depth) {
case 1:
BMP_DEBUG(printf("1-bit image\n"));
error = bmp_read_1bit(im, infile, info, hdr);
break;
case 4:
BMP_DEBUG(printf("4-bit image\n"));
error = bmp_read_4bit(im, infile, info, hdr);
break;
case 8:
BMP_DEBUG(printf("8-bit image\n"));
error = bmp_read_8bit(im, infile, info, hdr);
break;
case 16:
case 24:
case 32:
BMP_DEBUG(printf("Direct BMP image\n"));
error = bmp_read_direct(im, infile, info, hdr);
break;
default:
BMP_DEBUG(printf("Unknown bit count\n"));
error = 1;
}
gdFree(hdr);
gdFree(info);
if (error) {
gdImageDestroy(im);
return NULL;
}
return im;
}
static int bmp_read_header(gdIOCtx *infile, bmp_hdr_t *hdr)
{
if(
!gdGetWordLSB(&hdr->magic, infile) ||
!gdGetIntLSB(&hdr->size, infile) ||
!gdGetWordLSB(&hdr->reserved1, infile) ||
!gdGetWordLSB(&hdr->reserved2 , infile) ||
!gdGetIntLSB(&hdr->off , infile)
) {
return 1;
}
return 0;
}
static int bmp_read_info(gdIOCtx *infile, bmp_info_t *info)
{
/* read BMP length so we can work out the version */
if (!gdGetIntLSB(&info->len, infile)) {
return 1;
}
switch (info->len) {
/* For now treat Windows v4 + v5 as v3 */
case BMP_WINDOWS_V3:
case BMP_WINDOWS_V4:
case BMP_WINDOWS_V5:
BMP_DEBUG(printf("Reading Windows Header\n"));
if (bmp_read_windows_v3_info(infile, info)) {
return 1;
}
break;
case BMP_OS2_V1:
if (bmp_read_os2_v1_info(infile, info)) {
return 1;
}
break;
case BMP_OS2_V2:
if (bmp_read_os2_v2_info(infile, info)) {
return 1;
}
break;
default:
BMP_DEBUG(printf("Unhandled bitmap\n"));
return 1;
}
return 0;
}
static int bmp_read_windows_v3_info(gdIOCtxPtr infile, bmp_info_t *info)
{
if (
!gdGetIntLSB(&info->width, infile) ||
!gdGetIntLSB(&info->height, infile) ||
!gdGetWordLSB(&info->numplanes, infile) ||
!gdGetWordLSB(&info->depth, infile) ||
!gdGetIntLSB(&info->enctype, infile) ||
!gdGetIntLSB(&info->size, infile) ||
!gdGetIntLSB(&info->hres, infile) ||
!gdGetIntLSB(&info->vres, infile) ||
!gdGetIntLSB(&info->numcolors, infile) ||
!gdGetIntLSB(&info->mincolors, infile)
) {
return 1;
}
if (info->height < 0) {
info->topdown = 1;
info->height = -info->height;
} else {
info->topdown = 0;
}
info->type = BMP_PALETTE_4;
if (info->width <= 0 || info->height <= 0 || info->numplanes <= 0 ||
info->depth <= 0 || info->numcolors < 0 || info->mincolors < 0) {
return 1;
}
return 0;
}
static int bmp_read_os2_v1_info(gdIOCtxPtr infile, bmp_info_t *info)
{
if (
!gdGetWordLSB((signed short int *)&info->width, infile) ||
!gdGetWordLSB((signed short int *)&info->height, infile) ||
!gdGetWordLSB(&info->numplanes, infile) ||
!gdGetWordLSB(&info->depth, infile)
) {
return 1;
}
/* OS2 v1 doesn't support topdown */
info->topdown = 0;
info->numcolors = 1 << info->depth;
info->type = BMP_PALETTE_3;
if (info->width <= 0 || info->height <= 0 || info->numplanes <= 0 ||
info->depth <= 0 || info->numcolors < 0) {
return 1;
}
return 0;
}
static int bmp_read_os2_v2_info(gdIOCtxPtr infile, bmp_info_t *info)
{
char useless_bytes[24];
if (
!gdGetIntLSB(&info->width, infile) ||
!gdGetIntLSB(&info->height, infile) ||
!gdGetWordLSB(&info->numplanes, infile) ||
!gdGetWordLSB(&info->depth, infile) ||
!gdGetIntLSB(&info->enctype, infile) ||
!gdGetIntLSB(&info->size, infile) ||
!gdGetIntLSB(&info->hres, infile) ||
!gdGetIntLSB(&info->vres, infile) ||
!gdGetIntLSB(&info->numcolors, infile) ||
!gdGetIntLSB(&info->mincolors, infile)
) {
return 1;
}
/* Lets seek the next 24 pointless bytes, we don't care too much about it */
if (!gdGetBuf(useless_bytes, 24, infile)) {
return 1;
}
if (info->height < 0) {
info->topdown = 1;
info->height = -info->height;
} else {
info->topdown = 0;
}
info->type = BMP_PALETTE_4;
if (info->width <= 0 || info->height <= 0 || info->numplanes <= 0 ||
info->depth <= 0 || info->numcolors < 0 || info->mincolors < 0) {
return 1;
}
return 0;
}
static int bmp_read_direct(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header)
{
int ypos = 0, xpos = 0, row = 0;
int padding = 0, alpha = 0, red = 0, green = 0, blue = 0;
signed short int data = 0;
switch(info->enctype) {
case BMP_BI_RGB:
/* no-op */
break;
case BMP_BI_BITFIELDS:
if (info->depth == 24) {
BMP_DEBUG(printf("Bitfield compression isn't supported for 24-bit\n"));
return 1;
}
BMP_DEBUG(printf("Currently no bitfield support\n"));
return 1;
break;
case BMP_BI_RLE8:
if (info->depth != 8) {
BMP_DEBUG(printf("RLE is only valid for 8-bit images\n"));
return 1;
}
case BMP_BI_RLE4:
if (info->depth != 4) {
BMP_DEBUG(printf("RLE is only valid for 4-bit images\n"));
return 1;
}
case BMP_BI_JPEG:
case BMP_BI_PNG:
default:
BMP_DEBUG(printf("Unsupported BMP compression format\n"));
return 1;
}
/* There is a chance the data isn't until later, would be wierd but it is possible */
if (gdTell(infile) != header->off) {
/* Should make sure we don't seek past the file size */
gdSeek(infile, header->off);
}
/* The line must be divisible by 4, else its padded with NULLs */
padding = ((int)(info->depth / 8) * info->width) % 4;
if (padding) {
padding = 4 - padding;
}
for (ypos = 0; ypos < info->height; ++ypos) {
if (info->topdown) {
row = ypos;
} else {
row = info->height - ypos - 1;
}
for (xpos = 0; xpos < info->width; xpos++) {
if (info->depth == 16) {
if (!gdGetWordLSB(&data, infile)) {
return 1;
}
BMP_DEBUG(printf("Data: %X\n", data));
red = ((data & 0x7C00) >> 10) << 3;
green = ((data & 0x3E0) >> 5) << 3;
blue = (data & 0x1F) << 3;
BMP_DEBUG(printf("R: %d, G: %d, B: %d\n", red, green, blue));
} else if (info->depth == 24) {
if (!gdGetByte(&blue, infile) || !gdGetByte(&green, infile) || !gdGetByte(&red, infile)) {
return 1;
}
} else {
if (!gdGetByte(&blue, infile) || !gdGetByte(&green, infile) || !gdGetByte(&red, infile) || !gdGetByte(&alpha, infile)) {
return 1;
}
}
/*alpha = gdAlphaMax - (alpha >> 1);*/
gdImageSetPixel(im, xpos, row, gdTrueColor(red, green, blue));
}
for (xpos = padding; xpos > 0; --xpos) {
if (!gdGetByte(&red, infile)) {
return 1;
}
}
}
return 0;
}
static int bmp_read_palette(gdImagePtr im, gdIOCtxPtr infile, int count, int read_four)
{
int i;
int r, g, b, z;
for (i = 0; i < count; i++) {
if (
!gdGetByte(&r, infile) ||
!gdGetByte(&g, infile) ||
!gdGetByte(&b, infile) ||
(read_four && !gdGetByte(&z, infile))
) {
return 1;
}
im->red[i] = r;
im->green[i] = g;
im->blue[i] = b;
im->open[i] = 1;
}
return 0;
}
static int bmp_read_1bit(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header)
{
int ypos = 0, xpos = 0, row = 0, index = 0;
int padding = 0, current_byte = 0, bit = 0;
if (info->enctype != BMP_BI_RGB) {
return 1;
}
if (!info->numcolors) {
info->numcolors = 2;
} else if (info->numcolors < 0 || info->numcolors > 2) {
return 1;
}
if (bmp_read_palette(im, infile, info->numcolors, (info->type == BMP_PALETTE_4))) {
return 1;
}
im->colorsTotal = info->numcolors;
/* There is a chance the data isn't until later, would be wierd but it is possible */
if (gdTell(infile) != header->off) {
/* Should make sure we don't seek past the file size */
gdSeek(infile, header->off);
}
/* The line must be divisible by 4, else its padded with NULLs */
padding = ((int)ceill(0.1 * info->width)) % 4;
if (padding) {
padding = 4 - padding;
}
for (ypos = 0; ypos < info->height; ++ypos) {
if (info->topdown) {
row = ypos;
} else {
row = info->height - ypos - 1;
}
for (xpos = 0; xpos < info->width; xpos += 8) {
/* Bitmaps are always aligned in bytes so we'll never overflow */
if (!gdGetByte(&current_byte, infile)) {
return 1;
}
for (bit = 0; bit < 8; bit++) {
index = ((current_byte & (0x80 >> bit)) != 0 ? 0x01 : 0x00);
if (im->open[index]) {
im->open[index] = 0;
}
gdImageSetPixel(im, xpos + bit, row, index);
/* No need to read anything extra */
if ((xpos + bit) >= info->width) {
break;
}
}
}
for (xpos = padding; xpos > 0; --xpos) {
if (!gdGetByte(&index, infile)) {
return 1;
}
}
}
return 0;
}
static int bmp_read_4bit(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header)
{
int ypos = 0, xpos = 0, row = 0, index = 0;
int padding = 0, current_byte = 0;
if (info->enctype != BMP_BI_RGB && info->enctype != BMP_BI_RLE4) {
return 1;
}
if (!info->numcolors) {
info->numcolors = 16;
} else if (info->numcolors < 0 || info->numcolors > 16) {
return 1;
}
if (bmp_read_palette(im, infile, info->numcolors, (info->type == BMP_PALETTE_4))) {
return 1;
}
im->colorsTotal = info->numcolors;
/* There is a chance the data isn't until later, would be wierd but it is possible */
if (gdTell(infile) != header->off) {
/* Should make sure we don't seek past the file size */
gdSeek(infile, header->off);
}
/* The line must be divisible by 4, else its padded with NULLs */
padding = ((int)ceil(0.5 * info->width)) % 4;
if (padding) {
padding = 4 - padding;
}
switch (info->enctype) {
case BMP_BI_RGB:
for (ypos = 0; ypos < info->height; ++ypos) {
if (info->topdown) {
row = ypos;
} else {
row = info->height - ypos - 1;
}
for (xpos = 0; xpos < info->width; xpos += 2) {
if (!gdGetByte(&current_byte, infile)) {
return 1;
}
index = (current_byte >> 4) & 0x0f;
if (im->open[index]) {
im->open[index] = 0;
}
gdImageSetPixel(im, xpos, row, index);
/* This condition may get called often, potential optimsations */
if (xpos >= info->width) {
break;
}
index = current_byte & 0x0f;
if (im->open[index]) {
im->open[index] = 0;
}
gdImageSetPixel(im, xpos + 1, row, index);
}
for (xpos = padding; xpos > 0; --xpos) {
if (!gdGetByte(&index, infile)) {
return 1;
}
}
}
break;
case BMP_BI_RLE4:
if (bmp_read_rle(im, infile, info)) {
return 1;
}
break;
default:
return 1;
}
return 0;
}
static int bmp_read_8bit(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info, bmp_hdr_t *header)
{
int ypos = 0, xpos = 0, row = 0, index = 0;
int padding = 0;
if (info->enctype != BMP_BI_RGB && info->enctype != BMP_BI_RLE8) {
return 1;
}
if (!info->numcolors) {
info->numcolors = 256;
} else if (info->numcolors < 0 || info->numcolors > 256) {
return 1;
}
if (bmp_read_palette(im, infile, info->numcolors, (info->type == BMP_PALETTE_4))) {
return 1;
}
im->colorsTotal = info->numcolors;
/* There is a chance the data isn't until later, would be wierd but it is possible */
if (gdTell(infile) != header->off) {
/* Should make sure we don't seek past the file size */
gdSeek(infile, header->off);
}
/* The line must be divisible by 4, else its padded with NULLs */
padding = (1 * info->width) % 4;
if (padding) {
padding = 4 - padding;
}
switch (info->enctype) {
case BMP_BI_RGB:
for (ypos = 0; ypos < info->height; ++ypos) {
if (info->topdown) {
row = ypos;
} else {
row = info->height - ypos - 1;
}
for (xpos = 0; xpos < info->width; ++xpos) {
if (!gdGetByte(&index, infile)) {
return 1;
}
if (im->open[index]) {
im->open[index] = 0;
}
gdImageSetPixel(im, xpos, row, index);
}
/* Could create a new variable, but it isn't really worth it */
for (xpos = padding; xpos > 0; --xpos) {
if (!gdGetByte(&index, infile)) {
return 1;
}
}
}
break;
case BMP_BI_RLE8:
if (bmp_read_rle(im, infile, info)) {
return 1;
}
break;
default:
return 1;
}
return 0;
}
static int bmp_read_rle(gdImagePtr im, gdIOCtxPtr infile, bmp_info_t *info)
{
int ypos = 0, xpos = 0, row = 0, index = 0;
int rle_length = 0, rle_data = 0;
int padding = 0;
int i = 0, j = 0;
int pixels_per_byte = 8 / info->depth;
for (ypos = 0; ypos < info->height && xpos <= info->width;) {
if (!gdGetByte(&rle_length, infile) || !gdGetByte(&rle_data, infile)) {
return 1;
}
row = info->height - ypos - 1;
if (rle_length != BMP_RLE_COMMAND) {
if (im->open[rle_data]) {
im->open[rle_data] = 0;
}
for (i = 0; (i < rle_length) && (xpos < info->width);) {
for (j = 1; (j <= pixels_per_byte) && (xpos < info->width) && (i < rle_length); j++, xpos++, i++) {
index = (rle_data & (((1 << info->depth) - 1) << (8 - (j * info->depth)))) >> (8 - (j * info->depth));
if (im->open[index]) {
im->open[index] = 0;
}
gdImageSetPixel(im, xpos, row, index);
}
}
} else if (rle_length == BMP_RLE_COMMAND && rle_data > 2) {
/* Uncompressed RLE needs to be even */
padding = 0;
for (i = 0; (i < rle_data) && (xpos < info->width); i += pixels_per_byte) {
int max_pixels = pixels_per_byte;
if (!gdGetByte(&index, infile)) {
return 1;
}
padding++;
if (rle_data - i < max_pixels) {
max_pixels = rle_data - i;
}
for (j = 1; (j <= max_pixels) && (xpos < info->width); j++, xpos++) {
int temp = (index >> (8 - (j * info->depth))) & ((1 << info->depth) - 1);
if (im->open[temp]) {
im->open[temp] = 0;
}
gdImageSetPixel(im, xpos, row, temp);
}
}
/* Make sure the bytes read are even */
if (padding % 2 && !gdGetByte(&index, infile)) {
return 1;
}
} else if (rle_length == BMP_RLE_COMMAND && rle_data == BMP_RLE_ENDOFLINE) {
/* Next Line */
xpos = 0;
ypos++;
} else if (rle_length == BMP_RLE_COMMAND && rle_data == BMP_RLE_DELTA) {
/* Delta Record, used for bmp files that contain other data*/
if (!gdGetByte(&rle_length, infile) || !gdGetByte(&rle_data, infile)) {
return 1;
}
xpos += rle_length;
ypos += rle_data;
} else if (rle_length == BMP_RLE_COMMAND && rle_data == BMP_RLE_ENDOFBITMAP) {
/* End of bitmap */
break;
}
}
return 0;
}
#if GD_MAJOR_VERSION == 2 && GD_MINOR_VERSION < 1
static int gdGetWordLSB(signed short int *result, gdIOCtx * ctx)
{
unsigned int high = 0, low = 0;
low = (ctx->getC) (ctx);
if (low == EOF) {
return 0;
}
high = (ctx->getC) (ctx);
if (high == EOF) {
return 0;
}
if (result) {
*result = (high << 8) | low;
}
return 1;
}
static int gdGetIntLSB(signed int *result, gdIOCtx * ctx)
{
int c = 0;
unsigned int r = 0;
c = (ctx->getC) (ctx);
if (c == EOF) {
return 0;
}
r |= (c << 24);
r >>= 8;
c = (ctx->getC) (ctx);
if (c == EOF) {
return 0;
}
r |= (c << 24);
r >>= 8;
c = (ctx->getC) (ctx);
if (c == EOF) {
return 0;
}
r |= (c << 24);
r >>= 8;
c = (ctx->getC) (ctx);
if (c == EOF) {
return 0;
}
r |= (c << 24);
if (result) {
*result = (signed int)r;
}
return 1;
}
#endif

361
utils/wpseditor/screenshot/main.c Normal file
View file

@ -0,0 +1,361 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2008 by Maurus Cuelenaere
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <dlfcn.h>
#include <unistd.h>
#include "gd.h"
#include "gdfonts.h"
#include "api.h"
#define DEBUGF1 _debug
#define DEBUGF2 if(verbose) _debug
#define getFont() gdFontGetSmall()
static struct trackstate mp3data =
{
(char*)"Test title",
(char*)"Test artist",
(char*)"Test album",
(char*)"Test genre",
(char*)"Test disc",
(char*)"Test track",
(char*)"Test year",
(char*)"Test composer",
(char*)"Test comment",
(char*)"Test album artist",
(char*)"Test grouping",
1, /* int discnum */
1, /* int tracknum */
1, /* int version */
1, /* int layer */
2008, /* int year */
100, /* int length */
70 /* int elapsed */
};
static struct wpsstate wpsdata = {-20, -1, -1, 70, API_STATUS_FASTFORWARD};
/* volume, fontheight, fontwidth, battery_level, audio_status */
static struct proxy_api api;
static bool verbose = false;
static int (*wps_init)(const char* buff, struct proxy_api *api, bool isfile);
static int (*wps_display)();
static int (*wps_refresh)();
static gdImagePtr framebuffer;
static gdImagePtr backdrop;
extern gdImagePtr gdImageCreateFromBmp(FILE * inFile);
extern char *get_current_dir_name (void) __THROW;
int _debug(const char* fmt,...)
{
#if 0 /* Doesn't want to compile ?? */
struct va_list ap;
va_start(ap, fmt);
fprintf(stdout, "[DBG] ");
vfprintf(stdout, fmt, ap);
fprintf(stdout, "\n");
va_end(ap);
return 0;
#else
return -1;
#endif
}
void _putsxy(int x, int y, const unsigned char *str)
{
struct viewport_api avp;
int black = gdImageColorAllocate(framebuffer, 0, 0, 0);
api.get_current_vp(&avp);
gdImageString(framebuffer, getFont(), x + avp.x, y + avp.y - avp.fontheight, (unsigned char*)str, black);
}
void _transparent_bitmap_part(const void *src, int src_x, int src_y,
int stride, int x, int y, int width, int height)
{
FILE *_image;
gdImagePtr image;
int pink;
DEBUGF2("transparent_bitmap_part(const void *src=%s, int src_x=%d, int src_y=%d, int stride=%d, int x=%d, int y=%d, int width=%d, int height=%d", (char*)src, src_x, src_y, stride, x, y, width, height);
_image = fopen(src, "rb");
if(_image == NULL)
return;
image = gdImageCreateFromBmp(_image);
fclose(_image);
pink = gdTrueColor(255, 0, 255);
gdImageColorTransparent(image, pink);
gdImageCopy(framebuffer, image, x, y, src_x, src_y, width, height);
gdImageDestroy(image);
}
void _bitmap_part(const void *src, int src_x, int src_y,
int stride, int x, int y, int width, int height)
{
FILE *_image;
gdImagePtr image;
DEBUGF2("bitmap_part(const void *src=%s, int src_x=%d, int src_y=%d, int stride=%d, int x=%d, int y=%d, int width=%d, int height=%d", (char*)src, src_x, src_y, stride, x, y, width, height);
_image = fopen(src, "rb");
if(_image == NULL)
return;
image = gdImageCreateFromBmp(_image);
fclose(_image);
gdImageCopy(framebuffer, image, x, y, src_x, src_y, width, height);
gdImageDestroy(image);
}
void _drawpixel(int x, int y)
{
int black = gdImageColorAllocate(framebuffer, 0, 0, 0);
gdImageSetPixel(framebuffer, x, y, black);
}
void _fillrect(int x, int y, int width, int height)
{
/* Don't draw this as backdrop is used */
#if 0
int black = gdImageColorAllocate(framebuffer, 0, 0, 0);
gdImageFilledRectangle(framebuffer, x, y, x+width, y+height, black);
#endif
}
void _hline(int x1, int x2, int y)
{
int black = gdImageColorAllocate(framebuffer, 0, 0, 0);
gdImageLine(framebuffer, x1, y, x2, y, black);
}
void _vline(int x, int y1, int y2)
{
int black = gdImageColorAllocate(framebuffer, 0, 0, 0);
gdImageLine(framebuffer, x, y1, x, y2, black);
}
void _clear_viewport(int x, int y, int w, int h, int color)
{
if(backdrop == NULL)
return;
gdImageCopy(framebuffer, backdrop, x, y, x, y, w, h);
}
static bool _load_wps_backdrop(char* filename)
{
FILE *image;
if(backdrop != NULL)
gdImageDestroy(backdrop);
DEBUGF2("load backdrop: %s", filename);
image = fopen(filename, "rb");
if(image == NULL)
return false;
backdrop = gdImageCreateFromBmp(image);
fclose(image);
return true;
}
int _read_bmp_file(const char* filename, int *width, int *height)
{
FILE *_image;
gdImagePtr image;
DEBUGF2("load backdrop: %s", filename);
_image = fopen(filename, "rb");
if(_image == NULL)
return 0;
image = gdImageCreateFromBmp(_image);
fclose(_image);
*width = image->sx;
*height = image->sy;
gdImageDestroy(image);
return 1;
}
static void _drawBackdrop()
{
if(backdrop == NULL)
return;
gdImageCopy(framebuffer, backdrop, 0, 0, 0, 0, backdrop->sx, backdrop->sy);
}
static int screenshot(char *model, char *wps, char *png)
{
char lib[255];
void *handle;
FILE *out, *in;
in = fopen(wps, "rb");
if(in == NULL)
{
fprintf(stderr, "[ERR] Cannot open WPS: %s\n", wps);
return -1;
}
fclose(in);
out = fopen(png, "wb");
if(out == NULL)
{
fprintf(stderr, "[ERR] Cannot open PNG: %s\n", png);
return -2;
}
snprintf(lib, 255, "%s/libwps_%s.so", (char*)get_current_dir_name(), (char*)model);
handle = dlopen(lib, RTLD_LAZY);
if (!handle)
{
fprintf(stderr, "[ERR] Cannot open library: %s\n", dlerror());
fclose(out);
return -3;
}
wps_init = dlsym(handle, "wps_init");
wps_display = dlsym(handle, "wps_display");
wps_refresh = dlsym(handle, "wps_refresh");
if (!wps_init || !wps_display || !wps_refresh)
{
fprintf(stderr, "[ERR] Failed to resolve funcs!");
dlclose(handle);
fclose(out);
return -4;
}
memset(&api, 0, sizeof(struct proxy_api));
if(verbose)
api.verbose = 3;
else
api.verbose = 0;
api.putsxy = &_putsxy;
api.transparent_bitmap_part = &_transparent_bitmap_part;
api.bitmap_part = &_bitmap_part;
api.drawpixel = &_drawpixel;
api.fillrect = &_fillrect;
api.hline = &_hline;
api.vline = &_vline;
api.clear_viewport = &_clear_viewport;
api.load_wps_backdrop = &_load_wps_backdrop;
api.read_bmp_file = &_read_bmp_file;
api.debugf = &_debug;
wps_init(wps, &api, true);
framebuffer = gdImageCreateTrueColor(api.getwidth(), api.getheight());
_drawBackdrop();
if(strcmp(api.get_model_name(), model) != 0)
{
fprintf(stderr, "[ERR] Model name doesn't match the one supplied by the library\n");
fprintf(stderr, " %s <-> %s\n", model, api.get_model_name());
dlclose(handle);
fclose(out);
gdImageDestroy(framebuffer);
gdImageDestroy(backdrop);
wps_init = NULL;
wps_display = NULL;
wps_refresh = NULL;
return -5;
}
fprintf(stdout, "[INFO] Model: %s\n", api.get_model_name());
wpsdata.fontheight = getFont()->h;
wpsdata.fontwidth = getFont()->w;
api.set_wpsstate(wpsdata);
api.set_trackstate(mp3data);
api.set_next_trackstate(mp3data);
_drawBackdrop();
wps_refresh();
gdImagePng(framebuffer, out);
fprintf(stdout, "[INFO] Image written\n");
dlclose(handle);
fclose(out);
gdImageDestroy(framebuffer);
gdImageDestroy(backdrop);
wps_init = NULL;
wps_display = NULL;
wps_refresh = NULL;
return 0;
}
static void usage(void)
{
fprintf(stderr, "Usage: screenshot [-V] <MODEL> <WPS_FILE> <OUT_PNG>\n");
fprintf(stderr, "Example: screenshot h10_5gb iCatcher.wps out.png\n");
}
int main(int argc, char ** argv)
{
if(argc < 4)
{
usage();
return -1;
}
if(strcmp(argv[1], "-V") == 0)
{
verbose = true;
return screenshot(argv[2], argv[3], argv[4]);
}
else
{
verbose = false;
return screenshot(argv[1], argv[2], argv[3]);
}
return 0;
}