~ubuntu-branches/debian/experimental/cuneiform/experimental

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/lns32/src/smooth.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Baumann
  • Date: 2009-07-10 17:58:10 UTC
  • Revision ID: james.westby@ubuntu.com-20090710175810-rqc89d2i3tki9m89
Tags: upstream-0.7.0+dfsg
Import upstream version 0.7.0+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
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
#include "lnslang.h"
 
58
 
 
59
#include "smooth.h"
 
60
#include "lns.h"
 
61
///////////////////////////////////////////////////////////////////
 
62
static Int32* buff=NULL;
 
63
static int nLines=0; // count of lines passed through buffer
 
64
static int width_dword =0;
 
65
 
 
66
#define DEF_SMOOTH_HEIGHT 4
 
67
#define MAX_SMOOTH_HEIGHT 16   // crazy...
 
68
 
 
69
static int nSmoothHeight=DEF_SMOOTH_HEIGHT; // count of lines smoothed vertically
 
70
 
 
71
Bool     smooth_start(int _width_dword)
 
72
{
 
73
   nSmoothHeight = LnsGetProfileInt("nSmoothHeight", DEF_SMOOTH_HEIGHT);
 
74
   if (nSmoothHeight < 0 || nSmoothHeight > MAX_SMOOTH_HEIGHT)
 
75
      nSmoothHeight = DEF_SMOOTH_HEIGHT;
 
76
 
 
77
   if (nSmoothHeight == 0)
 
78
      return TRUE; // no smoothing
 
79
 
 
80
   width_dword = _width_dword;
 
81
   buff = (Int32 *)(malloc(4*width_dword*(nSmoothHeight+1) ) );
 
82
   if (buff==NULL)
 
83
      return FALSE;
 
84
 
 
85
   memset(buff, 0xff,  4*width_dword*(nSmoothHeight+1) ); // start - all white
 
86
   nLines =0;
 
87
   return TRUE;
 
88
}
 
89
 
 
90
Int32    smooth_get_height() // count of lines joined lines
 
91
{
 
92
   return nSmoothHeight;
 
93
}
 
94
 
 
95
Int32*   smooth_update(Int32* new_line)
 
96
{
 
97
   if (nSmoothHeight==0 || nSmoothHeight==1)
 
98
      return new_line;
 
99
 
 
100
   int pos = 1 + (nLines % nSmoothHeight);     // 1..nSmoothHeight used to keep lines
 
101
                                               // 0 pos used for result
 
102
   nLines++;
 
103
 
 
104
   memcpy(buff + pos * width_dword, new_line, 4*width_dword); // save line
 
105
 
 
106
   // make smooth
 
107
   if (nSmoothHeight == 4)
 
108
   {
 
109
      Int32* p0=buff;
 
110
      Int32* p1=buff + width_dword;
 
111
      Int32* p2=buff + width_dword*2;
 
112
      Int32* p3=buff + width_dword*3;
 
113
      Int32* p4=buff + width_dword*4;
 
114
 
 
115
      int wi = width_dword;
 
116
      while (wi--)
 
117
      {
 
118
         *p0++ = ((*p1++) & (*p2++)) & ((*p3++) & (*p4++));
 
119
      }
 
120
 
 
121
      return buff;
 
122
   }
 
123
   if (nSmoothHeight == 3)
 
124
   {
 
125
      Int32* p0=buff;
 
126
      Int32* p1=buff + width_dword;
 
127
      Int32* p2=buff + width_dword*2;
 
128
      Int32* p3=buff + width_dword*3;
 
129
 
 
130
      int wi = width_dword;
 
131
      while (wi--)
 
132
      {
 
133
         *p0++ = ((*p1++) & (*p2++)) & ((*p3++));
 
134
      }
 
135
   }
 
136
   if (nSmoothHeight == 2)
 
137
   {
 
138
      Int32* p0=buff;
 
139
      Int32* p1=buff + width_dword;
 
140
      Int32* p2=buff + width_dword*2;
 
141
 
 
142
      int wi = width_dword;
 
143
      while (wi--)
 
144
      {
 
145
         *p0++ = ((*p1++) & (*p2++));
 
146
      }
 
147
   }
 
148
   if (nSmoothHeight > 4)
 
149
   {
 
150
      Int32* p0=buff;
 
151
      int wi = width_dword;
 
152
      while (wi--)
 
153
      {
 
154
         *p0 = 0xffffffff;
 
155
         int sh = nSmoothHeight;
 
156
         Int32* p1=p0;
 
157
         while (sh--)
 
158
         {
 
159
            p1 += width_dword;
 
160
            *p0 &= *p1;
 
161
         }
 
162
         p0++;
 
163
      }
 
164
   }
 
165
 
 
166
   return buff;
 
167
}
 
168
 
 
169
void     smooth_finish()
 
170
{
 
171
   if (buff)
 
172
   {
 
173
      free(buff);
 
174
      buff = NULL;
 
175
   }
 
176
}