/* $Id: udelay.c,v 1.19 2005/01/18 06:30:24 reinelt Exp $ * * short delays * * Copyright (C) 1999, 2000 Michael Reinelt * Copyright (C) 2004 The LCD4Linux Team * * This file is part of LCD4Linux. * * LCD4Linux 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, or (at your option) * any later version. * * LCD4Linux is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * * $Log: udelay.c,v $ * Revision 1.19 2005/01/18 06:30:24 reinelt * added (C) to all copyright statements * * Revision 1.18 2004/09/18 09:48:29 reinelt * HD44780 cleanup and prepararation for I2C backend * LCM-162 submodel framework * * Revision 1.17 2004/06/20 10:09:56 reinelt * * 'const'ified the whole source * * Revision 1.16 2004/04/12 05:14:42 reinelt * another BIG FAT WARNING on the use of raw ports instead of ppdev * * Revision 1.15 2004/04/12 04:56:00 reinelt * emitted a BIG FAT WARNING if msr.h could not be found (and therefore * the gettimeofday() delay loop would be used) * * Revision 1.14 2003/10/12 04:46:19 reinelt * * * first try to integrate the Evaluator into a display driver (MatrixOrbital here) * small warning in processor.c fixed (thanks to Zachary Giles) * workaround for udelay() on alpha (no msr.h avaliable) (thanks to Zachary Giles) * * Revision 1.13 2003/10/05 17:58:50 reinelt * libtool junk; copyright messages cleaned up * * Revision 1.12 2003/07/18 04:43:14 reinelt * udelay: unnecessary sanity check removed * * Revision 1.11 2003/04/04 06:02:04 reinelt * new parallel port abstraction scheme * * Revision 1.10 2003/02/27 07:43:11 reinelt * * asm/msr.h: included hard-coded definition of rdtscl() if msr.h cannot be found. * * autoconf/automake/autoanything: switched back to 1.4. Hope it works again. * * Revision 1.9 2002/08/21 06:09:53 reinelt * some T6963 fixes, ndelay wrap * * Revision 1.8 2002/08/17 14:14:21 reinelt * * USBLCD fixes * * Revision 1.7 2002/04/29 11:00:28 reinelt * * added Toshiba T6963 driver * added ndelay() with nanosecond resolution * * Revision 1.6 2001/08/08 05:40:24 reinelt * * renamed CLK_TCK to CLOCKS_PER_SEC * * Revision 1.5 2001/03/12 13:44:58 reinelt * * new udelay() using Time Stamp Counters * * Revision 1.4 2001/03/12 12:39:36 reinelt * * reworked autoconf a lot: drivers may be excluded, #define's went to config.h * * Revision 1.3 2001/03/01 22:33:50 reinelt * * renamed Raster_flush() to PPM_flush() * * Revision 1.2 2000/07/31 10:43:44 reinelt * * some changes to support kernel-2.4 (different layout of various files in /proc) * * Revision 1.1 2000/04/15 16:56:52 reinelt * * moved delay loops to udelay.c * renamed -d (debugging) switch to -v (verbose) * new switch -d to calibrate delay loop * 'Delay' entry for HD44780 back again * delay loops will not calibrate automatically, because this will fail with hich CPU load * */ /* * * exported fuctions: * * void udelay (unsigned long usec) * delays program execution for usec microseconds * uses global variable 'loops_per_usec', which has to be set before. * This function does busy-waiting! so use only for delays smaller * than 10 msec * * void udelay_calibrate (void) (if USE_OLD_UDELAY is defined) * does a binary approximation for 'loops_per_usec' * should be called several times on an otherwise idle machine * the maximum value should be used * * void udelay_init (void) * selects delay method (gettimeofday() ord rdtsc() according * to processor features * */ #include "config.h" #include #include #ifdef USE_OLD_UDELAY #include #else #include #include #include #include #include #include #ifdef HAVE_ASM_MSR_H #include #endif #endif #include "debug.h" #include "udelay.h" #ifdef USE_OLD_UDELAY unsigned long loops_per_usec; void ndelay (const unsigned long nsec) { unsigned long loop=(nsec*loops_per_usec+999)/1000; __asm__ (".align 16\n" "1:\tdecl %0\n" "\tjne 1b" : /* no result */ :"a" (loop)); } /* adopted from /usr/src/linux/init/main.c */ void udelay_calibrate (void) { clock_t tick; unsigned long bit; loops_per_usec=1; while (loops_per_usec<<=1) { tick=clock(); while (clock()==tick); tick=clock(); ndelay(1000000000/CLOCKS_PER_SEC); if (clock()>tick) break; } loops_per_usec>>=1; bit=loops_per_usec; while (bit>>=1) { loops_per_usec|=bit; tick=clock(); while (clock()==tick); tick=clock(); ndelay(1000000000/CLOCKS_PER_SEC); if (clock()>tick) loops_per_usec&=~bit; } } #else static unsigned int ticks_per_usec=0; static void getCPUinfo (int *hasTSC, double *MHz) { int fd; char buffer[4096], *p; *hasTSC=0; *MHz=-1; fd=open("/proc/cpuinfo", O_RDONLY); if (fd==-1) { error ("udelay: open(/proc/cpuinfo) failed: %s", strerror(errno)); return; } if (read (fd, &buffer, sizeof(buffer)-1)==-1) { error ("udelay: read(/proc/cpuinfo) failed: %s", strerror(errno)); close (fd); return; } close (fd); p=strstr(buffer, "flags"); if (p==NULL) { info ("udelay: /proc/cpuinfo has no 'flags' line"); } else { p=strstr(p, "tsc"); if (p==NULL) { info ("udelay: CPU does not support Time Stamp Counter"); } else { info ("udelay: CPU supports Time Stamp Counter"); *hasTSC=1; } } p=strstr(buffer, "cpu MHz"); if (p==NULL) { info ("udelay: /proc/cpuinfo has no 'cpu MHz' line"); } else { if (sscanf(p+7, " : %lf", MHz)!=1) { error ("udelay: parse(/proc/cpuinfo) failed: unknown 'cpu MHz' format"); *MHz=-1; } else { info ("udelay: CPU runs at %f MHz", *MHz); } } } void udelay_init (void) { #ifdef HAVE_ASM_MSR_H int tsc; double mhz; getCPUinfo (&tsc, &mhz); if (tsc && mhz>0.0) { ticks_per_usec=ceil(mhz); info ("udelay: using TSC delay loop, %u ticks per microsecond", ticks_per_usec); } else #else error ("udelay: The file 'include/asm/msr.h' was missing at compile time."); error ("udelay: Even if your CPU supports TSC, it will not be used!"); error ("udelay: You *really* should install msr.h and recompile LCD4linux!"); #endif { ticks_per_usec=0; info ("udelay: using gettimeofday() delay loop"); } } void ndelay (const unsigned long nsec) { #ifdef HAVE_ASM_MSR_H if (ticks_per_usec) { unsigned int t1, t2; unsigned long tsc; tsc=(nsec*ticks_per_usec+999)/1000; rdtscl(t1); do { rep_nop(); rdtscl(t2); } while ((t2-t1)1000000) { end.tv_usec-=1000000; end.tv_sec++; } do { rep_nop(); gettimeofday(&now, NULL); } while (now.tv_sec==end.tv_sec?now.tv_usec152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 
/* $Id$
 * $URL$
 *
 * image widget handling
 *
 * Copyright (C) 2006 Michael Reinelt <michael@reinelt.co.at>
 * Copyright (C) 2006 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net>
 *
 * 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, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

/* 
 * exported functions:
 *
 * WIDGET_CLASS Widget_Image
 *   the image widget
 *
 */


#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>

#ifdef HAVE_GD_GD_H
#include <gd/gd.h>
#else
#ifdef HAVE_GD_H
#include <gd.h>
#else
#error "gd.h not found!"
#error "cannot compile image widget"
#endif
#endif

#if GD2_VERS != 2
#error "lcd4linux requires libgd version 2"
#error "cannot compile image widget"
#endif

#include "debug.h"
#include "cfg.h"
#include "qprintf.h"
#include "property.h"
#include "timer.h"
#include "widget.h"
#include "widget_image.h"
#include "rgb.h"

#ifdef WITH_DMALLOC
#include <dmalloc.h>
#endif


static void widget_image_render(const char *Name, WIDGET_IMAGE * Image)
{
    int x, y;
    int inverted;
    gdImagePtr gdImage;

    /* clear bitmap */
    if (Image->bitmap) {
	int i;
	for (i = 0; i < Image->height * Image->width; i++) {
	    RGBA empty = {.R = 0x00,.G = 0x00,.B = 0x00,.A = 0x00 };
	    Image->bitmap[i] = empty;
	}
    }

    /* reload image only on first call or on explicit reload request */
    if (Image->gdImage == NULL || P2N(&Image->reload)) {

	char *file;
	FILE *fd;

	/* free previous image */
	if (Image->gdImage) {
	    gdImageDestroy(Image->gdImage);
	    Image->gdImage = NULL;
	}

	file = P2S(&Image->file);
	if (file == NULL || file[0] == '\0') {
	    error("Warning: Image %s has no file", Name);
	    return;
	}

	fd = fopen(file, "rb");
	if (fd == NULL) {
	    error("Warning: Image %s: fopen(%s) failed: %s", Name, file, strerror(errno));
	    return;
	}

	Image->gdImage = gdImageCreateFromPng(fd);
	fclose(fd);

	if (Image->gdImage == NULL) {
	    error("Warning: Image %s: CreateFromPng(%s) failed!", Name, file);
	    return;
	}

    }

    /* maybe resize bitmap */
    gdImage = Image->gdImage;
    if (gdImage->sx > Image->width) {
	Image->width = gdImage->sx;
	free(Image->bitmap);
	Image->bitmap = NULL;
    }
    if (gdImage->sy > Image->height) {
	Image->height = gdImage->sy;
	free(Image->bitmap);
	Image->bitmap = NULL;
    }
    if (Image->bitmap == NULL && Image->width > 0 && Image->height > 0) {
	int i = Image->width * Image->height * sizeof(Image->bitmap[0]);
	Image->bitmap = malloc(i);
	if (Image->bitmap == NULL) {
	    error("Warning: Image %s: malloc(%d) failed: %s", Name, i, strerror(errno));
	    return;
	}
	for (i = 0; i < Image->height * Image->width; i++) {
	    RGBA empty = {.R = 0x00,.G = 0x00,.B = 0x00,.A = 0x00 };
	    Image->bitmap[i] = empty;
	}
    }


    /* finally really render it */
    inverted = P2N(&Image->inverted);
    if (P2N(&Image->visible)) {
	for (x = 0; x < gdImage->sx; x++) {
	    for (y = 0; y < gdImage->sy; y++) {
		int p = gdImageGetTrueColorPixel(gdImage, x, y);
		int a = gdTrueColorGetAlpha(p);
		int i = y * Image->width + x;
		Image->bitmap[i].R = gdTrueColorGetRed(p);
		Image->bitmap[i].G = gdTrueColorGetGreen(p);
		Image->bitmap[i].B = gdTrueColorGetBlue(p);
		/* GD's alpha is 0 (opaque) to 127 (tranparanet) */
		/* our alpha is 0 (transparent) to 255 (opaque) */
		Image->bitmap[i].A = (a == 127) ? 0 : 255 - 2 * a;
		if (inverted) {
		    Image->bitmap[i].R = 255 - Image->bitmap[i].R;
		    Image->bitmap[i].G = 255 - Image->bitmap[i].G;
		    Image->bitmap[i].B = 255 - Image->bitmap[i].B;
		}
	    }
	}
    }
}


static void widget_image_update(void *Self)
{
    WIDGET *W = (WIDGET *) Self;
    WIDGET_IMAGE *Image = W->data;

    /* process the parent only */
    if (W->parent == NULL) {

	/* evaluate properties */
	property_eval(&Image->file);
	property_eval(&Image->update);
	property_eval(&Image->reload);
	property_eval(&Image->visible);
	property_eval(&Image->inverted);

	/* render image into bitmap */
	widget_image_render(W->name, Image);

    }

    /* finally, draw it! */
    if (W->class->draw)
	W->class->draw(W);

    /* add a new one-shot timer */
    if (P2N(&Image->update) > 0) {
	timer_add(widget_image_update, Self, P2N(&Image->update), 1);
    }
}



int widget_image_init(WIDGET * Self)
{
    char *section;
    WIDGET_IMAGE *Image;

    /* re-use the parent if one exists */
    if (Self->parent == NULL) {

	/* prepare config section */
	/* strlen("Widget:")=7 */
	section = malloc(strlen(Self->name) + 8);
	strcpy(section, "Widget:");
	strcat(section, Self->name);

	Image = malloc(sizeof(WIDGET_IMAGE));
	memset(Image, 0, sizeof(WIDGET_IMAGE));

	/* initial size */
	Image->width = 0;
	Image->height = 0;
	Image->bitmap = NULL;

	/* load properties */
	property_load(section, "file", NULL, &Image->file);
	property_load(section, "update", "100", &Image->update);
	property_load(section, "reload", "0", &Image->reload);
	property_load(section, "visible", "1", &Image->visible);
	property_load(section, "inverted", "0", &Image->inverted);

	/* sanity checks */
	if (!property_valid(&Image->file)) {
	    error("Warning: widget %s has no file", section);
	}

	free(section);
	Self->data = Image;

    } else {

	/* re-use the parent */
	Self->data = Self->parent->data;

    }

    /* just do it! */
    widget_image_update(Self);

    return 0;
}


int widget_image_quit(WIDGET * Self)
{
    if (Self) {
	/* do not deallocate child widget! */
	if (Self->parent == NULL) {
	    if (Self->data) {
		WIDGET_IMAGE *Image = Self->data;
		if (Image->gdImage) {
		    gdImageDestroy(Image->gdImage);
		    Image->gdImage = NULL;
		}
		free(Image->bitmap);
		property_free(&Image->file);
		property_free(&Image->update);
		property_free(&Image->reload);
		property_free(&Image->visible);
		property_free(&Image->inverted);
		free(Self->data);
		Self->data = NULL;
	    }
	}
    }

    return 0;

}



WIDGET_CLASS Widget_Image = {
    .name = "image",
    .type = WIDGET_TYPE_XY,
    .init = widget_image_init,
    .draw = NULL,
    .quit = widget_image_quit,
};
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-02 03:21:01 +0000