This repository has been archived by the owner on Oct 25, 2022. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathzbar.h
executable file
·1498 lines (1297 loc) · 52.5 KB
/
zbar.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*------------------------------------------------------------------------
* 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_
/** @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_CODE93 = 93, /**< Code 93. @since 0.11 */
ZBAR_CODE128 = 128, /**< Code 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_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_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;
/** 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);
/** 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;
/** 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);
/** 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 ouput 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);
/** 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