diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/Makefile.am.inc | 13 | ||||
| -rw-r--r-- | include/zbar.h | 1587 | ||||
| -rw-r--r-- | include/zbar/Decoder.h | 203 | ||||
| -rw-r--r-- | include/zbar/Exception.h | 199 | ||||
| -rw-r--r-- | include/zbar/Image.h | 322 | ||||
| -rw-r--r-- | include/zbar/ImageScanner.h | 149 | ||||
| -rw-r--r-- | include/zbar/Processor.h | 220 | ||||
| -rw-r--r-- | include/zbar/QZBar.h | 207 | ||||
| -rw-r--r-- | include/zbar/QZBarImage.h | 72 | ||||
| -rw-r--r-- | include/zbar/Scanner.h | 162 | ||||
| -rw-r--r-- | include/zbar/Symbol.h | 532 | ||||
| -rw-r--r-- | include/zbar/Video.h | 224 | ||||
| -rw-r--r-- | include/zbar/Window.h | 134 | ||||
| -rw-r--r-- | include/zbar/zbargtk.h | 253 |
14 files changed, 4277 insertions, 0 deletions
diff --git a/include/Makefile.am.inc b/include/Makefile.am.inc new file mode 100644 index 0000000..a782b29 --- /dev/null +++ b/include/Makefile.am.inc @@ -0,0 +1,13 @@ +zincludedir = $(includedir)/zbar +include_HEADERS = include/zbar.h +zinclude_HEADERS = include/zbar/Scanner.h include/zbar/Decoder.h \ + include/zbar/Exception.h include/zbar/Symbol.h include/zbar/Image.h \ + include/zbar/ImageScanner.h include/zbar/Video.h include/zbar/Window.h \ + include/zbar/Processor.h + +if HAVE_GTK +zinclude_HEADERS += include/zbar/zbargtk.h +endif +if HAVE_QT +zinclude_HEADERS += include/zbar/QZBar.h include/zbar/QZBarImage.h +endif diff --git a/include/zbar.h b/include/zbar.h new file mode 100644 index 0000000..66281c1 --- /dev/null +++ b/include/zbar.h @@ -0,0 +1,1587 @@ +/*------------------------------------------------------------------------ + * Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net> + * + * This file is part of the ZBar Bar Code Reader. + * + * The ZBar Bar Code Reader is free software; you can redistribute it + * and/or modify it under the terms of the GNU Lesser Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * The ZBar Bar Code Reader is distributed in the hope that it will be + * useful, but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser Public License for more details. + * + * You should have received a copy of the GNU Lesser Public License + * along with the ZBar Bar Code Reader; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + * + * http://sourceforge.net/projects/zbar + *------------------------------------------------------------------------*/ +#ifndef _ZBAR_H_ +#define _ZBAR_H_ + +#include <stdint.h> + +/** @file + * ZBar Barcode Reader C API definition + */ + +/** @mainpage + * + * interface to the barcode reader is available at several levels. + * most applications will want to use the high-level interfaces: + * + * @section high-level High-Level Interfaces + * + * these interfaces wrap all library functionality into an easy-to-use + * package for a specific toolkit: + * - the "GTK+ 2.x widget" may be used with GTK GUI applications. a + * Python wrapper is included for PyGtk + * - the @ref zbar::QZBar "Qt4 widget" may be used with Qt GUI + * applications + * - the Processor interface (in @ref c-processor "C" or @ref + * zbar::Processor "C++") adds a scanning window to an application + * with no GUI. + * + * @section mid-level Intermediate Interfaces + * + * building blocks used to construct high-level interfaces: + * - the ImageScanner (in @ref c-imagescanner "C" or @ref + * zbar::ImageScanner "C++") looks for barcodes in a library defined + * image object + * - the Window abstraction (in @ref c-window "C" or @ref + * zbar::Window "C++") sinks library images, displaying them on the + * platform display + * - the Video abstraction (in @ref c-video "C" or @ref zbar::Video + * "C++") sources library images from a video device + * + * @section low-level Low-Level Interfaces + * + * direct interaction with barcode scanning and decoding: + * - the Scanner (in @ref c-scanner "C" or @ref zbar::Scanner "C++") + * looks for barcodes in a linear intensity sample stream + * - the Decoder (in @ref c-decoder "C" or @ref zbar::Decoder "C++") + * extracts barcodes from a stream of bar and space widths + */ + +#ifdef __cplusplus + +/** C++ namespace for library interfaces */ +namespace zbar +{ +extern "C" { +#endif + +/** @name Global library interfaces */ +/*@{*/ + +/** "color" of element: bar or space. */ +typedef enum zbar_color_e +{ + ZBAR_SPACE = 0, /**< light area or space between bars */ + ZBAR_BAR = 1, /**< dark area or colored bar segment */ +} zbar_color_t; + +/** decoded symbol type. */ +typedef enum zbar_symbol_type_e +{ + ZBAR_NONE = 0, /**< no symbol decoded */ + ZBAR_PARTIAL = 1, /**< intermediate status */ + ZBAR_EAN2 = 2, /**< GS1 2-digit add-on */ + ZBAR_EAN5 = 5, /**< GS1 5-digit add-on */ + ZBAR_EAN8 = 8, /**< EAN-8 */ + ZBAR_UPCE = 9, /**< UPC-E */ + ZBAR_ISBN10 = 10, /**< ISBN-10 (from EAN-13). @since 0.4 */ + ZBAR_UPCA = 12, /**< UPC-A */ + ZBAR_EAN13 = 13, /**< EAN-13 */ + ZBAR_ISBN13 = 14, /**< ISBN-13 (from EAN-13). @since 0.4 */ + ZBAR_COMPOSITE = 15, /**< EAN/UPC composite */ + ZBAR_I25 = 25, /**< Interleaved 2 of 5. @since 0.4 */ + ZBAR_DATABAR = 34, /**< GS1 DataBar (RSS). @since 0.11 */ + ZBAR_DATABAR_EXP = 35, /**< GS1 DataBar Expanded. @since 0.11 */ + ZBAR_CODABAR = 38, /**< Codabar. @since 0.11 */ + ZBAR_CODE39 = 39, /**< Code 39. @since 0.4 */ + ZBAR_PDF417 = 57, /**< PDF417. @since 0.6 */ + ZBAR_QRCODE = 64, /**< QR Code. @since 0.10 */ + ZBAR_SQCODE = 80, /**< SQ Code. @since 0.20.1 */ + ZBAR_CODE93 = 93, /**< Code 93. @since 0.11 */ + ZBAR_CODE128 = 128, /**< Code 128 */ + + /* + * Please see _zbar_get_symbol_hash() if adding + * anything after 128 + */ + + /** mask for base symbol type. + * @deprecated in 0.11, remove this from existing code + */ + ZBAR_SYMBOL = 0x00ff, + /** 2-digit add-on flag. + * @deprecated in 0.11, a ::ZBAR_EAN2 component is used for + * 2-digit GS1 add-ons + */ + ZBAR_ADDON2 = 0x0200, + /** 5-digit add-on flag. + * @deprecated in 0.11, a ::ZBAR_EAN5 component is used for + * 5-digit GS1 add-ons + */ + ZBAR_ADDON5 = 0x0500, + /** add-on flag mask. + * @deprecated in 0.11, GS1 add-ons are represented using composite + * symbols of type ::ZBAR_COMPOSITE; add-on components use ::ZBAR_EAN2 + * or ::ZBAR_EAN5 + */ + ZBAR_ADDON = 0x0700, +} zbar_symbol_type_t; + +/** decoded symbol coarse orientation. + * @since 0.11 + */ +typedef enum zbar_orientation_e +{ + ZBAR_ORIENT_UNKNOWN = -1, /**< unable to determine orientation */ + ZBAR_ORIENT_UP, /**< upright, read left to right */ + ZBAR_ORIENT_RIGHT, /**< sideways, read top to bottom */ + ZBAR_ORIENT_DOWN, /**< upside-down, read right to left */ + ZBAR_ORIENT_LEFT, /**< sideways, read bottom to top */ +} zbar_orientation_t; + +/** error codes. */ +typedef enum zbar_error_e +{ + ZBAR_OK = 0, /**< no error */ + ZBAR_ERR_NOMEM, /**< out of memory */ + ZBAR_ERR_INTERNAL, /**< internal library error */ + ZBAR_ERR_UNSUPPORTED, /**< unsupported request */ + ZBAR_ERR_INVALID, /**< invalid request */ + ZBAR_ERR_SYSTEM, /**< system error */ + ZBAR_ERR_LOCKING, /**< locking error */ + ZBAR_ERR_BUSY, /**< all resources busy */ + ZBAR_ERR_XDISPLAY, /**< X11 display error */ + ZBAR_ERR_XPROTO, /**< X11 protocol error */ + ZBAR_ERR_CLOSED, /**< output window is closed */ + ZBAR_ERR_WINAPI, /**< windows system error */ + ZBAR_ERR_NUM /**< number of error codes */ +} zbar_error_t; + +/** decoder configuration options. + * @since 0.4 + */ +typedef enum zbar_config_e +{ + ZBAR_CFG_ENABLE = 0, /**< enable symbology/feature */ + ZBAR_CFG_ADD_CHECK, /**< enable check digit when optional */ + ZBAR_CFG_EMIT_CHECK, /**< return check digit when present */ + ZBAR_CFG_ASCII, /**< enable full ASCII character set */ + ZBAR_CFG_BINARY, /**< don't convert binary data to text */ + ZBAR_CFG_NUM, /**< number of boolean decoder configs */ + + ZBAR_CFG_MIN_LEN = 0x20, /**< minimum data length for valid decode */ + ZBAR_CFG_MAX_LEN, /**< maximum data length for valid decode */ + + ZBAR_CFG_UNCERTAINTY = 0x40, /**< required video consistency frames */ + + ZBAR_CFG_POSITION = 0x80, /**< enable scanner to collect position data */ + ZBAR_CFG_TEST_INVERTED, /**< if fails to decode, test inverted */ + + ZBAR_CFG_X_DENSITY = 0x100, /**< image scanner vertical scan density */ + ZBAR_CFG_Y_DENSITY, /**< image scanner horizontal scan density */ +} zbar_config_t; + +/** decoder symbology modifier flags. + * @since 0.11 + */ +typedef enum zbar_modifier_e +{ + /** barcode tagged as GS1 (EAN.UCC) reserved + * (eg, FNC1 before first data character). + * data may be parsed as a sequence of GS1 AIs + */ + ZBAR_MOD_GS1 = 0, + + /** barcode tagged as AIM reserved + * (eg, FNC1 after first character or digit pair) + */ + ZBAR_MOD_AIM, + + /** number of modifiers */ + ZBAR_MOD_NUM, +} zbar_modifier_t; + +typedef enum video_control_type_e +{ + VIDEO_CNTL_INTEGER = 1, + VIDEO_CNTL_MENU, + VIDEO_CNTL_BUTTON, + VIDEO_CNTL_INTEGER64, + VIDEO_CNTL_STRING, + VIDEO_CNTL_BOOLEAN, +} video_control_type_t; + +/** store video control menu + * @param name name of the menu item + * @param val integer value associated with the item + */ +typedef struct video_control_menu_s { + char *name; + int64_t value; +} video_control_menu_t; + +/** store video controls + * @param name name of the control + * @param group name of the control group/class + * @param type type of the control + * @param min minimum value of control (if control is integer) + * @param max maximum value of control (if control is integer) + * @param def default value of control (if control is integer) + * @param step increment steps (if control is integer) + * @param menu menu array + * @param menu_size menu size + * @since 0.20 + */ +typedef struct video_controls_s { + char *name; + char *group; + video_control_type_t type; + + int64_t min, max, def; + uint64_t step; + + unsigned int menu_size; + video_control_menu_t *menu; + + void *next; + + // video drivers may add extra private data in the end of this struct +} video_controls_t; + +/** store a video resolution + * @param width width of the video window + * @param height length of the video window + * @param max_fps maximum streaming speed, in frames per second + * @since 0.22 + */ +struct video_resolution_s { + unsigned int width, height; + float max_fps; +}; + +/** retrieve runtime library version information. + * @param major set to the running major version (unless NULL) + * @param minor set to the running minor version (unless NULL) + * @returns 0 + */ +extern int zbar_version(unsigned *major, unsigned *minor, unsigned *patch); + +/** set global library debug level. + * @param verbosity desired debug level. higher values create more spew + */ +extern void zbar_set_verbosity(int verbosity); + +/** increase global library debug level. + * eg, for -vvvv + */ +extern void zbar_increase_verbosity(void); + +/** retrieve string name for symbol encoding. + * @param sym symbol type encoding + * @returns the static string name for the specified symbol type, + * or "UNKNOWN" if the encoding is not recognized + */ +extern const char *zbar_get_symbol_name(zbar_symbol_type_t sym); + +/** retrieve string name for addon encoding. + * @param sym symbol type encoding + * @returns static string name for any addon, or the empty string + * if no addons were decoded + * @deprecated in 0.11 + */ +extern const char *zbar_get_addon_name(zbar_symbol_type_t sym); + +/** retrieve string name for configuration setting. + * @param config setting to name + * @returns static string name for config, + * or the empty string if value is not a known config + */ +extern const char *zbar_get_config_name(zbar_config_t config); + +/** retrieve string name for modifier. + * @param modifier flag to name + * @returns static string name for modifier, + * or the empty string if the value is not a known flag + */ +extern const char *zbar_get_modifier_name(zbar_modifier_t modifier); + +/** retrieve string name for orientation. + * @param orientation orientation encoding + * @returns the static string name for the specified orientation, + * or "UNKNOWN" if the orientation is not recognized + * @since 0.11 + */ +extern const char *zbar_get_orientation_name(zbar_orientation_t orientation); + +/** parse a configuration string of the form "[symbology.]config[=value]". + * the config must match one of the recognized names. + * the symbology, if present, must match one of the recognized names. + * if symbology is unspecified, it will be set to 0. + * if value is unspecified it will be set to 1. + * @returns 0 if the config is parsed successfully, 1 otherwise + * @since 0.4 + */ +extern int zbar_parse_config(const char *config_string, + zbar_symbol_type_t *symbology, + zbar_config_t *config, int *value); + +/** consistently compute fourcc values across architectures + * (adapted from v4l2 specification) + * @since 0.11 + */ +#define zbar_fourcc(a, b, c, d) \ + ((unsigned long)(a) | ((unsigned long)(b) << 8) | \ + ((unsigned long)(c) << 16) | ((unsigned long)(d) << 24)) + +/** parse a fourcc string into its encoded integer value. + * @since 0.11 + */ +static inline unsigned long zbar_fourcc_parse(const char *format) +{ + unsigned long fourcc = 0; + if (format) { + int i; + for (i = 0; i < 4 && format[i]; i++) + fourcc |= ((unsigned long)format[i]) << (i * 8); + } + return (fourcc); +} + +/** @internal type unsafe error API (don't use) */ +extern int _zbar_error_spew(const void *object, int verbosity); +extern const char *_zbar_error_string(const void *object, int verbosity); +extern zbar_error_t _zbar_get_error_code(const void *object); + +/*@}*/ + +struct zbar_symbol_s; +typedef struct zbar_symbol_s zbar_symbol_t; + +struct zbar_symbol_set_s; +typedef struct zbar_symbol_set_s zbar_symbol_set_t; + +/*------------------------------------------------------------*/ +/** @name Symbol interface + * decoded barcode symbol result object. stores type, data, and image + * location of decoded symbol. all memory is owned by the library + */ +/*@{*/ + +/** @typedef zbar_symbol_t + * opaque decoded symbol object. + */ + +/** symbol reference count manipulation. + * increment the reference count when you store a new reference to the + * symbol. decrement when the reference is no longer used. do not + * refer to the symbol once the count is decremented and the + * containing image has been recycled or destroyed. + * @note the containing image holds a reference to the symbol, so you + * only need to use this if you keep a symbol after the image has been + * destroyed or reused. + * @since 0.9 + */ +extern void zbar_symbol_ref(const zbar_symbol_t *symbol, int refs); + +/** retrieve type of decoded symbol. + * @returns the symbol type + */ +extern zbar_symbol_type_t zbar_symbol_get_type(const zbar_symbol_t *symbol); + +/** retrieve symbology boolean config settings. + * @returns a bitmask indicating which configs were set for the detected + * symbology during decoding. + * @since 0.11 + */ +extern unsigned int zbar_symbol_get_configs(const zbar_symbol_t *symbol); + +/** retrieve symbology modifier flag settings. + * @returns a bitmask indicating which characteristics were detected + * during decoding. + * @since 0.11 + */ +extern unsigned int zbar_symbol_get_modifiers(const zbar_symbol_t *symbol); + +/** retrieve data decoded from symbol. + * @returns the data string + */ +extern const char *zbar_symbol_get_data(const zbar_symbol_t *symbol); + +/** retrieve length of binary data. + * @returns the length of the decoded data + */ +extern unsigned int zbar_symbol_get_data_length(const zbar_symbol_t *symbol); + +/** retrieve a symbol confidence metric. + * @returns an unscaled, relative quantity: larger values are better + * than smaller values, where "large" and "small" are application + * dependent. + * @note expect the exact definition of this quantity to change as the + * metric is refined. currently, only the ordered relationship + * between two values is defined and will remain stable in the future + * @since 0.9 + */ +extern int zbar_symbol_get_quality(const zbar_symbol_t *symbol); + +/** retrieve current cache count. when the cache is enabled for the + * image_scanner this provides inter-frame reliability and redundancy + * information for video streams. + * @returns < 0 if symbol is still uncertain. + * @returns 0 if symbol is newly verified. + * @returns > 0 for duplicate symbols + */ +extern int zbar_symbol_get_count(const zbar_symbol_t *symbol); + +/** retrieve the number of points in the location polygon. the + * location polygon defines the image area that the symbol was + * extracted from. + * @returns the number of points in the location polygon + * @note this is currently not a polygon, but the scan locations + * where the symbol was decoded + */ +extern unsigned zbar_symbol_get_loc_size(const zbar_symbol_t *symbol); + +/** retrieve location polygon x-coordinates. + * points are specified by 0-based index. + * @returns the x-coordinate for a point in the location polygon. + * @returns -1 if index is out of range + */ +extern int zbar_symbol_get_loc_x(const zbar_symbol_t *symbol, unsigned index); + +/** retrieve location polygon y-coordinates. + * points are specified by 0-based index. + * @returns the y-coordinate for a point in the location polygon. + * @returns -1 if index is out of range + */ +extern int zbar_symbol_get_loc_y(const zbar_symbol_t *symbol, unsigned index); + +/** retrieve general orientation of decoded symbol. + * @returns a coarse, axis-aligned indication of symbol orientation or + * ::ZBAR_ORIENT_UNKNOWN if unknown + * @since 0.11 + */ +extern zbar_orientation_t +zbar_symbol_get_orientation(const zbar_symbol_t *symbol); + +/** iterate the set to which this symbol belongs (there can be only one). + * @returns the next symbol in the set, or + * @returns NULL when no more results are available + */ +extern const zbar_symbol_t *zbar_symbol_next(const zbar_symbol_t *symbol); + +/** retrieve components of a composite result. + * @returns the symbol set containing the components + * @returns NULL if the symbol is already a physical symbol + * @since 0.10 + */ +extern const zbar_symbol_set_t * +zbar_symbol_get_components(const zbar_symbol_t *symbol); + +/** iterate components of a composite result. + * @returns the first physical component symbol of a composite result + * @returns NULL if the symbol is already a physical symbol + * @since 0.10 + */ +extern const zbar_symbol_t * +zbar_symbol_first_component(const zbar_symbol_t *symbol); + +/** print XML symbol element representation to user result buffer. + * @see http://zbar.sourceforge.net/2008/barcode.xsd for the schema. + * @param symbol is the symbol to print + * @param buffer is the inout result pointer, it will be reallocated + * with a larger size if necessary. + * @param buflen is inout length of the result buffer. + * @returns the buffer pointer + * @since 0.6 + */ +extern char *zbar_symbol_xml(const zbar_symbol_t *symbol, char **buffer, + unsigned *buflen); + +/*@}*/ + +/*------------------------------------------------------------*/ +/** @name Symbol Set interface + * container for decoded result symbols associated with an image + * or a composite symbol. + * @since 0.10 + */ +/*@{*/ + +/** @typedef zbar_symbol_set_t + * opaque symbol iterator object. + * @since 0.10 + */ + +/** reference count manipulation. + * increment the reference count when you store a new reference. + * decrement when the reference is no longer used. do not refer to + * the object any longer once references have been released. + * @since 0.10 + */ +extern void zbar_symbol_set_ref(const zbar_symbol_set_t *symbols, int refs); + +/** retrieve set size. + * @returns the number of symbols in the set. + * @since 0.10 + */ +extern int zbar_symbol_set_get_size(const zbar_symbol_set_t *symbols); + +/** set iterator. + * @returns the first decoded symbol result in a set + * @returns NULL if the set is empty + * @since 0.10 + */ +extern const zbar_symbol_t * +zbar_symbol_set_first_symbol(const zbar_symbol_set_t *symbols); + +/** raw result iterator. + * @returns the first decoded symbol result in a set, *before* filtering + * @returns NULL if the set is empty + * @since 0.11 + */ +extern const zbar_symbol_t * +zbar_symbol_set_first_unfiltered(const zbar_symbol_set_t *symbols); + +/*@}*/ + +/*------------------------------------------------------------*/ +/** @name Image interface + * stores image data samples along with associated format and size + * metadata + */ +/*@{*/ + +struct zbar_image_s; +/** + * zbar_image_t: opaque image object. + */ +typedef struct zbar_image_s zbar_image_t; + +/** cleanup handler callback function. + * called to free sample data when an image is destroyed. + */ +typedef void(zbar_image_cleanup_handler_t)(zbar_image_t *image); + +/** data handler callback function. + * called when decoded symbol results are available for an image + */ +typedef void(zbar_image_data_handler_t)(zbar_image_t *image, + const void *userdata); + +/** new image constructor. + * @returns a new image object with uninitialized data and format. + * this image should be destroyed (using zbar_image_destroy()) as + * soon as the application is finished with it + */ +extern zbar_image_t *zbar_image_create(void); + +/** image destructor. all images created by or returned to the + * application should be destroyed using this function. when an image + * is destroyed, the associated data cleanup handler will be invoked + * if available + * @note make no assumptions about the image or the data buffer. + * they may not be destroyed/cleaned immediately if the library + * is still using them. if necessary, use the cleanup handler hook + * to keep track of image data buffers + */ +extern void zbar_image_destroy(zbar_image_t *image); + +/** image reference count manipulation. + * increment the reference count when you store a new reference to the + * image. decrement when the reference is no longer used. do not + * refer to the image any longer once the count is decremented. + * zbar_image_ref(image, -1) is the same as zbar_image_destroy(image) + * @since 0.5 + */ +extern void zbar_image_ref(zbar_image_t *image, int refs); + +/** image format conversion. refer to the documentation for supported + * image formats + * @returns a @em new image with the sample data from the original image + * converted to the requested format. the original image is + * unaffected. + * @note the converted image size may be rounded (up) due to format + * constraints + */ +extern zbar_image_t *zbar_image_convert(const zbar_image_t *image, + unsigned long format); + +/** image format conversion with crop/pad. + * if the requested size is larger than the image, the last row/column + * are duplicated to cover the difference. if the requested size is + * smaller than the image, the extra rows/columns are dropped from the + * right/bottom. + * @returns a @em new image with the sample data from the original + * image converted to the requested format and size. + * @note the image is @em not scaled + * @see zbar_image_convert() + * @since 0.4 + */ +extern zbar_image_t *zbar_image_convert_resize(const zbar_image_t *image, + unsigned long format, + unsigned width, unsigned height); + +/** retrieve the image format. + * @returns the fourcc describing the format of the image sample data + */ +extern unsigned long zbar_image_get_format(const zbar_image_t *image); + +/** retrieve a "sequence" (page/frame) number associated with this image. + * @since 0.6 + */ +extern unsigned zbar_image_get_sequence(const zbar_image_t *image); + +/** retrieve the width of the image. + * @returns the width in sample columns + */ +extern unsigned zbar_image_get_width(const zbar_image_t *image); + +/** retrieve the height of the image. + * @returns the height in sample rows + */ +extern unsigned zbar_image_get_height(const zbar_image_t *image); + +/** retrieve both dimensions of the image. + * fills in the width and height in samples + */ +extern void zbar_image_get_size(const zbar_image_t *image, unsigned *width, + unsigned *height); + +/** retrieve the crop rectangle. + * fills in the image coordinates of the upper left corner and size + * of an axis-aligned rectangular area of the image that will be scanned. + * defaults to the full image + * @since 0.11 + */ +extern void zbar_image_get_crop(const zbar_image_t *image, unsigned *x, + unsigned *y, unsigned *width, unsigned *height); + +/** return the image sample data. the returned data buffer is only + * valid until zbar_image_destroy() is called + */ +extern const void *zbar_image_get_data(const zbar_image_t *image); + +/** return the size of image data. + * @since 0.6 + */ +extern unsigned long zbar_image_get_data_length(const zbar_image_t *img); + +/** retrieve the decoded results. + * @returns the (possibly empty) set of decoded symbols + * @returns NULL if the image has not been scanned + * @since 0.10 + */ +extern const zbar_symbol_set_t * +zbar_image_get_symbols(const zbar_image_t *image); + +/** associate the specified symbol set with the image, replacing any + * existing results. use NULL to release the current results from the + * image. + * @see zbar_image_scanner_recycle_image() + * @since 0.10 + */ +extern void zbar_image_set_symbols(zbar_image_t *image, + const zbar_symbol_set_t *symbols); + +/** image_scanner decode result iterator. + * @returns the first decoded symbol result for an image + * or NULL if no results are available + */ +extern const zbar_symbol_t *zbar_image_first_symbol(const zbar_image_t *image); + +/** specify the fourcc image format code for image sample data. + * refer to the documentation for supported formats. + * @note this does not convert the data! + * (see zbar_image_convert() for that) + */ +extern void zbar_image_set_format(zbar_image_t *image, unsigned long format); + +/** associate a "sequence" (page/frame) number with this image. + * @since 0.6 + */ +extern void zbar_image_set_sequence(zbar_image_t *image, unsigned sequence_num); + +/** specify the pixel size of the image. + * @note this also resets the crop rectangle to the full image + * (0, 0, width, height) + * @note this does not affect the data! + */ +extern void zbar_image_set_size(zbar_image_t *image, unsigned width, + unsigned height); + +/** specify a rectangular region of the image to scan. + * the rectangle will be clipped to the image boundaries. + * defaults to the full image specified by zbar_image_set_size() + */ +extern void zbar_image_set_crop(zbar_image_t *image, unsigned x, unsigned y, + unsigned width, unsigned height); + +/** specify image sample data. when image data is no longer needed by + * the library the specific data cleanup handler will be called + * (unless NULL) + * @note application image data will not be modified by the library + */ +extern void zbar_image_set_data(zbar_image_t *image, const void *data, + unsigned long data_byte_length, + zbar_image_cleanup_handler_t *cleanup_hndlr); + +/** built-in cleanup handler. + * passes the image data buffer to free() + */ +extern void zbar_image_free_data(zbar_image_t *image); + +/** associate user specified data value with an image. + * @since 0.5 + */ +extern void zbar_image_set_userdata(zbar_image_t *image, void *userdata); + +/** return user specified data value associated with the image. + * @since 0.5 + */ +extern void *zbar_image_get_userdata(const zbar_image_t *image); + +/** dump raw image data to a file for debug. + * the data will be prefixed with a 16 byte header consisting of: + * - 4 bytes uint = 0x676d697a ("zimg") + * - 4 bytes format fourcc + * - 2 bytes width + * - 2 bytes height + * - 4 bytes size of following image data in bytes + * this header can be dumped w/eg: + * @verbatim + od -Ax -tx1z -N16 -w4 [file] +@endverbatim + * for some formats the image can be displayed/converted using + * ImageMagick, eg: + * @verbatim + display -size 640x480+16 [-depth ?] [-sampling-factor ?x?] \ + {GRAY,RGB,UYVY,YUV}:[file] +@endverbatim + * + * @param image the image object to dump + * @param filebase base filename, appended with ".XXXX.zimg" where + * XXXX is the format fourcc + * @returns 0 on success or a system error code on failure + */ +extern int zbar_image_write(const zbar_image_t *image, const char *filebase); + +/** read back an image in the format written by zbar_image_write() + * @note TBD + */ +extern zbar_image_t *zbar_image_read(char *filename); + +/*@}*/ + +/*------------------------------------------------------------*/ +/** @name Processor interface + * @anchor c-processor + * high-level self-contained image processor. + * processes video and images for barcodes, optionally displaying + * images to a library owned output window + */ +/*@{*/ + +struct zbar_processor_s; +/** opaque standalone processor object. */ +typedef struct zbar_processor_s zbar_processor_t; + +/** constructor. + * if threaded is set and threading is available the processor + * will spawn threads where appropriate to avoid blocking and + * improve responsiveness + */ +extern zbar_processor_t *zbar_processor_create(int threaded); + +/** destructor. cleans up all resources associated with the processor + */ +extern void zbar_processor_destroy(zbar_processor_t *processor); + +/** (re)initialization. + * opens a video input device and/or prepares to display output + */ +extern int zbar_processor_init(zbar_processor_t *processor, + const char *video_device, int enable_display); + +/** request a preferred size for the video image from the device. + * the request may be adjusted or completely ignored by the driver. + * @note must be called before zbar_processor_init() + * @since 0.6 + */ +extern int zbar_processor_request_size(zbar_processor_t *processor, + unsigned width, unsigned height); + +/** request a preferred video driver interface version for + * debug/testing. + * @note must be called before zbar_processor_init() + * @since 0.6 + */ +extern int zbar_processor_request_interface(zbar_processor_t *processor, + int version); + +/** request a preferred video I/O mode for debug/testing. You will + * get errors if the driver does not support the specified mode. + * @verbatim + 0 = auto-detect + 1 = force I/O using read() + 2 = force memory mapped I/O using mmap() + 3 = force USERPTR I/O (v4l2 only) +@endverbatim + * @note must be called before zbar_processor_init() + * @since 0.7 + */ +extern int zbar_processor_request_iomode(zbar_processor_t *video, int iomode); + +/** force specific input and output formats for debug/testing. + * @note must be called before zbar_processor_init() + */ +extern int zbar_processor_force_format(zbar_processor_t *processor, + unsigned long input_format, + unsigned long output_format); + +/** setup result handler callback. + * the specified function will be called by the processor whenever + * new results are available from the video stream or a static image. + * pass a NULL value to disable callbacks. + * @param processor the object on which to set the handler. + * @param handler the function to call when new results are available. + * @param userdata is set as with zbar_processor_set_userdata(). + * @returns the previously registered handler + */ +extern zbar_image_data_handler_t * +zbar_processor_set_data_handler(zbar_processor_t *processor, + zbar_image_data_handler_t *handler, + const void *userdata); + +/** associate user specified data value with the processor. + * @since 0.6 + */ +extern void zbar_processor_set_userdata(zbar_processor_t *processor, + void *userdata); + +/** return user specified data value associated with the processor. + * @since 0.6 + */ +extern void *zbar_processor_get_userdata(const zbar_processor_t *processor); + +/** set config for indicated symbology (0 for all) to specified value. + * @returns 0 for success, non-0 for failure (config does not apply to + * specified symbology, or value out of range) + * @see zbar_decoder_set_config() + * @since 0.4 + */ +extern int zbar_processor_set_config(zbar_processor_t *processor, + zbar_symbol_type_t symbology, + zbar_config_t config, int value); + +/** set video control value + * @returns 0 for success, non-0 for failure + * @since 0.20 + * @see zbar_video_set_control() + */ +extern int zbar_processor_set_control(zbar_processor_t *processor, + const char *control_name, int value); + +/** get video control value + * @returns 0 for success, non-0 for failure + * @since 0.20 + * @see zbar_video_get_control() + */ +extern int zbar_processor_get_control(zbar_processor_t *processor, + const char *control_name, int *value); + +/** parse configuration string using zbar_parse_config() + * and apply to processor using zbar_processor_set_config(). + * @returns 0 for success, non-0 for failure + * @see zbar_parse_config() + * @see zbar_processor_set_config() + * @since 0.4 + */ +static inline int zbar_processor_parse_config(zbar_processor_t *processor, + const char *config_string) +{ + zbar_symbol_type_t sym; + zbar_config_t cfg; + int val; + return (zbar_parse_config(config_string, &sym, &cfg, &val) || + zbar_processor_set_config(processor, sym, cfg, val)); +} + +/** retrieve the current state of the output window. + * @returns 1 if the output window is currently displayed, 0 if not. + * @returns -1 if an error occurs + */ +extern int zbar_processor_is_visible(zbar_processor_t *processor); + +/** show or hide the display window owned by the library. + * the size will be adjusted to the input size + */ +extern int zbar_processor_set_visible(zbar_processor_t *processor, int visible); + +/** control the processor in free running video mode. + * only works if video input is initialized. if threading is in use, + * scanning will occur in the background, otherwise this is only + * useful wrapping calls to zbar_processor_user_wait(). if the + * library output window is visible, video display will be enabled. + */ +extern int zbar_processor_set_active(zbar_processor_t *processor, int active); + +/** retrieve decode results for last scanned image/frame. + * @returns the symbol set result container or NULL if no results are + * available + * @note the returned symbol set has its reference count incremented; + * ensure that the count is decremented after use + * @since 0.10 + */ +extern const zbar_symbol_set_t * +zbar_processor_get_results(const zbar_processor_t *processor); + +/** wait for input to the display window from the user + * (via mouse or keyboard). + * @returns >0 when input is received, 0 if timeout ms expired + * with no input or -1 in case of an error + */ +extern int zbar_processor_user_wait(zbar_processor_t *processor, int timeout); + +/** process from the video stream until a result is available, + * or the timeout (in milliseconds) expires. + * specify a timeout of -1 to scan indefinitely + * (zbar_processor_set_active() may still be used to abort the scan + * from another thread). + * if the library window is visible, video display will be enabled. + * @note that multiple results may still be returned (despite the + * name). + * @returns >0 if symbols were successfully decoded, + * 0 if no symbols were found (ie, the timeout expired) + * or -1 if an error occurs + */ +extern int zbar_process_one(zbar_processor_t *processor, int timeout); + +/** process the provided image for barcodes. + * if the library window is visible, the image will be displayed. + * @returns >0 if symbols were successfully decoded, + * 0 if no symbols were found or -1 if an error occurs + */ +extern int zbar_process_image(zbar_processor_t *processor, zbar_image_t *image); + +/** enable dbus IPC API. + * @returns 0 successful + */ +int zbar_processor_request_dbus(zbar_processor_t *proc, int req_dbus_enabled); + +/** display detail for last processor error to stderr. + * @returns a non-zero value suitable for passing to exit() + */ +static inline int zbar_processor_error_spew(const zbar_processor_t *processor, + int verbosity) +{ + return (_zbar_error_spew(processor, verbosity)); +} + +/** retrieve the detail string for the last processor error. */ +static inline const char * +zbar_processor_error_string(const zbar_processor_t *processor, int verbosity) +{ + return (_zbar_error_string(processor, verbosity)); +} + +/** retrieve the type code for the last processor error. */ +static inline zbar_error_t +zbar_processor_get_error_code(const zbar_processor_t *processor) +{ + return (_zbar_get_error_code(processor)); +} + +/*@}*/ + +/*------------------------------------------------------------*/ +/** @name Video interface + * @anchor c-video + * mid-level video source abstraction. + * captures images from a video device + */ +/*@{*/ + +struct zbar_video_s; +/** opaque video object. */ +typedef struct zbar_video_s zbar_video_t; + +/** constructor. */ +extern zbar_video_t *zbar_video_create(void); + +/** destructor. */ +extern void zbar_video_destroy(zbar_video_t *video); + +/** open and probe a video device. + * the device specified by platform specific unique name + * (v4l device node path in *nix eg "/dev/video", + * DirectShow DevicePath property in windows). + * @returns 0 if successful or -1 if an error occurs + */ +extern int zbar_video_open(zbar_video_t *video, const char *device); + +/** retrieve file descriptor associated with open *nix video device + * useful for using select()/poll() to tell when new images are + * available (NB v4l2 only!!). + * @returns the file descriptor or -1 if the video device is not open + * or the driver only supports v4l1 + */ +extern int zbar_video_get_fd(const zbar_video_t *video); + +/** request a preferred size for the video image from the device. + * the request may be adjusted or completely ignored by the driver. + * @returns 0 if successful or -1 if the video device is already + * initialized + * @since 0.6 + */ +extern int zbar_video_request_size(zbar_video_t *video, unsigned width, + unsigned height); + +/** request a preferred driver interface version for debug/testing. + * @note must be called before zbar_video_open() + * @since 0.6 + */ +extern int zbar_video_request_interface(zbar_video_t *video, int version); + +/** request a preferred I/O mode for debug/testing. You will get + * errors if the driver does not support the specified mode. + * @verbatim + 0 = auto-detect + 1 = force I/O using read() + 2 = force memory mapped I/O using mmap() + 3 = force USERPTR I/O (v4l2 only) +@endverbatim + * @note must be called before zbar_video_open() + * @since 0.7 + */ +extern int zbar_video_request_iomode(zbar_video_t *video, int iomode); + +/** retrieve current output image width. + * @returns the width or 0 if the video device is not open + */ +extern int zbar_video_get_width(const zbar_video_t *video); + +/** retrieve current output image height. + * @returns the height or 0 if the video device is not open + */ +extern int zbar_video_get_height(const zbar_video_t *video); + +/** initialize video using a specific format for debug. + * use zbar_negotiate_format() to automatically select and initialize + * the best available format + */ +extern int zbar_video_init(zbar_video_t *video, unsigned long format); + +/** start/stop video capture. + * all buffered images are retired when capture is disabled. + * @returns 0 if successful or -1 if an error occurs + */ +extern int zbar_video_enable(zbar_video_t *video, int enable); + +/** retrieve next captured image. blocks until an image is available. + * @returns NULL if video is not enabled or an error occurs + */ +extern zbar_image_t *zbar_video_next_image(zbar_video_t *video); + +/** set video control value (integer). + * @returns 0 for success, non-0 for failure + * @since 0.20 + * @see zbar_processor_set_control() + */ +extern int zbar_video_set_control(zbar_video_t *video, const char *control_name, + int value); + +/** get video control value (integer). + * @returns 0 for success, non-0 for failure + * @since 0.20 + * @see zbar_processor_get_control() + */ +extern int zbar_video_get_control(zbar_video_t *video, const char *control_name, + int *value); + +/** get available controls from video source + * @returns 0 for success, non-0 for failure + * @since 0.20 + */ +extern struct video_controls_s * +zbar_video_get_controls(const zbar_video_t *video, int index); + +/** get available video resolutions from video source + * @returns 0 for success, non-0 for failure + * @since 0.22 + */ +extern struct video_resolution_s * +zbar_video_get_resolutions(const zbar_video_t *vdo, int index); + +/** display detail for last video error to stderr. + * @returns a non-zero value suitable for passing to exit() + */ +static inline int zbar_video_error_spew(const zbar_video_t *video, + int verbosity) +{ + return (_zbar_error_spew(video, verbosity)); +} + +/** retrieve the detail string for the last video error. */ +static inline const char *zbar_video_error_string(const zbar_video_t *video, + int verbosity) +{ + return (_zbar_error_string(video, verbosity)); +} + +/** retrieve the type code for the last video error. */ +static inline zbar_error_t zbar_video_get_error_code(const zbar_video_t *video) +{ + return (_zbar_get_error_code(video)); +} + +/*@}*/ + +/*------------------------------------------------------------*/ +/** @name Window interface + * @anchor c-window + * mid-level output window abstraction. + * displays images to user-specified platform specific output window + */ +/*@{*/ + +struct zbar_window_s; +/** opaque window object. */ +typedef struct zbar_window_s zbar_window_t; + +/** constructor. */ +extern zbar_window_t *zbar_window_create(void); + +/** destructor. */ +extern void zbar_window_destroy(zbar_window_t *window); + +/** associate reader with an existing platform window. + * This can be any "Drawable" for X Windows or a "HWND" for windows. + * input images will be scaled into the output window. + * pass NULL to detach from the resource, further input will be + * ignored + */ +extern int zbar_window_attach(zbar_window_t *window, void *x11_display_w32_hwnd, + unsigned long x11_drawable); + +/** control content level of the reader overlay. + * the overlay displays graphical data for informational or debug + * purposes. higher values increase the level of annotation (possibly + * decreasing performance). @verbatim + 0 = disable overlay + 1 = outline decoded symbols (default) + 2 = also track and display input frame rate +@endverbatim + */ +extern void zbar_window_set_overlay(zbar_window_t *window, int level); + +/** retrieve current content level of reader overlay. + * @see zbar_window_set_overlay() + * @since 0.10 + */ +extern int zbar_window_get_overlay(const zbar_window_t *window); + +/** draw a new image into the output window. */ +extern int zbar_window_draw(zbar_window_t *window, zbar_image_t *image); + +/** redraw the last image (exposure handler). */ +extern int zbar_window_redraw(zbar_window_t *window); + +/** resize the image window (reconfigure handler). + * this does @em not update the contents of the window + * @since 0.3, changed in 0.4 to not redraw window + */ +extern int zbar_window_resize(zbar_window_t *window, unsigned width, + unsigned height); + +/** display detail for last window error to stderr. + * @returns a non-zero value suitable for passing to exit() + */ +static inline int zbar_window_error_spew(const zbar_window_t *window, + int verbosity) +{ + return (_zbar_error_spew(window, verbosity)); +} + +/** retrieve the detail string for the last window error. */ +static inline const char *zbar_window_error_string(const zbar_window_t *window, + int verbosity) +{ + return (_zbar_error_string(window, verbosity)); +} + +/** retrieve the type code for the last window error. */ +static inline zbar_error_t +zbar_window_get_error_code(const zbar_window_t *window) +{ + return (_zbar_get_error_code(window)); +} + +/** select a compatible format between video input and output window. + * the selection algorithm attempts to use a format shared by + * video input and window output which is also most useful for + * barcode scanning. if a format conversion is necessary, it will + * heuristically attempt to minimize the cost of the conversion + */ +extern int zbar_negotiate_format(zbar_video_t *video, zbar_window_t *window); + +/*@}*/ + +/*------------------------------------------------------------*/ +/** @name Image Scanner interface + * @anchor c-imagescanner + * mid-level image scanner interface. + * reads barcodes from 2-D images + */ +/*@{*/ + +struct zbar_image_scanner_s; +/** opaque image scanner object. */ +typedef struct zbar_image_scanner_s zbar_image_scanner_t; + +/** constructor. */ +extern zbar_image_scanner_t *zbar_image_scanner_create(void); + +/** destructor. */ +extern void zbar_image_scanner_destroy(zbar_image_scanner_t *scanner); + +/** setup result handler callback. + * the specified function will be called by the scanner whenever + * new results are available from a decoded image. + * pass a NULL value to disable callbacks. + * @returns the previously registered handler + */ +extern zbar_image_data_handler_t * +zbar_image_scanner_set_data_handler(zbar_image_scanner_t *scanner, + zbar_image_data_handler_t *handler, + const void *userdata); + +/** request sending decoded codes via D-Bus + * @see zbar_processor_parse_config() + * @since 0.21 + */ +extern int zbar_image_scanner_request_dbus(zbar_image_scanner_t *scanner, + int req_dbus_enabled); + +/** set config for indicated symbology (0 for all) to specified value. + * @returns 0 for success, non-0 for failure (config does not apply to + * specified symbology, or value out of range) + * @see zbar_decoder_set_config() + * @since 0.4 + */ +extern int zbar_image_scanner_set_config(zbar_image_scanner_t *scanner, + zbar_symbol_type_t symbology, + zbar_config_t config, int value); + +/** get config for indicated symbology + * @returns 0 for success, non-0 for failure (config does not apply to + * specified symbology, or value out of range). On success, *value is filled. + * @since 0.22 + */ +extern int zbar_image_scanner_get_config(zbar_image_scanner_t *scanner, + zbar_symbol_type_t symbology, + zbar_config_t config, int *value); + +/** parse configuration string using zbar_parse_config() + * and apply to image scanner using zbar_image_scanner_set_config(). + * @returns 0 for success, non-0 for failure + * @see zbar_parse_config() + * @see zbar_image_scanner_set_config() + * @since 0.4 + */ +static inline int zbar_image_scanner_parse_config(zbar_image_scanner_t *scanner, + const char *config_string) +{ + zbar_symbol_type_t sym; + zbar_config_t cfg; + int val; + return (zbar_parse_config(config_string, &sym, &cfg, &val) || + zbar_image_scanner_set_config(scanner, sym, cfg, val)); +} + +/** enable or disable the inter-image result cache (default disabled). + * mostly useful for scanning video frames, the cache filters + * duplicate results from consecutive images, while adding some + * consistency checking and hysteresis to the results. + * this interface also clears the cache + */ +extern void zbar_image_scanner_enable_cache(zbar_image_scanner_t *scanner, + int enable); + +/** remove any previously decoded results from the image scanner and the + * specified image. somewhat more efficient version of + * zbar_image_set_symbols(image, NULL) which may retain memory for + * subsequent decodes + * @since 0.10 + */ +extern void zbar_image_scanner_recycle_image(zbar_image_scanner_t *scanner, + zbar_image_t *image); + +/** retrieve decode results for last scanned image. + * @returns the symbol set result container or NULL if no results are + * available + * @note the symbol set does not have its reference count adjusted; + * ensure that the count is incremented if the results may be kept + * after the next image is scanned + * @since 0.10 + */ +extern const zbar_symbol_set_t * +zbar_image_scanner_get_results(const zbar_image_scanner_t *scanner); + +/** scan for symbols in provided image. The image format must be + * "Y800" or "GRAY". + * @returns >0 if symbols were successfully decoded from the image, + * 0 if no symbols were found or -1 if an error occurs + * @see zbar_image_convert() + * @since 0.9 - changed to only accept grayscale images + */ +extern int zbar_scan_image(zbar_image_scanner_t *scanner, zbar_image_t *image); + +/*@}*/ + +/*------------------------------------------------------------*/ +/** @name Decoder interface + * @anchor c-decoder + * low-level bar width stream decoder interface. + * identifies symbols and extracts encoded data + */ +/*@{*/ + +struct zbar_decoder_s; +/** opaque decoder object. */ +typedef struct zbar_decoder_s zbar_decoder_t; + +/** decoder data handler callback function. + * called by decoder when new data has just been decoded + */ +typedef void(zbar_decoder_handler_t)(zbar_decoder_t *decoder); + +/** constructor. */ +extern zbar_decoder_t *zbar_decoder_create(void); + +/** destructor. */ +extern void zbar_decoder_destroy(zbar_decoder_t *decoder); + +/** set config for indicated symbology (0 for all) to specified value. + * @returns 0 for success, non-0 for failure (config does not apply to + * specified symbology, or value out of range) + * @since 0.4 + */ +extern int zbar_decoder_set_config(zbar_decoder_t *decoder, + zbar_symbol_type_t symbology, + zbar_config_t config, int value); + +/** get config for indicated symbology + * @returns 0 for success, non-0 for failure (config does not apply to + * specified symbology, or value out of range). On success, *value is filled. + * @since 0.22 + */ +extern int zbar_decoder_get_config(zbar_decoder_t *decoder, + zbar_symbol_type_t symbology, + zbar_config_t config, int *value); + +/** parse configuration string using zbar_parse_config() + * and apply to decoder using zbar_decoder_set_config(). + * @returns 0 for success, non-0 for failure + * @see zbar_parse_config() + * @see zbar_decoder_set_config() + * @since 0.4 + */ +static inline int zbar_decoder_parse_config(zbar_decoder_t *decoder, + const char *config_string) +{ + zbar_symbol_type_t sym; + zbar_config_t cfg; + int val; + return (zbar_parse_config(config_string, &sym, &cfg, &val) || + zbar_decoder_set_config(decoder, sym, cfg, val)); +} + +/** retrieve symbology boolean config settings. + * @returns a bitmask indicating which configs are currently set for the + * specified symbology. + * @since 0.11 + */ +extern unsigned int zbar_decoder_get_configs(const zbar_decoder_t *decoder, + zbar_symbol_type_t symbology); + +/** clear all decoder state. + * any partial symbols are flushed + */ +extern void zbar_decoder_reset(zbar_decoder_t *decoder); + +/** mark start of a new scan pass. + * clears any intra-symbol state and resets color to ::ZBAR_SPACE. + * any partially decoded symbol state is retained + */ +extern void zbar_decoder_new_scan(zbar_decoder_t *decoder); + +/** process next bar/space width from input stream. + * the width is in arbitrary relative units. first value of a scan + * is ::ZBAR_SPACE width, alternating from there. + * @returns appropriate symbol type if width completes + * decode of a symbol (data is available for retrieval) + * @returns ::ZBAR_PARTIAL as a hint if part of a symbol was decoded + * @returns ::ZBAR_NONE (0) if no new symbol data is available + */ +extern zbar_symbol_type_t zbar_decode_width(zbar_decoder_t *decoder, + unsigned width); + +/** retrieve color of @em next element passed to + * zbar_decode_width(). */ +extern zbar_color_t zbar_decoder_get_color(const zbar_decoder_t *decoder); + +/** retrieve last decoded data. + * @returns the data string or NULL if no new data available. + * the returned data buffer is owned by library, contents are only + * valid between non-0 return from zbar_decode_width and next library + * call + */ +extern const char *zbar_decoder_get_data(const zbar_decoder_t *decoder); + +/** retrieve length of binary data. + * @returns the length of the decoded data or 0 if no new data + * available. + */ +extern unsigned int zbar_decoder_get_data_length(const zbar_decoder_t *decoder); + +/** retrieve last decoded symbol type. + * @returns the type or ::ZBAR_NONE if no new data available + */ +extern zbar_symbol_type_t zbar_decoder_get_type(const zbar_decoder_t *decoder); + +/** retrieve modifier flags for the last decoded symbol. + * @returns a bitmask indicating which characteristics were detected + * during decoding. + * @since 0.11 + */ +extern unsigned int zbar_decoder_get_modifiers(const zbar_decoder_t *decoder); + +/** retrieve last decode direction. + * @returns 1 for forward and -1 for reverse + * @returns 0 if the decode direction is unknown or does not apply + * @since 0.11 + */ +extern int zbar_decoder_get_direction(const zbar_decoder_t *decoder); + +/** setup data handler callback. + * the registered function will be called by the decoder + * just before zbar_decode_width() returns a non-zero value. + * pass a NULL value to disable callbacks. + * @returns the previously registered handler + */ +extern zbar_decoder_handler_t * +zbar_decoder_set_handler(zbar_decoder_t *decoder, + zbar_decoder_handler_t *handler); + +/** associate user specified data value with the decoder. */ +extern void zbar_decoder_set_userdata(zbar_decoder_t *decoder, void *userdata); + +/** return user specified data value associated with the decoder. */ +extern void *zbar_decoder_get_userdata(const zbar_decoder_t *decoder); + +/*@}*/ + +/*------------------------------------------------------------*/ +/** @name Scanner interface + * @anchor c-scanner + * low-level linear intensity sample stream scanner interface. + * identifies "bar" edges and measures width between them. + * optionally passes to bar width decoder + */ +/*@{*/ + +struct zbar_scanner_s; +/** opaque scanner object. */ +typedef struct zbar_scanner_s zbar_scanner_t; + +/** constructor. + * if decoder is non-NULL it will be attached to scanner + * and called automatically at each new edge + * current color is initialized to ::ZBAR_SPACE + * (so an initial BAR->SPACE transition may be discarded) + */ +extern zbar_scanner_t *zbar_scanner_create(zbar_decoder_t *decoder); + +/** destructor. */ +extern void zbar_scanner_destroy(zbar_scanner_t *scanner); + +/** clear all scanner state. + * also resets an associated decoder + */ +extern zbar_symbol_type_t zbar_scanner_reset(zbar_scanner_t *scanner); + +/** mark start of a new scan pass. resets color to ::ZBAR_SPACE. + * also updates an associated decoder. + * @returns any decode results flushed from the pipeline + * @note when not using callback handlers, the return value should + * be checked the same as zbar_scan_y() + * @note call zbar_scanner_flush() at least twice before calling this + * method to ensure no decode results are lost + */ +extern zbar_symbol_type_t zbar_scanner_new_scan(zbar_scanner_t *scanner); + +/** flush scanner processing pipeline. + * forces current scanner position to be a scan boundary. + * call multiple times (max 3) to completely flush decoder. + * @returns any decode/scan results flushed from the pipeline + * @note when not using callback handlers, the return value should + * be checked the same as zbar_scan_y() + * @since 0.9 + */ +extern zbar_symbol_type_t zbar_scanner_flush(zbar_scanner_t *scanner); + +/** process next sample intensity value. + * intensity (y) is in arbitrary relative units. + * @returns result of zbar_decode_width() if a decoder is attached, + * otherwise @returns (::ZBAR_PARTIAL) when new edge is detected + * or 0 (::ZBAR_NONE) if no new edge is detected + */ +extern zbar_symbol_type_t zbar_scan_y(zbar_scanner_t *scanner, int y); + +/** process next sample from RGB (or BGR) triple. */ +static inline zbar_symbol_type_t zbar_scan_rgb24(zbar_scanner_t *scanner, + unsigned char *rgb) +{ + return (zbar_scan_y(scanner, rgb[0] + rgb[1] + rgb[2])); +} + +/** retrieve last scanned width. */ +extern unsigned zbar_scanner_get_width(const zbar_scanner_t *scanner); + +/** retrieve sample position of last edge. + * @since 0.10 + */ +extern unsigned zbar_scanner_get_edge(const zbar_scanner_t *scn, + unsigned offset, int prec); + +/** retrieve last scanned color. */ +extern zbar_color_t zbar_scanner_get_color(const zbar_scanner_t *scanner); + +/*@}*/ + +#ifdef __cplusplus +} +} + +#include "zbar/Decoder.h" +#include "zbar/Exception.h" +#include "zbar/Image.h" +#include "zbar/ImageScanner.h" +#include "zbar/Processor.h" +#include "zbar/Scanner.h" +#include "zbar/Symbol.h" +#include "zbar/Video.h" +#include "zbar/Window.h" +#endif + +#endif diff --git a/include/zbar/Decoder.h b/include/zbar/Decoder.h new file mode 100644 index 0000000..60d34c3 --- /dev/null +++ b/include/zbar/Decoder.h @@ -0,0 +1,203 @@ +//------------------------------------------------------------------------ +// Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net> +// +// This file is part of the ZBar Bar Code Reader. +// +// The ZBar Bar Code Reader is free software; you can redistribute it +// and/or modify it under the terms of the GNU Lesser Public License as +// published by the Free Software Foundation; either version 2.1 of +// the License, or (at your option) any later version. +// +// The ZBar Bar Code Reader is distributed in the hope that it will be +// useful, but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser Public License for more details. +// +// You should have received a copy of the GNU Lesser Public License +// along with the ZBar Bar Code Reader; if not, write to the Free +// Software Foundation, Inc., 51 Franklin St, Fifth Floor, +// Boston, MA 02110-1301 USA +// +// http://sourceforge.net/projects/zbar +//------------------------------------------------------------------------ +#ifndef _ZBAR_DECODER_H_ +#define _ZBAR_DECODER_H_ + +/// @file +/// Decoder C++ wrapper + +#ifndef _ZBAR_H_ +#error "include zbar.h in your application, **not** zbar/Decoder.h" +#endif + +#include <string> + +namespace zbar +{ +/// low-level bar width stream decoder interface. +/// identifies symbols and extracts encoded data + +class Decoder +{ +public: + /// Decoder result handler. + /// applications should subtype this and pass an instance to + /// set_handler() to implement result processing + class Handler + { + public: + virtual ~Handler() + { + } + + /// invoked by the Decoder as decode results become available. + virtual void decode_callback(Decoder &decoder) = 0; + }; + + /// constructor. + Decoder() : _handler(NULL) + { + _decoder = zbar_decoder_create(); + } + + ~Decoder() + { + zbar_decoder_destroy(_decoder); + } + + /// clear all decoder state. + /// see zbar_decoder_reset() + void reset() + { + zbar_decoder_reset(_decoder); + } + + /// mark start of a new scan pass. + /// see zbar_decoder_new_scan() + void new_scan() + { + zbar_decoder_new_scan(_decoder); + } + + /// process next bar/space width from input stream. + /// see zbar_decode_width() + zbar_symbol_type_t decode_width(unsigned width) + { + return (zbar_decode_width(_decoder, width)); + } + + /// process next bar/space width from input stream. + /// see zbar_decode_width() + Decoder &operator<<(unsigned width) + { + zbar_decode_width(_decoder, width); + return (*this); + } + + /// retrieve color of @em next element passed to Decoder. + /// see zbar_decoder_get_color() + zbar_color_t get_color() const + { + return (zbar_decoder_get_color(_decoder)); + } + + /// retrieve last decoded symbol type. + /// see zbar_decoder_get_type() + zbar_symbol_type_t get_type() const + { + return (zbar_decoder_get_type(_decoder)); + } + + /// retrieve string name of last decoded symbol type. + /// see zbar_get_symbol_name() + const char *get_symbol_name() const + { + return (zbar_get_symbol_name(zbar_decoder_get_type(_decoder))); + } + + /// retrieve string name for last decode addon. + /// see zbar_get_addon_name() + /// @deprecated in 0.11 + const char *get_addon_name() const + { + return (zbar_get_addon_name(zbar_decoder_get_type(_decoder))); + } + + /// retrieve last decoded data in ASCII format as a char array. + /// see zbar_decoder_get_data() + const char *get_data_chars() const + { + return (zbar_decoder_get_data(_decoder)); + } + + /// retrieve last decoded data as a std::string. + /// see zbar_decoder_get_data() + const std::string get_data_string() const + { + return (std::string(zbar_decoder_get_data(_decoder), + zbar_decoder_get_data_length(_decoder))); + } + + /// retrieve last decoded data as a std::string. + /// see zbar_decoder_get_data() + const std::string get_data() const + { + return (get_data_string()); + } + + /// retrieve length of decoded binary data. + /// see zbar_decoder_get_data_length() + int get_data_length() const + { + return (zbar_decoder_get_data_length(_decoder)); + } + + /// retrieve last decode direction. + /// see zbar_decoder_get_direction() + /// @since 0.11 + int get_direction() const + { + return (zbar_decoder_get_direction(_decoder)); + } + + /// setup callback to handle result data. + void set_handler(Handler &handler) + { + _handler = &handler; + zbar_decoder_set_handler(_decoder, _cb); + zbar_decoder_set_userdata(_decoder, this); + } + + /// set config for indicated symbology (0 for all) to specified value. + /// @see zbar_decoder_set_config() + /// @since 0.4 + int set_config(zbar_symbol_type_t symbology, zbar_config_t config, + int value) + { + return (zbar_decoder_set_config(_decoder, symbology, config, value)); + } + + /// set config parsed from configuration string. + /// @see zbar_decoder_parse_config() + /// @since 0.4 + int set_config(std::string cfgstr) + { + return (zbar_decoder_parse_config(_decoder, cfgstr.c_str())); + } + +private: + friend class Scanner; + zbar_decoder_t *_decoder; + Handler *_handler; + + static void _cb(zbar_decoder_t *cdcode) + { + Decoder *dcode = (Decoder *)zbar_decoder_get_userdata(cdcode); + if (dcode && dcode->_handler) + dcode->_handler->decode_callback(*dcode); + } +}; + +} // namespace zbar + +#endif diff --git a/include/zbar/Exception.h b/include/zbar/Exception.h new file mode 100644 index 0000000..d9fe458 --- /dev/null +++ b/include/zbar/Exception.h @@ -0,0 +1,199 @@ +//------------------------------------------------------------------------ +// Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net> +// +// This file is part of the ZBar Bar Code Reader. +// +// The ZBar Bar Code Reader is free software; you can redistribute it +// and/or modify it under the terms of the GNU Lesser Public License as +// published by the Free Software Foundation; either version 2.1 of +// the License, or (at your option) any later version. +// +// The ZBar Bar Code Reader is distributed in the hope that it will be +// useful, but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser Public License for more details. +// +// You should have received a copy of the GNU Lesser Public License +// along with the ZBar Bar Code Reader; if not, write to the Free +// Software Foundation, Inc., 51 Franklin St, Fifth Floor, +// Boston, MA 02110-1301 USA +// +// http://sourceforge.net/projects/zbar +//------------------------------------------------------------------------ +#ifndef _ZBAR_EXCEPTION_H_ +#define _ZBAR_EXCEPTION_H_ + +/// @file +/// C++ Exception definitions + +#ifndef _ZBAR_H_ +#error "include zbar.h in your application, **not** zbar/Exception.h" +#endif + +#include <cstddef> +#include <exception> +#include <new> + +namespace zbar +{ +/// base class for exceptions defined by this API. +class Exception : public std::exception +{ +public: + /// create exception from C library error + Exception(const void *obj = NULL) : std::exception(), _obj(obj) + { + } + + ~Exception() throw() + { + } + + /// retrieve error message + virtual const char *what() const throw() + { + if (!_obj) + return ("zbar library unspecified generic error"); + return (_zbar_error_string(_obj, 0)); + } + +private: + const void *_obj; +}; + +/// internal library error. +class InternalError : public Exception +{ +public: + /// create exception from C library error + InternalError(const void *obj) : Exception(obj) + { + } +}; + +/// unsupported request. +class UnsupportedError : public Exception +{ +public: + /// create exception from C library error + UnsupportedError(const void *obj) : Exception(obj) + { + } +}; + +/// invalid request. +class InvalidError : public Exception +{ +public: + /// create exception from C library error + InvalidError(const void *obj) : Exception(obj) + { + } +}; + +/// failed system call. +class SystemError : public Exception +{ +public: + /// create exception from C library error + SystemError(const void *obj) : Exception(obj) + { + } +}; + +/// locking error. +class LockingError : public Exception +{ +public: + /// create exception from C library error + LockingError(const void *obj) : Exception(obj) + { + } +}; + +/// all resources busy. +class BusyError : public Exception +{ +public: + /// create exception from C library error + BusyError(const void *obj) : Exception(obj) + { + } +}; + +/// X11 display error. +class XDisplayError : public Exception +{ +public: + /// create exception from C library error + XDisplayError(const void *obj) : Exception(obj) + { + } +}; + +/// X11 protocol error. +class XProtoError : public Exception +{ +public: + /// create exception from C library error + XProtoError(const void *obj) : Exception(obj) + { + } +}; + +/// output window is closed. +class ClosedError : public Exception +{ +public: + /// create exception from C library error + ClosedError(const void *obj) : Exception(obj) + { + } +}; + +/// image format error +class FormatError : public Exception +{ + // FIXME needs c equivalent + + virtual const char *what() const throw() + { + // FIXME what format? + return ("unsupported format"); + } +}; + +/// @internal + +/// extract error information and create exception. +static inline std::exception throw_exception(const void *obj) +{ + switch (_zbar_get_error_code(obj)) { + case ZBAR_ERR_NOMEM: + throw std::bad_alloc(); + case ZBAR_ERR_INTERNAL: + throw InternalError(obj); + case ZBAR_ERR_UNSUPPORTED: + throw UnsupportedError(obj); + case ZBAR_ERR_INVALID: + throw InvalidError(obj); + case ZBAR_ERR_SYSTEM: + throw SystemError(obj); + case ZBAR_ERR_LOCKING: + throw LockingError(obj); + case ZBAR_ERR_BUSY: + throw BusyError(obj); + case ZBAR_ERR_XDISPLAY: + throw XDisplayError(obj); + case ZBAR_ERR_XPROTO: + throw XProtoError(obj); + case ZBAR_ERR_CLOSED: + throw ClosedError(obj); + default: + throw Exception(obj); + } +} + +} // namespace zbar + +#endif diff --git a/include/zbar/Image.h b/include/zbar/Image.h new file mode 100644 index 0000000..ec2217b --- /dev/null +++ b/include/zbar/Image.h @@ -0,0 +1,322 @@ +//------------------------------------------------------------------------ +// Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net> +// +// This file is part of the ZBar Bar Code Reader. +// +// The ZBar Bar Code Reader is free software; you can redistribute it +// and/or modify it under the terms of the GNU Lesser Public License as +// published by the Free Software Foundation; either version 2.1 of +// the License, or (at your option) any later version. +// +// The ZBar Bar Code Reader is distributed in the hope that it will be +// useful, but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser Public License for more details. +// +// You should have received a copy of the GNU Lesser Public License +// along with the ZBar Bar Code Reader; if not, write to the Free +// Software Foundation, Inc., 51 Franklin St, Fifth Floor, +// Boston, MA 02110-1301 USA +// +// http://sourceforge.net/projects/zbar +//------------------------------------------------------------------------ +#ifndef _ZBAR_IMAGE_H_ +#define _ZBAR_IMAGE_H_ + +/// @file +/// Image C++ wrapper + +#ifndef _ZBAR_H_ +#error "include zbar.h in your application, **not** zbar/Image.h" +#endif + +#include <assert.h> +#include <iterator> +#include "Exception.h" +#include "Symbol.h" + +namespace zbar +{ +class Video; + +/// stores image data samples along with associated format and size +/// metadata + +class Image +{ +public: + /// general Image result handler. + /// applications should subtype this and pass an instance to + /// eg. ImageScanner::set_handler() to implement result processing + class Handler + { + public: + virtual ~Handler() + { + } + + /// invoked by library when Image should be processed + virtual void image_callback(Image &image) = 0; + + /// cast this handler to the C handler + operator zbar_image_data_handler_t *() const + { + return (_cb); + } + + private: + static void _cb(zbar_image_t *zimg, const void *userdata) + { + if (userdata) { + Image *image = (Image *)zbar_image_get_userdata(zimg); + if (image) + ((Handler *)userdata)->image_callback(*image); + else { + Image tmp(zimg, 1); + ((Handler *)userdata)->image_callback(tmp); + } + } + } + }; + + class SymbolIterator : public zbar::SymbolIterator + { + public: + /// default constructor. + SymbolIterator() : zbar::SymbolIterator() + { + } + + /// constructor. + SymbolIterator(const SymbolSet &syms) : zbar::SymbolIterator(syms) + { + } + + /// copy constructor. + SymbolIterator(const SymbolIterator &iter) : zbar::SymbolIterator(iter) + { + } + }; + + /// constructor. + /// create a new Image with the specified parameters + Image(unsigned width = 0, unsigned height = 0, + const std::string &format = "", const void *data = NULL, + unsigned long length = 0) + : _img(zbar_image_create()) + { + zbar_image_set_userdata(_img, this); + if (width && height) + set_size(width, height); + if (format.length()) + set_format(format); + if (data && length) + set_data(data, length); + } + + ~Image() + { + if (zbar_image_get_userdata(_img) == this) + zbar_image_set_userdata(_img, NULL); + zbar_image_ref(_img, -1); + } + + /// cast to C image object + operator const zbar_image_t *() const + { + return (_img); + } + + /// cast to C image object + operator zbar_image_t *() + { + return (_img); + } + + /// retrieve the image format. + /// see zbar_image_get_format() + unsigned long get_format() const + { + return (zbar_image_get_format(_img)); + } + + /// specify the fourcc image format code for image sample data. + /// see zbar_image_set_format() + void set_format(unsigned long format) + { + zbar_image_set_format(_img, format); + } + + /// specify the fourcc image format code for image sample data. + /// see zbar_image_set_format() + void set_format(const std::string &format) + { + unsigned long fourcc = zbar_fourcc_parse(format.c_str()); + zbar_image_set_format(_img, fourcc); + } + + /// retrieve a "sequence" (page/frame) number associated with this + /// image. + /// see zbar_image_get_sequence() + /// @since 0.6 + unsigned get_sequence() const + { + return (zbar_image_get_sequence(_img)); + } + + /// associate a "sequence" (page/frame) number with this image. + /// see zbar_image_set_sequence() + /// @since 0.6 + void set_sequence(unsigned sequence_num) + { + zbar_image_set_sequence(_img, sequence_num); + } + + /// retrieve the width of the image. + /// see zbar_image_get_width() + unsigned get_width() const + { + return (zbar_image_get_width(_img)); + } + + /// retrieve the height of the image. + /// see zbar_image_get_height() + unsigned get_height() const + { + return (zbar_image_get_height(_img)); + } + + /// retrieve both dimensions of the image. + /// see zbar_image_get_size() + /// @since 0.11 + void get_size(unsigned &width, unsigned &height) const + { + zbar_image_get_size(_img, &width, &height); + } + + /// specify the pixel size of the image. + /// see zbar_image_set_size() + void set_size(unsigned width, unsigned height) + { + zbar_image_set_size(_img, width, height); + } + + /// retrieve the scan crop rectangle. + /// see zbar_image_get_crop() + void get_crop(unsigned &x, unsigned &y, unsigned &width, + unsigned &height) const + { + zbar_image_get_crop(_img, &x, &y, &width, &height); + } + + /// set the scan crop rectangle. + /// see zbar_image_set_crop() + void set_crop(unsigned x, unsigned y, unsigned width, unsigned height) + { + zbar_image_set_crop(_img, x, y, width, height); + } + + /// return the image sample data. + /// see zbar_image_get_data() + const void *get_data() const + { + return (zbar_image_get_data(_img)); + } + + /// return the size of the image sample data. + /// see zbar_image_get_data_length() + /// @since 0.6 + unsigned long get_data_length() const + { + return (zbar_image_get_data_length(_img)); + } + + /// specify image sample data. + /// see zbar_image_set_data() + void set_data(const void *data, unsigned long length) + { + zbar_image_set_data(_img, data, length, _cleanup); + } + + /// image format conversion. + /// see zbar_image_convert() + Image convert(unsigned long format) const + { + zbar_image_t *img = zbar_image_convert(_img, format); + if (img) + return (Image(img)); + throw FormatError(); + } + + /// image format conversion. + /// see zbar_image_convert() + /// @since 0.11 + Image convert(std::string format) const + { + unsigned long fourcc = zbar_fourcc_parse(format.c_str()); + return (convert(fourcc)); + } + + /// image format conversion with crop/pad. + /// see zbar_image_convert_resize() + /// @since 0.4 + Image convert(unsigned long format, unsigned width, unsigned height) const + { + zbar_image_t *img; + + img = zbar_image_convert_resize(_img, format, width, height); + if (img) + return (Image(img)); + throw FormatError(); + } + + const SymbolSet get_symbols() const + { + return (SymbolSet(zbar_image_get_symbols(_img))); + } + + void set_symbols(const SymbolSet &syms) + { + zbar_image_set_symbols(_img, syms); + } + + /// create a new SymbolIterator over decoded results. + SymbolIterator symbol_begin() const + { + return (SymbolIterator(get_symbols())); + } + + /// return a SymbolIterator suitable for ending iteration. + SymbolIterator symbol_end() const + { + return (SymbolIterator()); + } + +protected: + friend class Video; + + /// constructor. + /// @internal + /// create a new Image from a zbar_image_t C object + Image(zbar_image_t *src, int refs = 0) : _img(src) + { + if (refs) + zbar_image_ref(_img, refs); + zbar_image_set_userdata(_img, this); + } + + /// default data cleanup (noop) + /// @internal + static void _cleanup(zbar_image_t *img) + { + // by default nothing is cleaned + assert(img); + } + +private: + zbar_image_t *_img; +}; + +} // namespace zbar + +#endif diff --git a/include/zbar/ImageScanner.h b/include/zbar/ImageScanner.h new file mode 100644 index 0000000..157a76d --- /dev/null +++ b/include/zbar/ImageScanner.h @@ -0,0 +1,149 @@ +//------------------------------------------------------------------------ +// Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net> +// +// This file is part of the ZBar Bar Code Reader. +// +// The ZBar Bar Code Reader is free software; you can redistribute it +// and/or modify it under the terms of the GNU Lesser Public License as +// published by the Free Software Foundation; either version 2.1 of +// the License, or (at your option) any later version. +// +// The ZBar Bar Code Reader is distributed in the hope that it will be +// useful, but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser Public License for more details. +// +// You should have received a copy of the GNU Lesser Public License +// along with the ZBar Bar Code Reader; if not, write to the Free +// Software Foundation, Inc., 51 Franklin St, Fifth Floor, +// Boston, MA 02110-1301 USA +// +// http://sourceforge.net/projects/zbar +//------------------------------------------------------------------------ +#ifndef _ZBAR_IMAGE_SCANNER_H_ +#define _ZBAR_IMAGE_SCANNER_H_ + +/// @file +/// Image Scanner C++ wrapper + +#ifndef _ZBAR_H_ +#error "include zbar.h in your application, **not** zbar/ImageScanner.h" +#endif + +#include "Image.h" + +namespace zbar +{ +/// mid-level image scanner interface. +/// reads barcodes from a 2-D Image + +class ImageScanner +{ +public: + /// constructor. + ImageScanner(zbar_image_scanner_t *scanner = NULL) + { + if (scanner) + _scanner = scanner; + else + _scanner = zbar_image_scanner_create(); + } + + ~ImageScanner() + { + zbar_image_scanner_destroy(_scanner); + } + + /// cast to C image_scanner object + operator zbar_image_scanner_t *() const + { + return (_scanner); + } + + /// setup result handler callback. + void set_handler(Image::Handler &handler) + { + zbar_image_scanner_set_data_handler(_scanner, handler, &handler); + } + + /// request sending decoded codes via D-Bus + /// @see zbar_processor_parse_config() + /// @since 0.21 + int request_dbus(bool enabled) + { + return zbar_image_scanner_request_dbus(_scanner, enabled); + } + + /// set config for indicated symbology (0 for all) to specified value. + /// @see zbar_image_scanner_set_config() + /// @since 0.4 + int set_config(zbar_symbol_type_t symbology, zbar_config_t config, + int value) + { + return ( + zbar_image_scanner_set_config(_scanner, symbology, config, value)); + } + + /// set config for indicated symbology (0 for all) to specified value. + /// @see zbar_image_scanner_set_config() + /// @since 0.22 + int get_config(zbar_symbol_type_t symbology, zbar_config_t config, + int &value) + { + return ( + zbar_image_scanner_get_config(_scanner, symbology, config, &value)); + } + + /// set config parsed from configuration string. + /// @see zbar_image_scanner_parse_config() + /// @since 0.4 + int set_config(std::string cfgstr) + { + return (zbar_image_scanner_parse_config(_scanner, cfgstr.c_str())); + } + + /// enable or disable the inter-image result cache. + /// see zbar_image_scanner_enable_cache() + void enable_cache(bool enable = true) + { + zbar_image_scanner_enable_cache(_scanner, enable); + } + + /// remove previous results from scanner and image. + /// @see zbar_image_scanner_recycle_image() + /// @since 0.10 + void recycle_image(Image &image) + { + zbar_image_scanner_recycle_image(_scanner, image); + } + + /// retrieve decode results for last scanned image. + /// @see zbar_image_scanner_get_results() + /// @since 0.10 + const SymbolSet get_results() const + { + return (SymbolSet(zbar_image_scanner_get_results(_scanner))); + } + + /// scan for symbols in provided image. + /// see zbar_scan_image() + int scan(Image &image) + { + return (zbar_scan_image(_scanner, image)); + } + + /// scan for symbols in provided image. + /// see zbar_scan_image() + ImageScanner &operator<<(Image &image) + { + scan(image); + return (*this); + } + +private: + zbar_image_scanner_t *_scanner; +}; + +} // namespace zbar + +#endif diff --git a/include/zbar/Processor.h b/include/zbar/Processor.h new file mode 100644 index 0000000..4da36ce --- /dev/null +++ b/include/zbar/Processor.h @@ -0,0 +1,220 @@ +//------------------------------------------------------------------------ +// Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net> +// +// This file is part of the ZBar Bar Code Reader. +// +// The ZBar Bar Code Reader is free software; you can redistribute it +// and/or modify it under the terms of the GNU Lesser Public License as +// published by the Free Software Foundation; either version 2.1 of +// the License, or (at your option) any later version. +// +// The ZBar Bar Code Reader is distributed in the hope that it will be +// useful, but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser Public License for more details. +// +// You should have received a copy of the GNU Lesser Public License +// along with the ZBar Bar Code Reader; if not, write to the Free +// Software Foundation, Inc., 51 Franklin St, Fifth Floor, +// Boston, MA 02110-1301 USA +// +// http://sourceforge.net/projects/zbar +//------------------------------------------------------------------------ +#ifndef _ZBAR_PROCESSOR_H_ +#define _ZBAR_PROCESSOR_H_ + +/// @file +/// Processor C++ wrapper + +#ifndef _ZBAR_H_ +#error "include zbar.h in your application, **not** zbar/Processor.h" +#endif + +#include "Exception.h" +#include "Image.h" + +namespace zbar +{ +/// high-level self-contained image processor. +/// processes video and images for barcodes, optionally displaying +/// images to a library owned output window + +class Processor +{ +public: + /// value to pass for no timeout. + static const int FOREVER = -1; + + /// constructor. + Processor(bool threaded = true, const char *video_device = "", + bool enable_display = true) + { + _processor = zbar_processor_create(threaded); + if (!_processor) + throw std::bad_alloc(); + init(video_device, enable_display); + } + + ~Processor() + { + zbar_processor_destroy(_processor); + } + + /// cast to C processor object. + operator zbar_processor_t *() + { + return (_processor); + } + + /// opens a video input device and/or prepares to display output. + /// see zbar_processor_init() + void init(const char *video_device = "", bool enable_display = true) + { + if (zbar_processor_init(_processor, video_device, enable_display)) + throw_exception(_processor); + } + + /// setup result handler callback. + /// see zbar_processor_set_data_handler() + void set_handler(Image::Handler &handler) + { + zbar_processor_set_data_handler(_processor, handler, &handler); + } + + /// set config for indicated symbology (0 for all) to specified value. + /// @see zbar_processor_set_config() + /// @since 0.4 + int set_config(zbar_symbol_type_t symbology, zbar_config_t config, + int value) + { + return ( + zbar_processor_set_config(_processor, symbology, config, value)); + } + + /// set config parsed from configuration string. + /// @see zbar_processor_parse_config() + /// @since 0.4 + int set_config(std::string cfgstr) + { + return (zbar_processor_parse_config(_processor, cfgstr.c_str())); + } + + /// retrieve the current state of the output window. + /// see zbar_processor_is_visible() + bool is_visible() + { + int rc = zbar_processor_is_visible(_processor); + if (rc < 0) + throw_exception(_processor); + return (rc != 0); + } + + /// show or hide the display window owned by the library. + /// see zbar_processor_set_visible() + void set_visible(bool visible = true) + { + if (zbar_processor_set_visible(_processor, visible) < 0) + throw_exception(_processor); + } + + /// control the processor in free running video mode. + /// see zbar_processor_set_active() + void set_active(bool active = true) + { + if (zbar_processor_set_active(_processor, active) < 0) + throw_exception(_processor); + } + + /// retrieve decode results for last scanned image. + /// @see zbar_processor_get_results() + /// @since 0.10 + const SymbolSet get_results() const + { + return (SymbolSet(zbar_processor_get_results(_processor))); + } + + /// wait for input to the display window from the user. + /// see zbar_processor_user_wait() + int user_wait(int timeout = FOREVER) + { + int rc = zbar_processor_user_wait(_processor, timeout); + if (rc < 0) + throw_exception(_processor); + return (rc); + } + + /// process from the video stream until a result is available. + /// see zbar_process_one() + void process_one(int timeout = FOREVER) + { + if (zbar_process_one(_processor, timeout) < 0) + throw_exception(_processor); + } + + /// process the provided image for barcodes. + /// see zbar_process_image() + void process_image(Image &image) + { + if (zbar_process_image(_processor, image) < 0) + throw_exception(_processor); + } + + /// process the provided image for barcodes. + /// see zbar_process_image() + Processor &operator<<(Image &image) + { + process_image(image); + return (*this); + } + + /// force specific input and output formats for debug/testing. + /// see zbar_processor_force_format() + void force_format(unsigned long input_format, unsigned long output_format) + { + if (zbar_processor_force_format(_processor, input_format, + output_format)) + throw_exception(_processor); + } + + /// force specific input and output formats for debug/testing. + /// see zbar_processor_force_format() + void force_format(std::string &input_format, std::string &output_format) + { + unsigned long ifourcc = zbar_fourcc_parse(input_format.c_str()); + unsigned long ofourcc = zbar_fourcc_parse(output_format.c_str()); + if (zbar_processor_force_format(_processor, ifourcc, ofourcc)) + throw_exception(_processor); + } + + /// request a preferred size for the video image from the device. + /// see zbar_processor_request_size() + /// @since 0.6 + void request_size(int width, int height) + { + zbar_processor_request_size(_processor, width, height); + } + + /// request a preferred driver interface version for debug/testing. + /// see zbar_processor_request_interface() + /// @since 0.6 + void request_interface(int version) + { + zbar_processor_request_interface(_processor, version); + } + + /// request a preferred I/O mode for debug/testing. + /// see zbar_processor_request_iomode() + /// @since 0.7 + void request_iomode(int iomode) + { + if (zbar_processor_request_iomode(_processor, iomode)) + throw_exception(_processor); + } + +private: + zbar_processor_t *_processor; +}; + +} // namespace zbar + +#endif diff --git a/include/zbar/QZBar.h b/include/zbar/QZBar.h new file mode 100644 index 0000000..35825c3 --- /dev/null +++ b/include/zbar/QZBar.h @@ -0,0 +1,207 @@ +//------------------------------------------------------------------------ +// Copyright 2008-2009 (c) Jeff Brown <spadix@users.sourceforge.net> +// +// This file is part of the ZBar Bar Code Reader. +// +// The ZBar Bar Code Reader is free software; you can redistribute it +// and/or modify it under the terms of the GNU Lesser Public License as +// published by the Free Software Foundation; either version 2.1 of +// the License, or (at your option) any later version. +// +// The ZBar Bar Code Reader is distributed in the hope that it will be +// useful, but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser Public License for more details. +// +// You should have received a copy of the GNU Lesser Public License +// along with the ZBar Bar Code Reader; if not, write to the Free +// Software Foundation, Inc., 51 Franklin St, Fifth Floor, +// Boston, MA 02110-1301 USA +// +// http://sourceforge.net/projects/zbar +//------------------------------------------------------------------------ +#ifndef _QZBAR_H_ +#define _QZBAR_H_ + +/// @file +/// Barcode Reader Qt4 Widget + +#include <QtGui> +#if QT_VERSION >= 0x050000 +#include <QtWidgets> +#else +#include <qwidget.h> +#endif +#include <zbar.h> + +namespace zbar +{ +class QZBarThread; + +/// barcode reader Qt4 widget. +/// embeds a barcode reader directly into a Qt4 based GUI. the widget +/// can process barcodes from a video source (using the QZBar::videoDevice +/// and QZBar::videoEnabled properties) or from individual QImages +/// supplied to the QZBar::scanImage() slot +/// @since 1.5 + +class QZBar : public QWidget +{ + Q_OBJECT + + /// the currently opened video device. + /// + /// setting a new device opens it and automatically sets + /// QZBar::videoEnabled + /// + /// @see videoDevice(), setVideoDevice() + Q_PROPERTY(QString videoDevice READ videoDevice WRITE setVideoDevice + DESIGNABLE false) + + /// video device streaming state. + /// + /// use to pause/resume video scanning. + /// + /// @see isVideoEnabled(), setVideoEnabled() + Q_PROPERTY(bool videoEnabled READ isVideoEnabled WRITE setVideoEnabled + DESIGNABLE false) + + /// video device opened state. + /// + /// (re)setting QZBar::videoDevice should eventually cause it + /// to be opened or closed. any errors while streaming/scanning + /// will also cause the device to be closed + /// + /// @see isVideoOpened() + Q_PROPERTY(bool videoOpened READ isVideoOpened DESIGNABLE false) + +public: + // Should match the types at video_control_type_e + // get_controls() will do the mapping between the two types. + enum ControlType + { + Unknown, + Integer, + Menu, + Button, + Integer64, + String, + Boolean, + }; + + /// constructs a barcode reader widget with the given @a parent + QZBar(QWidget *parent = NULL, int verbosity = 0); + + ~QZBar(); + + /// retrieve the currently opened video device. + /// @returns the current video device or the empty string if no + /// device is opened + QString videoDevice() const; + + /// retrieve the current video enabled state. + /// @returns true if video scanning is currently enabled, false + /// otherwise + bool isVideoEnabled() const; + + /// retrieve the current video opened state. + /// @returns true if video device is currently opened, false otherwise + bool isVideoOpened() const; + + /// @{ + /// @internal + + QSize sizeHint() const; + int heightForWidth(int) const; + QPaintEngine *paintEngine() const; + + /// @} + +public Q_SLOTS: + + /// open a new video device. + /// + /// use an empty string to close a currently opened device. + /// + /// @note since opening a device may take some time, this call will + /// return immediately and the device will be opened asynchronously + void setVideoDevice(const QString &videoDevice); + + /// enable/disable video scanning. + /// has no effect unless a video device is opened + void setVideoEnabled(bool videoEnabled = true); + + /// scan for barcodes in a QImage. + void scanImage(const QImage &image); + + /// get controls from the camera device + int get_controls(int index, char **name = NULL, char **group = NULL, + enum ControlType *type = NULL, int *min = NULL, + int *max = NULL, int *def = NULL, int *step = NULL); + + /// Get items for control menus + QVector<QPair<int, QString> > get_menu(int index); + + // get/set controls from the camera device + int set_control(char *name, bool value); + int set_control(char *name, int value); + int get_control(char *name, bool *value); + int get_control(char *name, int *value); + + int set_config(std::string cfgstr); + int set_config(zbar_symbol_type_t symbology, zbar_config_t config, + int value); + int get_config(zbar_symbol_type_t symbology, zbar_config_t config, + int &value); + void request_size(unsigned width, unsigned height, bool trigger = true); + int get_resolution(int index, unsigned &width, unsigned &height, + float &max_fps); + unsigned videoWidth(); + unsigned videoHeight(); + int request_dbus(bool enabled); + +Q_SIGNALS: + /// emitted when when a video device is opened or closed. + /// + /// (re)setting QZBar::videoDevice should eventually cause it + /// to be opened or closed. any errors while streaming/scanning + /// will also cause the device to be closed + void videoOpened(bool videoOpened); + + /// emitted when a barcode is decoded from an image. + /// the symbol type and contained data are provided as separate + /// parameters. + void decoded(int type, const QString &data); + + /// emitted when a barcode is decoded from an image. + /// the symbol type name is prefixed to the data, separated by a + /// colon + void decodedText(const QString &text); + + /// @{ + /// @internal + +protected: + void attach(); + void showEvent(QShowEvent *); + void paintEvent(QPaintEvent *); + void resizeEvent(QResizeEvent *); + void changeEvent(QEvent *); + void dragEnterEvent(QDragEnterEvent *); + void dropEvent(QDropEvent *); + +protected Q_SLOTS: + void sizeChange(); + + /// @} + +private: + QZBarThread *thread; + QString _videoDevice; + bool _videoEnabled; + bool _attached; +}; + +}; // namespace zbar + +#endif diff --git a/include/zbar/QZBarImage.h b/include/zbar/QZBarImage.h new file mode 100644 index 0000000..ccacb24 --- /dev/null +++ b/include/zbar/QZBarImage.h @@ -0,0 +1,72 @@ +//------------------------------------------------------------------------ +// Copyright 2008-2010 (c) Jeff Brown <spadix@users.sourceforge.net> +// +// This file is part of the ZBar Bar Code Reader. +// +// The ZBar Bar Code Reader is free software; you can redistribute it +// and/or modify it under the terms of the GNU Lesser Public License as +// published by the Free Software Foundation; either version 2.1 of +// the License, or (at your option) any later version. +// +// The ZBar Bar Code Reader is distributed in the hope that it will be +// useful, but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser Public License for more details. +// +// You should have received a copy of the GNU Lesser Public License +// along with the ZBar Bar Code Reader; if not, write to the Free +// Software Foundation, Inc., 51 Franklin St, Fifth Floor, +// Boston, MA 02110-1301 USA +// +// http://sourceforge.net/projects/zbar +//------------------------------------------------------------------------ +#ifndef _QZBARIMAGE_H_ +#define _QZBARIMAGE_H_ + +/// @file +/// QImage to Image type conversion wrapper + +#include <qimage.h> +#include <zbar.h> + +namespace zbar +{ +/// wrap a QImage and convert into a format suitable for scanning. + +class QZBarImage : public Image +{ +public: + /// construct a zbar library image based on an existing QImage. + + QZBarImage(const QImage &qimg) : qimg(qimg) + { + QImage::Format fmt = qimg.format(); + if (fmt != QImage::Format_RGB32 && fmt != QImage::Format_ARGB32 && + fmt != QImage::Format_ARGB32_Premultiplied) + throw FormatError(); + + unsigned bpl = qimg.bytesPerLine(); + unsigned width = bpl / 4; + unsigned height = qimg.height(); + set_size(width, height); + set_format(zbar_fourcc('B', 'G', 'R', '4')); +#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0) + unsigned long datalen = qimg.sizeInBytes(); +#elif QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) + unsigned long datalen = qimg.byteCount(); +#else + unsigned long datalen = qimg.numBytes(); +#endif + set_data(qimg.bits(), datalen); + + if ((width * 4 != bpl) || (width * height * 4 > datalen)) + throw FormatError(); + } + +private: + QImage qimg; +}; + +}; // namespace zbar + +#endif diff --git a/include/zbar/Scanner.h b/include/zbar/Scanner.h new file mode 100644 index 0000000..a6a38e8 --- /dev/null +++ b/include/zbar/Scanner.h @@ -0,0 +1,162 @@ +//------------------------------------------------------------------------ +// Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net> +// +// This file is part of the ZBar Bar Code Reader. +// +// The ZBar Bar Code Reader is free software; you can redistribute it +// and/or modify it under the terms of the GNU Lesser Public License as +// published by the Free Software Foundation; either version 2.1 of +// the License, or (at your option) any later version. +// +// The ZBar Bar Code Reader is distributed in the hope that it will be +// useful, but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser Public License for more details. +// +// You should have received a copy of the GNU Lesser Public License +// along with the ZBar Bar Code Reader; if not, write to the Free +// Software Foundation, Inc., 51 Franklin St, Fifth Floor, +// Boston, MA 02110-1301 USA +// +// http://sourceforge.net/projects/zbar +//------------------------------------------------------------------------ +#ifndef _ZBAR_SCANNER_H_ +#define _ZBAR_SCANNER_H_ + +/// @file +/// Scanner C++ wrapper + +#ifndef _ZBAR_H_ +#error "include zbar.h in your application, **not** zbar/Scanner.h" +#endif + +#include <stdio.h> + +namespace zbar +{ +/// low-level linear intensity sample stream scanner interface. +/// identifies "bar" edges and measures width between them. +/// optionally passes to bar width Decoder + +class Scanner +{ +public: + /// constructor. + /// @param decoder reference to a Decoder instance which will + /// be passed scan results automatically + Scanner(Decoder &decoder) + { + _scanner = zbar_scanner_create(decoder._decoder); + } + + /// constructor. + /// @param decoder pointer to a Decoder instance which will + /// be passed scan results automatically + Scanner(Decoder *decoder = NULL) + { + zbar_decoder_t *zdcode = NULL; + if (decoder) + zdcode = decoder->_decoder; + _scanner = zbar_scanner_create(zdcode); + } + + ~Scanner() + { + zbar_scanner_destroy(_scanner); + } + + /// clear all scanner state. + /// see zbar_scanner_reset() + void reset() + { + zbar_scanner_reset(_scanner); + } + + /// mark start of a new scan pass. + /// see zbar_scanner_new_scan() + zbar_symbol_type_t new_scan() + { + _type = zbar_scanner_new_scan(_scanner); + return (_type); + } + + /// flush scanner pipeline. + /// see zbar_scanner_flush() + zbar_symbol_type_t flush() + { + _type = zbar_scanner_flush(_scanner); + return (_type); + } + + /// process next sample intensity value. + /// see zbar_scan_y() + zbar_symbol_type_t scan_y(int y) + { + _type = zbar_scan_y(_scanner, y); + return (_type); + } + + /// process next sample intensity value. + /// see zbar_scan_y() + Scanner &operator<<(int y) + { + _type = zbar_scan_y(_scanner, y); + return (*this); + } + + /// process next sample from RGB (or BGR) triple. + /// see zbar_scan_rgb24() + zbar_symbol_type_t scan_rgb24(unsigned char *rgb) + { + _type = zbar_scan_rgb24(_scanner, rgb); + return (_type); + } + + /// process next sample from RGB (or BGR) triple. + /// see zbar_scan_rgb24() + Scanner &operator<<(unsigned char *rgb) + { + _type = zbar_scan_rgb24(_scanner, rgb); + return (*this); + } + + /// retrieve last scanned width. + /// see zbar_scanner_get_width() + unsigned get_width() const + { + return (zbar_scanner_get_width(_scanner)); + } + + /// retrieve last scanned color. + /// see zbar_scanner_get_color() + zbar_color_t get_color() const + { + return (zbar_scanner_get_color(_scanner)); + } + + /// retrieve last scan result. + zbar_symbol_type_t get_type() const + { + return (_type); + } + + /// cast to C scanner + operator zbar_scanner_t *() const + { + return (_scanner); + } + + /// retrieve C scanner + const zbar_scanner_t *get_c_scanner() const + { + return (_scanner); + } + +private: + zbar_scanner_t *_scanner; + zbar_symbol_type_t _type; +}; + +} // namespace zbar + +#endif diff --git a/include/zbar/Symbol.h b/include/zbar/Symbol.h new file mode 100644 index 0000000..f3a5668 --- /dev/null +++ b/include/zbar/Symbol.h @@ -0,0 +1,532 @@ +//------------------------------------------------------------------------ +// Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net> +// +// This file is part of the ZBar Bar Code Reader. +// +// The ZBar Bar Code Reader is free software; you can redistribute it +// and/or modify it under the terms of the GNU Lesser Public License as +// published by the Free Software Foundation; either version 2.1 of +// the License, or (at your option) any later version. +// +// The ZBar Bar Code Reader is distributed in the hope that it will be +// useful, but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser Public License for more details. +// +// You should have received a copy of the GNU Lesser Public License +// along with the ZBar Bar Code Reader; if not, write to the Free +// Software Foundation, Inc., 51 Franklin St, Fifth Floor, +// Boston, MA 02110-1301 USA +// +// http://sourceforge.net/projects/zbar +//------------------------------------------------------------------------ +#ifndef _ZBAR_SYMBOL_H_ +#define _ZBAR_SYMBOL_H_ + +/// @file +/// Symbol C++ wrapper + +#ifndef _ZBAR_H_ +#error "include zbar.h in your application, **not** zbar/Symbol.h" +#endif + +#include <assert.h> +#include <ostream> +#include <stdlib.h> +#include <string> + +namespace zbar +{ +class SymbolIterator; + +/// container for decoded result symbols associated with an image +/// or a composite symbol. + +class SymbolSet +{ +public: + /// constructor. + SymbolSet(const zbar_symbol_set_t *syms = NULL) : _syms(syms) + { + ref(); + } + + /// copy constructor. + SymbolSet(const SymbolSet &syms) : _syms(syms._syms) + { + ref(); + } + + /// destructor. + ~SymbolSet() + { + ref(-1); + } + + /// assignment. + SymbolSet &operator=(const SymbolSet &syms) + { + syms.ref(); + ref(-1); + _syms = syms._syms; + return (*this); + } + + /// truth testing. + bool operator!() const + { + return (!_syms || !get_size()); + } + + /// manipulate reference count. + void ref(int delta = 1) const + { + if (_syms) + zbar_symbol_set_ref((zbar_symbol_set_t *)_syms, delta); + } + + /// cast to C symbol set. + operator const zbar_symbol_set_t *() const + { + return (_syms); + } + + int get_size() const + { + return ((_syms) ? zbar_symbol_set_get_size(_syms) : 0); + } + + /// create a new SymbolIterator over decoded results. + SymbolIterator symbol_begin() const; + + /// return a SymbolIterator suitable for ending iteration. + const SymbolIterator symbol_end() const; + +private: + const zbar_symbol_set_t *_syms; +}; + +/// decoded barcode symbol result object. stores type, data, and +/// image location of decoded symbol + +class Symbol +{ +public: + /// image pixel location (x, y) coordinate tuple. + class Point + { + public: + int x; ///< x-coordinate. + int y; ///< y-coordinate. + + Point() + { + } + + Point(int x, int y) : x(x), y(y) + { + } + + /// copy constructor. + Point(const Point &pt) : x(pt.x), y(pt.y) + { + } + + /// assignment. + Point &operator=(const Point &pt) + { + x = pt.x; + y = pt.y; + return (*this); + } + }; + + /// iteration over Point objects in a symbol location polygon. + class PointIterator : public std::iterator<std::input_iterator_tag, Point> + { + public: + /// constructor. + PointIterator(const Symbol *sym = NULL, int index = 0) + : _sym(sym), _index(index) + { + if (sym) + sym->ref(1); + if (!sym || (unsigned)_index >= zbar_symbol_get_loc_size(*_sym)) + _index = -1; + } + + /// copy constructor. + PointIterator(const PointIterator &iter) + : _sym(iter._sym), _index(iter._index) + { + if (_sym) + _sym->ref(); + } + + /// destructor. + ~PointIterator() + { + if (_sym) + _sym->ref(-1); + } + + /// assignment. + PointIterator &operator=(const PointIterator &iter) + { + if (iter._sym) + iter._sym->ref(); + if (_sym) + _sym->ref(-1); + _sym = iter._sym; + _index = iter._index; + return (*this); + } + + /// truth testing. + bool operator!() const + { + return (!_sym || _index < 0); + } + + /// advance iterator to next Point. + PointIterator &operator++() + { + unsigned int i = ++_index; + if (!_sym || i >= zbar_symbol_get_loc_size(*_sym)) + _index = -1; + return (*this); + } + + /// retrieve currently referenced Point. + const Point operator*() const + { + assert(!!*this); + if (!*this) + return (Point()); + return (Point(zbar_symbol_get_loc_x(*_sym, _index), + zbar_symbol_get_loc_y(*_sym, _index))); + } + + /// test if two iterators refer to the same Point in the same + /// Symbol. + bool operator==(const PointIterator &iter) const + { + return (_index == iter._index && + ((_index < 0) || _sym == iter._sym)); + } + + /// test if two iterators refer to the same Point in the same + /// Symbol. + bool operator!=(const PointIterator &iter) const + { + return (!(*this == iter)); + } + + private: + const Symbol *_sym; + int _index; + }; + + /// constructor. + Symbol(const zbar_symbol_t *sym = NULL) : _xmlbuf(NULL), _xmllen(0) + { + init(sym); + ref(); + } + + /// copy constructor. + Symbol(const Symbol &sym) + : _sym(sym._sym), _type(sym._type), _data(sym._data), _xmlbuf(NULL), + _xmllen(0) + { + ref(); + } + + /// destructor. + ~Symbol() + { + if (_xmlbuf) + free(_xmlbuf); + ref(-1); + } + + /// assignment. + Symbol &operator=(const Symbol &sym) + { + sym.ref(1); + ref(-1); + _sym = sym._sym; + _type = sym._type; + _data = sym._data; + return (*this); + } + + Symbol &operator=(const zbar_symbol_t *sym) + { + if (sym) + zbar_symbol_ref(sym, 1); + ref(-1); + init(sym); + return (*this); + } + + /// truth testing. + bool operator!() const + { + return (!_sym); + } + + void ref(int delta = 1) const + { + if (_sym) + zbar_symbol_ref((zbar_symbol_t *)_sym, delta); + } + + /// cast to C symbol. + operator const zbar_symbol_t *() const + { + return (_sym); + } + + /// test if two Symbol objects refer to the same C symbol. + bool operator==(const Symbol &sym) const + { + return (_sym == sym._sym); + } + + /// test if two Symbol objects refer to the same C symbol. + bool operator!=(const Symbol &sym) const + { + return (!(*this == sym)); + } + + /// retrieve type of decoded symbol. + zbar_symbol_type_t get_type() const + { + return (_type); + } + + /// retrieve the string name of the symbol type. + const std::string get_type_name() const + { + return (zbar_get_symbol_name(_type)); + } + + /// retrieve the string name for any addon. + /// @deprecated in 0.11 + const std::string get_addon_name() const + { + return (zbar_get_addon_name(_type)); + } + + /// retrieve data decoded from symbol. + const std::string get_data() const + { + return (_data); + } + + /// retrieve length of binary data + unsigned get_data_length() const + { + return ((_sym) ? zbar_symbol_get_data_length(_sym) : 0); + } + + /// retrieve inter-frame coherency count. + /// see zbar_symbol_get_count() + /// @since 0.5 + int get_count() const + { + return ((_sym) ? zbar_symbol_get_count(_sym) : -1); + } + + /// retrieve loosely defined relative quality metric. + /// see zbar_symbol_get_quality() + /// @since 0.11 + int get_quality() const + { + return ((_sym) ? zbar_symbol_get_quality(_sym) : 0); + } + + SymbolSet get_components() const + { + return (SymbolSet((_sym) ? zbar_symbol_get_components(_sym) : NULL)); + } + + /// create a new PointIterator at the start of the location + /// polygon. + PointIterator point_begin() const + { + return (PointIterator(this)); + } + + /// return a PointIterator suitable for ending iteration. + const PointIterator point_end() const + { + return (PointIterator()); + } + + /// see zbar_symbol_get_loc_size(). + int get_location_size() const + { + return ((_sym) ? zbar_symbol_get_loc_size(_sym) : 0); + } + + /// see zbar_symbol_get_loc_x(). + int get_location_x(unsigned index) const + { + return ((_sym) ? zbar_symbol_get_loc_x(_sym, index) : -1); + } + + /// see zbar_symbol_get_loc_y(). + int get_location_y(unsigned index) const + { + return ((_sym) ? zbar_symbol_get_loc_y(_sym, index) : -1); + } + + /// see zbar_symbol_get_orientation(). + /// @since 0.11 + int get_orientation() const + { + return (zbar_symbol_get_orientation(_sym)); + } + + /// see zbar_symbol_xml(). + const std::string xml() const + { + if (!_sym) + return (""); + return (zbar_symbol_xml(_sym, (char **)&_xmlbuf, (unsigned *)&_xmllen)); + } + +protected: + /// (re)initialize Symbol from C symbol object. + void init(const zbar_symbol_t *sym = NULL) + { + _sym = sym; + if (sym) { + _type = zbar_symbol_get_type(sym); + _data = std::string(zbar_symbol_get_data(sym), + zbar_symbol_get_data_length(sym)); + } else { + _type = ZBAR_NONE; + _data = ""; + } + } + +private: + const zbar_symbol_t *_sym; + zbar_symbol_type_t _type; + std::string _data; + char *_xmlbuf; + unsigned _xmllen; +}; + +/// iteration over Symbol result objects in a scanned Image or SymbolSet. +class SymbolIterator : public std::iterator<std::input_iterator_tag, Symbol> +{ +public: + /// default constructor. + SymbolIterator() + { + } + + /// constructor. + SymbolIterator(const SymbolSet &syms) : _syms(syms) + { + const zbar_symbol_set_t *zsyms = _syms; + if (zsyms) + _sym = zbar_symbol_set_first_symbol(zsyms); + } + + /// copy constructor. + SymbolIterator(const SymbolIterator &iter) : _syms(iter._syms) + { + const zbar_symbol_set_t *zsyms = _syms; + if (zsyms) + _sym = zbar_symbol_set_first_symbol(zsyms); + } + + ~SymbolIterator() + { + } + + /// assignment. + SymbolIterator &operator=(const SymbolIterator &iter) + { + _syms = iter._syms; + _sym = iter._sym; + return (*this); + } + + bool operator!() const + { + return (!_syms || !_sym); + } + + /// advance iterator to next Symbol. + SymbolIterator &operator++() + { + if (!!_sym) + _sym = zbar_symbol_next(_sym); + else if (!!_syms) + _sym = zbar_symbol_set_first_symbol(_syms); + return (*this); + } + + /// retrieve currently referenced Symbol. + const Symbol operator*() const + { + return (_sym); + } + + /// access currently referenced Symbol. + const Symbol *operator->() const + { + return (&_sym); + } + + /// test if two iterators refer to the same Symbol + bool operator==(const SymbolIterator &iter) const + { + // it is enough to test the symbols, as they belong + // to only one set (also simplifies invalid case) + return (_sym == iter._sym); + } + + /// test if two iterators refer to the same Symbol + bool operator!=(const SymbolIterator &iter) const + { + return (!(*this == iter)); + } + + const SymbolIterator end() const + { + return (SymbolIterator()); + } + +private: + SymbolSet _syms; + Symbol _sym; +}; + +inline SymbolIterator SymbolSet::symbol_begin() const +{ + return (SymbolIterator(*this)); +} + +inline const SymbolIterator SymbolSet::symbol_end() const +{ + return (SymbolIterator()); +} + +/// @relates Symbol +/// stream the string representation of a Symbol. +static inline std::ostream &operator<<(std::ostream &out, const Symbol &sym) +{ + out << sym.get_type_name() << ":" << sym.get_data(); + return (out); +} + +} // namespace zbar + +#endif diff --git a/include/zbar/Video.h b/include/zbar/Video.h new file mode 100644 index 0000000..07d11c2 --- /dev/null +++ b/include/zbar/Video.h @@ -0,0 +1,224 @@ +//------------------------------------------------------------------------ +// Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net> +// +// This file is part of the ZBar Bar Code Reader. +// +// The ZBar Bar Code Reader is free software; you can redistribute it +// and/or modify it under the terms of the GNU Lesser Public License as +// published by the Free Software Foundation; either version 2.1 of +// the License, or (at your option) any later version. +// +// The ZBar Bar Code Reader is distributed in the hope that it will be +// useful, but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser Public License for more details. +// +// You should have received a copy of the GNU Lesser Public License +// along with the ZBar Bar Code Reader; if not, write to the Free +// Software Foundation, Inc., 51 Franklin St, Fifth Floor, +// Boston, MA 02110-1301 USA +// +// http://sourceforge.net/projects/zbar +//------------------------------------------------------------------------ +#ifndef _ZBAR_VIDEO_H_ +#define _ZBAR_VIDEO_H_ + +/// @file +/// Video Input C++ wrapper + +#ifndef _ZBAR_H_ +#error "include zbar.h in your application, **not** zbar/Video.h" +#endif + +#include "Image.h" + +namespace zbar +{ +/// mid-level video source abstraction. +/// captures images from a video device + +class Video +{ +public: + /// constructor. + Video(zbar_video_t *video = NULL) + { + if (video) + _video = video; + else + _video = zbar_video_create(); + } + + /// constructor. + Video(std::string &device) + { + _video = zbar_video_create(); + open(device); + } + + ~Video() + { + zbar_video_destroy(_video); + } + + /// cast to C video object. + operator zbar_video_t *() const + { + return (_video); + } + + /// open and probe a video device. + void open(std::string &device) + { + if (zbar_video_open(_video, device.c_str())) + throw_exception(_video); + } + + /// close video device if open. + void close() + { + if (zbar_video_open(_video, NULL)) + throw_exception(_video); + } + + /// initialize video using a specific format for debug. + /// see zbar_video_init() + void init(unsigned long fourcc) + { + if (zbar_video_init(_video, fourcc)) + throw_exception(_video); + } + + /// initialize video using a specific format for debug. + /// see zbar_video_init() + void init(std::string &format) + { + unsigned int fourcc = zbar_fourcc_parse(format.c_str()); + if (zbar_video_init(_video, fourcc)) + throw_exception(_video); + } + + /// retrieve file descriptor associated with open *nix video device. + /// see zbar_video_get_fd() + int get_fd() + { + return (zbar_video_get_fd(_video)); + } + + /// retrieve current output image width. + /// see zbar_video_get_width() + int get_width() + { + return (zbar_video_get_width(_video)); + } + + /// retrieve current output image height. + /// see zbar_video_get_height() + int get_height() + { + return (zbar_video_get_height(_video)); + } + + /// start/stop video capture. + /// see zbar_video_enable() + void enable(bool enable = true) + { + if (zbar_video_enable(_video, enable)) + throw_exception(_video); + } + + /// retrieve next captured image. + /// see zbar_video_next_image() + Image next_image() + { + zbar_image_t *img = zbar_video_next_image(_video); + if (!img) + throw_exception(_video); + return (Image(img)); + } + + /// request a preferred size for the video image from the device. + /// see zbar_video_request_size() + /// @since 0.6 + void request_size(int width, int height) + { + zbar_video_request_size(_video, width, height); + } + + /// request a preferred driver interface version for debug/testing. + /// see zbar_video_request_interface() + /// @since 0.6 + void request_interface(int version) + { + zbar_video_request_interface(_video, version); + } + + /// request a preferred I/O mode for debug/testing. + /// see zbar_video_request_iomode() + /// @since 0.7 + void request_iomode(int iomode) + { + if (zbar_video_request_iomode(_video, iomode)) + throw_exception(_video); + } + + /// get the information about a control at a given index + /// see zbar_video_get_controls() + /// @since 0.11 + struct video_controls_s *get_controls(int index) + { + return (zbar_video_get_controls(_video, index)); + } + + /// set the value on an integer control + /// see zbar_video_set_control_n() + /// @since 0.11 + int set_control(const char *name, int value) + { + return zbar_video_set_control(_video, name, value); + } + + /// set the value on a boolean control + /// see zbar_video_set_control_b() + /// @since 0.11 + int set_control(const char *name, bool value) + { + return zbar_video_set_control(_video, name, value ? 1 : 0); + } + + /// get the value on a boolean control + /// see zbar_video_get_control_b() + /// @since 0.11 + int get_control(const char *name, int *value) + { + return zbar_video_get_control(_video, name, value); + } + + /// get the value on an integer control + /// see zbar_video_get_control_n() + /// @since 0.11 + int get_control(const char *name, bool *value) + { + int __value; + int ret = zbar_video_get_control(_video, name, &__value); + + *value = __value ? true : false; + + return ret; + } + + /// get the information about a control at a given index + /// see zbar_video_get_resolutions() + /// @since 0.22 + struct video_resolution_s *get_resolution(int index) + { + return (zbar_video_get_resolutions(_video, index)); + } + +private: + zbar_video_t *_video; +}; + +} // namespace zbar + +#endif diff --git a/include/zbar/Window.h b/include/zbar/Window.h new file mode 100644 index 0000000..a378e02 --- /dev/null +++ b/include/zbar/Window.h @@ -0,0 +1,134 @@ +//------------------------------------------------------------------------ +// Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net> +// +// This file is part of the ZBar Bar Code Reader. +// +// The ZBar Bar Code Reader is free software; you can redistribute it +// and/or modify it under the terms of the GNU Lesser Public License as +// published by the Free Software Foundation; either version 2.1 of +// the License, or (at your option) any later version. +// +// The ZBar Bar Code Reader is distributed in the hope that it will be +// useful, but WITHOUT ANY WARRANTY; without even the implied warranty +// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser Public License for more details. +// +// You should have received a copy of the GNU Lesser Public License +// along with the ZBar Bar Code Reader; if not, write to the Free +// Software Foundation, Inc., 51 Franklin St, Fifth Floor, +// Boston, MA 02110-1301 USA +// +// http://sourceforge.net/projects/zbar +//------------------------------------------------------------------------ +#ifndef _ZBAR_WINDOW_H_ +#define _ZBAR_WINDOW_H_ + +/// @file +/// Output Window C++ wrapper + +#ifndef _ZBAR_H_ +#error "include zbar.h in your application, **not** zbar/Window.h" +#endif + +#include "Image.h" + +namespace zbar +{ +/// mid-level output window abstraction. +/// displays images to user-specified platform specific output window + +class Window +{ +public: + /// constructor. + Window(zbar_window_t *window = NULL) + { + if (window) + _window = window; + else + _window = zbar_window_create(); + } + + /// constructor. + Window(void *x11_display_w32_hwnd, unsigned long x11_drawable) + { + _window = zbar_window_create(); + attach(x11_display_w32_hwnd, x11_drawable); + } + + ~Window() + { + zbar_window_destroy(_window); + } + + /// cast to C window object. + operator zbar_window_t *() const + { + return (_window); + } + + /// associate reader with an existing platform window. + /// see zbar_window_attach() + void attach(void *x11_display_w32_hwnd, unsigned long x11_drawable = 0) + { + if (zbar_window_attach(_window, x11_display_w32_hwnd, x11_drawable) < 0) + throw_exception(_window); + } + + /// control content level of the reader overlay. + /// see zbar_window_set_overlay() + void set_overlay(int level) + { + zbar_window_set_overlay(_window, level); + } + + /// retrieve current content level of reader overlay. + /// see zbar_window_get_overlay() + + /// draw a new image into the output window. + /// see zbar_window_draw() + void draw(Image &image) + { + if (zbar_window_draw(_window, image) < 0) + throw_exception(_window); + } + + /// clear the image from the output window. + /// see zbar_window_draw() + void clear() + { + if (zbar_window_draw(_window, NULL) < 0) + throw_exception(_window); + } + + /// redraw the last image. + /// zbar_window_redraw() + void redraw() + { + if (zbar_window_redraw(_window) < 0) + throw_exception(_window); + } + + /// resize the image window. + /// zbar_window_resize() + void resize(unsigned width, unsigned height) + { + if (zbar_window_resize(_window, width, height) < 0) + throw_exception(_window); + } + +private: + zbar_window_t *_window; +}; + +/// select a compatible format between video input and output window. +/// see zbar_negotiate_format() +static inline void negotiate_format(Video &video, Window &window) +{ + if (zbar_negotiate_format(video, window) < 0) + throw_exception(video); +} + +} // namespace zbar + +#endif diff --git a/include/zbar/zbargtk.h b/include/zbar/zbargtk.h new file mode 100644 index 0000000..217f502 --- /dev/null +++ b/include/zbar/zbargtk.h @@ -0,0 +1,253 @@ +/*------------------------------------------------------------------------ + * Copyright 2008-2009 (c) Jeff Brown <spadix@users.sourceforge.net> + * + * This file is part of the ZBar Bar Code Reader. + * + * The ZBar Bar Code Reader is free software; you can redistribute it + * and/or modify it under the terms of the GNU Lesser Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * The ZBar Bar Code Reader is distributed in the hope that it will be + * useful, but WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser Public License for more details. + * + * You should have received a copy of the GNU Lesser Public License + * along with the ZBar Bar Code Reader; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA + * + * http://sourceforge.net/projects/zbar + *------------------------------------------------------------------------*/ +#ifndef __ZBAR_GTK_H__ +#define __ZBAR_GTK_H__ + +/* + * NOTE: before modifying this file, please see: + * + * https://wiki.gnome.org/Projects/GObjectIntrospection/Annotations/ + * https://gi.readthedocs.io/en/latest/annotations/giannotations.html + * + * For the annotations needed for Gobject Introspection (GIR) to work + */ + +/** + * SECTION:ZBarGtk + * @short_description: barcode reader GTK+ 2.x widget + * @Title: ZBar Gtk bindings + * @include: zbar/zbargtk.h + * + * embeds a barcode reader directly into a GTK+ based GUI. the widget + * can process barcodes from a video source (using the + * #ZBarGtk:video-device and #ZBarGtk:video-enabled properties) or + * from individual GdkPixbufs supplied to zbar_gtk_scan_image() + * + * Since: 1.0 + */ + +#include <glib.h> +#include <glib-object.h> +#include <gtk/gtk.h> + +#include <zbar.h> + +G_BEGIN_DECLS + +/* --- type macros --- */ +#define ZBAR_TYPE_GTK (zbar_gtk_get_type()) +#define ZBAR_GTK(object) \ + (G_TYPE_CHECK_INSTANCE_CAST((object), ZBAR_TYPE_GTK, ZBarGtk)) +#define ZBAR_GTK_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), ZBAR_TYPE_GTK, ZBarGtkClass)) +#define ZBAR_IS_GTK(object) \ + (G_TYPE_CHECK_INSTANCE_TYPE((object), ZBAR_TYPE_GTK)) +#define ZBAR_IS_GTK_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), ZBAR_TYPE_GTK)) +#define ZBAR_GTK_GET_CLASS(object) \ + (G_TYPE_INSTANCE_GET_CLASS((object), ZBAR_TYPE_GTK, ZBarGtkClass)) + +/* --- typedefs & structures --- */ + +typedef struct _ZBarGtk ZBarGtk; +typedef struct _ZBarGtkClass ZBarGtkClass; + +/** + * _ZBarGtk: (rename-to ZBarGtk) (ref-func zbar_gtk_new) (get-value-func zbar_gtk_get_type) + * @widget: pointer to GtkWidget + * @_private: used internally + */ +struct _ZBarGtk { + GtkWidget widget; + gpointer *_private; + + /* properties */ + + /* + * ZBarGtk:video-device: + * + * the currently set video device. + * + * setting a new device opens it and automatically sets + * #ZBarGtk:video-enabled. set the empty string ("") or NULL to + * close. + */ + + /* + * ZBarGtk:video-enabled: + * + * video device streaming state. + * + * use to pause/resume video scanning. + */ + + /* + * ZBarGtk:video-opened: + * + * video device opened state. + * + * (re)setting #ZBarGtk:video-device should eventually cause it + * to be opened or closed. any errors while streaming/scanning + * will also cause the device to be closed + */ +}; + +/** + * _ZBarGtkClass: + */ +struct _ZBarGtkClass { + GtkWidgetClass parent_class; + + /* signals */ + + /** + * ZBarGtk::decoded: + * @widget: the object that received the signal + * @symbol_type: the type of symbol decoded (a zbar_symbol_type_t) + * @data: the data decoded from the symbol + * + * emitted when a barcode is decoded from an image. + * the symbol type and contained data are provided as separate + * parameters + */ + void (*decoded)(ZBarGtk *zbar, zbar_symbol_type_t symbol_type, + const char *data); + + /** + * ZBarGtk::decoded-text: + * @widget: the object that received the signal + * @text: the decoded data prefixed by the string name of the + * symbol type (separated by a colon) + * + * emitted when a barcode is decoded from an image. + * the symbol type name is prefixed to the data, separated by a + * colon + */ + void (*decoded_text)(ZBarGtk *zbar, const char *text); + + /** + * ZBarGtk:scan-image: + * @widget: the object that received the signal + * @image: the image to scan for barcodes + */ + void (*scan_image)(ZBarGtk *zbar, GdkPixbuf *image); +}; + +/** + * zbar_gtk_get_type: (skip) + * Returns ZBarGtk type + * @returns: #GType + */ +GType zbar_gtk_get_type(void) G_GNUC_CONST; + +/** + * zbar_gtk_new: + * create a new barcode reader widget instance. + * initially has no associated video device or image. + * + * Returns: (transfer full): a new #ZBarGtk widget instance + */ +GtkWidget *zbar_gtk_new(void); + +/** + * zbar_gtk_scan_image: + * @zbar: pointer to #ZBarGtk + * @image: the GdkPixbuf used to store the image + * + */ +void zbar_gtk_scan_image(ZBarGtk *zbar, GdkPixbuf *image); + +/** + * zbar_gtk_get_video_device: + * retrieve the currently opened video device. + * @zbar: pointer to #ZBarGtk + * + * Returns: the current video device or NULL if no device is opened + */ +const char *zbar_gtk_get_video_device(ZBarGtk *zbar); + +/** + * zbar_gtk_set_video_device: + * open a new video device. + * @zbar: pointer to #ZBarGtk + * @video_device: (nullable) (type filename) : the platform specific name of + * the device to open. use NULL to close a currently opened device. + * + * @note since opening a device may take some time, this call will + * return immediately and the device will be opened asynchronously + */ +void zbar_gtk_set_video_device(ZBarGtk *zbar, const char *video_device); + +/** + * zbar_gtk_get_video_enabled: + * retrieve the current video enabled state. + * @zbar: pointer to #ZBarGtk + * + * Returns: true if video scanning is currently enabled, false otherwise + */ +gboolean zbar_gtk_get_video_enabled(ZBarGtk *zbar); + +/** + * zbar_gtk_set_video_enabled: + * enable/disable video scanning. + * @zbar: pointer to #ZBarGtk + * @video_enabled: true to enable video scanning, false to disable + * + * has no effect unless a video device is opened + */ +void zbar_gtk_set_video_enabled(ZBarGtk *zbar, gboolean video_enabled); + +/** + * zbar_gtk_get_video_opened: + * retrieve the current video opened state. + * @zbar: pointer to #ZBarGtk + * + * Returns: true if video device is currently opened, false otherwise + */ +gboolean zbar_gtk_get_video_opened(ZBarGtk *zbar); + +/** + * zbar_gtk_request_video_size: + * set video camera resolution. + * @zbar: pointer to #ZBarGtk + * @width: width in pixels + * @height: height in pixels + * + * @note this call must be made before video is initialized + */ +void zbar_gtk_request_video_size(ZBarGtk *zbar, int width, int height); + +/** + * zbar_gtk_image_from_pixbuf: + * utility function to populate a zbar_image_t from a GdkPixbuf. + * @image: (type gpointer) : the zbar library image destination to populate + * @pixbuf: the GdkPixbuf source + * + * Returns: TRUE if successful or FALSE if the conversion could not be + * performed for some reason + */ +gboolean zbar_gtk_image_from_pixbuf(zbar_image_t *image, GdkPixbuf *pixbuf); + +G_END_DECLS + +#endif |