1 /*
2 * p64-addblk.cc --
3 *
4 * FIXME: This file needs a description here.
5 *
6 * Copyright (c) 1996-2002 The Regents of the University of California.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 * A. Redistributions of source code must retain the above copyright notice,
13 * this list of conditions and the following disclaimer.
14 * B. Redistributions in binary form must reproduce the above copyright notice,
15 * this list of conditions and the following disclaimer in the documentation
16 * and/or other materials provided with the distribution.
17 * C. Neither the names of the copyright holders nor the names of its
18 * contributors may be used to endorse or promote products derived from this
19 * software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
22 * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
23 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
25 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 /*
35 * Splice a decoded block directly into the construction buffer.
36 */
37 inline void P64Decoder::splice(int dc, short* blk, u_char* out, u_int stride)
38 {
39 /* FIXME can we get overflow from idct/iquant? */
40
41 for (int k = 8; --k >= 0; ) {
42
43 u_int v;
44 u_int* o = (u_int*)out;
45 #if BYTE_ORDER == LITTLE_ENDIAN
46 v = blk[0] + dc & 0xff;
47 v |= (blk[1] + dc & 0xff) << 8;
48 v |= (blk[2] + dc & 0xff) << 16;
49 v |= blk[3] + dc << 24;
50 o[0] = v;
51
52 v = blk[4] + dc & 0xff;
53 v |= (blk[5] + dc & 0xff) << 8;
54 v |= (blk[6] + dc & 0xff) << 16;
55 v |= blk[7] + dc << 24;
56 o[1] = v;
57 #else
58 v = blk[0] + dc << 24;
59 v |= (blk[1] + dc & 0xff) << 16;
60 v |= (blk[2] + dc & 0xff) << 8;
61 v |= blk[3] + dc & 0xff;
62 o[0] = v;
63
64 v = blk[4] + dc << 24;
65 v |= (blk[5] + dc & 0xff) << 16;
66 v |= (blk[6] + dc & 0xff) << 8;
67 v |= blk[7] + dc & 0xff;
68 o[1] = v;
69 #endif
70 blk += 8;
71 out += stride;
72 }
73 }
74
75 /*
76 * Mix in a motion-compensated, unfiltered block. Note that
77 * the input block may be misaligned so we cannot try fancy,
78 * word-at-a-time accesses without being careful. The output
79 * block is, of course, aligned.
80 */
81 void P64Decoder::addblk(short* blk, u_char* in,
82 u_char* out, u_int stride)
83 {
84 #ifdef notyet
85 if (((u_long)in & 3) == 0) {
86 /*
87 * Input buffer aligned.
88 * Take advantage of this.
89 */
90 addblka(dc, blk, in, out, stride);
91 return;
92 }
93 #endif
94 for (int i = 8; --i >= 0;) {
95 register int t;
96
97 u_int v;
98 u_int* o = (u_int*)out;
99 #if BYTE_ORDER == LITTLE_ENDIAN
100 v = UCLIMIT(*blk++ + in[0]) & 0xff;
101 v |= (UCLIMIT(*blk++ + in[1]) & 0xff) << 8;
102 v |= (UCLIMIT(*blk++ + in[2]) & 0xff) << 16;
103 v |= UCLIMIT(*blk++ + in[3]) << 24;
104 o[0] = v;
105
106 v = UCLIMIT(*blk++ + in[4]) & 0xff;
107 v |= (UCLIMIT(*blk++ + in[5]) & 0xff) << 8;
108 v |= (UCLIMIT(*blk++ + in[6]) & 0xff) << 16;
109 v |= UCLIMIT(*blk++ + in[7]) << 24;
110 o[1] = v;
111 #else
112 v = UCLIMIT(*blk++ + in[0]) << 24;
113 v |= (UCLIMIT(*blk++ + in[1]) & 0xff) << 16;
114 v |= (UCLIMIT(*blk++ + in[2]) & 0xff) << 8;
115 v |= UCLIMIT(*blk++ + in[3]) & 0xff;
116 o[0] = v;
117
118 v = UCLIMIT(*blk++ + in[4]) << 24;
119 v |= (UCLIMIT(*blk++ + in[5]) & 0xff) << 16;
120 v |= (UCLIMIT(*blk++ + in[6]) & 0xff) << 8;
121 v |= UCLIMIT(*blk++ + in[7]) & 0xff;
122 o[1] = v;
123 #endif
124 in += stride;
125 out += stride;
126 }
127 }
128
129 /*
130 * Same as addblk, but input buffer is aligned.
131 */
132 void P64Decoder::addblka(int dc, short* blk, u_char* in,
133 u_char* out, u_int stride)
134 {
135 for (int k = 8; --k >= 0;) {
136 register int t;
137
138 u_int v;
139 u_int* o = (u_int*)out;
140 u_int w = *(u_int*)in;
141 #if BYTE_ORDER == LITTLE_ENDIAN
142 v = UCLIMIT(*blk++ + dc + (w & 0xff)) & 0xff;
143 v |= (UCLIMIT(*blk++ + dc + (w >> 8 & 0xff)) & 0xff) << 8;
144 v |= (UCLIMIT(*blk++ + dc + (w >> 16 & 0xff)) & 0xff) << 16;
145 v |= UCLIMIT(*blk++ + dc + (w >> 24 & 0xff)) << 24;
146 o[0] = v;
147
148 w = *(u_int*)(in + 4);
149 v = UCLIMIT(*blk++ + dc + (w & 0xff)) & 0xff;
150 v |= (UCLIMIT(*blk++ + dc + (w >> 8 & 0xff)) & 0xff) << 8;
151 v |= (UCLIMIT(*blk++ + dc + (w >> 16 & 0xff)) & 0xff) << 16;
152 v |= UCLIMIT(*blk++ + dc + (w >> 24 & 0xff)) << 24;
153 o[1] = v;
154 #else
155 v = UCLIMIT(*blk++ + dc + (w >> 24 & 0xff)) << 24;
156 v |= (UCLIMIT(*blk++ + dc + (w >> 16 & 0xff)) & 0xff) << 16;
157 v |= (UCLIMIT(*blk++ + dc + (w >> 8 & 0xff)) & 0xff) << 8;
158 v |= UCLIMIT(*blk++ + dc + (w & 0xff)) & 0xff;
159 o[0] = v;
160
161 w = *(u_int*)(in + 4);
162 v = UCLIMIT(*blk++ + dc + (w >> 24 & 0xff)) << 24;
163 v |= (UCLIMIT(*blk++ + dc + (w >> 16 & 0xff)) & 0xff) << 16;
164 v |= (UCLIMIT(*blk++ + dc + (w >> 8 & 0xff)) & 0xff) << 8;
165 v |= UCLIMIT(*blk++ + dc + (w & 0xff)) & 0xff;
166 o[1] = v;
167 #endif
168 in += stride;
169 out += stride;
170 }
171 }
172
173
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.