← Back to branch summary

~ubuntu-branches/ubuntu/trusty/cuneiform/trusty

« 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, c-assert.diff, slovenian-slv.diff
  • Date: 2011-01-26 21:53:07 UTC
  • mfrom: (5.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20110126215307-62x61mcesr607qb7
Tags: 1.0.0+dfsg-2
http://bugs.debian.org/608345
http://bugs.debian.org/572061
http://bugs.debian.org/602512
* Upload to unstable.
* Explicitly build-depend on pkg-config. Thanks to Stefano Rivera for the
  bug report.
* Add Vcs-* fields.
* Use the standard C assert() macro, rather than custom Cuneiform one.
  [c-assert.diff]
* Pass CFLAGS, CXXFLAGS and LDFLAGS (get from dpkg-buildflags) to cmake
  (closes: #608345). Thanks to Sami Liedes for the bug report.
  + Build depend on dpkg-dev (>= 1.15.7).
* Pass --parallel to dh.
  + Bump debhelper minimum version to 7.4.10.
* Update debian/copyright to the latest DEP-5 version.
* Bump year in debian/copyright.
* Explicitly link to GraphicsMagick (rather than via the ImageMagick
  compatibility layer).
* Don't ship /usr/lib/cuneiform/*.so symlinks. These libraries are
  considered private, at least until #598616 is fixed.
* Rename some private variables in debian/rules to make them lowercase.
* Update patch headers.
* Provide proper ‘build-arch’ and ‘build-indep’ targets in debian/rules.
* Document input format in the manual page (closes: #572061). Thanks to
  Janusz S. Bień for the bug report.
* Use ‘slv’ (rather than ‘slo’) as language code for Slovenian.
  [slovenian-slv.diff]
* Fix package description: Slovenian is supported, Slovak is not.
* Improve documentation of the language (-l) option (closes: #602512).
  Thanks to Jari Aalto for the bug report.
* Install reasons file for vrms.

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);