~ubuntu-branches/ubuntu/trusty/basilisk2/trusty

« back to all changes in this revision

Viewing changes to src/Unix/video_blit.h

  • Committer: Bazaar Package Importer
  • Author(s): Jonas Smedegaard
  • Date: 2003-07-24 00:48:57 UTC
  • Revision ID: james.westby@ubuntu.com-20030724004857-vnv33v6vf7a7u0z6
Tags: upstream-0.9.20030722
ImportĀ upstreamĀ versionĀ 0.9.20030722

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
 *  video_blit.h - Video/graphics emulation, blitters
 
3
 *
 
4
 *  Basilisk II (C) 1997-2002 Christian Bauer
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; either version 2 of the License, or
 
9
 *  (at your option) any later version.
 
10
 *
 
11
 *  This program is distributed in the hope that it will be useful,
 
12
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 *  GNU General Public License for more details.
 
15
 *
 
16
 *  You should have received a copy of the GNU General Public License
 
17
 *  along with this program; if not, write to the Free Software
 
18
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 */
 
20
 
 
21
#ifndef FB_DEPTH
 
22
# error "Undefined screen depth"
 
23
#endif
 
24
 
 
25
#if !defined(FB_BLIT_1) && (FB_DEPTH <= 16)
 
26
# error "Undefined 16-bit word blit function"
 
27
#endif
 
28
 
 
29
#if !defined(FB_BLIT_2)
 
30
# error "Undefined 32-bit word blit function"
 
31
#endif
 
32
 
 
33
#if !defined(FB_BLIT_4)
 
34
# error "Undefined 64-bit word blit function"
 
35
#endif
 
36
 
 
37
static void FB_FUNC_NAME(uint8 * dest, const uint8 * source, uint32 length)
 
38
{
 
39
#define DEREF_WORD_PTR(ptr, ofs) (((uint16 *)(ptr))[(ofs)])
 
40
#define DEREF_LONG_PTR(ptr, ofs) (((uint32 *)(ptr))[(ofs)])
 
41
#define DEREF_QUAD_PTR(ptr, ofs) (((uint64 *)(ptr))[(ofs)])
 
42
        
 
43
#ifndef UNALIGNED_PROFITABLE
 
44
#if FB_DEPTH <= 8
 
45
        // Align source and dest to 16-bit word boundaries
 
46
        if (((unsigned long) source) & 1) {
 
47
                *dest++ = *source++;
 
48
                length -= 1;
 
49
        }
 
50
#endif
 
51
        
 
52
#if FB_DEPTH <= 16
 
53
        // Align source and dest to 32-bit word boundaries
 
54
        if (((unsigned long) source) & 2) {
 
55
                FB_BLIT_1(DEREF_WORD_PTR(dest, 0), DEREF_WORD_PTR(source, 0));
 
56
                dest += 2; source += 2;
 
57
                length -= 2;
 
58
        }
 
59
#endif
 
60
#endif
 
61
        
 
62
        // Blit 8-byte words
 
63
        if (length >= 8) {
 
64
                const int remainder = (length / 8) % 8;
 
65
                source += remainder * 8;
 
66
                dest += remainder * 8;
 
67
                
 
68
                int n = ((length / 8) + 7) / 8;
 
69
                switch (remainder) {
 
70
                case 0: do {
 
71
                                dest += 64; source += 64;
 
72
                                FB_BLIT_4(DEREF_QUAD_PTR(dest, -8), DEREF_QUAD_PTR(source, -8));
 
73
                case 7: FB_BLIT_4(DEREF_QUAD_PTR(dest, -7), DEREF_QUAD_PTR(source, -7));
 
74
                case 6: FB_BLIT_4(DEREF_QUAD_PTR(dest, -6), DEREF_QUAD_PTR(source, -6));
 
75
                case 5: FB_BLIT_4(DEREF_QUAD_PTR(dest, -5), DEREF_QUAD_PTR(source, -5));
 
76
                case 4: FB_BLIT_4(DEREF_QUAD_PTR(dest, -4), DEREF_QUAD_PTR(source, -4));
 
77
                case 3: FB_BLIT_4(DEREF_QUAD_PTR(dest, -3), DEREF_QUAD_PTR(source, -3));
 
78
                case 2: FB_BLIT_4(DEREF_QUAD_PTR(dest, -2), DEREF_QUAD_PTR(source, -2));
 
79
                case 1: FB_BLIT_4(DEREF_QUAD_PTR(dest, -1), DEREF_QUAD_PTR(source, -1));
 
80
                                } while (--n > 0);
 
81
                }
 
82
        }
 
83
        
 
84
        // There could be one long left to blit
 
85
        if (length & 4) {
 
86
                FB_BLIT_2(DEREF_LONG_PTR(dest, 0), DEREF_LONG_PTR(source, 0));
 
87
#if FB_DEPTH <= 16
 
88
                dest += 4;
 
89
                source += 4;
 
90
#endif
 
91
        }
 
92
        
 
93
#if FB_DEPTH <= 16
 
94
        // There could be one word left to blit
 
95
        if (length & 2) {
 
96
                FB_BLIT_1(DEREF_WORD_PTR(dest, 0), DEREF_WORD_PTR(source, 0));
 
97
#if FB_DEPTH <= 8
 
98
                dest += 2;
 
99
                source += 2;
 
100
#endif
 
101
        }
 
102
#endif
 
103
        
 
104
#if FB_DEPTH <= 8
 
105
        // There could be one byte left to blit
 
106
        if (length & 1)
 
107
                *dest = *source;
 
108
#endif
 
109
        
 
110
#undef DEREF_LONG_PTR
 
111
#undef DEREF_WORD_PTR
 
112
}
 
113
 
 
114
#undef FB_FUNC_NAME
 
115
 
 
116
#ifdef FB_BLIT_1
 
117
#undef FB_BLIT_1
 
118
#endif
 
119
 
 
120
#ifdef FB_BLIT_2
 
121
#undef FB_BLIT_2
 
122
#endif
 
123
 
 
124
#ifdef FB_BLIT_4
 
125
#undef FB_BLIT_4
 
126
#endif
 
127
 
 
128
#ifdef FB_DEPTH
 
129
#undef FB_DEPTH
 
130
#endif