← Back to branch summary

~ubuntu-branches/ubuntu/precise/cuneiform/precise

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/rimage/sources/main/crturner.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jakub Wilk
  • Date: 2010-09-14 15:53:54 UTC
  • mto: (5.1.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 6.
  • Revision ID: james.westby@ubuntu.com-20100914155354-i3uu2woc5aucphax
Tags: upstream-1.0.0+dfsg
ImportĀ upstreamĀ versionĀ 1.0.0+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
cuneiform_src/Kern/rimage/sources/main/crturner.cpp
1
1
/*
2
 
Copyright (c) 1993-2008, Cognitive Technologies
3
 
All rights reserved.
4
 
 
5
 
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½,
6
 
ļæ½ļæ½ļæ½ ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½:
7
 
 
8
 
      * ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
9
 
        ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
10
 
        ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½.
11
 
      * ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½/ļæ½ļæ½ļæ½ ļæ½
12
 
        ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
13
 
        ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½
14
 
        ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½.
15
 
      * ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ Cognitive Technologies, ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½
16
 
        ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½/ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
17
 
        ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½, ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
18
 
        ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½.
19
 
 
20
 
ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½/ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ "ļæ½ļæ½ļæ½
21
 
ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½" ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½-ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½,
22
 
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ ļæ½ļæ½
23
 
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½. ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
24
 
ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½/ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½
25
 
ļæ½ļæ½ŃØļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½
26
 
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
27
 
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ (ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½,
28
 
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½/ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½-ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
29
 
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½/ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½,
30
 
ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½), ļæ½ļæ½ ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½, ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½
31
 
ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½.
32
 
 
33
 
Redistribution and use in source and binary forms, with or without modification,
34
 
are permitted provided that the following conditions are met:
35
 
 
36
 
    * Redistributions of source code must retain the above copyright notice,
37
 
      this list of conditions and the following disclaimer.
38
 
    * Redistributions in binary form must reproduce the above copyright notice,
39
 
      this list of conditions and the following disclaimer in the documentation
40
 
      and/or other materials provided with the distribution.
41
 
    * Neither the name of the Cognitive Technologies nor the names of its
42
 
      contributors may be used to endorse or promote products derived from this
43
 
      software without specific prior written permission.
44
 
 
45
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
46
 
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
47
 
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48
 
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
49
 
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50
 
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
51
 
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
52
 
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
53
 
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
54
 
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
55
 
*/
56
 
 
57
 
// ļæ½RTurner.cpp: implementation of the CRTurner class.
 
2
 Copyright (c) 1993-2008, Cognitive Technologies
 
3
 All rights reserved.
 
4
 
 
5
 Š Š°Š·Ń€ŠµŃˆŠ°ŠµŃ‚ся ŠæŠ¾Š²Ń‚Š¾Ń€Š½Š¾Šµ Ń€Š°ŃŠæрŠ¾ŃŃ‚Ń€Š°Š½ŠµŠ½ŠøŠµ Šø ŠøсŠæŠ¾Š»ŃŒŠ·Š¾Š²Š°Š½ŠøŠµ ŠŗŠ°Šŗ Š² Š²ŠøŠ“Šµ ŠøсхŠ¾Š“Š½Š¾Š³Š¾ ŠŗŠ¾Š“Š°,
 
6
 Ń‚Š°Šŗ Šø Š² Š“Š²Š¾ŠøчŠ½Š¾Š¹ Ń„Š¾Ń€Š¼Šµ, Ń ŠøŠ·Š¼ŠµŠ½ŠµŠ½ŠøяŠ¼Šø ŠøŠ»Šø Š±ŠµŠ·, ŠæрŠø ŃŠ¾Š±Š»ŃŽŠ“ŠµŠ½ŠøŠø ŃŠ»ŠµŠ“ующŠøх ŃƒŃŠ»Š¾Š²ŠøŠ¹:
 
7
 
 
8
 * ŠŸŃ€Šø ŠæŠ¾Š²Ń‚Š¾Ń€Š½Š¾Š¼ Ń€Š°ŃŠæрŠ¾ŃŃ‚Ń€Š°Š½ŠµŠ½ŠøŠø ŠøсхŠ¾Š“Š½Š¾Š³Š¾ ŠŗŠ¾Š“Š° Š“Š¾Š»Š¶Š½Ń‹ Š¾ŃŃ‚Š°Š²Š°Ń‚ŃŒŃŃ ŃƒŠŗŠ°Š·Š°Š½Š½Š¾Šµ
 
9
 Š²Ń‹ŃˆŠµ ŃƒŠ²ŠµŠ“Š¾Š¼Š»ŠµŠ½ŠøŠµ Š¾Š± Š°Š²Ń‚Š¾Ń€ŃŠŗŠ¾Š¼ ŠæрŠ°Š²Šµ, ŃŃ‚Š¾Ń‚ ŃŠæŠøсŠ¾Šŗ ŃƒŃŠ»Š¾Š²ŠøŠ¹ Šø ŠæŠ¾ŃŠ»ŠµŠ“ующŠøŠ¹
 
10
 Š¾Ń‚ŠŗŠ°Š· Š¾Ń‚ Š³Š°Ń€Š°Š½Ń‚ŠøŠ¹.
 
11
 * ŠŸŃ€Šø ŠæŠ¾Š²Ń‚Š¾Ń€Š½Š¾Š¼ Ń€Š°ŃŠæрŠ¾ŃŃ‚Ń€Š°Š½ŠµŠ½ŠøŠø Š“Š²Š¾ŠøчŠ½Š¾Š³Š¾ ŠŗŠ¾Š“Š° Š² Š“Š¾ŠŗуŠ¼ŠµŠ½Ń‚Š°Ń†ŠøŠø Šø/ŠøŠ»Šø Š²
 
12
 Š“руŠ³Šøх Š¼Š°Ń‚ŠµŃ€ŠøŠ°Š»Š°Ń…, ŠæŠ¾ŃŃ‚Š°Š²Š»ŃŠµŠ¼Ń‹Ń… ŠæрŠø Ń€Š°ŃŠæрŠ¾ŃŃ‚Ń€Š°Š½ŠµŠ½ŠøŠø, Š“Š¾Š»Š¶Š½Ń‹ ŃŠ¾Ń…Ń€Š°Š½ŃŃ‚ŃŒŃŃ
 
13
 ŃƒŠŗŠ°Š·Š°Š½Š½Š°Ń Š²Ń‹ŃˆŠµ ŠøŠ½Ń„Š¾Ń€Š¼Š°Ń†Šøя Š¾Š± Š°Š²Ń‚Š¾Ń€ŃŠŗŠ¾Š¼ ŠæрŠ°Š²Šµ, ŃŃ‚Š¾Ń‚ ŃŠæŠøсŠ¾Šŗ ŃƒŃŠ»Š¾Š²ŠøŠ¹ Šø
 
14
 ŠæŠ¾ŃŠ»ŠµŠ“ующŠøŠ¹ Š¾Ń‚ŠŗŠ°Š· Š¾Ń‚ Š³Š°Ń€Š°Š½Ń‚ŠøŠ¹.
 
15
 * ŠŠø Š½Š°Š·Š²Š°Š½ŠøŠµ Cognitive Technologies, Š½Šø ŠøŠ¼ŠµŠ½Š° ŠµŠµ ŃŠ¾Ń‚Ń€ŃƒŠ“Š½ŠøŠŗŠ¾Š² Š½Šµ Š¼Š¾Š³ŃƒŃ‚
 
16
 Š±Ń‹Ń‚ŃŒ ŠøсŠæŠ¾Š»ŃŒŠ·Š¾Š²Š°Š½Ń‹ Š² ŠŗŠ°Ń‡ŠµŃŃ‚Š²Šµ ŃŃ€ŠµŠ“стŠ²Š° ŠæŠ¾Š“Š“ŠµŃ€Š¶ŠŗŠø Šø/ŠøŠ»Šø ŠæрŠ¾Š“Š²ŠøŠ¶ŠµŠ½Šøя
 
17
 ŠæрŠ¾Š“уŠŗтŠ¾Š², Š¾ŃŠ½Š¾Š²Š°Š½Š½Ń‹Ń… Š½Š° ŃŃ‚Š¾Š¼ ŠŸŠž, Š±ŠµŠ· ŠæрŠµŠ“Š²Š°Ń€ŠøтŠµŠ»ŃŒŠ½Š¾Š³Š¾ ŠæŠøсьŠ¼ŠµŠ½Š½Š¾Š³Š¾
 
18
 Ń€Š°Š·Ń€ŠµŃˆŠµŠ½Šøя.
 
19
 
 
20
 Š­Š¢Š ŠŸŠ ŠžŠ“Š ŠŠœŠœŠ ŠŸŠ Š•Š”ŠžŠ”Š¢ŠŠ’Š›Š•ŠŠ Š’Š›ŠŠ”Š•Š›Š¬Š¦ŠŠœŠ˜ ŠŠ’Š¢ŠžŠ Š”ŠšŠ˜Š„ ŠŸŠ ŠŠ’ Š˜/Š˜Š›Š˜ Š”Š Š£Š“Š˜ŠœŠ˜ Š›Š˜Š¦ŠŠœŠ˜ "ŠšŠŠš
 
21
 ŠžŠŠ Š•Š”Š¢Š¬" Š‘Š•Š— ŠšŠŠšŠžŠ“Šž-Š›Š˜Š‘Šž Š’Š˜Š”Š Š“ŠŠ ŠŠŠ¢Š˜Š™, Š’Š«Š ŠŠ–Š•ŠŠŠ«Š„ ŠÆŠ’ŠŠž Š˜Š›Š˜ ŠŸŠžŠ”Š ŠŠ—Š£ŠœŠ•Š’ŠŠ•ŠœŠ«Š„,
 
22
 Š’ŠšŠ›Š®Š§ŠŠÆ Š“ŠŠ ŠŠŠ¢Š˜Š˜ ŠšŠžŠœŠœŠ•Š Š§Š•Š”ŠšŠžŠ™ Š¦Š•ŠŠŠžŠ”Š¢Š˜ Š˜ ŠŸŠ Š˜Š“ŠžŠ”ŠŠžŠ”Š¢Š˜ Š”Š›ŠÆ ŠšŠžŠŠšŠ Š•Š¢ŠŠžŠ™ Š¦Š•Š›Š˜, ŠŠž ŠŠ•
 
23
 ŠžŠ“Š ŠŠŠ˜Š§Š˜Š’ŠŠÆŠ”Š¬ Š˜ŠœŠ˜. ŠŠ˜ Š’Š›ŠŠ”Š•Š›Š•Š¦ ŠŠ’Š¢ŠžŠ Š”ŠšŠ˜Š„ ŠŸŠ ŠŠ’ Š˜ ŠŠ˜ ŠžŠ”ŠŠž Š”Š Š£Š“ŠžŠ• Š›Š˜Š¦Šž, ŠšŠžŠ¢ŠžŠ ŠžŠ•
 
24
 ŠœŠžŠ–Š•Š¢ Š˜Š—ŠœŠ•ŠŠÆŠ¢Š¬ Š˜/Š˜Š›Š˜ ŠŸŠžŠ’Š¢ŠžŠ ŠŠž Š ŠŠ”ŠŸŠ ŠžŠ”Š¢Š ŠŠŠÆŠ¢Š¬ ŠŸŠ ŠžŠ“Š ŠŠœŠœŠ£, ŠŠ˜ Š’ ŠšŠžŠ•Šœ Š”Š›Š£Š§ŠŠ• ŠŠ•
 
25
 ŠŠ•Š”ŠŠ¢ ŠžŠ¢Š’Š•Š¢Š”Š¢Š’Š•ŠŠŠžŠ”Š¢Š˜, Š’ŠšŠ›Š®Š§ŠŠÆ Š›Š®Š‘Š«Š• ŠžŠ‘Š©Š˜Š•, Š”Š›Š£Š§ŠŠ™ŠŠ«Š•, Š”ŠŸŠ•Š¦Š˜ŠŠ›Š¬ŠŠ«Š• Š˜Š›Š˜
 
26
 ŠŸŠžŠ”Š›Š•Š”ŠžŠ’ŠŠ’ŠØŠ˜Š• Š£Š‘Š«Š¢ŠšŠ˜, Š”Š’ŠÆŠ—ŠŠŠŠ«Š• Š” Š˜Š”ŠŸŠžŠ›Š¬Š—ŠžŠ’ŠŠŠ˜Š•Šœ Š˜Š›Š˜ ŠŸŠžŠŠ•Š”Š•ŠŠŠ«Š• Š’Š”Š›Š•Š”Š”Š¢Š’Š˜Š•
 
27
 ŠŠ•Š’ŠžŠ—ŠœŠžŠ–ŠŠžŠ”Š¢Š˜ Š˜Š”ŠŸŠžŠ›Š¬Š—ŠžŠ’ŠŠŠ˜ŠÆ ŠŸŠ ŠžŠ“Š ŠŠœŠœŠ« (Š’ŠšŠ›Š®Š§ŠŠÆ ŠŸŠžŠ¢Š•Š Š˜ Š”ŠŠŠŠ«Š„, Š˜Š›Š˜ Š”ŠŠŠŠ«Š•,
 
28
 Š”Š¢ŠŠ’ŠØŠ˜Š• ŠŠ•Š“ŠžŠ”ŠŠ«ŠœŠ˜, Š˜Š›Š˜ Š£Š‘Š«Š¢ŠšŠ˜ Š˜/Š˜Š›Š˜ ŠŸŠžŠ¢Š•Š Š˜ Š”ŠžŠ„ŠžŠ”ŠžŠ’, ŠŸŠžŠŠ•Š”Š•ŠŠŠ«Š• Š˜Š—-Š—Š Š”Š•Š™Š”Š¢Š’Š˜Š™
 
29
 Š¢Š Š•Š¢Š¬Š˜Š„ Š›Š˜Š¦ Š˜/Š˜Š›Š˜ ŠžŠ¢ŠšŠŠ—Š ŠŸŠ ŠžŠ“Š ŠŠœŠœŠ« Š ŠŠ‘ŠžŠ¢ŠŠ¢Š¬ Š”ŠžŠ’ŠœŠ•Š”Š¢ŠŠž Š” Š”Š Š£Š“Š˜ŠœŠ˜ ŠŸŠ ŠžŠ“Š ŠŠœŠœŠŠœŠ˜,
 
30
 ŠŠž ŠŠ• ŠžŠ“Š ŠŠŠ˜Š§Š˜Š’ŠŠÆŠ”Š¬ Š­Š¢Š˜ŠœŠ˜ Š”Š›Š£Š§ŠŠÆŠœŠ˜), ŠŠž ŠŠ• ŠžŠ“Š ŠŠŠ˜Š§Š˜Š’ŠŠÆŠ”Š¬ Š˜ŠœŠ˜, Š”ŠŠ–Š• Š•Š”Š›Š˜ Š¢ŠŠšŠžŠ™
 
31
 Š’Š›ŠŠ”Š•Š›Š•Š¦ Š˜Š›Š˜ Š”Š Š£Š“ŠžŠ• Š›Š˜Š¦Šž Š‘Š«Š›Š˜ Š˜Š—Š’Š•Š©Š•ŠŠ« Šž Š’ŠžŠ—ŠœŠžŠ–ŠŠžŠ”Š¢Š˜ Š¢ŠŠšŠ˜Š„ Š£Š‘Š«Š¢ŠšŠžŠ’ Š˜ ŠŸŠžŠ¢Š•Š Š¬.
 
32
 
 
33
 Redistribution and use in source and binary forms, with or without modification,
 
34
 are permitted provided that the following conditions are met:
 
35
 
 
36
 * Redistributions of source code must retain the above copyright notice,
 
37
 this list of conditions and the following disclaimer.
 
38
 * Redistributions in binary form must reproduce the above copyright notice,
 
39
 this list of conditions and the following disclaimer in the documentation
 
40
 and/or other materials provided with the distribution.
 
41
 * Neither the name of the Cognitive Technologies nor the names of its
 
42
 contributors may be used to endorse or promote products derived from this
 
43
 software without specific prior written permission.
 
44
 
 
45
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
46
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
47
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
48
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 
49
 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
50
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 
51
 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 
52
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 
53
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
54
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
55
 */
 
56
 
 
57
// Š”RTurner.cpp: implementation of the CRTurner class.
58
58
//
59
59
//////////////////////////////////////////////////////////////////////
60
60
//#define RIMAGE_DUMP_TO_FILE
74
74
// Construction/Destruction
75
75
//////////////////////////////////////////////////////////////////////
76
76
 
77
 
CRTurner::CRTurner()
78
 
{
79
 
        Word32 i,j;
80
 
        Word8 mask, mask2;
 
77
CRTurner::CRTurner() {
 
78
        uint32_t i, j;
 
79
        uchar mask, mask2;
81
80
 
82
 
        hLineBuffer = 0x00000000;   //NULL;
 
81
        hLineBuffer = 0x00000000; //NULL;
83
82
 
84
83
        wRightMask[0] = 0xfe;
85
84
        wLeftMask[0] = 0x7f;
86
85
        wRightShift[0] = 7;
87
86
        wBitMask[7] = 0x01;
88
87
 
89
 
        for ( i = 1; i < 8; i++ )
90
 
        {
91
 
                wRightMask[i] =  wRightMask[i - 1] << 1;
 
88
        for (i = 1; i < 8; i++) {
 
89
                wRightMask[i] = wRightMask[i - 1] << 1;
92
90
 
93
91
                wLeftMask[i] = wLeftMask[i - 1] >> 1;
94
92
 
95
 
                wRightShift[i] = wRightShift[i-1] - 1;
 
93
                wRightShift[i] = wRightShift[i - 1] - 1;
96
94
 
97
95
                wBitMask[7 - i] = wBitMask[8 - i] << 1;
98
96
        }
99
97
 
100
 
    for(i = 0; i < 256; i++)
101
 
    {
 
98
        for (i = 0; i < 256; i++) {
102
99
                Turn1at180[i] = 0;
103
100
 
104
101
                mask = 0x80;
105
102
                mask2 = 0x1;
106
103
 
107
 
                for(j = 0; j < 8; mask >>= 1, mask2 <<= 1, j++)
108
 
                {
109
 
                        if((i & mask) != 0)
 
104
                for (j = 0; j < 8; mask >>= 1, mask2 <<= 1, j++) {
 
105
                        if ((i & mask) != 0)
110
106
                                Turn1at180[i] += mask2;
111
107
 
112
108
                }
113
109
        }
114
110
 
115
 
        for( i = 0; i < 132; i++)
116
 
        {
 
111
        for (i = 0; i < 132; i++) {
117
112
                memset(Turn1at90[i], 0x0, 8);
118
113
        }
119
114
 
120
 
        for( i = 0; i < 8; i++ )
121
 
                for (j = 0; j < 8; j++ )
122
 
                {
 
115
        for (i = 0; i < 8; i++)
 
116
                for (j = 0; j < 8; j++) {
123
117
                        Turn1at90[wBitMask[i]][j] = wBitMask[j];
124
118
                }
125
119
}
126
120
 
127
 
CRTurner::~CRTurner()
128
 
{
129
 
 
130
 
}
131
 
 
132
 
void * CRTurner::TurnDIB(void *pDIB, Word32 wAngle)
133
 
{
134
 
    return NULL;
135
 
}
136
 
 
137
 
Bool32 CRTurner::FreeDIB(void *pDIB)
138
 
{
 
121
CRTurner::~CRTurner() {
 
122
 
 
123
}
 
124
 
 
125
void * CRTurner::TurnDIB(void *pDIB, uint32_t wAngle) {
 
126
        return NULL;
 
127
}
 
128
 
 
129
Bool32 CRTurner::FreeDIB(void *pDIB) {
139
130
        return TRUE;
140
131
}
141
132
 
142
 
Bool32 CRTurner::TurnDIB(PCTDIB pInDIB, PCTDIB pOutDIB, Word32 wAngle)
143
 
{
 
133
Bool32 CRTurner::TurnDIB(PCTDIB pInDIB, PCTDIB pOutDIB, uint32_t wAngle) {
144
134
        Bool32 bRet;
145
135
 
146
 
        if ( !pInDIB || !pOutDIB )
 
136
        if (!pInDIB || !pOutDIB)
147
137
                return FALSE;
148
138
 
149
 
        WriteDIBtoBMP("BeforeTurn.bmp",pInDIB);
 
139
        WriteDIBtoBMP("BeforeTurn.bmp", pInDIB);
150
140
 
151
 
        switch(wAngle)
152
 
        {
 
141
        switch (wAngle) {
153
142
        case RIMAGE_TURN_90:
154
143
                bRet = Turn90(pInDIB, pOutDIB);
155
144
                break;
166
155
        }
167
156
 
168
157
        WriteDIBtoBMP("AfterTurn.bmp", pInDIB);
169
 
        if ( bRet )
 
158
        if (bRet)
170
159
                WriteDIBtoBMP("DestinationTurn.bmp", pOutDIB);
171
160
 
172
161
        return bRet;
173
162
}
174
163
 
175
 
Bool32 CRTurner::Turn90(PCTDIB pInDIB, PCTDIB pOutDIB)
176
 
{
 
164
Bool32 CRTurner::Turn90(PCTDIB pInDIB, PCTDIB pOutDIB) {
177
165
        Bool32 bRet = FALSE;
178
166
 
179
 
        if ( CheckInAndOut90(pInDIB, pOutDIB) )
180
 
        {
181
 
                switch (pInDIB->GetPixelSize())
182
 
                {
183
 
                case 1 :
 
167
        if (CheckInAndOut90(pInDIB, pOutDIB)) {
 
168
                switch (pInDIB->GetPixelSize()) {
 
169
                case 1:
184
170
                        bRet = Turn90LA(pInDIB, pOutDIB);
185
171
                        break;
186
172
                case 8:
198
184
        return bRet;
199
185
}
200
186
 
201
 
Bool32 CRTurner::Turn180(PCTDIB pInDIB, PCTDIB pOutDIB)
202
 
{
 
187
Bool32 CRTurner::Turn180(PCTDIB pInDIB, PCTDIB pOutDIB) {
203
188
        Bool32 bRet = FALSE;
204
189
 
205
 
        if ( CheckInAndOut180(pInDIB, pOutDIB) )
206
 
        {
207
 
                switch (pInDIB->GetPixelSize())
208
 
                {
209
 
                case 1 :
 
190
        if (CheckInAndOut180(pInDIB, pOutDIB)) {
 
191
                switch (pInDIB->GetPixelSize()) {
 
192
                case 1:
210
193
                        bRet = Turn180LA(pInDIB, pOutDIB);
211
194
                        break;
212
195
                case 8:
224
207
        return bRet;
225
208
}
226
209
 
227
 
Bool32 CRTurner::Turn270(PCTDIB pInDIB, PCTDIB pOutDIB)
228
 
{
 
210
Bool32 CRTurner::Turn270(PCTDIB pInDIB, PCTDIB pOutDIB) {
229
211
        Bool32 bRet = FALSE;
230
212
 
231
 
        if ( CheckInAndOut90(pInDIB, pOutDIB) )
232
 
        {
233
 
                switch (pInDIB->GetPixelSize())
234
 
                {
235
 
                case 1 :
 
213
        if (CheckInAndOut90(pInDIB, pOutDIB)) {
 
214
                switch (pInDIB->GetPixelSize()) {
 
215
                case 1:
236
216
                        bRet = Turn270LA(pInDIB, pOutDIB);
237
217
                        break;
238
218
                case 8:
250
230
        return bRet;
251
231
}
252
232
 
253
 
Bool32 CRTurner::Turn180LA(PCTDIB pInDIB, PCTDIB pOutDIB)
254
 
{
 
233
Bool32 CRTurner::Turn180LA(PCTDIB pInDIB, PCTDIB pOutDIB) {
255
234
        Bool32 bRet = FALSE;
256
 
        Word32 nLine;
257
 
        Word32 sLine;
258
 
        Word32 sLineSize;
259
 
        Word32 sShift;
260
 
        Word32 rShift;
261
 
        PWord8 sPix;
262
 
        PWord8 nPix;
263
 
        Word32 wLines = pInDIB->GetLinesNumber();
264
 
        Word32 sLineWidth = pInDIB->GetLineWidth();
265
 
        Word32 sBytesPerLine = pOutDIB->GetUsedLineWidthInBytes();
266
 
        Word32 cByte;
 
235
        uint32_t nLine;
 
236
        uint32_t sLine;
 
237
        uint32_t sLineSize;
 
238
        uint32_t sShift;
 
239
        uint32_t rShift;
 
240
        puchar sPix;
 
241
        puchar nPix;
 
242
        uint32_t wLines = pInDIB->GetLinesNumber();
 
243
        uint32_t sLineWidth = pInDIB->GetLineWidth();
 
244
        uint32_t sBytesPerLine = pOutDIB->GetUsedLineWidthInBytes();
 
245
        uint32_t cByte;
267
246
 
268
247
        FreeBuffers();
269
248
 
270
 
        hLineBuffer = RIMAGEDAlloc((sLineSize = pInDIB->GetLineWidthInBytes()),"CRTurner::Turn180LA - line buffer" );
271
 
        LineBuffer  = (PWord8)RIMAGELock(hLineBuffer);
 
249
        hLineBuffer = RIMAGEDAlloc((sLineSize = pInDIB->GetLineWidthInBytes()),
 
250
                        "CRTurner::Turn180LA - line buffer");
 
251
        LineBuffer = (puchar) RIMAGELock(hLineBuffer);
272
252
 
273
 
        // ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
253
        // ŠæŠ¾Š·ŠøцŠøя ŠæŠ¾ŃŠ»ŠµŠ“Š½ŠµŠ³Š¾ ŠæŠøŠŗсŠµŠ»Š°
274
254
        sShift = pOutDIB->GetPixelShiftInByte(pOutDIB->GetLineWidth() - 1);
275
255
        rShift = 7 - sShift;
276
256
 
277
 
        for( nLine = 0, sLine = wLines - 1; nLine < wLines; nLine++, sLine--)
278
 
        {
279
 
                // ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½
280
 
                sPix = (PWord8)pInDIB->GetPtrToLine(sLine);
 
257
        for (nLine = 0, sLine = wLines - 1; nLine < wLines; nLine++, sLine--) {
 
258
                // ŠŗŠ¾ŠæŠøруŠµŠ¼ Š² Š±ŃƒŃ„ŠµŃ€ Š²ŃŃŽ ŃŃ‚Ń€Š¾Šŗу Šø ŠæрŠø ŃŃ‚Š¾Š¼ ŃŠ“Š²ŠøŠ³Š°ŠµŠ¼ ŠµŃ‘
 
259
                sPix = (puchar) pInDIB->GetPtrToLine(sLine);
281
260
 
282
 
                if ( sShift == 7 )
283
 
                {
284
 
                        nPix = (PWord8)pOutDIB->GetPtrToLine(nLine) + sBytesPerLine - 1;
285
 
                }
286
 
                else
287
 
                {
 
261
                if (sShift == 7) {
 
262
                        nPix = (puchar) pOutDIB->GetPtrToLine(nLine) + sBytesPerLine - 1;
 
263
                } else {
288
264
                        nPix = LineBuffer + sBytesPerLine - 1;
289
265
                }
290
266
 
291
 
                for (  cByte = 0; cByte < sBytesPerLine; cByte++ )
292
 
                {
293
 
                        // ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
267
                for (cByte = 0; cByte < sBytesPerLine; cByte++) {
 
268
                        // ŠæрŠ¾ŃŃ‚Š¾ ŠŗŠ¾ŠæŠøруŠµŠ¼ ŠæŠµŃ€ŠµŠ²Š¾Ń€Š°Ń‡ŠøŠ²Š°Ń
294
269
                        *nPix = Turn1at180[*sPix];
295
270
                        nPix--;
296
271
                        sPix++;
297
272
                }
298
273
 
299
 
                if ( sShift != 7 )
300
 
                {
 
274
                if (sShift != 7) {
301
275
                        nPix = LineBuffer;
302
276
 
303
 
                        for (  cByte = 0; cByte < sBytesPerLine; cByte++ )
304
 
                        {
305
 
                                // ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
277
                        for (cByte = 0; cByte < sBytesPerLine; cByte++) {
 
278
                                // ŃŠ“Š²ŠøŠ³Š°ŠµŠ¼
306
279
                                *nPix = (*nPix) << rShift;
307
 
                                *nPix |= (*(nPix + 1) >> (sShift + 1) ) & (wLeftMask[sShift]);
 
280
                                *nPix |= (*(nPix + 1) >> (sShift + 1)) & (wLeftMask[sShift]);
308
281
                                nPix++;
309
282
                        }
310
 
                        // ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
 
283
                        // Ń‚ŠµŠæŠµŃ€ŃŒ ŠŗŠ¾ŠæŠøруŠµŠ¼ Š² Š²Ń‹Ń…Š¾Š“Š½Š¾Š¹
311
284
                        sPix = LineBuffer;
312
 
                        nPix = (PWord8)pOutDIB->GetPtrToLine(nLine);
 
285
                        nPix = (puchar) pOutDIB->GetPtrToLine(nLine);
313
286
                        memcpy(nPix, sPix, sBytesPerLine);
314
287
                }
315
288
                bRet = TRUE;
320
293
        return bRet;
321
294
}
322
295
 
323
 
void CRTurner::FreeBuffers()
324
 
{
325
 
        if ( hLineBuffer )
326
 
        {
 
296
void CRTurner::FreeBuffers() {
 
297
        if (hLineBuffer) {
327
298
                RIMAGEFree(hLineBuffer);
328
299
                hLineBuffer = 0x00000000;//NULL;
329
300
        }
330
301
}
331
302
 
332
 
Bool32 CRTurner::CheckInAndOut180(PCTDIB pIn, PCTDIB pOut)
333
 
{
334
 
        if ( pIn->GetImageHeight() != pOut->GetImageHeight() ||
335
 
                 pIn->GetImageWidth()  != pOut->GetImageWidth()  ||
336
 
                 pIn->GetPixelSize()   != pOut->GetPixelSize()      )
337
 
        {
338
 
                SetReturnCode_rimage(IDS_RIMAGE_OUTCOME_DIB_NOT_LINK_TO_INCOME);
339
 
                 return FALSE;
340
 
        }
341
 
 
342
 
        return TRUE;
343
 
}
344
 
 
345
 
Bool32 CRTurner::CheckInAndOut90(PCTDIB pIn, PCTDIB pOut)
346
 
{
347
 
        if ( pIn->GetImageHeight() != pOut->GetImageWidth() ||
348
 
                 pIn->GetImageWidth()  != pOut->GetImageHeight()  ||
349
 
                 pIn->GetPixelSize()   != pOut->GetPixelSize()      )
350
 
        {
351
 
                SetReturnCode_rimage(IDS_RIMAGE_OUTCOME_DIB_NOT_LINK_TO_INCOME);
352
 
                return FALSE;
353
 
        }
354
 
 
355
 
        return TRUE;
356
 
}
357
 
 
358
 
Bool32 CRTurner::Turn90LA(PCTDIB pInDIB, PCTDIB pOutDIB)
359
 
{
360
 
        Word32 dLines = pOutDIB->GetLinesNumber();
361
 
        Word32 sLines = pInDIB->GetLinesNumber();  //
362
 
        Int32  sX;
363
 
        Int32  dX;
364
 
        Int32  dLine;
365
 
        Int32  sLine;
366
 
        PWord8 sPix;
367
 
        PWord8 dPix;
368
 
        Word32 sBytesPerLine = pOutDIB->GetLineWidth()/8;
369
 
        Word32 cByte;
370
 
        Word32 sShift;
371
 
 
372
 
        for ( dLine = 0, sX = 0; dLine < (Int32)dLines; dLine++, sX++ )
373
 
        {
374
 
                // ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½
375
 
                dPix = (PWord8)pOutDIB->GetPtrToLine(dLine);
376
 
                // ļæ½ļæ½ļæ½ļæ½ļæ½
377
 
                sShift = pInDIB->GetPixelShiftInByte(sX);
378
 
                // ļæ½ļæ½ 8 ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
379
 
                for ( cByte = 0, sLine = sLines - 1, dX = 0; cByte < sBytesPerLine; cByte++, dX += 8 )
380
 
                {
381
 
                        *dPix = 0x0;
382
 
 
383
 
                        //x.......
384
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine--);
385
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][0];
386
 
 
387
 
                        //.x......
388
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine--);
389
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][1];
390
 
 
391
 
                        //..x.....
392
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine--);
393
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][2];
394
 
 
395
 
                        //...x....
396
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine--);
397
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][3];
398
 
 
399
 
                        //....x...
400
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine--);
401
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][4];
402
 
 
403
 
                        //.....x..
404
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine--);
405
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][5];
406
 
 
407
 
                        //......x.
408
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine--);
409
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][6];
410
 
 
411
 
                        //.......x
412
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine--);
413
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][7];
414
 
 
415
 
                        dPix++;
416
 
                }
417
 
 
418
 
                // ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
419
 
                if ( sLine >= 0 )
420
 
                {
421
 
                        *dPix = 0x0;
422
 
 
423
 
                        for ( ; sLine >= 0; sLine--, dX++ )
424
 
                        {
425
 
                                sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine);
426
 
                                *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][(pOutDIB->GetPixelShiftInByte(dX))];
427
 
                        }
428
 
                }
429
 
        }
430
 
        return TRUE;
431
 
}
432
 
 
433
 
Bool32 CRTurner::Turn270LA(PCTDIB pInDIB, PCTDIB pOutDIB)
434
 
{
435
 
        Word32 dLines = pOutDIB->GetLinesNumber();
436
 
        Word32 sLines = pInDIB->GetLinesNumber();  //
437
 
        Int32  sX;
438
 
        Int32  dX;
439
 
        Int32  dLine;
440
 
        Int32  sLine;
441
 
        PWord8 sPix;
442
 
        PWord8 dPix;
443
 
        Word32 sBytesPerLine = pOutDIB->GetLineWidth()/8;
444
 
        Word32 cByte;
445
 
        Word32 sShift;
446
 
 
447
 
        for ( dLine = 0, sX = dLines - 1; dLine < (Int32)dLines; dLine++, sX-- )
448
 
        {
449
 
                // ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½
450
 
                dPix = (PWord8)pOutDIB->GetPtrToLine(dLine);
451
 
                // ļæ½ļæ½ļæ½ļæ½ļæ½
452
 
                sShift = pInDIB->GetPixelShiftInByte(sX);
453
 
                // ļæ½ļæ½ 8 ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
454
 
                for ( cByte = 0, sLine = 0, dX = 0; cByte < sBytesPerLine; cByte++, dX += 8 )
455
 
                {
456
 
                        *dPix = 0x0;
457
 
 
458
 
                        //x.......
459
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine++);
460
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][0];
461
 
 
462
 
                        //.x......
463
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine++);
464
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][1];
465
 
 
466
 
                        //..x.....
467
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine++);
468
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][2];
469
 
 
470
 
                        //...x....
471
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine++);
472
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][3];
473
 
 
474
 
                        //....x...
475
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine++);
476
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][4];
477
 
 
478
 
                        //.....x..
479
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine++);
480
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][5];
481
 
 
482
 
                        //......x.
483
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine++);
484
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][6];
485
 
 
486
 
                        //.......x
487
 
                        sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine++);
488
 
                        *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][7];
489
 
 
490
 
                        dPix++;
491
 
                }
492
 
 
493
 
                // ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½
494
 
                // ļæ½ļæ½ļæ½ļæ½ ļæ½ļæ½ļæ½ļæ½
495
 
                if ( sLine < (Int32)sLines )
496
 
                {
497
 
                        *dPix = 0x0;
498
 
 
499
 
                        for ( ; sLine < (Int32)sLines; sLine++, dX++ )
500
 
                        {
501
 
                                sPix = (PWord8)pInDIB->GetPtrToPixel(sX, sLine);
502
 
 
503
 
                                *dPix |= Turn1at90[((*sPix)&wBitMask[sShift])][(pOutDIB->GetPixelShiftInByte(dX))];
504
 
                        }
505
 
                }
506
 
        }
507
 
        return TRUE;
508
 
}
509
 
 
510
 
Bool32 CRTurner::Turn90GC(PCTDIB pIn, PCTDIB pOut)
511
 
{
512
 
        Bool32  bRet = FALSE;
513
 
        Int32   sX;
514
 
        Int32   dX;
515
 
        Int32   dLine;
516
 
        Int32   sLine;
517
 
        PWord8  sPix8;
518
 
        PWord8  dPix8;
519
 
        PWord16 sPix16;
520
 
        PWord16 dPix16;
521
 
        PWord32 sPix32;
522
 
        PWord32 dPix32;
523
 
        Word32  dLines = pOut->GetLinesNumber();
524
 
        Word32  sLines = pIn->GetLinesNumber();  //
525
 
        Word32  wPixSize = pIn->GetPixelSize() / 8;
526
 
 
527
 
        switch (wPixSize)
528
 
        {
529
 
        case 1:
530
 
                for( dLine = 0, sX = 0;  dLine < (Int32)dLines; dLine++, sX++ )
531
 
                {
532
 
                CONTINUEPIXEL(dPix8 = (PWord8)pOut->GetPtrToLine( dLine ));
533
 
 
534
 
                        for ( sLine = sLines - 1, dX = 0; dX < (Int32)sLines; sLine--, dX++, dPix8++ )
535
 
                        {
536
 
                                CONTINUEPIXEL(sPix8 = (PWord8)pIn->GetPtrToPixel( sX, sLine));
537
 
                                *dPix8 = *sPix8;
538
 
                        }
539
 
                }
540
 
                bRet = TRUE;
541
 
                break;
542
 
 
543
 
        case 2:
544
 
                for( dLine = 0, sX = 0;  dLine < (Int32)dLines; dLine++, sX++ )
545
 
                {
546
 
                        CONTINUEPIXEL(dPix16 = (PWord16)pOut->GetPtrToLine( dLine ));
547
 
 
548
 
                        for ( sLine = sLines - 1, dX = 0; dX < (Int32)sLines; sLine--, dX++, dPix16++ )
549
 
                        {
550
 
                                CONTINUEPIXEL(sPix16 = (PWord16)pIn->GetPtrToPixel( sX, sLine));
551
 
                                *dPix16 = *sPix16;
552
 
                        }
553
 
                }
554
 
                bRet = TRUE;
555
 
                break;
556
 
 
557
 
        case 3:
558
 
                for( dLine = 0, sX = 0;  dLine < (Int32)dLines; dLine++, sX++ )
559
 
                {
560
 
                        CONTINUEPIXEL(dPix8 = (PWord8)pOut->GetPtrToLine( dLine )) ;
561
 
 
562
 
                        for ( sLine = sLines - 1, dX = 0; dX < (Int32)sLines; sLine--, dX++ )
563
 
                        {
564
 
                                CONTINUEPIXEL(sPix8 = (PWord8)pIn->GetPtrToPixel( sX, sLine));
565
 
                                *dPix8++ = *sPix8++;
566
 
                                *dPix8++ = *sPix8++;
567
 
                                *dPix8++ = *sPix8++;
568
 
                        }
569
 
                }
570
 
                bRet = TRUE;
571
 
                break;
572
 
 
573
 
        case 4:
574
 
                for( dLine = 0, sX = 0;  dLine < (Int32)dLines; dLine++, sX++ )
575
 
                {
576
 
                        CONTINUEPIXEL(dPix32 = (PWord32)pOut->GetPtrToLine( dLine ));
577
 
 
578
 
                        for ( sLine = sLines - 1, dX = 0; dX < (Int32)sLines; sLine--, dX++, dPix32++ )
579
 
                        {
580
 
                                CONTINUEPIXEL(sPix32 = (PWord32)pIn->GetPtrToPixel( sX, sLine));
581
 
                                *dPix32 = *sPix32;
582
 
                        }
583
 
                }
584
 
                bRet = TRUE;
585
 
                break;
586
 
 
587
 
        default:
588
 
                bRet = FALSE;
589
 
        }
590
 
 
591
 
        return bRet;
592
 
}
593
 
 
594
 
Bool32 CRTurner::Turn180GC(PCTDIB pIn, PCTDIB pOut)
595
 
{
596
 
        Bool32  bRet = FALSE;
597
 
        Word32  dLine;
598
 
        Word32  sLine;
599
 
        Word32  wPix;
600
 
        PWord8  sPix8;
601
 
        PWord8  dPix8;
602
 
        PWord16 sPix16;
603
 
        PWord16 dPix16;
604
 
        PWord32 sPix32;
605
 
        PWord32 dPix32;
606
 
        Word32  wPixSize = pIn->GetPixelSize() / 8;
607
 
        Word32  wLines = pIn->GetLinesNumber();
608
 
        Word32  sLineWidth = pIn->GetLineWidth();
609
 
 
610
 
        switch (wPixSize)
611
 
        {
612
 
        case 1:
613
 
                for( dLine = 0, sLine = wLines - 1; dLine < wLines; dLine++, sLine--)
614
 
                {
615
 
                        sPix8 = (PWord8)pIn->GetPtrToPixel( sLineWidth - 1, sLine);
616
 
                        dPix8 = (PWord8)pOut->GetPtrToLine( dLine );
617
 
 
618
 
                        for ( wPix = 0; wPix < sLineWidth; wPix++, sPix8 --, dPix8 ++ )
619
 
                        {
620
 
                                *dPix8 = *sPix8;
621
 
                        }
622
 
                }
623
 
                bRet = TRUE;
624
 
                break;
625
 
 
626
 
        case 2:
627
 
                for( dLine = 0, sLine = wLines - 1; dLine < wLines; dLine++, sLine--)
628
 
                {
629
 
                        sPix16 = (PWord16)pIn->GetPtrToPixel( sLineWidth - 1, sLine);
630
 
                        dPix16 = (PWord16)pOut->GetPtrToLine( dLine );
631
 
 
632
 
                        for ( wPix = 0; wPix < sLineWidth; wPix++, sPix16 --, dPix16 ++ )
633
 
                        {
634
 
                                *dPix16 = *sPix16;
635
 
                        }
636
 
                }
637
 
                bRet = TRUE;
638
 
                break;
639
 
 
640
 
        case 3:
641
 
                for( dLine = 0, sLine = wLines - 1; dLine < wLines; dLine++, sLine--)
642
 
                {
643
 
                        sPix8 = (PWord8)pIn->GetPtrToPixel( sLineWidth - 1, sLine);
644
 
                        dPix8 = (PWord8)pOut->GetPtrToLine( dLine );
645
 
 
646
 
                        for ( wPix = 0; wPix < sLineWidth; wPix++, sPix8 -= 6)
647
 
                        {
648
 
                                *dPix8++ = *sPix8++;
649
 
                                *dPix8++ = *sPix8++;
650
 
                                *dPix8++ = *sPix8++;
651
 
                        }
652
 
                }
653
 
                bRet = TRUE;
654
 
                break;
655
 
 
656
 
        case 4:
657
 
                for( dLine = 0, sLine = wLines - 1; dLine < wLines; dLine++, sLine--)
658
 
                {
659
 
                        sPix32 = (PWord32)pIn->GetPtrToPixel( sLineWidth - 1, sLine);
660
 
                        dPix32 = (PWord32)pOut->GetPtrToLine( dLine );
661
 
 
662
 
                        for ( wPix = 0; wPix < sLineWidth; wPix++, sPix32--, dPix32++ )
663
 
                        {
664
 
                                *dPix32 = *sPix32;
665
 
                        }
666
 
                }
667
 
                bRet = TRUE;
668
 
                break;
669
 
 
670
 
        default:
671
 
                bRet = FALSE;
672
 
        }
673
 
 
674
 
        return bRet;
675
 
}
676
 
 
677
 
Bool32 CRTurner::Turn270GC(PCTDIB pIn, PCTDIB pOut)
678
 
{
679
 
        Bool32  bRet = FALSE;
680
 
        Int32   sX;
681
 
        Int32   dX;
682
 
        Int32   dLine;
683
 
        Int32   sLine;
684
 
        PWord8  sPix8;
685
 
        PWord8  dPix8;
686
 
        PWord16 sPix16;
687
 
        PWord16 dPix16;
688
 
        PWord32 sPix32;
689
 
        PWord32 dPix32;
690
 
        Word32  dLines = pOut->GetLinesNumber();
691
 
        Word32  sLines = pIn->GetLinesNumber();  //
692
 
        Word32  wPixSize = pIn->GetPixelSize() / 8;
693
 
 
694
 
        switch (wPixSize)
695
 
        {
696
 
        case 1:
697
 
                for( dLine = 0, sX = dLines - 1;  dLine < (Int32)dLines; dLine++, sX-- )
698
 
                {
699
 
                        CONTINUEPIXEL(dPix8 = (PWord8)pOut->GetPtrToLine( dLine ));
700
 
 
701
 
                        for ( sLine = 0, dX = 0; sLine < (Int32)sLines; sLine++, dX++, dPix8++ )
702
 
                        {
703
 
                                CONTINUEPIXEL(sPix8 = (PWord8)pIn->GetPtrToPixel( sX, sLine));
704
 
                                *dPix8 = *sPix8;
705
 
                        }
706
 
                }
707
 
                bRet = TRUE;
708
 
                break;
709
 
 
710
 
        case 2:
711
 
                for( dLine = 0, sX = dLines - 1;  dLine < (Int32)dLines; dLine++, sX-- )
712
 
                {
713
 
                        CONTINUEPIXEL(dPix16 = (PWord16)pOut->GetPtrToLine( dLine ));
714
 
 
715
 
                        for ( sLine = 0, dX = 0; sLine < (Int32)sLines; sLine++, dX++, dPix16++ )
716
 
                        {
717
 
                                CONTINUEPIXEL(sPix16 = (PWord16)pIn->GetPtrToPixel( sX, sLine));
718
 
                                *dPix16 = *sPix16;
719
 
                        }
720
 
                }
721
 
                bRet = TRUE;
722
 
                break;
723
 
 
724
 
        case 3:
725
 
                for( dLine = 0, sX = dLines - 1;  dLine < (Int32)dLines; dLine++, sX-- )
726
 
                {
727
 
                        CONTINUEPIXEL(dPix8 = (PWord8)pOut->GetPtrToLine( dLine ));
728
 
 
729
 
                        for ( sLine = 0, dX = 0; sLine < (Int32)sLines; sLine++, dX++  )
730
 
                        {
731
 
                                CONTINUEPIXEL(sPix8 = (PWord8)pIn->GetPtrToPixel( sX, sLine));
732
 
                                *dPix8++ = *sPix8++;
733
 
                                *dPix8++ = *sPix8++;
734
 
                                *dPix8++ = *sPix8++;
735
 
                        }
736
 
                }
737
 
                bRet = TRUE;
738
 
                break;
739
 
 
740
 
        case 4:
741
 
                for( dLine = 0, sX = dLines - 1;  dLine < (Int32)dLines; dLine++, sX-- )
742
 
                {
743
 
                        CONTINUEPIXEL(dPix32 = (PWord32)pOut->GetPtrToLine( dLine ));
744
 
 
745
 
                        for ( sLine = 0, dX = 0; sLine < (Int32)sLines; sLine++, dX++, dPix32++ )
746
 
                        {
747
 
                                CONTINUEPIXEL(sPix32 = (PWord32)pIn->GetPtrToPixel( sX, sLine));
748
 
                                *dPix32 = *sPix32;
749
 
                        }
750
 
                }
751
 
                bRet = TRUE;
752
 
                break;
753
 
 
754
 
        default:
755
 
                bRet = FALSE;
756
 
        }
757
 
 
758
 
        return bRet;
759
 
}
760
 
 
761
 
Bool32 CRTurner::WriteDIBtoBMP(const char *cName, PCTDIB pDIB)
762
 
{
 
303
Bool32 CRTurner::CheckInAndOut180(PCTDIB pIn, PCTDIB pOut) {
 
304
        if (pIn->GetImageHeight() != pOut->GetImageHeight() || pIn->GetImageWidth()
 
305
                        != pOut->GetImageWidth() || pIn->GetPixelSize()
 
306
                        != pOut->GetPixelSize()) {
 
307
                SetReturnCode_rimage(IDS_RIMAGE_OUTCOME_DIB_NOT_LINK_TO_INCOME);
 
308
                return FALSE;
 
309
        }
 
310
 
 
311
        return TRUE;
 
312
}
 
313
 
 
314
Bool32 CRTurner::CheckInAndOut90(PCTDIB pIn, PCTDIB pOut) {
 
315
        if (pIn->GetImageHeight() != pOut->GetImageWidth() || pIn->GetImageWidth()
 
316
                        != pOut->GetImageHeight() || pIn->GetPixelSize()
 
317
                        != pOut->GetPixelSize()) {
 
318
                SetReturnCode_rimage(IDS_RIMAGE_OUTCOME_DIB_NOT_LINK_TO_INCOME);
 
319
                return FALSE;
 
320
        }
 
321
 
 
322
        return TRUE;
 
323
}
 
324
 
 
325
Bool32 CRTurner::Turn90LA(PCTDIB pInDIB, PCTDIB pOutDIB) {
 
326
        uint32_t dLines = pOutDIB->GetLinesNumber();
 
327
        uint32_t sLines = pInDIB->GetLinesNumber(); //
 
328
        int32_t sX;
 
329
        int32_t dX;
 
330
        int32_t dLine;
 
331
        int32_t sLine;
 
332
        puchar sPix;
 
333
        puchar dPix;
 
334
        uint32_t sBytesPerLine = pOutDIB->GetLineWidth() / 8;
 
335
        uint32_t cByte;
 
336
        uint32_t sShift;
 
337
 
 
338
        for (dLine = 0, sX = 0; dLine < (int32_t) dLines; dLine++, sX++) {
 
339
                // Š½Š°Ń‡Š°Š»Š¾ Š»ŠøŠ½ŠøŠø
 
340
                dPix = (puchar) pOutDIB->GetPtrToLine(dLine);
 
341
                // ŃŠ“Š²ŠøŠ³
 
342
                sShift = pInDIB->GetPixelShiftInByte(sX);
 
343
                // ŠæŠ¾ 8 ŠæŠøŠŗсŠµŠ»ŠµŠ¹
 
344
                for (cByte = 0, sLine = sLines - 1, dX = 0; cByte < sBytesPerLine; cByte++, dX
 
345
                                += 8) {
 
346
                        *dPix = 0x0;
 
347
 
 
348
                        //x.......
 
349
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine--);
 
350
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][0];
 
351
 
 
352
                        //.x......
 
353
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine--);
 
354
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][1];
 
355
 
 
356
                        //..x.....
 
357
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine--);
 
358
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][2];
 
359
 
 
360
                        //...x....
 
361
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine--);
 
362
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][3];
 
363
 
 
364
                        //....x...
 
365
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine--);
 
366
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][4];
 
367
 
 
368
                        //.....x..
 
369
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine--);
 
370
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][5];
 
371
 
 
372
                        //......x.
 
373
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine--);
 
374
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][6];
 
375
 
 
376
                        //.......x
 
377
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine--);
 
378
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][7];
 
379
 
 
380
                        dPix++;
 
381
                }
 
382
 
 
383
                // ŠæŠ¾ŃŠ»ŠµŠ“Š½ŠøŠ¹ Š½ŠµŠæŠ¾Š»Š½Ń‹Š¹ ŠæŠøŠŗсŠµŠ»
 
384
                if (sLine >= 0) {
 
385
                        *dPix = 0x0;
 
386
 
 
387
                        for (; sLine >= 0; sLine--, dX++) {
 
388
                                sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine);
 
389
                                *dPix
 
390
                                                |= Turn1at90[((*sPix) & wBitMask[sShift])][(pOutDIB->GetPixelShiftInByte(
 
391
                                                                dX))];
 
392
                        }
 
393
                }
 
394
        }
 
395
        return TRUE;
 
396
}
 
397
 
 
398
Bool32 CRTurner::Turn270LA(PCTDIB pInDIB, PCTDIB pOutDIB) {
 
399
        uint32_t dLines = pOutDIB->GetLinesNumber();
 
400
        uint32_t sLines = pInDIB->GetLinesNumber(); //
 
401
        int32_t sX;
 
402
        int32_t dX;
 
403
        int32_t dLine;
 
404
        int32_t sLine;
 
405
        puchar sPix;
 
406
        puchar dPix;
 
407
        uint32_t sBytesPerLine = pOutDIB->GetLineWidth() / 8;
 
408
        uint32_t cByte;
 
409
        uint32_t sShift;
 
410
 
 
411
        for (dLine = 0, sX = dLines - 1; dLine < (int32_t) dLines; dLine++, sX--) {
 
412
                // Š½Š°Ń‡Š°Š»Š¾ Š»ŠøŠ½ŠøŠø
 
413
                dPix = (puchar) pOutDIB->GetPtrToLine(dLine);
 
414
                // ŃŠ“Š²ŠøŠ³
 
415
                sShift = pInDIB->GetPixelShiftInByte(sX);
 
416
                // ŠæŠ¾ 8 ŠæŠøŠŗсŠµŠ»ŠµŠ¹
 
417
                for (cByte = 0, sLine = 0, dX = 0; cByte < sBytesPerLine; cByte++, dX
 
418
                                += 8) {
 
419
                        *dPix = 0x0;
 
420
 
 
421
                        //x.......
 
422
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine++);
 
423
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][0];
 
424
 
 
425
                        //.x......
 
426
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine++);
 
427
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][1];
 
428
 
 
429
                        //..x.....
 
430
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine++);
 
431
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][2];
 
432
 
 
433
                        //...x....
 
434
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine++);
 
435
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][3];
 
436
 
 
437
                        //....x...
 
438
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine++);
 
439
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][4];
 
440
 
 
441
                        //.....x..
 
442
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine++);
 
443
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][5];
 
444
 
 
445
                        //......x.
 
446
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine++);
 
447
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][6];
 
448
 
 
449
                        //.......x
 
450
                        sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine++);
 
451
                        *dPix |= Turn1at90[((*sPix) & wBitMask[sShift])][7];
 
452
 
 
453
                        dPix++;
 
454
                }
 
455
 
 
456
                // ŠæŠ¾ŃŠ»ŠµŠ“Š½ŠøŠ¹ Š½ŠµŠæŠ¾Š»Š½Ń‹Š¹ ŠæŠøŠŗсŠµŠ»
 
457
                // ŠµŃŠ»Šø ŠµŃŃ‚ŃŒ
 
458
                if (sLine < (int32_t) sLines) {
 
459
                        *dPix = 0x0;
 
460
 
 
461
                        for (; sLine < (int32_t) sLines; sLine++, dX++) {
 
462
                                sPix = (puchar) pInDIB->GetPtrToPixel(sX, sLine);
 
463
 
 
464
                                *dPix
 
465
                                                |= Turn1at90[((*sPix) & wBitMask[sShift])][(pOutDIB->GetPixelShiftInByte(
 
466
                                                                dX))];
 
467
                        }
 
468
                }
 
469
        }
 
470
        return TRUE;
 
471
}
 
472
 
 
473
Bool32 CRTurner::Turn90GC(PCTDIB pIn, PCTDIB pOut) {
 
474
        Bool32 bRet = FALSE;
 
475
        int32_t sX;
 
476
        int32_t dX;
 
477
        int32_t dLine;
 
478
        int32_t sLine;
 
479
        puchar sPix8;
 
480
        puchar dPix8;
 
481
        uint16_t * sPix16;
 
482
        uint16_t * dPix16;
 
483
        uint32_t * sPix32;
 
484
        uint32_t * dPix32;
 
485
        uint32_t dLines = pOut->GetLinesNumber();
 
486
        uint32_t sLines = pIn->GetLinesNumber(); //
 
487
        uint32_t wPixSize = pIn->GetPixelSize() / 8;
 
488
 
 
489
        switch (wPixSize) {
 
490
        case 1:
 
491
                for (dLine = 0, sX = 0; dLine < (int32_t) dLines; dLine++, sX++) {
 
492
                        CONTINUEPIXEL(dPix8 = (puchar)pOut->GetPtrToLine( dLine ));
 
493
 
 
494
                        for (sLine = sLines - 1, dX = 0; dX < (int32_t) sLines; sLine--, dX++, dPix8++) {
 
495
                                CONTINUEPIXEL(sPix8 = (puchar)pIn->GetPtrToPixel( sX, sLine));
 
496
                                *dPix8 = *sPix8;
 
497
                        }
 
498
                }
 
499
                bRet = TRUE;
 
500
                break;
 
501
 
 
502
        case 2:
 
503
                for (dLine = 0, sX = 0; dLine < static_cast<int32_t>(dLines); dLine++, sX++) {
 
504
                        CONTINUEPIXEL(dPix16 = (uint16_t *)pOut->GetPtrToLine( dLine ));
 
505
 
 
506
                        for (sLine = sLines - 1, dX = 0; dX < (int32_t) sLines; sLine--, dX++, dPix16++) {
 
507
                                CONTINUEPIXEL(sPix16 = (uint16_t*)pIn->GetPtrToPixel( sX, sLine));
 
508
                                *dPix16 = *sPix16;
 
509
                        }
 
510
                }
 
511
                bRet = TRUE;
 
512
                break;
 
513
 
 
514
        case 3:
 
515
                for (dLine = 0, sX = 0; dLine < (int32_t) dLines; dLine++, sX++) {
 
516
                        CONTINUEPIXEL(dPix8 = (puchar)pOut->GetPtrToLine( dLine ));
 
517
 
 
518
                        for (sLine = sLines - 1, dX = 0; dX < (int32_t) sLines; sLine--, dX++) {
 
519
                                CONTINUEPIXEL(sPix8 = (puchar)pIn->GetPtrToPixel( sX, sLine));
 
520
                                *dPix8++ = *sPix8++;
 
521
                                *dPix8++ = *sPix8++;
 
522
                                *dPix8++ = *sPix8++;
 
523
                        }
 
524
                }
 
525
                bRet = TRUE;
 
526
                break;
 
527
 
 
528
        case 4:
 
529
                for (dLine = 0, sX = 0; dLine < (int32_t) dLines; dLine++, sX++) {
 
530
                        CONTINUEPIXEL(dPix32 = (uint32_t *)pOut->GetPtrToLine( dLine ));
 
531
 
 
532
                        for (sLine = sLines - 1, dX = 0; dX < (int32_t) sLines; sLine--, dX++, dPix32++) {
 
533
                                CONTINUEPIXEL(sPix32 = (uint32_t *)pIn->GetPtrToPixel( sX, sLine));
 
534
                                *dPix32 = *sPix32;
 
535
                        }
 
536
                }
 
537
                bRet = TRUE;
 
538
                break;
 
539
 
 
540
        default:
 
541
                bRet = FALSE;
 
542
        }
 
543
 
 
544
        return bRet;
 
545
}
 
546
 
 
547
Bool32 CRTurner::Turn180GC(PCTDIB pIn, PCTDIB pOut) {
 
548
        Bool32 bRet = FALSE;
 
549
        uint32_t dLine;
 
550
        uint32_t sLine;
 
551
        uint32_t wPix;
 
552
        puchar sPix8;
 
553
        puchar dPix8;
 
554
        uint16_t * sPix16;
 
555
        uint16_t * dPix16;
 
556
        uint32_t * sPix32;
 
557
        uint32_t * dPix32;
 
558
        uint32_t wPixSize = pIn->GetPixelSize() / 8;
 
559
        uint32_t wLines = pIn->GetLinesNumber();
 
560
        uint32_t sLineWidth = pIn->GetLineWidth();
 
561
 
 
562
        switch (wPixSize) {
 
563
        case 1:
 
564
                for (dLine = 0, sLine = wLines - 1; dLine < wLines; dLine++, sLine--) {
 
565
                        sPix8 = (puchar) pIn->GetPtrToPixel(sLineWidth - 1, sLine);
 
566
                        dPix8 = (puchar) pOut->GetPtrToLine(dLine);
 
567
 
 
568
                        for (wPix = 0; wPix < sLineWidth; wPix++, sPix8--, dPix8++) {
 
569
                                *dPix8 = *sPix8;
 
570
                        }
 
571
                }
 
572
                bRet = TRUE;
 
573
                break;
 
574
 
 
575
        case 2:
 
576
                for (dLine = 0, sLine = wLines - 1; dLine < wLines; dLine++, sLine--) {
 
577
                        sPix16 = (uint16_t*) pIn->GetPtrToPixel(sLineWidth - 1, sLine);
 
578
                        dPix16 = (uint16_t*) pOut->GetPtrToLine(dLine);
 
579
 
 
580
                        for (wPix = 0; wPix < sLineWidth; wPix++, sPix16--, dPix16++) {
 
581
                                *dPix16 = *sPix16;
 
582
                        }
 
583
                }
 
584
                bRet = TRUE;
 
585
                break;
 
586
 
 
587
        case 3:
 
588
                for (dLine = 0, sLine = wLines - 1; dLine < wLines; dLine++, sLine--) {
 
589
                        sPix8 = (puchar) pIn->GetPtrToPixel(sLineWidth - 1, sLine);
 
590
                        dPix8 = (puchar) pOut->GetPtrToLine(dLine);
 
591
 
 
592
                        for (wPix = 0; wPix < sLineWidth; wPix++, sPix8 -= 6) {
 
593
                                *dPix8++ = *sPix8++;
 
594
                                *dPix8++ = *sPix8++;
 
595
                                *dPix8++ = *sPix8++;
 
596
                        }
 
597
                }
 
598
                bRet = TRUE;
 
599
                break;
 
600
 
 
601
        case 4:
 
602
                for (dLine = 0, sLine = wLines - 1; dLine < wLines; dLine++, sLine--) {
 
603
                        sPix32 = (uint32_t*) pIn->GetPtrToPixel(sLineWidth - 1, sLine);
 
604
                        dPix32 = (uint32_t*) pOut->GetPtrToLine(dLine);
 
605
 
 
606
                        for (wPix = 0; wPix < sLineWidth; wPix++, sPix32--, dPix32++) {
 
607
                                *dPix32 = *sPix32;
 
608
                        }
 
609
                }
 
610
                bRet = TRUE;
 
611
                break;
 
612
 
 
613
        default:
 
614
                bRet = FALSE;
 
615
        }
 
616
 
 
617
        return bRet;
 
618
}
 
619
 
 
620
Bool32 CRTurner::Turn270GC(PCTDIB pIn, PCTDIB pOut) {
 
621
        Bool32 bRet = FALSE;
 
622
        int32_t sX;
 
623
        int32_t dX;
 
624
        int32_t dLine;
 
625
        int32_t sLine;
 
626
        puchar sPix8;
 
627
        puchar dPix8;
 
628
        uint16_t * sPix16;
 
629
        uint16_t * dPix16;
 
630
        uint32_t * sPix32;
 
631
        uint32_t * dPix32;
 
632
        uint32_t dLines = pOut->GetLinesNumber();
 
633
        uint32_t sLines = pIn->GetLinesNumber(); //
 
634
        uint32_t wPixSize = pIn->GetPixelSize() / 8;
 
635
 
 
636
        switch (wPixSize) {
 
637
        case 1:
 
638
                for (dLine = 0, sX = dLines - 1; dLine < (int32_t) dLines; dLine++, sX--) {
 
639
                        CONTINUEPIXEL(dPix8 = (puchar)pOut->GetPtrToLine( dLine ));
 
640
 
 
641
                        for (sLine = 0, dX = 0; sLine < (int32_t) sLines; sLine++, dX++, dPix8++) {
 
642
                                CONTINUEPIXEL(sPix8 = (puchar)pIn->GetPtrToPixel( sX, sLine));
 
643
                                *dPix8 = *sPix8;
 
644
                        }
 
645
                }
 
646
                bRet = TRUE;
 
647
                break;
 
648
 
 
649
        case 2:
 
650
                for (dLine = 0, sX = dLines - 1; dLine < static_cast<int32_t>(dLines); dLine++, sX--) {
 
651
                        CONTINUEPIXEL(dPix16 = (uint16_t*)pOut->GetPtrToLine( dLine ));
 
652
 
 
653
                        for (sLine = 0, dX = 0; sLine < static_cast<int32_t>(sLines); sLine++, dX++, dPix16++) {
 
654
                                CONTINUEPIXEL(sPix16 = (uint16_t *)pIn->GetPtrToPixel( sX, sLine));
 
655
                                *dPix16 = *sPix16;
 
656
                        }
 
657
                }
 
658
                bRet = TRUE;
 
659
                break;
 
660
 
 
661
        case 3:
 
662
                for (dLine = 0, sX = dLines - 1; dLine < static_cast<int32_t>(dLines); dLine++, sX--) {
 
663
                        CONTINUEPIXEL(dPix8 = (puchar)pOut->GetPtrToLine( dLine ));
 
664
 
 
665
                        for (sLine = 0, dX = 0; sLine < static_cast<int32_t>(sLines); sLine++, dX++) {
 
666
                                CONTINUEPIXEL(sPix8 = (puchar)pIn->GetPtrToPixel( sX, sLine));
 
667
                                *dPix8++ = *sPix8++;
 
668
                                *dPix8++ = *sPix8++;
 
669
                                *dPix8++ = *sPix8++;
 
670
                        }
 
671
                }
 
672
                bRet = TRUE;
 
673
                break;
 
674
 
 
675
        case 4:
 
676
                for (dLine = 0, sX = dLines - 1; dLine < (int32_t) dLines; dLine++, sX--) {
 
677
                        CONTINUEPIXEL(dPix32 = (uint32_t *)pOut->GetPtrToLine( dLine ));
 
678
 
 
679
                        for (sLine = 0, dX = 0; sLine < (int32_t) sLines; sLine++, dX++, dPix32++) {
 
680
                                CONTINUEPIXEL(sPix32 = (uint32_t *)pIn->GetPtrToPixel( sX, sLine));
 
681
                                *dPix32 = *sPix32;
 
682
                        }
 
683
                }
 
684
                bRet = TRUE;
 
685
                break;
 
686
 
 
687
        default:
 
688
                bRet = FALSE;
 
689
        }
 
690
 
 
691
        return bRet;
 
692
}
 
693
 
 
694
Bool32 CRTurner::WriteDIBtoBMP(const char *cName, PCTDIB pDIB) {
763
695
#ifdef RIMAGE_DUMP_TO_FILE
764
 
        Word32  wBMPSize = pDIB->GetDIBSize() + 14;
 
696
        uint32_t wBMPSize = pDIB->GetDIBSize() + 14;
765
697
        PumaMemoryToFileDumper BMPDump(cName);
766
698
 
767
699
        BMPDump.AddDump("BM",2);