/*---------------------------------------------------------------------------*-
fb_print_char
-----------------------------------------------------------------------------
Descriptif: Cette fonction permet d'afficher un caractère en fonction
de la couleur et de la position choisie par l'utilisateur.
Entrée : int color : couleur choisie
int color_fond : couleur de fond
unsigned char car : caractère choisi
int x : position en x sur l'afficheur
int y : position en y sur l'afficheur
Sortie : Aucune
-*---------------------------------------------------------------------------*/
void fb_print_char(int color, int color_fond, unsigned char car, int x, int y)
{
unsigned char ligne;
unsigned int j;
unsigned int i;
unsigned int tab[] = { 1, 2, 4, 8, 16, 32, 64, 128};
// Permet de parcourir les 8 lignes
for (i = 0; i < 8 ; i++)
{
// Permet de récuperer la valeur codé sur 8 bits
// pour le caractère.
ligne = fb_font_data[car-FIRST_CHAR][i];
// Permet de parcourir les 8 colonnes
for (j = 0 ; j < 8; j++)
{
// Permet de déterminer si on doit allumer le pixel cocnerné
if (ligne & tab[7-j])
fb_set_pixel(y+i,x+j,color);
else
fb_set_pixel(y+i,x+j,color_fond);
}
}
}
void fb_draw_line2(int x0, int y0, int x1, int y1, uchar color)
{
int i;
int steep = 1;
int sx, sy; /* step positive or negative (1 or -1) */
int dx, dy; /* delta (difference in X and Y between points) */
int e;
/*
* optimize for vertical and horizontal lines here
*/
dx = (x1 > x0) ? (x1 - x0) : x0 - x1;
sx = ((x1 - x0) > 0) ? 1 : -1;
dy = (y1 > y0) ? (y1 - y0) : y0 - y1;
sy = ((y1 - y0) > 0) ? 1 : -1;
e = (dy << 1) - dx;
for (i = 0; i < dx; i++) {
if (steep) {
fb_set_pixel(x0,y0,color);
} else {
fb_set_pixel(y0,x0,color);
}
while (e >= 0) {
y0 += sy;
e -= (dx << 1);
}
x0 += sx;
e += (dy << 1);
}
}
int fb_font_draw_bitmap(FB_SCREEN *screenp, FT_Bitmap *bitmap, FT_Int x, FT_Int y)
{
COLOR_32 color[2], backcolor;
FB_POINT point;
FT_Int i, j, p, q;
FT_Int x_max = x + bitmap->width;
FT_Int y_max = y + bitmap->rows;
unsigned char ch;
color[0] = fb_formatRGB(255, 255, 255);
color[1] = fb_formatRGB(120, 120, 120);
backcolor = fb_formatRGB(0, 0, 0);
for ( j = y, q = 0; j < y_max; j++, q++ )
{
for ( i = x, p = 0; i < x_max; i++, p++ ){
ch = bitmap->buffer[q * bitmap->width + p];
if(ch > 128){
//int fb_set_pixel(FB_POINT *point, int x, int y, COLOR_32 color);
fb_set_pixel(&point, i, j, color[0]);
//int fb_draw_pixel(struct framebuffer *fbp, FB_POINT *point);
fb_draw_pixel_screen(screenp, &point);
}else if(ch > 10){
fb_set_pixel(&point, i, j, color[1]);
fb_draw_pixel_screen(screenp, &point);
}else{
fb_set_pixel(&point, i, j, backcolor);
fb_draw_pixel_screen(screenp, &point);
}
}
}
return 0;
}
// ------------------------------------------------------------------
// fb_draw_circle draws a circle at the specified location based on
// bresenham's circle drawing algorithm
void fb_draw_circle(ulong x, ulong y, ulong radius, uchar color)
{
ulong xpos, ypos, d;
xpos = x;
ypos = radius;
d = 3 - (2 * ypos);
while(ypos >= xpos)
{
fb_set_pixel(x + xpos, y + ypos, color); // point in octant 1
fb_set_pixel(x - xpos, y + ypos, color); // point in octant 4
fb_set_pixel(x - xpos, y - ypos, color); // point in octant 5
fb_set_pixel(x + xpos, y - ypos, color); // point in octant 8
fb_set_pixel(x + ypos, y + xpos, color); // point in octant 2
fb_set_pixel(x - ypos, y + xpos, color); // point in octant 3
fb_set_pixel(x - ypos, y - xpos, color); // point in octant 6
fb_set_pixel(x + ypos, y - xpos, color); // point in octant 7
if (d < 0)
{
d = (d + (4 * xpos)) + 6;
}
else
{
d = (d + (4 * (xpos - ypos))) + 10;
ypos = ypos - 1;
}
xpos++;
}
}
/* Dessine un cercle en fonction des coordonn�es du centre, du rayon,
et de la couleur */
int fb_circle(int yPos, int xPos, int radius, int color) {
int i, y;
int a, b, c, d;
if (radius >= LCD_MAX_X / 2)
radius = LCD_MAX_X / 2;
for (i = 0; i <= radius; i++) {
y = circleYpos(i, radius); /* calcul pixel p�riph�rie */
a = (yPos > LCD_MAX_Y) ? LCD_MAX_Y : yPos;
b = (yPos < 0) ? 0 : yPos;
c = (xPos + i > LCD_MAX_X) ? LCD_MAX_X : xPos + i;
d = (xPos - i < 0) ? 0 : xPos - i;
fb_set_pixel(a, c, color);
fb_set_pixel(b, c, color);
fb_set_pixel(a, d, color);
fb_set_pixel(b, d, color);
a = (yPos + y > LCD_MAX_Y) ? LCD_MAX_Y : yPos + y;
b = (yPos - y < 0) ? 0 : yPos - y;
c = (xPos + i > LCD_MAX_X) ? LCD_MAX_X : xPos + i;
d = (xPos - i < 0) ? 0 : xPos - i;
fb_set_pixel(a, c, color);
fb_set_pixel(b, c, color);
fb_set_pixel(a, d, color);
fb_set_pixel(b, d, color);
}
return 0;
}
FB_Surface *
gfx_bitmap_load(GFX_Bitmap *bitmap) {
int bpp = bitmap->bytes_per_pixel;
FB_Surface *sfc;
FB_Color c;
sfc = fb_create_surface(bitmap->width, bitmap->height, FB_FORMAT_BEST);
for (int y=0; y<sfc->height; y++) {
for (int x=0; x<sfc->width; x++) {
int idx = y * sfc->width * bpp + x * bpp;
c.a = 0xff;
switch (bpp) {
case 4:
c.a = bitmap->pixel_data[idx + 3];
// fall through!
case 3:
c.b = bitmap->pixel_data[idx + 2];
c.g = bitmap->pixel_data[idx + 1];
c.r = bitmap->pixel_data[idx + 0];
break;
case 1:
c.r = c.g = c.b = bitmap->pixel_data[idx];
break;
}
fb_set_pixel(sfc, x, y, &c);
}
}
return (sfc);
}
FB_Surface *
gfx_glyph_load(GFX_Bitmap *bitmap, FB_Color *c) {
int bpp = bitmap->bytes_per_pixel;
FB_Surface *sfc;
sfc = fb_create_surface(bitmap->width, bitmap->height, FB_FORMAT_BEST);
for (int y=0; y<sfc->height; y++) {
for (int x=0; x<sfc->width; x++) {
int idx = y * sfc->width * bpp + x * bpp;
switch (bpp) {
case 1:
// grayscale image
c->a = bitmap->pixel_data[idx + 0];
break;
case 4:
// RGBA image
c->a = bitmap->pixel_data[idx + 3];
break;
}
fb_set_pixel(sfc, x, y, c);
}
}
return (sfc);
}
// ------------------------------------------------------------------
// fb_print_char prints a character at the specified location.
//
void fb_print_char(uchar cchar, ulong x, ulong y, uchar color)
{
ulong idx1, idx2;
uchar font_line, fcolor;
// printable characters only
if ((cchar < FIRST_CHAR) || (cchar > LAST_CHAR))
return;
// loop through each row of the font.
for(idx1 = 0; idx1 < FONT_HEIGHT; idx1++)
{
// read the byte which describes this row of the font.
font_line = fb_font_data[(cchar - FIRST_CHAR) * FONT_STEP][idx1];
// loop through each column of this row.
for(idx2 = 0; idx2 < 8; idx2++)
{
// set the pixel based on the value of this bit of the font,
// using the requested or the backround color.
fcolor = font_line & 1 << ((FONT_WIDTH - 1) - idx2) ? color : bcolor;
fb_set_pixel(x + idx2, y + idx1, fcolor);
}
}
}
void fb_rect_fill(int y_min, int y_max, int x_min, int x_max, int couleur) {
int x = 0, y = 0;
for (y = y_min; y <= y_max; y++)
for (x = x_min; x <= x_max; x++)
fb_set_pixel(y, x, couleur);
}
/* remplit un cercle en fonction des coordonn�es du centre, du rayon,
et de la couleur */
int fb_circle_fill(int yPos,int xPos,int radius,int color){
int i,j,y;
if (radius >= LCD_MAX_X/2) radius = LCD_MAX_X/2;
if (xPos+radius >= LCD_MAX_X) xPos = LCD_MAX_X-1-radius;
if (yPos+radius >= LCD_MAX_Y) yPos = LCD_MAX_Y-1-radius;
if (xPos-radius < 0 ) xPos = radius;
if (yPos-radius < 0 ) yPos = radius;
for (i=0;i<=radius;i++){
y = circleYpos( i, radius); /* calcul pixel p�riph�rie */
for (j=0;j<=y;j++) { /* remplissage */
fb_set_pixel(yPos+j,xPos+i,color);
fb_set_pixel(yPos-j,xPos+i,color);
fb_set_pixel(yPos+j,xPos-i,color);
fb_set_pixel(yPos-j,xPos-i,color);
}
}
return 0;
}
/*
* Draw a line form point1 to point2.
*/
int fb_draw_line_screen(FB_SCREEN *screenp, FB_POINT *point1, FB_POINT *point2)
{
/* generalized integer Bresenham's algorithm for all quadrants
* the line end points aire (x1, y1) and (x2 , y2), assumed not equal
* all variables are assumed integer*/
/* initialize variables */
FB_POINT point;
int x, y, dx, dy;
int s1, s2;
int e; /* err(math) */
int i, tmp, interchange;
x = point1->x;
y = point1->y;
dx = abs(point2->x - x);
dy = abs(point2->y - y);
s1 = fb_line_sign(point2->x - point1->x);
s2 = fb_line_sign(point2->y - point1->y);
/* interchange dx and dy depending on the slope of the line */
if(dy > dx){
tmp = dx;
dx = dy;
dy = tmp;
interchange = 1;
}else{
interchange = 0;
}
/* initialize the error term to compensate for a non zero intercept */
e = 2 * dy - dx;
/* main loop */
for(i = 0; i <= dx; i++){
fb_set_pixel(&point, x, y, point1->color);
fb_draw_pixel_screen(screenp, &point);
while(e > 0){
if(interchange == 1){
x = x + s1;
}else{
y = y + s2;
}
e = e - 2 * dx;
}
if(interchange == 1){
y = y + s2;
}else{
x = x + s1;
}
e = e + 2 * dy;
}
return 0;
}
// ------------------------------------------------------------------
// fb_print_charx2 prints a double-sized character at the specified location.
//
void fb_print_charx2(char cchar, ulong x, ulong y, uchar color)
{
ulong idx1, idx2;
ushort font_line;
uchar fcolor;
// printable characters only
if (((unsigned char)cchar < FIRST_CHAR) ||
((unsigned char)cchar > LAST_CHAR))
return;
// loop through each row of the font.
for(idx1 = 0; idx1 < FONT_HEIGHT; idx1++)
{
// read the byte which describes this row of the font.
font_line = (fb_font_data[(cchar - FIRST_CHAR) * FONT_STEP][idx1]) << 8;
if (FONT_WIDTH > 8) // get the second byte if present
{
font_line = fb_font_data[(cchar - FIRST_CHAR) * FONT_STEP][idx1 + 1];
}
// loop through each column of this row.
for(idx2 = 0; idx2 < FONT_WIDTH; idx2++)
{
// determine the color of this pixel block.
fcolor = font_line & (1 << ((FONT_WIDTH - 1) - idx2)) ? color : bcolor;
// set the pixel block (2x2) based on the value of this bit of
// the font, using the requested or the backround color.
fb_set_pixel(x + (idx2 << 1), y + (idx1 << 1), fcolor);
fb_set_pixel(x + (idx2 << 1) + 1, y + (idx1 << 1), fcolor);
fb_set_pixel(x + (idx2 << 1), y + (idx1 << 1) + 1, fcolor);
fb_set_pixel(x + (idx2 << 1) + 1, y + (idx1 << 1) + 1, fcolor);
}
}
}
void fb_draw_circle2(ulong xpos, ulong ypos, ulong radius, uchar color)
{
int x;
int y = radius;
int d = -radius;
for(x = 1; x < (radius/1.414); x++)
{ d += (2 * x) - 1;
if (d >= 0)
{ y--;
d -= (2 * y); /* Must do this AFTER y-- */
}
// fb_set_pixel(x + xpos, y + ypos, color);
fb_set_pixel(xpos + x, ypos + y, color); // point in octant 1
fb_set_pixel(xpos - x, ypos + y, color); // point in octant 4
fb_set_pixel(xpos - x, ypos - y, color); // point in octant 5
fb_set_pixel(xpos + x, ypos - y, color); // point in octant 8
fb_set_pixel(xpos + y, ypos + x, color); // point in octant 2
fb_set_pixel(xpos - y, ypos + x, color); // point in octant 3
fb_set_pixel(xpos - y, ypos - x, color); // point in octant 6
fb_set_pixel(xpos + y, ypos - x, color); // point in octant 7
}
}
/*
* Draw a line form point1 to point2, only for the first octant
*/
int fb_draw_line_study(FB *fbp, FB_POINT *point1, FB_POINT *point2)
{
/* Bresenham's line rasterization algorithm for the first octant
* the line end points are (x1, y1) and (x2, y2), assumed not equal
* Interger is the interger function*/
FB_POINT point;
int x, y, dx, dy;
float m, e;
int i;
/* initialize variables */
x = point1->x;
y = point1->y;
dx = point2->x - point1->x;
dy = point2->y - point1->y;
m = dy / (float)dx;
/* initialize e to compensate for a nonzero intercept */
e = m - 0.5;
#if TEST
fprintf(stdout, "initialize variables: \n");
fprintf(stdout, "(x, y) = (%d, %d)\n", x, y);
fprintf(stdout, "(dx, dy) = (%d, %d)\n", dx, dy);
fprintf(stdout, "m = %f, e = %f\n", m, e);
#endif
/* begin the main loop */
for(i = 0; i < dx; i++){
fb_set_pixel(&point, x, y, point1->color);
fb_draw_pixel(fbp, &point);
while(e > 0){
y = y + 1;
e = e - 1;
}
x = x + 1;
e = e + m;
}
return 0;
}
void fb_line(int x0, int y0, int x1, int y1, int color){
int dx, dy, sx, sy, err, e2;
/* On calcule les deltas en X et en Y entre les 2 points de la ligne */
dx = abs(x1 - x0);
dy = abs(y1 - y0);
/* On calcule le sens de tracage et "l'erreur" (erreur = 0 -> segment à 45°) */
if (x0 < x1){
sx = 1;
}else{
sx = -1;
}
if (y0 < y1){
sy = 1;
}else{
sy = -1;
}
err = dx - dy;
/* Boucle de tracage de la ligne */
do {
fb_set_pixel(y0,x0,color); // Dessiner un pixel
e2 = 2 * err;
// On corrige la trajectoire en X
if (e2 > -dy) {
err = err - dy;
x0 = x0 + sx;
}
// On corrige la trajectoire en Y
if (e2 < dx) {
err = err + dx;
y0 = y0 + sy;
}
} while ((x0 != x1) || (y0 != y1));
}
/*
* Draw a frame for image,
* @imgnum: status->img_list_mini[imgnum];
*/
int maindeal_img_frame_draw(struct mainstatus *status, FB_IMAGE *imagep,
COLOR_32 startcolor, COLOR_32 stopcolor, int thick)
{
int i;
int tmp; /* RGB temporary value */
COLOR_32 color;
FB_POINT point1;
FB_RECT rect;
for(i = 0; i < thick; i++){
tmp = startcolor + (stopcolor - startcolor) / thick * i;
color = fb_formatRGB(tmp, tmp, tmp);
fb_set_pixel(&point1, imagep->x - i - 1, imagep->y - i - 1 , color);
fb_rect_set(&rect, &point1, imagep->width + 2 * i,
imagep->height + 2 * i);
//int fb_rect_draw_nonfill(FB *fbp, FB_RECT *rectp);
fb_rect_draw_nofill_screen(&status->screen, &rect);
}
return 0;
}
/**
* load jpeg file to fb_pixmap
* @param filename name of bmp file on the disk to load
* @param fb_pixmap pointer to the memory for pixmap
* @param w width of loaded image
* @param h height of loaded image
* @return 0 if success, 1 if failure.
*/
int jpeg2fb_pixmap(char * filename, fb_pixel ** fb_pixmap, Uint16 * w, Uint16 * h)
{
int i, j;
/* This struct contains the JPEG decompression parameters and pointers to
* working space (which is allocated as needed by the JPEG library).
*/
struct jpeg_decompress_struct cinfo;
/* We use our private extension JPEG error handler.
* Note that this struct must live as long as the main JPEG parameter
* struct, to avoid dangling-pointer problems.
*/
struct my_error_mgr jerr;
/* source file */
FILE * infile;
/* Output row buffer */
JSAMPARRAY buffer;
/* physical row width in output buffer */
int row_stride;
/* In this example we want to open the input file before doing anything else,
* so that the setjmp() error recovery below can assume the file is open.
* VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
* requires it in order to read binary files.
*/
if ((infile = fopen(filename, "rb")) == NULL) {
fprintf(stderr, "can't open %s\n", filename);
return 1;
}
/* Step 1: allocate and initialize JPEG decompression object */
/* We set up the normal JPEG error routines, then override error_exit. */
cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = my_error_exit;
/* Establish the setjmp return context for my_error_exit to use. */
if (setjmp(jerr.setjmp_buffer))
{
/* If we get here, the JPEG code has signaled an error.
* We need to clean up the JPEG object, close the input file, and return.
*/
jpeg_destroy_decompress(&cinfo);
fclose(infile);
return 1;
}
/* Now we can initialize the JPEG decompression object. */
jpeg_create_decompress(&cinfo);
/* Step 2: specify data source (eg, a file) */
jpeg_stdio_src(&cinfo, infile);
/* Step 3: read file parameters with jpeg_read_header() */
(void) jpeg_read_header(&cinfo, TRUE);
/* We can ignore the return value from jpeg_read_header since
* (a) suspension is not possible with the stdio data source, and
* (b) we passed TRUE to reject a tables-only JPEG file as an error.
* See libjpeg.doc for more info.
*/
/* Step 4: set parameters for decompression */
/* In this example, we don't need to change any of the defaults set by
* jpeg_read_header(), so we do nothing here.
*/
cinfo.out_color_space = JCS_RGB;
/*
switch (cinfo.jpeg_color_space)
{
case JCS_YCbCr:
//printf("YUV colorspace detected.\n");
cinfo.out_color_space = JCS_YCbCr;
break;
case JCS_GRAYSCALE:
//printf("Grayscale colorspace detected.\n");
cinfo.out_color_space = JCS_GRAYSCALE;
break;
default:
printf("Unsupported colorspace detected.\n");
break;
}
*/
/* Step 5: Start decompressor */
(void) jpeg_start_decompress(&cinfo);
/* We can ignore the return value since suspension is not possible
* with the stdio data source.
*/
/* We may need to do some setup of our own at this point before reading
* the data. After jpeg_start_decompress() we have the correct scaled
* output image dimensions available, as well as the output colormap
* if we asked for color quantization.
* In this example, we need to make an output work buffer of the right size.
*/
/* JSAMPLEs per row in output buffer */
row_stride = cinfo.output_width * cinfo.output_components;
/* Make a one-row-high sample array that will go away when done with image */
buffer = (*cinfo.mem->alloc_sarray)
((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
/* Step 6: while (scan lines remain to be read) */
/* Here we use the library's state variable cinfo.output_scanline as the
* loop counter, so that we don't have to keep track ourselves.
*/
*w = cinfo.output_width;
*h = cinfo.output_height;
*fb_pixmap = (fb_pixel*)malloc((*w) * (*h) * pixelsize);
if ((*fb_pixmap)==NULL)
{
/* error while allocating memory */
fclose(infile);
(void)jpeg_finish_decompress(&cinfo);
jpeg_destroy_decompress(&cinfo);
return 1;
}
j = 0;
/* We are reading each row of image, one by one */
while (cinfo.output_scanline < cinfo.output_height) {
/* jpeg_read_scanlines expects an array of pointers to scanlines.
* Here the array is only one element long, but you could ask for
* more than one scanline at a time if that's more convenient.
*/
(void) jpeg_read_scanlines(&cinfo, buffer, 1);
/* Assume put_scanline_someplace wants a pointer and sample count. */
for (i = 0; i < cinfo.output_width; i++) {
/* Some of pointer magic, that allow me to create pixel in right framebuffer format */
fb_set_pixel((*fb_pixmap)+((i+j*(*w))*pixelsize), *((*buffer)+i*3+0), *((*buffer)+i*3+1), *((*buffer)+i*3+2));
}
j++;
}
/* Step 7: Finish decompression */
/* We can ignore the return value since suspension is not possible
* with the stdio data source.
*/
(void) jpeg_finish_decompress(&cinfo);
/* Step 8: Release JPEG decompression object */
/* This is an important step since it will release a good deal of memory. */
jpeg_destroy_decompress(&cinfo);
/* After finish_decompress, we can close the input file.
* Here we postpone it until after no more JPEG errors are possible,
* so as to simplify the setjmp error logic above. (Actually, I don't
* think that jpeg_destroy can do an error exit, but why assume anything...)
*/
fclose(infile);
/* At this point you may want to check to see whether any corrupt-data
* warnings occurred (test whether jerr.pub.num_warnings is nonzero).
*/
/* And we're done! */
return 0;
}