tesseract_bin 1.0.0

data/vendor/tesseract-2.04/ccutil/ocrshell.cpp

@@ -0,0 +1,772 @@
+/**********************************************************************
+ * 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
+}