Subversion Repositories freemyipod

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
881 theseven 1 
#include "global.h"
2 
#include "interface/lcd/lcd.h"
3 
#include "interface/framebuffer/framebuffer.h"
4 
#include "sys/util.h"
5 
 
6 
void lcd_init(const struct lcd_instance* instance)
7 
{
8 
    instance->driver->init(instance);
9 
}
10 
 
11 
enum framebuffer_format lcd_get_native_format(const struct lcd_instance* instance)
12 
{
13 
    return instance->driver->get_native_format(instance);
14 
}
15 
 
16 
void lcd_power(const struct lcd_instance* instance, bool on)
17 
{
18 
    instance->driver->power(instance, on);
19 
}
20 
 
21 
void lcd_backlight(const struct lcd_instance* instance, int brightness)
22 
{
23 
    instance->driver->backlight(instance, brightness);
24 
}
25 
 
26 
void lcd_setup_range(const struct lcd_instance* instance, int x, int y, int w, int h)
27 
{
28 
    instance->driver->setup_range(instance, x, y, w, h);
29 
}
30 
 
31 
void lcd_fill_pixels(const struct lcd_instance* instance, uint32_t color, int count)
32 
{
33 
    instance->driver->fill_pixels(instance, color, count);
34 
}
35 
 
36 
void lcd_blit_pixels(const struct lcd_instance* instance, void* buffer, int count)
37 
{
38 
    instance->driver->blit_pixels(instance, buffer, count);
39 
}
40 
 
41 
void lcd_fill(const struct lcd_instance* instance, int x, int y, int w, int h,
42 
              enum framebuffer_format format, uint32_t color, enum framebuffer_conversion_quality quality)
43 
{
44 
    enum framebuffer_format native = lcd_get_native_format(instance);
45 
    if (format != native)
46 
    {
47 
        if (framebuffer_format_wordsize[format] == 16) color = swap16(color);
48 
        else if (framebuffer_format_wordsize[format] == 32) color = swap32(color);
49 
        color = framebuffer_convert_color(format, native, color);
50 
        if (framebuffer_format_wordsize[native] == 16) color = swap16(color);
51 
        else if (framebuffer_format_wordsize[native] == 32) color = swap32(color);
52 
    }
53 
    lcd_setup_range(instance, x, y, w, h);
54 
    lcd_fill_pixels(instance, color, w * h);
55 
}
56 
 
57 
void lcd_blit(const struct lcd_instance* instance, int x, int y, int w, int h,
58 
              const struct framebuffer_instance* framebuffer, int fx, int fy, enum framebuffer_conversion_quality quality)
59 
{
60 
    int stride = framebuffer->width;
61 
    enum framebuffer_format infmt = framebuffer->format;
62 
    enum framebuffer_format outfmt = lcd_get_native_format(instance);
63 
    int inwsize = framebuffer_format_wordsize[infmt];
64 
    int outwsize = framebuffer_format_wordsize[outfmt];
65 
 
66 
    lcd_setup_range(instance, x, y, w, h);
67 
 
68 
    if (w == stride)
69 
    {
70 
        w *= h;
71 
        h = 1;
72 
    }
73 
 
74 
    if (infmt == outfmt && inwsize >= 8)
75 
    {
76 
        void* in = framebuffer->data + (fy * stride + fx) * (inwsize >> 3);
77 
        while (h--)
78 
        {
79 
            lcd_blit_pixels(instance, in, w);
80 
            in += (stride - w) * (inwsize >> 3);
81 
        }
82 
        return;
83 
    }
84 
 
85 
    int inmask = 0xffffffff >> (32 - inwsize);
86 
    uint32_t* in = framebuffer->data;
87 
    int inbit = (fy * stride + fx) * inwsize;
88 
    in += inbit >> 5;
89 
    inbit &= 31;
90 
    uint32_t buf[64];
91 
    while (h--)
92 
    {
93 
        int pixels = w;
94 
        uint32_t idata = swap32(*in) << inbit;
95 
        while (pixels > 0)
96 
        {
97 
            int processed = 0;
98 
            uint32_t* out = buf;
99 
            int outbit = 0;
100 
            uint32_t odata;
101 
            while (((void*)out) < ((void*)buf) + sizeof(buf) && processed < pixels)
102 
            {
103 
                if (inbit == 32)
104 
                {
105 
                    idata = swap32(*++in);
106 
                    inbit = 0;
107 
                }
108 
                if (!outbit) odata = 0;
109 
                idata = ((idata << inwsize) | (idata >> (32 - inwsize)));
110 
                odata <<= outwsize;
111 
                uint32_t data = idata & inmask;
112 
                if (infmt != outfmt) data = framebuffer_convert_color(infmt, outfmt, data);
113 
                odata |= data;
114 
                inbit += inwsize;
115 
                outbit += outwsize;
116 
                if (outbit == 32)
117 
                {
118 
                    *out++ = swap32(odata);
119 
                    outbit = 0;
120 
                }
121 
                processed++;
122 
            }
123 
            if (outbit) *out = swap32(odata << (32 - outbit));
124 
            lcd_blit_pixels(instance, buf, processed);
125 
            pixels -= processed;
126 
        }
127 
        inbit += (stride - w) * inwsize;
128 
        in += inbit >> 5;
129 
        inbit &= 31;
130 
    }
131 
}
132 
 
133 
void lcd_fb_update_handler(const void* arg, const struct framebuffer_instance* fb, int x, int y, int w, int h)
134 
{
135 
    const struct lcd_instance* instance = (const struct lcd_instance*)arg;
136 
    lcd_blit(instance, x, y, w, h, fb, x, y, FRAMEBUFFER_CONVERSION_QUALITY_CLIP);
137 
}