Adding upstream version 0.23.93.upstream/0.23.93upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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