/**********************************************************************
* File: ocrshell.cpp
* Description: Code for the OCR side of the OCR API.
* Author: Hewlett-Packard Co
*
* (C) Copyright 1996, Hewlett-Packard Co.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
/**********************************************************************
* This file contains code for the OCR side of the HP OCR interface.
* The code is designed to be used with either an ANSI C or C++ compiler.
* The structures are designed to allow them to be used with any
* structure alignment upto 8.
**********************************************************************/
#include "mfcpch.h"
#include "ocrshell.h"
#include "tprintf.h"
#include <stdlib.h>
#define EXTERN
#ifdef __UNIX__
EXTERN ESHM_INFO shm; /*info on shm */
#define TICKS 1
#endif
#ifdef __MSW32__
EXTERN ESHM_INFO shm; /*info on shm */
#define TICKS 1000
#endif
#ifdef __MAC__
#if defined(__CFM68K__) && !defined(__USING_STATIC_LIBS__)
#pragma import on
#endif
extern volatile ESHM_INFO shm; /*info on shm */
extern unsigned short WaitForSingleObject( /*"C" */
volatile Boolean &semaphore,
unsigned long timeout);
extern unsigned short ReleaseSemaphore( /*"C" */
volatile Boolean &semaphore);
#if defined(__CFM68K__) && !defined(__USING_STATIC_LIBS__)
#pragma import reset
#endif
#define WAIT_OBJECT_0 1
#define TICKS 60
#endif
typedef enum {
OCS_UNINIT, /*uninitialized */
OCS_SETUP_SHM, /*shm setup done */
OCS_SETUP_INFO, /*startinfo sent */
OCS_READING_STRIPS, /*read first but more to come */
OCS_READ_STRIPS, /*read all but no monitor yet */
OCS_RECOGNIZING, /*OCR incomplete */
OCS_SENDING_TEXT, /*sent buffer but more to come */
OCS_DEAD /*disconnected */
} OCR_STATE;
/* forward declarations - not in .h file as not needed outside this file*/
inT16 ocr_internal_shutdown(); /*closedown */
inT16 wait_for_mutex(); /*wait for HP to be ready */
inT16 wait_for_hp( /*wait for semaphore */
inT32 timeout /*in seconds */
);
inT16 release_mutex(); /*release mutex */
inT16 release_ocr(); /*release semaphore */
static inT32 font_count = 0; /*number of fonts */
static inT16 lines_read = 0; /*no read in this image */
/*current state */
static OCR_STATE ocr_state = OCS_UNINIT;
#ifdef __MAC__
pascal short TerminateOCR(AppleEvent *theEvent,
AppleEvent *theReply,
long refCon) {
ocr_internal_shutdown();
ExitToShell();
}
#endif
/**********************************************************************
* ocr_open_shm
*
* Attempt to connect to the shared memory segment and semaphores used
* in talking to the OCR engine. Called from OCR engine.
* The parameters are the command line arguments in order.
**********************************************************************/
#ifdef __MAC__
inT16
ocr_open_shm (uinT16 * lang)
#else
inT16
ocr_open_shm ( /*open the shm */
const char *shm_h, /*handle of shm */
const char *shm_size, /*size of shm segment */
const char *mutex_h, /*hp mutex */
const char *ocr_h, /*ocr semaphore */
const char *hp_h, /*hp semaphore */
const char *lang_str, /*language */
uinT16 * lang /*required language */
)
#endif
{
font_count = 0; /*no fonts yet */
#ifdef __MAC__
if (shm.OCRProcess.lowLongOfPSN && shm.OCRProcess.highLongOfPSN)
return HPERR;
*lang = shm.language;
GetCurrentProcess (&shm.OCRProcess);
if (WakeUpProcess (&shm.IPEProcess))
ExitToShell();
AEInstallEventHandler (kCoreEventClass, kAEQuitApplication,
(AEEventHandlerUPP) TerminateOCR, 0, FALSE);
#else
if (lang != NULL)
/*get language */
*lang = (uinT16) strtol (lang_str, NULL, 10);
#endif
if (ocr_state != OCS_UNINIT) {
ocr_error(OCR_ERR_BAD_STATE);
return OCR_API_BAD_STATE; /*incorrect state */
}
#ifdef __MSW32__
shm.shm_size = strtol (shm_size, NULL, 10);
/*convert to handle */
shm.shm_hand = (HANDLE) strtol (shm_h, NULL, 10);
shm.shm_mem = MapViewOfFile (shm.shm_hand, FILE_MAP_WRITE, 0, 0, 0);
if (shm.shm_mem == NULL)
return HPERR; /*failed */
/*convert to handle */
shm.mutex = (HANDLE) strtol (mutex_h, NULL, 10);
/*convert to handle */
shm.ocr_sem = (HANDLE) strtol (ocr_h, NULL, 10);
/*convert to handle */
shm.hp_sem = (HANDLE) strtol (hp_h, NULL, 10);
#endif
ocr_state = OCS_SETUP_SHM; /*record state */
return OKAY;
}
/**********************************************************************
* ocr_error
*
* Inform the HP side of an error.
* The OCR engine should do any cleanup of its own and exit aferwards.
* Uses the current state to determine how to send it and cleanup.
**********************************************************************/
void ocr_error( /*send an error code */
OCR_ERR_CODE code /*error code */
) {
ESTRIP_DESC *strip = (ESTRIP_DESC *) shm.shm_mem;
/*strip info */
ETEXT_DESC *monitor = (ETEXT_DESC *) shm.shm_mem;
/*progress monitor */
switch (ocr_state) {
case OCS_UNINIT: /*uninitialized */
case OCS_DEAD: /*uninitialized */
return; /*can't do anything else */
case OCS_SETUP_SHM: /*shm setup done */
if (font_count < 1)
font_count = 1;
ocr_setup_startinfo_ansi (-code, LANGE_NONE, "", "");
/*report error */
break;
case OCS_SETUP_INFO: /*startinfo sent */
if (ocr_get_first_image_strip () == NULL)
break; /*disconnected */
case OCS_READING_STRIPS: /*read first but more to come */
strip->x_size = -code; /*report error */
release_ocr(); /*send ack */
release_mutex();
break;
case OCS_READ_STRIPS: /*read all but no monitor yet */
monitor->count = 0; /*chars in this buffer(-1) */
monitor->progress = 0; /*percent complete increasing (0-100) */
/*text not complete */
monitor->more_to_come = FALSE;
monitor->ocr_alive = TRUE; /*ocr sets to 1, hp 0 */
monitor->err_code = -code; /*report error */
monitor->cancel = FALSE; /*0=continue, 1=cancel */
release_ocr(); /*send ack */
break;
case OCS_RECOGNIZING: /*OCR incomplete */
case OCS_SENDING_TEXT: /*sent buffer but more to come */
monitor->err_code = -code; /*report error */
release_ocr(); /*send ack */
}
ocr_internal_shutdown(); /*get ready for exit */
}
/**********************************************************************
* ocr_append_fontinfo
*
* Initialize one of the font descriptors.
**********************************************************************/
inT16 ocr_append_fontinfo( /*put info into shm */
uinT16 language, /*default language */
uinT8 font_family, /*serif/not, fixed/not */
uinT8 char_set, /*character set standard */
uinT8 pitch, /*fixed or prop */
const char *name /*plain ascii name */
) {
EOCR_DESC *desc; /*ocr engine info */
int index; /*char index */
inT32 font_index; /*which font */
if (ocr_state != OCS_SETUP_SHM) {
ocr_error(OCR_ERR_BAD_STATE);
return OCR_API_BAD_STATE; /*incorrect state */
}
/*turn to right type */
desc = (EOCR_DESC *) shm.shm_mem;
if (font_count >
(inT32) ((shm.shm_size - sizeof (EOCR_DESC)) / sizeof (EFONT_DESC)))
return OCR_API_NO_MEM; /*insufficient space */
font_index = font_count++; /*add a font */
/*setup structure */
desc->fonts[font_index].language = language;
/*setup structure */
desc->fonts[font_index].font_family = font_family;
/*setup structure */
desc->fonts[font_index].char_set = char_set;
/*setup structure */
desc->fonts[font_index].pitch = pitch;
if (name != NULL) {
for (index = 0; index < MAX_FONT_NAME && name[index] != 0; index++)
desc->fonts[font_index].name[index] = name[index];
}
else
index = 0;
desc->fonts[font_index].name[index] = 0;
return OKAY;
}
/**********************************************************************
* ocr_setup_startinfo
*
* Setup the info on the OCR engine. Uses 16 bit chars to name the
* engine.
**********************************************************************/
inT16 ocr_setup_startinfo( /*put info into shm */
inT32 protocol, /*interface version */
uinT16 language, /*default language */
const uinT16 *name, /*name of engine */
const uinT16 *version /*version of engine */
) {
EOCR_DESC *desc; /*ocr engine info */
int index; /*char index */
inT16 result; /*from open */
if (ocr_state != OCS_SETUP_SHM || font_count < 1) {
ocr_error(OCR_ERR_BAD_STATE);
return OCR_API_BAD_STATE; /*incorrect state */
}
/*turn to right type */
desc = (EOCR_DESC *) shm.shm_mem;
desc->protocol = protocol; /*setup structure */
desc->font_count = font_count;
desc->language = language;
for (index = 0; index < MAX_OCR_NAME && name[index] != 0; index++)
desc->name[index] = name[index];
desc->name[index] = 0;
for (index = 0; index < MAX_OCR_VERSION && version[index] != 0; index++)
desc->version[index] = version[index];
desc->version[index] = 0;
result = release_ocr ();
if (result != OKAY)
return result;
ocr_state = OCS_SETUP_INFO; /*record state */
return OKAY;
}
/**********************************************************************
* ocr_setup_startinfo_ansi
*
* Setup the info on the OCR engine. Uses 8 bit chars to name the
* engine.
**********************************************************************/
inT16 ocr_setup_startinfo_ansi( /*put info into shm */
uinT32 protocol, /*interface version */
uinT16 language, /*default language */
const char *name, /*name of engine */
const char *version /*version of engine */
) {
EOCR_DESC *desc; /*ocr engine info */
int index; /*char index */
inT16 result; /*from open */
if (ocr_state != OCS_SETUP_SHM || font_count < 1) {
ocr_error(OCR_ERR_BAD_STATE);
return OCR_API_BAD_STATE; /*incorrect state */
}
/*turn to right type */
desc = (EOCR_DESC *) shm.shm_mem;
desc->protocol = protocol; /*setup structure */
desc->font_count = font_count;
desc->language = language;
for (index = 0; index < MAX_OCR_NAME && name[index] != 0; index++)
desc->name[index] = name[index];
desc->name[index] = 0;
for (index = 0; index < MAX_OCR_VERSION && version[index] != 0; index++)
desc->version[index] = version[index];
desc->version[index] = 0;
result = release_ocr ();
if (result != OKAY)
return result;
ocr_state = OCS_SETUP_INFO; /*record state */
return OKAY;
}
/**********************************************************************
* ocr_get_first_image_strip
*
* Wait for the master to send the first image strip and return a
* pointer to it. The result is NULL if it is time to exit.
**********************************************************************/
ESTRIP_DESC *ocr_get_first_image_strip() { /*get image strip */
ESTRIP_DESC *strip; /*strip info */
inT16 result; /*of wait/release */
if (ocr_state != OCS_SETUP_INFO) {
tprintf ("Bad state reading strip");
ocr_error(OCR_ERR_BAD_STATE);
return NULL; /*incorrect state */
}
/*strip info */
strip = (ESTRIP_DESC *) shm.shm_mem;
lines_read = 0;
result = wait_for_mutex ();
if (result != OKAY) {
tprintf ("Mutax wait failed reading strip");
return NULL; /*HP dead */
}
result = release_mutex ();
if (result != OKAY) {
tprintf ("Mutax release failed reading strip");
return NULL; /*HP dead */
}
result = wait_for_hp (READIM_TIMEOUT);
if (result != OKAY) {
tprintf ("Wait for HP failed reading strip");
return NULL; /*HP dead */
}
lines_read = strip->strip_size;/*lines read so far */
if (lines_read < strip->y_size)
/*record state */
ocr_state = OCS_READING_STRIPS;
else
ocr_state = OCS_READ_STRIPS;
if (strip->x_size == 0 || strip->y_size == 0)
return NULL; /*end of job */
return strip;
}
/**********************************************************************
* ocr_get_next_image_strip
*
* Wait for the master to send the next image strip and return a
* pointer to it. The result is NULL if it is time to exit.
**********************************************************************/
ESTRIP_DESC *ocr_get_next_image_strip() { /*get image strip */
ESTRIP_DESC *strip; /*strip info */
inT16 result; /*of wait/release */
if (ocr_state != OCS_READING_STRIPS) {
ocr_error(OCR_ERR_BAD_STATE);
return NULL; /*incorrect state */
}
/*strip info */
strip = (ESTRIP_DESC *) shm.shm_mem;
result = release_ocr ();
if (result != OKAY)
return NULL; /*HP dead */
result = wait_for_hp (READIM_TIMEOUT);
if (result != OKAY)
return NULL; /*HP dead */
/*lines read so far */
lines_read += strip->strip_size;
if (lines_read < strip->y_size)
/*record state */
ocr_state = OCS_READING_STRIPS;
else
ocr_state = OCS_READ_STRIPS;
return strip;
}
/**********************************************************************
* ocr_setup_monitor
*
* Setup the progress monitor. Call before starting the recognize task.
**********************************************************************/
ETEXT_DESC *ocr_setup_monitor() { /*setup monitor */
ETEXT_DESC *monitor; /*progress monitor */
/*text info */
monitor = (ETEXT_DESC *) shm.shm_mem;
monitor->count = 0; /*chars in this buffer(-1) */
monitor->progress = 0; /*percent complete increasing (0-100) */
monitor->more_to_come = TRUE; /*text not complete */
monitor->ocr_alive = TRUE; /*ocr sets to 1, hp 0 */
monitor->err_code = 0; /*used by ocr_error */
monitor->cancel = FALSE; /*0=continue, 1=cancel */
//by jetsoft
//the sem functions are old and were meant for an hp product
// if (release_ocr () != OKAY)
// return NULL; /*release failed */
ocr_state = OCS_RECOGNIZING; /*record state */
return monitor;
}
/**********************************************************************
* ocr_char_space
*
* Return the number of chars that can be fitted into the buffer.
**********************************************************************/
inT32 ocr_char_space() { /*put char into shm */
ETEXT_DESC *buf; /*text buffer */
int result;
/*progress info */
buf = (ETEXT_DESC *) shm.shm_mem;
if (buf == NULL)
return 0;
result =
(shm.shm_size - sizeof (ETEXT_DESC)) / sizeof (EANYCODE_CHAR) -
buf->count + 1;
// while (buf->hp_alive==-1)
// Sleep(50); /*wait for HP*/
return result;
}
/**********************************************************************
* ocr_append_char
*
* Add a character to the output. Returns OKAY if successful, OCR_API_NO_MEM
* if there was insufficient room in the buffer.
**********************************************************************/
inT16 ocr_append_char( /*put char into shm */
uinT16 char_code, /*character itself */
inT16 left, /*of char (-1) */
inT16 right, /*of char (-1) */
inT16 top, /*of char (-1) */
inT16 bottom, /*of char (-1) */
inT16 font_index, /*what font (-1) */
uinT8 confidence, /*0=perfect, 100=reject (0/100) */
uinT8 point_size, /*of char, 72=i inch, (10) */
inT8 blanks, /*no of spaces before this char (1) */
uinT8 enhancement, /*char enhancement (0) */
OCR_CHAR_DIRECTION text_dir, /*rendering direction (OCR_CDIR_RIGHT_LEFT) */
OCR_LINE_DIRECTION line_dir, /*line rendering direction (OCR_LDIR_DOWN_RIGHT) */
OCR_NEWLINE_TYPE nl_type /*type of newline (if any) (OCR_NL_NONE) */
) {
ETEXT_DESC *buf; /*text buffer */
int index; /*char index */
inT16 result; /*of callback */
if (ocr_state != OCS_RECOGNIZING && ocr_state != OCS_SENDING_TEXT) {
ocr_error(OCR_ERR_BAD_STATE);
return OCR_API_BAD_STATE; /*incorrect state */
}
if (char_code == ' ' || char_code == '\n' || char_code == '\r'
|| char_code == '\t')
return OCR_API_BAD_CHAR; /*illegal char */
/*progress info */
buf = (ETEXT_DESC *) shm.shm_mem;
result =
(shm.shm_size - sizeof (ETEXT_DESC)) / sizeof (EANYCODE_CHAR) -
buf->count;
if (result < 1)
return OCR_API_NO_MEM; /*insufficient room */
index = buf->count++; /*count of chars */
/*setup structure */
buf->text[index].char_code = char_code;
buf->text[index].left = left; /*setup structure */
buf->text[index].right = right;/*setup structure */
buf->text[index].top = top; /*setup structure */
/*setup structure */
buf->text[index].bottom = bottom;
/*setup structure */
buf->text[index].font_index = font_index;
/*setup structure */
buf->text[index].confidence = confidence;
/*setup structure */
buf->text[index].point_size = point_size;
/*setup structure */
buf->text[index].blanks = blanks;
if (nl_type == OCR_NL_NONE) {
if (text_dir == OCR_CDIR_TOP_BOTTOM || text_dir == OCR_CDIR_BOTTOM_TOP)
buf->text[index].formatting = (text_dir << 5) | 128;
/*setup structure */
else
/*setup structure */
buf->text[index].formatting = text_dir << 5;
}
else {
buf->text[index].formatting = (nl_type << 6) | (line_dir << 5);
/*setup structure */
}
buf->text[index].formatting |= enhancement & (~EUC_FORMAT_MASK);
return OKAY;
}
/**********************************************************************
* ocr_send_text
*
* Send the text to the host and wait for the ack.
* Use this function after a sequence of ocr_append_char calls to
* actually sent the text to the master process.
* Set more to come TRUE if there is more text in this page, FALSE
* if the OCR engine is now ready to receive another image.
**********************************************************************/
inT16 ocr_send_text( /*send shm */
BOOL8 more_to_come /*any text left */
) {
ETEXT_DESC *buf; /*text buffer */
if (ocr_state != OCS_RECOGNIZING && ocr_state != OCS_SENDING_TEXT) {
ocr_error(OCR_ERR_BAD_STATE);
return OCR_API_BAD_STATE; /*incorrect state */
}
/*progress info */
buf = (ETEXT_DESC *) shm.shm_mem;
/*setup structure */
buf->more_to_come = more_to_come;
if (more_to_come) {
if ((buf->text[buf->count - 1].formatting >> 6) != OCR_NL_NEWLINE
&& (buf->text[buf->count - 1].formatting >> 6) != OCR_NL_NEWPARA) {
/*force line end */
buf->text[buf->count - 1].formatting &= 63;
buf->text[buf->count - 1].formatting |= OCR_NL_NEWLINE << 6;
}
}
else {
if (buf->count < 1)
ocr_append_char ('~', -1, -1, -1, -1, 0, 100, 10, 0,
0, OCR_CDIR_RIGHT_LEFT, OCR_LDIR_DOWN_RIGHT,
OCR_NL_NEWPARA);
/*dummy character */
else if ((buf->text[buf->count - 1].formatting >> 6) != OCR_NL_NEWPARA) {
/*force para end */
buf->text[buf->count - 1].formatting &= 63;
buf->text[buf->count - 1].formatting |= OCR_NL_NEWPARA << 6;
}
}
if (release_ocr () != OKAY)
return HPERR; /*release failed */
if (wait_for_hp (READTEXT_TIMEOUT) != OKAY)
return HPERR;
if (more_to_come) {
buf->count = 0; /*setup structure */
ocr_state = OCS_SENDING_TEXT;/*record state */
}
else
ocr_state = OCS_SETUP_INFO; /*record state */
return OKAY;
}
/**********************************************************************
* ocr_shutdown
*
* Closedown communications with the HP side and free up handles.
**********************************************************************/
inT16 ocr_shutdown() { /*closedown */
#ifdef __MAC__
shm.OCRProcess.lowLongOfPSN = kNoProcess;
shm.OCRProcess.highLongOfPSN = 0;
#endif
ocr_error(OCR_ERR_CLEAN_EXIT); /*signal exit */
return OKAY;
}
/**********************************************************************
* ocr_internal_shutdown
*
* Free up handles or whatever to clean up without attempting to communicate.
**********************************************************************/
inT16 ocr_internal_shutdown() { /*closedown */
ocr_state = OCS_DEAD; /*record state */
#ifdef __MSW32__
if (shm.shm_mem != NULL) {
UnmapViewOfFile (shm.shm_mem);
CloseHandle (shm.shm_hand); /*no longer used */
CloseHandle (shm.mutex); /*release handles */
CloseHandle (shm.ocr_sem);
CloseHandle (shm.hp_sem);
shm.shm_mem = NULL;
}
#elif defined (__MAC__)
shm.OCRProcess.lowLongOfPSN = kNoProcess;
shm.OCRProcess.highLongOfPSN = 0;
#endif
return OKAY;
}
/**********************************************************************
* wait_for_mutex
*
* Wait for the HP side to release its mutex.
* The return value is HPERR if the HP side has terminated.
**********************************************************************/
inT16 wait_for_mutex() { /*wait for HP to be ready */
inT16 result = HPERR; /*return code */
#if defined (__MSW32__) || defined (__MAC__)
result = WaitForSingleObject (shm.mutex, (unsigned long) -1)
/*wait for thread to move */
/*bad if timeout */
== WAIT_OBJECT_0 ? OKAY : HPERR;
#endif
if (result != OKAY)
ocr_internal_shutdown();
return result;
}
/**********************************************************************
* wait_for_hp
*
* Wait for the HP side to release its semaphore.
* The return value is HPERR if the timeout (in seconds) elapsed.
**********************************************************************/
inT16 wait_for_hp( /*wait for semaphore */
inT32 timeout /*in seconds */
) {
inT16 result = HPERR; /*return code */
#if defined (__MSW32__) || defined (__MAC__)
/*wait for thread to move */
result = WaitForSingleObject (shm.hp_sem, timeout * TICKS)
/*bad if timeout */
== WAIT_OBJECT_0 ? OKAY : HPERR;
#endif
if (result != OKAY)
ocr_internal_shutdown();
return result;
}
/**********************************************************************
* release_mutex
*
* Release the HP mutex.
* The return value is OKAY if the call succeeds.
**********************************************************************/
inT16 release_mutex() { /*release mutex */
inT16 result = HPERR; /*return code */
#ifdef __MSW32__
/*release it */
result = ReleaseMutex (shm.mutex) ? OKAY : HPERR;
#elif defined (__MAC__)
/*release it */
result = ReleaseSemaphore (shm.mutex) ? OKAY : HPERR;
#endif
if (result != OKAY)
ocr_internal_shutdown();
return result;
}
/**********************************************************************
* release_ocr
*
* Release the OCR semaphore.
* The return value is OKAY if the call succeeds.
**********************************************************************/
inT16 release_ocr() { /*release semaphore */
inT32 timeout; //time allowed
timeout = RELEASE_TIMEOUT * TICKS;
#ifdef __MSW32__
//jetsoft
// this stuff is old and no longer applies
return OKAY;
//
BOOL result = 0; //of release
do {
//release it
result = ReleaseSemaphore (shm.ocr_sem, 1, NULL);
if (result == FALSE) {
timeout -= 50;
Sleep (50);
}
}
while (result == FALSE && timeout > 0);
if (!result)
ocr_internal_shutdown();
return OKAY;
#elif defined (__MAC__)
inT16 result = HPERR; /*return code */
/*release it */
result = ReleaseSemaphore (shm.ocr_sem) ? OKAY : HPERR;
if (result != OKAY)
ocr_internal_shutdown();
return result;
#elif defined (__UNIX__)
return 0;
#endif
}