auto import from //depot/cupcake/@135843
[android/platform/external/neven.git] / Embedded / common / src / b_ImageEm / APhImage.c
1 /*
2  * Copyright (C) 2008 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 /* ---- includes ----------------------------------------------------------- */
18
19 #include "b_BasicEm/Math.h"
20 #include "b_BasicEm/Functions.h"
21 #include "b_ImageEm/APhImage.h"
22 #include "b_ImageEm/ComplexImage.h"
23
24 /* ------------------------------------------------------------------------- */
25
26 /* ========================================================================= */
27 /*                                                                           */
28 /* ---- \ghd{ auxiliary functions } ---------------------------------------- */
29 /*                                                                           */
30 /* ========================================================================= */
31
32 /* ------------------------------------------------------------------------- */
33
34 /* ========================================================================= */
35 /*                                                                           */
36 /* ---- \ghd{ constructor / destructor } ----------------------------------- */
37 /*                                                                           */
38 /* ========================================================================= */
39
40 /* ------------------------------------------------------------------------- */
41
42 void bim_APhImage_init( struct bbs_Context* cpA,
43                                             struct bim_APhImage* ptrA )
44 {
45         bbs_APhArr_init( cpA, &ptrA->arrE );
46         ptrA->widthE = 0;
47         ptrA->heightE = 0;
48 }
49
50 /* ------------------------------------------------------------------------- */
51
52 void bim_APhImage_create( struct bbs_Context* cpA,
53                                                   struct bim_APhImage* ptrA, 
54                                                   uint32 widthA, 
55                                                   uint32 heightA,
56                                               struct bbs_MemSeg* mspA )
57 {
58         if( bbs_Context_error( cpA ) ) return;
59         if( ptrA->arrE.arrPtrE != 0 )
60         {
61                 bim_APhImage_size( cpA, ptrA, widthA, heightA );
62         }
63         else
64         {
65                 bbs_APhArr_create( cpA, &ptrA->arrE, widthA * heightA, mspA );
66                 ptrA->widthE  = widthA;
67                 ptrA->heightE = heightA;
68         }
69 }
70
71 /* ------------------------------------------------------------------------- */
72
73 void bim_APhImage_exit( struct bbs_Context* cpA,
74                                             struct bim_APhImage* ptrA )
75 {
76         bbs_APhArr_exit( cpA, &ptrA->arrE );
77         ptrA->widthE = 0;
78         ptrA->heightE = 0;      
79 }
80
81 /* ------------------------------------------------------------------------- */
82
83 /* ========================================================================= */
84 /*                                                                           */
85 /* ---- \ghd{ operators } -------------------------------------------------- */
86 /*                                                                           */
87 /* ========================================================================= */
88
89 /* ------------------------------------------------------------------------- */
90
91 void bim_APhImage_copy( struct bbs_Context* cpA,
92                                             struct bim_APhImage* ptrA, 
93                                                 const struct bim_APhImage* srcPtrA )
94 {
95 #ifdef DEBUG1
96         if( ptrA->arrE.allocatedSizeE < srcPtrA->arrE.allocatedSizeE )
97         {
98                 bbs_ERROR0( "void bim_APhImage_copy( struct bim_APhImage*, uint32 sizeA ):\n"
99                                    "Unsufficient allocated memory" );
100                 return;
101         }
102 #endif
103         ptrA->widthE = srcPtrA->widthE;
104         ptrA->heightE = srcPtrA->heightE;
105         bbs_APhArr_copy( cpA, &ptrA->arrE, &srcPtrA->arrE );
106 }
107
108 /* ------------------------------------------------------------------------- */
109
110 flag bim_APhImage_equal( struct bbs_Context* cpA,
111                                                  const struct bim_APhImage* ptrA, 
112                                                  const struct bim_APhImage* srcPtrA )
113 {
114         if( ptrA->widthE != srcPtrA->widthE ) return FALSE;
115         if( ptrA->heightE != srcPtrA->heightE ) return FALSE;
116         return bbs_APhArr_equal( cpA, &ptrA->arrE, &srcPtrA->arrE );
117 }
118
119 /* ------------------------------------------------------------------------- */
120
121 /* ========================================================================= */
122 /*                                                                           */
123 /* ---- \ghd{ query functions } -------------------------------------------- */
124 /*                                                                           */
125 /* ========================================================================= */
126
127 /* ------------------------------------------------------------------------- */
128
129 /* ========================================================================= */
130 /*                                                                           */
131 /* ---- \ghd{ modify functions } ------------------------------------------- */
132 /*                                                                           */
133 /* ========================================================================= */
134
135 /* ------------------------------------------------------------------------- */
136         
137 void bim_APhImage_size( struct bbs_Context* cpA,
138                                             struct bim_APhImage* ptrA, 
139                                                 uint32 widthA, 
140                                                 uint32 heightA )
141 {
142 #ifdef DEBUG1
143         if( ptrA->arrE.allocatedSizeE < widthA * heightA )
144         {
145                 bbs_ERROR0( "void bim_APhImage_size( struct bim_APhImage*, uint32 sizeA ):\n"
146                                    "Unsufficient allocated memory" );
147                 return;
148         }
149 #endif
150         ptrA->widthE  = widthA;
151         ptrA->heightE = heightA;
152         bbs_APhArr_size( cpA, &ptrA->arrE, widthA * heightA );
153 }
154
155 /* ------------------------------------------------------------------------- */
156         
157 /* ========================================================================= */
158 /*                                                                           */
159 /* ---- \ghd{ I/O } -------------------------------------------------------- */
160 /*                                                                           */
161 /* ========================================================================= */
162
163 /* ------------------------------------------------------------------------- */
164         
165 uint32 bim_APhImage_memSize( struct bbs_Context* cpA,
166                                                          const struct bim_APhImage* ptrA )
167 {
168         return  bbs_SIZEOF16( uint32 )
169                   + bbs_SIZEOF16( uint32 ) /* version */
170                   + bbs_SIZEOF16( ptrA->widthE ) 
171                   + bbs_SIZEOF16( ptrA->heightE )
172                   + bbs_APhArr_memSize( cpA, &ptrA->arrE ); 
173 }
174
175 /* ------------------------------------------------------------------------- */
176         
177 uint32 bim_APhImage_memWrite( struct bbs_Context* cpA,
178                                                           const struct bim_APhImage* ptrA, 
179                                                           uint16* memPtrA )
180 {
181         uint32 memSizeL = bim_APhImage_memSize( cpA, ptrA );
182         memPtrA += bbs_memWrite32( &memSizeL, memPtrA );
183         memPtrA += bbs_memWriteUInt32( bim_APH_IMAGE_VERSION, memPtrA );
184         memPtrA += bbs_memWrite32( &ptrA->widthE, memPtrA );
185         memPtrA += bbs_memWrite32( &ptrA->heightE, memPtrA );
186         bbs_APhArr_memWrite( cpA, &ptrA->arrE, memPtrA );
187         return memSizeL;
188 }
189
190 /* ------------------------------------------------------------------------- */
191         
192 uint32 bim_APhImage_memRead( struct bbs_Context* cpA,
193                                                          struct bim_APhImage* ptrA, 
194                                                          const uint16* memPtrA,
195                                                  struct bbs_MemSeg* mspA )
196 {
197         uint32 memSizeL, widthL, heightL, versionL;
198         if( bbs_Context_error( cpA ) ) return 0;
199         memPtrA += bbs_memRead32( &memSizeL, memPtrA );
200         memPtrA += bbs_memReadVersion32( cpA, &versionL, bim_APH_IMAGE_VERSION, memPtrA );
201         memPtrA += bbs_memRead32( &widthL, memPtrA );
202         memPtrA += bbs_memRead32( &heightL, memPtrA );
203
204         ptrA->widthE  = widthL;
205         ptrA->heightE = heightL;
206         bbs_APhArr_memRead( cpA, &ptrA->arrE, memPtrA, mspA );
207
208         if( memSizeL != bim_APhImage_memSize( cpA, ptrA ) )
209         {
210                 bbs_ERR0( bbs_ERR_CORRUPT_DATA, "uint32 bim_APhImage_memRead( const struct bim_APhImage*, const void* ):\n"
211                    "size mismatch" ); 
212                 return 0;
213         }
214         return memSizeL;
215 }
216
217 /* ------------------------------------------------------------------------- */
218         
219 /* ========================================================================= */
220 /*                                                                           */
221 /* ---- \ghd{ exec functions } --------------------------------------------- */
222 /*                                                                           */
223 /* ========================================================================= */
224
225 /* ------------------------------------------------------------------------- */
226
227 void bim_APhImage_setAllPixels( struct bbs_Context* cpA,
228                                                             struct bim_APhImage* ptrA, 
229                                                                 struct bbs_APh valueA )
230 {
231         long iL;
232         struct bbs_APh* ptrL = ptrA->arrE.arrPtrE;
233         for( iL = ptrA->widthE * ptrA->heightE; iL > 0; iL-- )
234         {
235                 *ptrL++ = valueA;
236         }
237 }
238
239 /* ------------------------------------------------------------------------- */
240
241 /**
242                         |                               |                               |                               |
243                         |       (loop x1)       |       (loop x2)       |       (loop x3)       |
244                         o------------->-o------------>--o------------->-o
245                         |                               |                               |                               |
246                         |                               |                               |                               |
247                         |                               |                               |                               |
248                         |                               |                               |                               |
249         ( sectionL->x1E, sectionL->y1E )                |                               |
250 ---------o-     R-------------------------------|----------------
251                  |      |                               |                               |                               |
252                  |      |                               |                               |                               |
253                  |      |                               |                               |                               |
254                  |      |                               |                               |                               |
255    (loop y1)|                           |                               |                               |
256                  |      |                               |                               |                               |
257                  V      |                               |                               |                               |
258                  |      |                               |( 0, 0 )               |                               |               X
259 ---------o------------------I------------------------------------------------->
260                  |      |                               |                               |                               |
261                  |      |                               |                               |                               |
262                  |      |                               |                               |                               |
263                  |      |                               |                               |                               |
264                  |      |                               |                               |                               |
265    (loop y2)|                           |                               |                               |
266                  |      |                               |                               |                               |
267                  |      |                               |                               |                               |
268                  |      |                               |                               |                               |
269                  V      |                               |                               |                               |
270                  |      |                               |                               |                               |
271 ---------o------------------|---------------I                           |
272                  |      |                               |               ( srcPtrA->widthE, srcPtrA->heightE )
273                  |      |                               |                                                               |
274                  |      |                               |                                                               |
275                  |      |                               |                                                               |
276                  |      |                               |                                                               |
277                  |      |                               |                                                               |
278    (loop y3)|                           |                                                               |
279                  |      |                               |                                                               |
280                  |      |                               |                                                               |
281                  V      |                               |                                                               |
282                  |      |                               |                                                               |
283 ---------o--------------------------------------------------R
284                                                         |                               ( sectionL->x2E, sectionL->y2E )
285                                                         |
286                                                   Y     |
287                                                         |
288                                                         |
289                                                         V
290
291   To understand how the algorithm work refer to the diagram above.
292   The image boundaries are indicated by letter "I" ( 0, 0 ) to ( srcPtrA->widthE, srcPtrA->heightE )
293   The rectangle boundaries are indicated by letter "R" ( sectionPtrA->x1E, sectionPtrA->y1E ) to ( sectionPtrA->x2E, sectionPtrA->y2E )
294
295   In the above example the intersection of the image and the rectange is
296   ( 0, 0 ), ( srcPtrA->widthE, srcPtrA->heightE )
297
298   The size of the destination image is always ( ( sectionL->x2E, sectionL->y2E ) - ( sectionL->x1E, sectionL->y1E ) )
299
300   All coordinates are assumed to be relative to the original image.
301
302   1. parse all pixels in "loop y1"
303         1.a. parse all pixels in "loop x1"
304         1.b. parse all pixels in "loop x2"
305         1.c. parse all pixels in "loop x3"
306   2. parse all pixels in "loop y2"
307         2.a. parse all pixels in "loop x1"
308         2.b. parse all pixels in "loop x2"
309         2.c. parse all pixels in "loop x3"
310   3. parse all pixels in "loop y3"
311         3.a. parse all pixels in "loop x1"
312         3.b. parse all pixels in "loop x2"
313         3.c. parse all pixels in "loop x3"
314
315 */
316
317 /** copies a section of given image */
318 void bim_APhImage_copySection( struct bbs_Context* cpA,
319                                                            struct bim_APhImage* ptrA, 
320                                                                    const struct bim_APhImage* srcPtrA, 
321                                                                    const struct bts_Int16Rect* sectionPtrA )
322 {
323
324         struct bbs_APh* srcPixelPtrL;
325         struct bbs_APh* dstPixelPtrL;
326         int32 yIndexL;
327         int32 xIndexL;
328
329         struct bts_Int16Rect srcImageSubSectionL;
330         struct bts_Int16Rect sectionL;
331
332         /* make sure that the rectangle passed is correct, in case the x2 < x1 or y2 < y1, swap them */
333         sectionL.x1E = bbs_min( sectionPtrA->x1E, sectionPtrA->x2E );
334         sectionL.x2E = bbs_max( sectionPtrA->x1E, sectionPtrA->x2E );
335         sectionL.y1E = bbs_min( sectionPtrA->y1E, sectionPtrA->y2E );
336         sectionL.y2E = bbs_max( sectionPtrA->y1E, sectionPtrA->y2E );
337
338         /* find the intersection betweem the rectangle and the image, the image always starts at 0,0 */
339         srcImageSubSectionL.x1E = bbs_max( 0, sectionL.x1E );
340         srcImageSubSectionL.y1E = bbs_max( 0, sectionL.y1E );
341         srcImageSubSectionL.x2E = bbs_min( ( int32 ) srcPtrA->widthE, sectionL.x2E );
342         srcImageSubSectionL.y2E = bbs_min( ( int32 ) srcPtrA->heightE, sectionL.y2E );
343
344         /* If the image and the rectangle do not intersect in X direction, set the intersecting rectangle to the image coordinates */
345         if( srcImageSubSectionL.x2E < srcImageSubSectionL.x1E )
346         {
347                 srcImageSubSectionL.x1E = 0;
348                 srcImageSubSectionL.x2E = srcPtrA->widthE;
349         }
350         /* do the same as above in the Y direction */
351         if( srcImageSubSectionL.y2E < srcImageSubSectionL.y1E )
352         {
353                 srcImageSubSectionL.y1E = 0;
354                 srcImageSubSectionL.y2E = srcPtrA->heightE;
355         }
356
357         /* set size, and allocate required memory for the destination image if required */
358         bim_APhImage_size( cpA, ptrA, sectionL.x2E - sectionL.x1E, sectionL.y2E - sectionL.y1E );
359
360         /* get the pointer to the destination image */
361         dstPixelPtrL = ptrA->arrE.arrPtrE;
362
363         /* 1. parse all pixels in "loop y1" */
364         for( yIndexL = sectionL.y1E; yIndexL < srcImageSubSectionL.y1E && yIndexL < sectionL.y2E; yIndexL++ )
365         {
366                 /* move to the first pixel that needs to be copied. */
367                 srcPixelPtrL = srcPtrA->arrE.arrPtrE;
368
369                 /* 1.a. parse all pixels in "loop x1" */
370                 for( xIndexL = sectionL.x1E; xIndexL < srcImageSubSectionL.x1E && xIndexL < sectionL.x2E; xIndexL++ )
371                 {
372                         *dstPixelPtrL++ = *srcPixelPtrL;
373                 }
374                 /* 1.b. parse all pixels in "loop x2" */
375                 for( ; xIndexL < srcImageSubSectionL.x2E && xIndexL < sectionL.x2E; xIndexL++ )
376                 {
377                         *dstPixelPtrL++ = *srcPixelPtrL++;
378                 }
379                 srcPixelPtrL--;
380                 /* 1.c. parse all pixels in "loop x3" */
381                 for( ; xIndexL < sectionL.x2E; xIndexL++ )
382                 {
383                         *dstPixelPtrL++ = *srcPixelPtrL;
384                 }
385         }
386         /* 2. parse all pixels in "loop y2" */
387         for( ; yIndexL < srcImageSubSectionL.y2E && yIndexL < sectionL.y2E; yIndexL++ )
388         {
389                 /* move to the first pixel that needs to be copied. */
390                 srcPixelPtrL = srcPtrA->arrE.arrPtrE + yIndexL * srcPtrA->widthE + srcImageSubSectionL.x1E;
391
392                 /* 2.a. parse all pixels in "loop x1" */
393                 for( xIndexL = sectionL.x1E; xIndexL < srcImageSubSectionL.x1E && xIndexL < sectionL.x2E; xIndexL++ )
394                 {
395                         *dstPixelPtrL++ = *srcPixelPtrL;
396                 }
397                 /* 2.b. parse all pixels in "loop x2" */
398                 for( ; xIndexL < srcImageSubSectionL.x2E && xIndexL < sectionL.x2E; xIndexL++ )
399                 {
400                         *dstPixelPtrL++ = *srcPixelPtrL++;
401                 }
402                 srcPixelPtrL--;
403                 /* 2.c. parse all pixels in "loop x3" */
404                 for( ; xIndexL < sectionL.x2E; xIndexL++ )
405                 {
406                         *dstPixelPtrL++ = *srcPixelPtrL;
407                 }
408         }
409         /* 3. parse all pixels in "loop y3" */
410         for( ; yIndexL < sectionL.y2E; yIndexL++ )
411         {
412                 srcPixelPtrL = srcPtrA->arrE.arrPtrE + ( srcImageSubSectionL.y2E - 1 ) * srcPtrA->widthE + srcImageSubSectionL.x1E;
413
414                 /* 3.a. parse all pixels in "loop x1" */
415                 for( xIndexL = sectionL.x1E; xIndexL < srcImageSubSectionL.x1E && xIndexL < sectionL.x2E; xIndexL++ )
416                 {
417                         *dstPixelPtrL++ = *srcPixelPtrL;
418                 }
419                 /* 3.b. parse all pixels in "loop x3" */
420                 for( ; xIndexL < srcImageSubSectionL.x2E && xIndexL < sectionL.x2E; xIndexL++ )
421                 {
422                         *dstPixelPtrL++ = *srcPixelPtrL++;
423                 }
424                 srcPixelPtrL--;
425                 /* 3.c. parse all pixels in "loop x3" */
426                 for( ; xIndexL < sectionL.x2E; xIndexL++ )
427                 {
428                         *dstPixelPtrL++ = *srcPixelPtrL;
429                 }
430         }
431
432 }
433
434 /* ------------------------------------------------------------------------- */
435
436 void bim_APhImage_importComplex( struct bbs_Context* cpA,
437                                                                  struct bim_APhImage* dstPtrA, 
438                                                                  const struct bim_ComplexImage* srcPtrA )
439 {
440         long iL;
441         struct bbs_APh* dstL;
442         const struct bbs_Complex* srcL;
443         bim_APhImage_size( cpA, dstPtrA, srcPtrA->widthE, srcPtrA->heightE );
444         dstL = dstPtrA->arrE.arrPtrE;
445         srcL = srcPtrA->arrE.arrPtrE;
446         for( iL = srcPtrA->widthE * srcPtrA->heightE; iL > 0; iL-- )
447         {
448                 bbs_APh_importComplex( dstL++, srcL++ );
449         }       
450 }
451
452 /* ------------------------------------------------------------------------- */
453
454 /* ========================================================================= */
455
456