← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/lns32/src/sbambuk.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/lns32/src/sbambuk.cpp
2
2
Copyright (c) 1993-2008, Cognitive Technologies
3
3
All rights reserved.
4
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
 
�������� ��� ������ ���� ���� �������� � ����������� ����� ������� � ������.
 
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
32
 
33
33
Redistribution and use in source and binary forms, with or without modification,
34
34
are permitted provided that the following conditions are met:
72
72
   #include "smooth.h"
73
73
   static int _smooth_height=0;
74
74
 
75
 
        static Word8 bytebit0[8] = {
 
75
        static uchar bytebit0[8] = {
76
76
                0x7F, 0xBF,     0xDF,   0xEF,
77
77
                0xF7,   0xFB,   0xFD,   0xFE
78
78
        };
80
80
 
81
81
 
82
82
   /* VERTICAL FILTRATION+SEGMENT EXTRACTION PART...*******************/
83
 
   //   static Word16 cur_row_ = 0;
 
83
   //   static uint16_t cur_row_ = 0;
84
84
 
85
85
   // static TBlackSeg far * v_segments_;
86
86
   //   static TBlackSeg far * cur_seg_;
154
154
                assert( filter );
155
155
                assert( filter->isOk() );
156
156
 
157
 
      Word8*   new_line = NULL;
 
157
      uchar*   new_line = NULL;
158
158
                int             cur_row = 0;
159
159
//      int width_byte = reader->lineWidthByte(); assert(width_byte > 0);
160
160
 
162
162
 
163
163
                if (height() < 17) {
164
164
                        for (cur_row = bottom; cur_row <= top; cur_row++) {
165
 
            new_line = (Word8*)(reader->getLine());
 
165
            new_line = (uchar*)(reader->getLine());
166
166
            if (new_line == NULL)
167
167
            {
168
168
               errCode = ER_CANTREAD;
186
186
                /* process first 16 lines - extract horisontal and fill buffer*/
187
187
                for (cur_row = bottom; cur_row < bottom + 16; cur_row++)
188
188
      {
189
 
         new_line = (Word8*)(reader->getLine());
 
189
         new_line = (uchar*)(reader->getLine());
190
190
         if (new_line == NULL)
191
191
         {
192
192
            errCode = ER_CANTREAD;
206
206
                #ifndef NDEBUG_SBAMBUK
207
207
                        started_ = 0;
208
208
                #endif
209
 
      new_line = (Word8*)(reader->getLine());
 
209
      new_line = (uchar*)(reader->getLine());
210
210
      if (new_line == NULL)
211
211
      {
212
212
         errCode = ER_CANTREAD;
219
219
                };
220
220
 
221
221
/*
222
 
      if (!vBambuk.vUpdateFirst(    (Int32*)new_line,
223
 
                                    (Int32*)(filter->cur16),
 
222
      if (!vBambuk.vUpdateFirst(    (int32_t*)new_line,
 
223
                                    (int32_t*)(filter->cur16),
224
224
                                                                                                16
225
225
                                                                                  )
226
226
                        ) {
228
228
                        return WRONG();
229
229
                };
230
230
*/
231
 
      Int32 white_line[1024]; memset(white_line, 0xff, sizeof(white_line));
232
 
      if (!vBambuk.vUpdate(    (Int32*)new_line,
233
 
                               (Int32*)(filter->cur16),
 
231
      int32_t white_line[1024]; memset(white_line, 0xff, sizeof(white_line));
 
232
      if (!vBambuk.vUpdate(    (int32_t*)new_line,
 
233
                               (int32_t*)(filter->cur16),
234
234
                               white_line,
235
235
                                                                       16
236
236
                                                                  )
248
248
                /* main loop */
249
249
                for (cur_row = bottom + 17; cur_row <= top  ; cur_row++)
250
250
      {
251
 
         new_line = (Word8*)(reader->getLine());
 
251
         new_line = (uchar*)(reader->getLine());
252
252
         if (new_line == NULL)
253
253
         {
254
254
            errCode = ER_CANTREAD;
262
262
                                return WRONG();
263
263
                        };
264
264
#ifdef SMOOTH98
265
 
         new_line = (Word8*)smooth_update((Int32*)new_line);
 
265
         new_line = (uchar*)smooth_update((int32_t*)new_line);
266
266
#endif
267
 
         if (!vBambuk.vUpdate( (Int32*)new_line,
268
 
                               (Int32*)filter->cur16,
269
 
                               (Int32*)filter->last16,
 
267
         if (!vBambuk.vUpdate( (int32_t*)new_line,
 
268
                               (int32_t*)filter->cur16,
 
269
                               (int32_t*)filter->last16,
270
270
                                                                                 cur_row
271
271
                                                                          )
272
272
            ){                               errCode = ER_NOMEMORY;
279
279
      smooth_finish();
280
280
#endif
281
281
         if (!vBambuk.vUpdate( white_line,
282
 
                               (Int32*)filter->cur16,
283
 
                               (Int32*)filter->last16,
 
282
                               (int32_t*)filter->cur16,
 
283
                               (int32_t*)filter->last16,
284
284
                                                                                 cur_row
285
285
                                                                          )
286
286
            ){                               errCode = ER_NOMEMORY;
288
288
                        }
289
289
 
290
290
/*
291
 
      if (!vBambuk.vUpdateLast(  (Int32*)(filter->cur16),
292
 
                                 (Int32*)(filter->last16),
 
291
      if (!vBambuk.vUpdateLast(  (int32_t*)(filter->cur16),
 
292
                                 (int32_t*)(filter->last16),
293
293
                                                                                        top+1
294
294
                                                                                )
295
295
         ){                               errCode = ER_NOMEMORY;
305
305
#endif // __TGREADER_H
306
306
 
307
307
/**********************************************************************/
308
 
Bool TSegBambuk::vUpdate(  Int32* new_line,
309
 
                           Int32* cur16,
310
 
                           Int32* prev16,
 
308
Bool TSegBambuk::vUpdate(  int32_t* new_line,
 
309
                           int32_t* cur16,
 
310
                           int32_t* prev16,
311
311
                                                                        int cur_row
312
312
                                                                )
313
313
{  assert( new_line != NULL );
319
319
 
320
320
   int nbytes = width_byte_-1;
321
321
 
322
 
   Word8* cur_byte = (Word8*)cur16;
323
 
   Word8* prev_byte = (Word8*)prev16;
324
 
   Word8* new_byte = (Word8*)new_line;
 
322
   uchar* cur_byte = (uchar*)cur16;
 
323
   uchar* prev_byte = (uchar*)prev16;
 
324
   uchar* new_byte = (uchar*)new_line;
325
325
 
326
326
        for ( int i = 0; i < nbytes; i++ )
327
327
   {
328
328
                /* 1. process started segments */
329
 
      Word8 was_born = (*prev_byte) & ~(*cur_byte);
 
329
      uchar was_born = (*prev_byte) & ~(*cur_byte);
330
330
      if (was_born)
331
331
      {
332
332
                        col = i << 3; // i*8;
347
347
      }
348
348
 
349
349
                /* 2. process ended segments */
350
 
      Word8 has_died = ~(*cur_byte) & (*new_byte);
 
350
      uchar has_died = ~(*cur_byte) & (*new_byte);
351
351
        if (has_died)
352
352
      {
353
353
                        col = i << 3;   // i*8
376
376
        return TRUE;
377
377
} // vUpdate()
378
378
 
379
 
Bool TSegBambuk::vUpdateFirst(   Int32* new_line,
380
 
                                 Int32* cur16,
 
379
Bool TSegBambuk::vUpdateFirst(   int32_t* new_line,
 
380
                                 int32_t* cur16,
381
381
                                                                                        int cur_row
382
382
                                                                )
383
383
        {  assert( new_line != NULL );
384
384
                assert( cur16 != NULL );
385
385
                BHandle seg_handle;
386
386
 
387
 
      Int32 was_born_dword;
388
 
      Int32 has_died_dword;
389
 
                Word8 was_born, has_died;
 
387
      int32_t was_born_dword;
 
388
      int32_t has_died_dword;
 
389
                uchar was_born, has_died;
390
390
                int j, col;
391
391
 
392
392
                for ( int i = 0; i < width_dword_ - 1; i++ ){
395
395
#ifdef BIG_ENDIAN
396
396
            was_born_dword = SWAPLONG(was_born_dword);
397
397
#endif
398
 
                                if ( (was_born = (Word8)was_born_dword ) != 0){  // first byte
 
398
                                if ( (was_born = (uchar)was_born_dword ) != 0){  // first byte
399
399
                                        col = i << 5;   // i*32
400
400
                                        do {
401
401
                                                        segCount++;
411
411
                                                        #endif
412
412
                                        } while ( was_born &= bytebit0[j]);
413
413
                                };
414
 
                                if ( (was_born = (Word8)(was_born_dword >> 8) ) != 0){  // second byte
 
414
                                if ( (was_born = (uchar)(was_born_dword >> 8) ) != 0){  // second byte
415
415
                                        col = (i << 5) + 8;   // i*32 + 8
416
416
                                        do {
417
417
                                                        segCount++;
427
427
                                                        #endif
428
428
                                        } while ( was_born &= bytebit0[j]);
429
429
                                };
430
 
                                if ( (was_born = (Word8)(was_born_dword >> 16) ) != 0){  // third byte
 
430
                                if ( (was_born = (uchar)(was_born_dword >> 16) ) != 0){  // third byte
431
431
                                        col = (i << 5) + 16;   // i*32 + 8
432
432
                                        do {
433
433
                                                        segCount++;
443
443
                                                        #endif
444
444
                                        } while ( was_born &= bytebit0[j]);
445
445
                                };
446
 
                                if ( (was_born = (Word8)(was_born_dword >> 24) ) != 0){  // forth byte
 
446
                                if ( (was_born = (uchar)(was_born_dword >> 24) ) != 0){  // forth byte
447
447
                                        col = (i << 5) + 24;   // i*32 + 24
448
448
                                        do {
449
449
                                                        segCount++;
466
466
#ifdef BIG_ENDIAN
467
467
            has_died_dword= SWAPLONG(has_died_dword);
468
468
#endif
469
 
                                if ((has_died = (Word8)has_died_dword ) != 0){   // first byte
 
469
                                if ((has_died = (uchar)has_died_dword ) != 0){   // first byte
470
470
                                        col = i << 5;   // i*32
471
471
                                        do {
472
472
                                                        seg_handle = lastEntryMember( col+
485
485
#endif
486
486
                                        } while ( has_died &= bytebit0[j]);
487
487
                                };
488
 
                                if ((has_died = (Word8)(has_died_dword>>8) ) != 0){   // second byte
 
488
                                if ((has_died = (uchar)(has_died_dword>>8) ) != 0){   // second byte
489
489
                                        col = (i << 5) + 8;   // i*32
490
490
                                        do {
491
491
                                                        seg_handle = lastEntryMember( col+
504
504
#endif
505
505
                                        } while ( has_died &= bytebit0[j]);
506
506
                                };
507
 
                                if ( (has_died = (Word8)(has_died_dword>>16) ) != 0){   // third byte
 
507
                                if ( (has_died = (uchar)(has_died_dword>>16) ) != 0){   // third byte
508
508
                                        col = (i << 5) + 16;   // i*32
509
509
                                        do {
510
510
                                                        seg_handle = lastEntryMember( col+
523
523
#endif
524
524
                                        } while ( has_died &= bytebit0[j]);
525
525
                                };
526
 
                                if ( (has_died = (Word8)(has_died_dword>>24) ) != 0){   // forth byte
 
526
                                if ( (has_died = (uchar)(has_died_dword>>24) ) != 0){   // forth byte
527
527
                                        col = (i << 5) + 24;   // i*32
528
528
                                        do {
529
529
                                                        seg_handle = lastEntryMember( col+
550
550
                return TRUE;
551
551
        } // vUpdateFirst()
552
552
 
553
 
Bool TSegBambuk::vUpdateLast(    Int32* cur16,
554
 
                                 Int32* last16,
 
553
Bool TSegBambuk::vUpdateLast(    int32_t* cur16,
 
554
                                 int32_t* last16,
555
555
                                                                                        int cur_row
556
556
                                                                         )
557
557
        {
559
559
                assert( last16 != NULL );
560
560
                BHandle seg_handle;
561
561
 
562
 
      Int32 was_born_dword;
563
 
      Int32 has_died_dword;
564
 
                Word8 was_born, has_died;
 
562
      int32_t was_born_dword;
 
563
      int32_t has_died_dword;
 
564
                uchar was_born, has_died;
565
565
                int j, col;
566
566
 
567
567
                for ( int i = 0; i < width_dword_ - 1; i++ ){
570
570
#ifdef BIG_ENDIAN
571
571
            was_born_dword = SWAPLONG(was_born_dword);
572
572
#endif
573
 
                                if ((was_born = (Word8)was_born_dword) != 0){  // first byte
 
573
                                if ((was_born = (uchar)was_born_dword) != 0){  // first byte
574
574
                                        col = i << 5;   // i*32
575
575
                                        do {
576
576
                                                        segCount++;
586
586
                                                        #endif
587
587
                                        } while ( was_born &= bytebit0[j]);
588
588
                                };
589
 
                                if ((was_born = (Word8)(was_born_dword >> 8)) != 0){  // second byte
 
589
                                if ((was_born = (uchar)(was_born_dword >> 8)) != 0){  // second byte
590
590
                                        col = (i << 5) + 8;   // i*32 + 8
591
591
                                        do {
592
592
                                                        segCount++;
602
602
                                                        #endif
603
603
                                        } while ( was_born &= bytebit0[j]);
604
604
                                };
605
 
                                if ( (was_born = (Word8)(was_born_dword >> 16) ) != 0){  // third byte
 
605
                                if ( (was_born = (uchar)(was_born_dword >> 16) ) != 0){  // third byte
606
606
                                        col = (i << 5) + 16;   // i*32 + 8
607
607
                                        do {
608
608
                                                        segCount++;
618
618
                                                        #endif
619
619
                                        } while ( was_born &= bytebit0[j]);
620
620
                                };
621
 
                                if ( (was_born = (Word8)(was_born_dword >> 24)) != 0){  // forth byte
 
621
                                if ( (was_born = (uchar)(was_born_dword >> 24)) != 0){  // forth byte
622
622
                                        col = (i << 5) + 24;   // i*32 + 24
623
623
                                        do {
624
624
                                                        segCount++;
641
641
#ifdef BIG_ENDIAN
642
642
            has_died_dword= SWAPLONG(has_died_dword);
643
643
#endif
644
 
                                if ( (has_died = (Word8)has_died_dword ) != 0){   // first byte
 
644
                                if ( (has_died = (uchar)has_died_dword ) != 0){   // first byte
645
645
                                        col = i << 5;   // i*32
646
646
                                        do {
647
647
                                                        seg_handle = lastEntryMember( col+
660
660
#endif
661
661
                                        } while ( has_died &= bytebit0[j]);
662
662
                                };
663
 
                                if ( ( has_died = (Word8)(has_died_dword>>8) ) != 0){   // second byte
 
663
                                if ( ( has_died = (uchar)(has_died_dword>>8) ) != 0){   // second byte
664
664
                                        col = (i << 5) + 8;   // i*32
665
665
                                        do {
666
666
                                                        seg_handle = lastEntryMember( col+
679
679
#endif
680
680
                                        } while ( has_died &= bytebit0[j]);
681
681
                                };
682
 
                                if ( ( has_died = (Word8)(has_died_dword>>16) ) != 0){   // third byte
 
682
                                if ( ( has_died = (uchar)(has_died_dword>>16) ) != 0){   // third byte
683
683
                                        col = (i << 5) + 16;   // i*32
684
684
                                        do {
685
685
                                                        seg_handle = lastEntryMember( col+
698
698
#endif
699
699
                                        } while ( has_died &= bytebit0[j]);
700
700
                                };
701
 
                                if ( ( has_died = (Word8)(has_died_dword>>24) ) != 0){   // forth byte
 
701
                                if ( ( has_died = (uchar)(has_died_dword>>24) ) != 0){   // forth byte
702
702
                                        col = (i << 5) + 24;   // i*32
703
703
                                        do {
704
704
                                                        seg_handle = lastEntryMember( col+