source: Sophya/trunk/Poubelle/archTOI.old/decompress.c@ 1795

Last change on this file since 1795 was 342, checked in by ansari, 26 years ago

archtoi 2 aout 99
File size: 7.1 KB
Line 
1//#include <manip.h>
2#include "archeops.h"
3#include "compress.h"
4
5
6//*******************************************************************************************
7//**************** *****************
8//**************** decompress_3 *****************
9//**************** *****************
10//*******************************************************************************************
11
12#define ecart_mask 0x7 /* masque pour l'ecart */
13
14void decom_3(int4 val,int4* in,int4*out,int n);
15
16#define k_mask 0xf /* masque pour l'exposant */
17#define sgbi_ 0x4 /* bit de signe de l'ecart */
18#define sign_ 0xfffffff8 /* masque de signe de l'ecart */
19
20// compress un tableau in de n*9 points disposé avec un pas pasin
21// les data compressées sont ecrites dans le tableau out de n points
22// la valeur val est la valeur de reference du point origine
23
24/* comprime 9*n points : 1er point dans 1er mot, tous les ecarts dans les n mots suivants */
25/* 9*n ==> n+1 pour 72 points : 9 mots */
26
27
28void decompress_3_1(int4* in,int4*out,int n)
29{
30int4 val;
31val= *in;
32decom_3(val,in+1,out,n/9);
33}
34
35
36
37void decom_3(int4 val,int4* in,int4*out,int n)
38{
39register int4 R;
40int4 ec1,ec2,ec3,ec4,ec5,ec6,ec7,ec8,ec9;
41int i,k;
42
43for(i=0;i<n;i++)
44 {
45 R=in[i];
46 k=R&k_mask;
47 recup(ec1,29,k);
48 recup(ec2,26,k);
49 recup(ec3,23,k);
50 recup(ec4,20,k);
51 recup(ec5,17,k);
52 recup(ec6,14,k);
53 recup(ec7,11,k);
54 recup(ec8,8,k);
55 recup(ec9,5,k);
56
57 val+=ec1; out[i*9]=val;
58 val+=ec2; out[i*9+1]=val;
59 val+=ec3; out[i*9+2]=val;
60 val+=ec4; out[i*9+3]=val;
61 val+=ec5; out[i*9+4]=val;
62 val+=ec6; out[i*9+5]=val;
63 val+=ec7; out[i*9+6]=val;
64 val+=ec8; out[i*9+7]=val;
65 val+=ec9; out[i*9+8]=val;
66 }
67}
68
69
70
71//*******************************************************************************************
72//**************** *****************
73//**************** decompress_4 *****************
74//**************** *****************
75//*******************************************************************************************
76
77void decom_4(int4 val,int4* in,int4*out,int n);
78void decom_4_paire(int4 val1,int4 val2,int4* in,int4*out,int n);
79
80#undef ecart_mask
81#define ecart_mask 0xf /* masque pour l'ecart */
82#undef sgbi_
83#undef sign_
84
85
86
87#define k_mask 0xf /* masque pour l'exposant */
88#define sgbi_ 0x8 /* bit de signe de l'ecart */
89#define sign_ 0xfffffff0 /* masque de signe de l'ecart */
90
91
92/* comprime 7*n + 2 points (de 16 bit chacun) */
93/* 1er et 2 eme point dans 1er mot, les ecarts dans les n mots suivants */
94/* 7*n + 2 ==> n+1 ==> pour 72 points : 11 mots */
95
96
97void decompress_4_1(int4* in,int4*out,int n)
98{
99int4 val1,val2;
100val1= ( (*in & 0xffff0000)>>16 ) & 0x0000ffff;
101val2= ( (*in & 0x0000ffff) ) & 0x0000ffff;
102out[0]=val1;
103out[1]=val2;
104decom_4(val2,in+1,out+2,n/7);
105}
106
107
108
109void decom_4(int4 val,int4* in,int4*out,int n)
110{
111register int4 R;
112int4 ec1,ec2,ec3,ec4,ec5,ec6,ec7;
113int i,k;
114
115for(i=0;i<n;i++)
116 {
117 R=in[i];
118 k=R&k_mask;
119 recup(ec1,28,k);
120 recup(ec2,24,k);
121 recup(ec3,20,k);
122 recup(ec4,16,k);
123 recup(ec5,12,k);
124 recup(ec6,8,k);
125 recup(ec7,4,k);
126
127 val+=ec1; out[7*i]=val;
128 val+=ec2; out[7*i+1]=val;
129 val+=ec3; out[7*i+2]=val;
130 val+=ec4; out[7*i+3]=val;
131 val+=ec5; out[7*i+4]=val;
132 val+=ec6; out[7*i+5]=val;
133 val+=ec7; out[7*i+6]=val;
134 }
135}
136
137/********************************************************************************************/
138
139/* compresse en 4 bit mais par paire (pour data provenant de la detection synchrone) */
140
141/* 21 bit maleur maximum */
142/* comprime 7*n+2 points : 1er et 2eme point dans 1er et 2eme mot, suite dans n mots */
143/* différences entre valeures paires et entre valeures impaires uniquement */
144/* 7*n+2 ==> n+2 ==> pour 72 points : 12 mots */
145
146
147void decompress_4_2(int4* in,int4*out,int n)
148{
149int4 val1,val2;
150val1=in[0]; val2=in[1];
151out[0]=val1; out[1]=val2;
152decom_4_paire(val1,val2,in+2,out+2,n/7);
153}
154
155
156void decom_4_paire(int4 val1,int4 val2,int4* in,int4*out,int n)
157{
158register int4 R;
159int4 ec1,ec2,ec3,ec4,ec5,ec6,ec7;
160int i,k;
161
162for(i=0;i<n;i++)
163 {
164 R=in[i];
165 k=R&k_mask;
166 recup(ec1,28,k);
167 recup(ec2,24,k);
168 recup(ec3,20,k);
169 recup(ec4,16,k);
170 recup(ec5,12,k);
171 recup(ec6,8,k);
172 recup(ec7,4,k);
173
174// printf("i=%d k=%d ec= %d %d %d \n",i,k,ec1,ec2,ec3);
175
176
177 val1+=ec1; out[7*i]=val1;
178 val2+=ec2; out[7*i+1]=val2;
179 val1+=ec3; out[7*i+2]=val1;
180 val2+=ec4; out[7*i+3]=val2;
181 val1+=ec5; out[7*i+4]=val1;
182 val2+=ec6; out[7*i+5]=val2;
183 val1+=ec7; out[7*i+6]=val1;
184 R=val1;val1=val2;val2=R;
185 }
186}
187
188
189//*******************************************************************************************
190//**************** *****************
191//**************** compress_7 *****************
192//**************** *****************
193//*******************************************************************************************
194
195#undef sgbi_
196#undef sign_
197
198
199#undef ecart_mask
200#define ecart_mask 0x7f /* masque pour l'ecart 7 bits */
201#define sgbi_ 0x40 /* bit de signe de l'ecart */
202#define sign_ 0xffffff80 /* masque de signe de l'ecart */
203
204
205/* comprime 4*n points : 1er point dans 1er mot, tous les ecarts dans les n mots suivants */
206/* 4*n ==> n+1 */
207
208void decom_7(int4 val,int4* in,int4*out,int n);
209
210void decompress_7_1(int4* in,int4*out,int n)
211{
212int4 val;
213val=*in;
214*out=val;
215decom_7(val,in+1,out,n/4);
216}
217
218
219
220/* compress un tableau in de n*4 points disposé avec un pas pasin */
221/* les data compressées sont ecrites dans le tableau out de n points */
222/* la valeur val est la valeur de reference du point origine */
223
224void decom_7(int4 val,int4* in,int4*out,int n)
225{
226register int4 R;
227int4 ec1,ec2,ec3,ec4;
228int i,k;
229
230for(i=0;i<n;i++)
231 {
232 R=in[i];
233 k=R&k_mask;
234 recup(ec1,25,k);
235 recup(ec2,18,k);
236 recup(ec3,11,k);
237 recup(ec4,4,k);
238
239 val+=ec1; out[4*i]=val;
240 val+=ec2; out[4*i+1]=val;
241 val+=ec3; out[4*i+2]=val;
242 val+=ec4; out[4*i+3]=val;
243 }
244}
245
246/********************************************************************************/
247/* compresse en 7 bit mais par paire (pour data de la detection synchrone */
248/* 21 bit maleur maximum */
249/* comprime 4*n points : 1er et 2eme point dans 1er mot (16 bit chacun), */
250/* suite dans n mots */
251/* différences entre valeures paires et entre valeures impaires uniquement*/
252/* 4*n ==> n+1 */
253/********************************************************************************/
254
255void decom_7_paire(int4 val1,int4 val2,int4* in,int4*out,int n);
256
257void decompress_7_2(int4* in,int4*out,int n)
258{
259int4 val1,val2;
260val1= ( (*in & 0xffff0000)>>11 ) & 0x001fffe0;
261val2= ( (*in & 0x0000ffff)<<5 ) & 0x001fffe0;
262/*printf("val1=%x val2=%x \n",val1,val2);*/
263decom_7_paire(val1,val2,in+1,out,n/4);
264}
265
266
267void decom_7_paire(int4 val1,int4 val2,int4* in,int4*out,int n)
268{
269register int4 R;
270int4 ec1,ec2,ec3,ec4;
271int i,k;
272
273for(i=0;i<n;i++)
274 {
275 R=in[i];
276 k=R&k_mask;
277 recup(ec1,25,k);
278 recup(ec2,18,k);
279 recup(ec3,11,k);
280 recup(ec4,4,k);
281
282 val1+=ec1; out[4*i]=val1;
283 val2+=ec2; out[4*i+1]=val2;
284 val1+=ec3; out[4*i+2]=val1;
285 val2+=ec4; out[4*i+3]=val2;
286
287/*if(i<5) printf("in=%x i=%d k=%d ec= %x %x %x %x \n",R,i,k,ec1,ec2,ec3,ec4);*/
288
289 }
290}
291
292
Note: See TracBrowser for help on using the repository browser.