ccutil/ocrshell.h File Reference

#include "ocrclass.h"

Go to the source code of this file.

Defines

• #define EUC_FORMAT_MASK   0xe0

Functions

• INT16 ocr_append_char (UINT16 char_code, INT16 left, INT16 right, INT16 top, INT16 bottom, INT16 font_index, UINT8 confidence, UINT8 point_size, INT8 blanks, UINT8 enhancement, OCR_CHAR_DIRECTION text_dir, OCR_LINE_DIRECTION line_dir, OCR_NEWLINE_TYPE nl_type)

  Add a character to the output (shm).
  

• INT16 ocr_append_fontinfo (UINT16 language, UINT8 font_family, UINT8 char_set, UINT8 pitch, const char *name)

  Put font info into shm.
  

• INT32 ocr_char_space ()

  Put char into shm.
  

• void ocr_error (OCR_ERR_CODE code)

  Send an error code.
  

• ESTRIP_DESC * ocr_get_first_image_strip ()

  Get first image strip.
  

• ESTRIP_DESC * ocr_get_next_image_strip ()

  Get next image strip.
  

• INT16 ocr_open_shm (const char *shm_h, const char *shm_size, const char *mutex_h, const char *ocr_h, const char *hp_h, const char *lang_str, UINT16 *lang)

  Attempt to connect to the shared memory segment and semaphores used talking to the OCR engine.
  

• INT16 ocr_send_text (BOOL8 more_to_come)

  Send shm.
  

• ETEXT_DESC * ocr_setup_monitor ()

  Setup the progress monitor.
  

• INT16 ocr_setup_startinfo (UINT32 protocol, UINT16 language, const UINT16 *name, const UINT16 *version)
• INT16 ocr_setup_startinfo_ansi (UINT32 protocol, UINT16 language, const char *name, const char *version)

  Setup the info on the OCR engine.
  

• INT16 ocr_shutdown ()

  Close-down OCR.
  

---

Define Documentation

#define EUC_FORMAT_MASK   0xe0

Note:

File: ocrshell.h

• Code for the OCR side of the OCR API.
• 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.

Author:

Hewlett-Packard Co

Date:

1996

 * (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.

Definition at line 28 of file ocrshell.h.

Referenced by ocr_append_char().

---

Function Documentation

INT16 ocr_append_char	(	UINT16	char_code,
		INT16	left,
		INT16	right,
		INT16	top,
		INT16	bottom,
		INT16	font_index,
		UINT8	confidence,
		UINT8	point_size,
		INT8	blanks,
		UINT8	enhancement,
		OCR_CHAR_DIRECTION	text_dir,
		OCR_LINE_DIRECTION	line_dir,
		OCR_NEWLINE_TYPE	nl_type
	)

Add a character to the output (shm).

Parameters:

	char_code	character itself
	left	of char (-1)
	right	of char (-1)
	top	of char (-1)
	bottom	of char (-1)
	font_index	what font (-1)
	confidence	0=perfect, 100=reject (0/100)
	point_size	of char, 72=i inch, (10)
	blanks	no of spaces before this char (1)
	enhancement	char enhancement (0)
	text_dir	rendering direction (OCR_CDIR_RIGHT_LEFT)
	line_dir	line rendering direction (OCR_LDIR_DOWN_RIGHT)
	nl_type	type of newline (if any) (OCR_NL_NONE)

Returns:

OKAY or OCR_API_NO_MEM

Returns OKAY if successful, OCR_API_NO_MEM if there was insufficient room in the buffer.

Definition at line 510 of file ocrshell.cpp.

References EANYCODE_CHAR::blanks, EANYCODE_CHAR::bottom, EANYCODE_CHAR::char_code, EANYCODE_CHAR::confidence, ETEXT_DESC::count, EUC_FORMAT_MASK, EANYCODE_CHAR::font_index, EANYCODE_CHAR::formatting, EANYCODE_CHAR::left, OCR_API_BAD_CHAR, OCR_API_BAD_STATE, OCR_API_NO_MEM, OCR_CDIR_BOTTOM_TOP, OCR_CDIR_TOP_BOTTOM, OCR_ERR_BAD_STATE, ocr_error(), OCR_NL_NONE, ocr_state, OCS_RECOGNIZING, OCS_SENDING_TEXT, OKAY, EANYCODE_CHAR::point_size, EANYCODE_CHAR::right, shm, ESHM_INFO::shm_mem, ESHM_INFO::shm_size, ETEXT_DESC::text, and EANYCODE_CHAR::top.

Referenced by ocr_send_text(), and write_shm_text().

                       {
  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;
}

INT16 ocr_append_fontinfo	(	UINT16	language,
		UINT8	font_family,
		UINT8	char_set,
		UINT8	pitch,
		const char *	name
	)

Put font info into shm.

Initialize one of the font descriptors.

Definition at line 230 of file ocrshell.cpp.

References EFONT_DESC::char_set, font_count, EFONT_DESC::font_family, EOCR_DESC::fonts, EFONT_DESC::language, MAX_FONT_NAME, EFONT_DESC::name, NULL, OCR_API_BAD_STATE, OCR_API_NO_MEM, OCR_ERR_BAD_STATE, ocr_error(), ocr_state, OCS_SETUP_SHM, OKAY, EFONT_DESC::pitch, shm, ESHM_INFO::shm_mem, and ESHM_INFO::shm_size.

                           {
  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;
}

INT32 ocr_char_space

(

)

Put char into shm.

Return the number of chars that can be fitted into the buffer.

Definition at line 471 of file ocrshell.cpp.

References ETEXT_DESC::count, shm, ESHM_INFO::shm_mem, and ESHM_INFO::shm_size.

Referenced by write_shm_text().

                       {  /*put char into shm */
  ETEXT_DESC *buf;               /*text buffer */
  int result;

                                 /*progress info */
  buf = (ETEXT_DESC *) shm.shm_mem;
  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;
}

void ocr_error

(

OCR_ERR_CODE

code

)

Send an error code.

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.

Definition at line 179 of file ocrshell.cpp.

References FALSE, font_count, LANGE_NONE, NULL, ocr_get_first_image_strip(), ocr_internal_shutdown(), ocr_setup_startinfo_ansi(), ocr_state, OCS_DEAD, OCS_READ_STRIPS, OCS_READING_STRIPS, OCS_RECOGNIZING, OCS_SENDING_TEXT, OCS_SETUP_INFO, OCS_SETUP_SHM, OCS_UNINIT, release_mutex(), release_ocr(), shm, ESHM_INFO::shm_mem, TRUE, and ESTRIP_DESC::x_size.

Referenced by ocr_append_char(), ocr_append_fontinfo(), ocr_get_first_image_strip(), ocr_get_next_image_strip(), ocr_open_shm(), ocr_send_text(), ocr_setup_startinfo(), ocr_setup_startinfo_ansi(), and ocr_shutdown().

                {
  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 */
}

ESTRIP_DESC* ocr_get_first_image_strip

(

)

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.

Definition at line 361 of file ocrshell.cpp.

References lines_read, NULL, OCR_ERR_BAD_STATE, ocr_error(), ocr_state, OCS_READ_STRIPS, OCS_READING_STRIPS, OCS_SETUP_INFO, OKAY, READIM_TIMEOUT, release_mutex(), shm, ESHM_INFO::shm_mem, ESTRIP_DESC::strip_size, tprintf(), wait_for_hp(), wait_for_mutex(), ESTRIP_DESC::x_size, and ESTRIP_DESC::y_size.

Referenced by ocr_error().

                                         {  /*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;
}

ESTRIP_DESC* ocr_get_next_image_strip

(

)

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.

Definition at line 410 of file ocrshell.cpp.

References lines_read, NULL, OCR_ERR_BAD_STATE, ocr_error(), ocr_state, OCS_READ_STRIPS, OCS_READING_STRIPS, OKAY, READIM_TIMEOUT, release_ocr(), shm, ESHM_INFO::shm_mem, ESTRIP_DESC::strip_size, and wait_for_hp().

                                        {  /*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;
}

INT16 ocr_open_shm	(	const char *	shm_h,
		const char *	shm_size,
		const char *	mutex_h,
		const char *	ocr_h,
		const char *	hp_h,
		const char *	lang_str,
		UINT16 *	lang
	)

Attempt to connect to the shared memory segment and semaphores used talking to the OCR engine.

Parameters:

	shm_h	handle of shm
	shm_size	size of shm segment
	mutex_h	hp mutex
	ocr_h	ocr semaphore
	hp_h	hp semaphore
	lang_str	language
	lang	language (Mac only)

Returns:

status: OCR_API_BAD_STATE, OKAY, or HPERR

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.

Definition at line 120 of file ocrshell.cpp.

References FALSE, font_count, HPERR, NULL, OCR_API_BAD_STATE, OCR_ERR_BAD_STATE, ocr_error(), ocr_state, OCS_SETUP_SHM, OCS_UNINIT, OKAY, shm, ESHM_INFO::shm_mem, and ESHM_INFO::shm_size.

{
  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 // __MAC__
  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 //__MSW32__

  ocr_state = OCS_SETUP_SHM;     /*record state */
  return OKAY;

}

INT16 ocr_send_text

(

BOOL8

more_to_come

)

Send shm.

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.

Definition at line 590 of file ocrshell.cpp.

References ETEXT_DESC::count, EANYCODE_CHAR::formatting, HPERR, ETEXT_DESC::more_to_come, OCR_API_BAD_STATE, ocr_append_char(), OCR_CDIR_RIGHT_LEFT, OCR_ERR_BAD_STATE, ocr_error(), OCR_LDIR_DOWN_RIGHT, OCR_NL_NEWLINE, OCR_NL_NEWPARA, ocr_state, OCS_RECOGNIZING, OCS_SENDING_TEXT, OCS_SETUP_INFO, OKAY, READTEXT_TIMEOUT, release_ocr(), shm, ESHM_INFO::shm_mem, ETEXT_DESC::text, and wait_for_hp().

Referenced by output_pass(), and write_shm_text().

                     {
  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;
}

ETEXT_DESC* ocr_setup_monitor

(

)

Setup the progress monitor.

Call before starting the recognize task.

Definition at line 445 of file ocrshell.cpp.

References ETEXT_DESC::cancel, ETEXT_DESC::count, ETEXT_DESC::err_code, FALSE, ETEXT_DESC::more_to_come, NULL, ETEXT_DESC::ocr_alive, ocr_state, OCS_RECOGNIZING, OKAY, ETEXT_DESC::progress, release_ocr(), shm, ESHM_INFO::shm_mem, and TRUE.

                                {  /*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 */

  if (release_ocr () != OKAY)
    return NULL;                 /*release failed */

  ocr_state = OCS_RECOGNIZING;   /*record state */
  return monitor;
}

INT16 ocr_setup_startinfo	(	UINT32	protocol,
		UINT16	language,
		const UINT16 *	name,
		const UINT16 *	version
	)

INT16 ocr_setup_startinfo_ansi	(	UINT32	protocol,
		UINT16	language,
		const char *	name,
		const char *	version
	)

Setup the info on the OCR engine.

Uses 8 bit chars to name the engine.

Definition at line 319 of file ocrshell.cpp.

References EOCR_DESC::font_count, font_count, EOCR_DESC::language, MAX_OCR_NAME, MAX_OCR_VERSION, EOCR_DESC::name, OCR_API_BAD_STATE, OCR_ERR_BAD_STATE, ocr_error(), ocr_state, OCS_SETUP_INFO, OCS_SETUP_SHM, OKAY, EOCR_DESC::protocol, release_ocr(), shm, ESHM_INFO::shm_mem, and EOCR_DESC::version.

Referenced by ocr_error().

                                {
  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;
}

INT16 ocr_shutdown

(

)

Close-down OCR.

Closedown communications with the HP side and free up handles.

Definition at line 647 of file ocrshell.cpp.

References OCR_ERR_CLEAN_EXIT, ocr_error(), OKAY, and shm.

                     {  /*closedown */
  #ifdef __MAC__
  shm.OCRProcess.lowLongOfPSN = kNoProcess;
  shm.OCRProcess.highLongOfPSN = 0;
  #endif
  ocr_error(OCR_ERR_CLEAN_EXIT);  /*signal exit */

  return OKAY;
}

---