diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBarcodeFormat.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBarcodeFormat.h
new file mode 100644
index 0000000000000000000000000000000000000000..4f7459966a78fa36811b010fa22eed3750cd3f78
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBarcodeFormat.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Enumerates barcode formats known to this package. Please keep alphabetized.
+ */
+typedef enum {
+ /** Aztec 2D barcode format. */
+ kBarcodeFormatAztec,
+
+ /** CODABAR 1D format. */
+ kBarcodeFormatCodabar,
+
+ /** Code 39 1D format. */
+ kBarcodeFormatCode39,
+
+ /** Code 93 1D format. */
+ kBarcodeFormatCode93,
+
+ /** Code 128 1D format. */
+ kBarcodeFormatCode128,
+
+ /** Data Matrix 2D barcode format. */
+ kBarcodeFormatDataMatrix,
+
+ /** EAN-8 1D format. */
+ kBarcodeFormatEan8,
+
+ /** EAN-13 1D format. */
+ kBarcodeFormatEan13,
+
+ /** ITF (Interleaved Two of Five) 1D format. */
+ kBarcodeFormatITF,
+
+ /** MaxiCode 2D barcode format. */
+ kBarcodeFormatMaxiCode,
+
+ /** PDF417 format. */
+ kBarcodeFormatPDF417,
+
+ /** QR Code 2D barcode format. */
+ kBarcodeFormatQRCode,
+
+ /** RSS 14 */
+ kBarcodeFormatRSS14,
+
+ /** RSS EXPANDED */
+ kBarcodeFormatRSSExpanded,
+
+ /** UPC-A 1D format. */
+ kBarcodeFormatUPCA,
+
+ /** UPC-E 1D format. */
+ kBarcodeFormatUPCE,
+
+ /** UPC/EAN extension format. Not a stand-alone format. */
+ kBarcodeFormatUPCEANExtension
+} ZXBarcodeFormat;
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBinarizer.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBinarizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..5b3beb9c004ac10e7e0c5141f963bcecf5b9823a
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBinarizer.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if TARGET_OS_EMBEDDED || TARGET_IPHONE_SIMULATOR
+#include <ImageIO/ImageIO.h>
+#else
+#import <QuartzCore/QuartzCore.h>
+#endif
+
+#import "ZXBitArray.h"
+#import "ZXBitMatrix.h"
+#import "ZXLuminanceSource.h"
+
+/**
+ * This class hierarchy provides a set of methods to convert luminance data to 1 bit data.
+ * It allows the algorithm to vary polymorphically, for example allowing a very expensive
+ * thresholding technique for servers and a fast one for mobile. It also permits the implementation
+ * to vary, e.g. a JNI version for Android and a Java fallback version for other platforms.
+ */
+
+@interface ZXBinarizer : NSObject
+
+@property (nonatomic, retain, readonly) ZXLuminanceSource *luminanceSource;
+@property (nonatomic, assign, readonly) int width;
+@property (nonatomic, assign, readonly) int height;
+
+- (id)initWithSource:(ZXLuminanceSource *)source;
++ (id)binarizerWithSource:(ZXLuminanceSource *)source;
+- (ZXBitMatrix *)blackMatrixWithError:(NSError **)error;
+- (ZXBitArray *)blackRow:(int)y row:(ZXBitArray *)row error:(NSError **)error;
+- (ZXBinarizer *)createBinarizer:(ZXLuminanceSource *)source;
+- (CGImageRef)createImage;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBinarizer.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBinarizer.m
new file mode 100644
index 0000000000000000000000000000000000000000..cc31a9802f8fe2b1c2c7762689adda942cee05cc
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBinarizer.m
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBinarizer.h"
+
+#if TARGET_OS_EMBEDDED || TARGET_IPHONE_SIMULATOR
+#import <UIKit/UIKit.h>
+#define ZXBlack [[UIColor blackColor] CGColor]
+#define ZXWhite [[UIColor whiteColor] CGColor]
+#else
+#define ZXBlack CGColorGetConstantColor(kCGColorBlack)
+#define ZXWhite CGColorGetConstantColor(kCGColorWhite)
+#endif
+
+@interface ZXBinarizer ()
+
+@property (nonatomic, retain) ZXLuminanceSource *luminanceSource;
+
+@end
+
+@implementation ZXBinarizer
+
+@synthesize luminanceSource;
+
+- (id)initWithSource:(ZXLuminanceSource *)source {
+ if (self = [super init]) {
+ self.luminanceSource = source;
+ }
+
+ return self;
+}
+
++ (id)binarizerWithSource:(ZXLuminanceSource *)source {
+ return [[[self alloc] initWithSource:source] autorelease];
+}
+
+- (void)dealloc {
+ [luminanceSource release];
+
+ [super dealloc];
+}
+
+
+/**
+ * Converts one row of luminance data to 1 bit data. May actually do the conversion, or return
+ * cached data. Callers should assume this method is expensive and call it as seldom as possible.
+ * This method is intended for decoding 1D barcodes and may choose to apply sharpening.
+ * For callers which only examine one row of pixels at a time, the same BitArray should be reused
+ * and passed in with each call for performance. However it is legal to keep more than one row
+ * at a time if needed.
+ */
+- (ZXBitArray *)blackRow:(int)y row:(ZXBitArray *)row error:(NSError **)error {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+
+/**
+ * Converts a 2D array of luminance data to 1 bit data. As above, assume this method is expensive
+ * and do not call it repeatedly. This method is intended for decoding 2D barcodes and may or
+ * may not apply sharpening. Therefore, a row from this matrix may not be identical to one
+ * fetched using blackRow(), so don't mix and match between them.
+ */
+- (ZXBitMatrix *)blackMatrixWithError:(NSError **)error {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+
+/**
+ * Creates a new object with the same type as this Binarizer implementation, but with pristine
+ * state. This is needed because Binarizer implementations may be stateful, e.g. keeping a cache
+ * of 1 bit data. See Effective Java for why we can't use Java's clone() method.
+ */
+- (ZXBinarizer *)createBinarizer:(ZXLuminanceSource *)source {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+- (CGImageRef)createImage {
+ ZXBitMatrix *matrix = [self blackMatrixWithError:nil];
+ if (!matrix) {
+ return nil;
+ }
+ ZXLuminanceSource *source = [self luminanceSource];
+
+ int width = source.width;
+ int height = source.height;
+
+ int bytesPerRow = ((width&0xf)>>4)<<4;
+
+ CGColorSpaceRef gray = CGColorSpaceCreateDeviceGray();
+ CGContextRef context = CGBitmapContextCreate (
+ 0,
+ width,
+ height,
+ 8, // bits per component
+ bytesPerRow,
+ gray,
+ kCGImageAlphaNone);
+ CGColorSpaceRelease(gray);
+
+ CGRect r = CGRectZero;
+ r.size.width = width;
+ r.size.height = height;
+ CGContextSetFillColorWithColor(context, ZXBlack);
+ CGContextFillRect(context, r);
+
+ r.size.width = 1;
+ r.size.height = 1;
+
+ CGContextSetFillColorWithColor(context, ZXWhite);
+ for(int y=0; y<height; y++) {
+ r.origin.y = height-1-y;
+ for(int x=0; x<width; x++) {
+ if (![matrix getX:x y:y]) {
+ r.origin.x = x;
+ CGContextFillRect(context, r);
+ }
+ }
+ }
+
+ CGImageRef binary = CGBitmapContextCreateImage(context);
+ [NSMakeCollectable(binary) autorelease];
+
+ CGContextRelease(context);
+
+ return binary;
+}
+
+- (int)width {
+ return self.luminanceSource.width;
+}
+
+- (int)height {
+ return self.luminanceSource.height;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBinaryBitmap.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBinaryBitmap.h
new file mode 100644
index 0000000000000000000000000000000000000000..43ef35fcd3a3ddc458fb1411b33214f8f60dfc01
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBinaryBitmap.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This class is the core bitmap class used by ZXing to represent 1 bit data. Reader objects
+ * accept a BinaryBitmap and attempt to decode it.
+ */
+
+@class ZXBinarizer, ZXBitArray, ZXBitMatrix;
+
+@interface ZXBinaryBitmap : NSObject
+
+@property (nonatomic, readonly) int width;
+@property (nonatomic, readonly) int height;
+@property (nonatomic, readonly) BOOL cropSupported;
+@property (nonatomic, readonly) BOOL rotateSupported;
+
+- (id)initWithBinarizer:(ZXBinarizer *)binarizer;
++ (id)binaryBitmapWithBinarizer:(ZXBinarizer *)binarizer;
+- (ZXBitArray *)blackRow:(int)y row:(ZXBitArray *)row error:(NSError **)error;
+- (ZXBitMatrix *)blackMatrixWithError:(NSError **)error;
+- (ZXBinaryBitmap *)crop:(int)left top:(int)top width:(int)width height:(int)height;
+- (ZXBinaryBitmap *)rotateCounterClockwise;
+- (ZXBinaryBitmap *)rotateCounterClockwise45;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBinaryBitmap.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBinaryBitmap.m
new file mode 100644
index 0000000000000000000000000000000000000000..b532a267156a80037efc20dcfc4eb3380ebdb46c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXBinaryBitmap.m
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBinarizer.h"
+#import "ZXBinaryBitmap.h"
+#import "ZXBitArray.h"
+#import "ZXBitMatrix.h"
+
+@interface ZXBinaryBitmap ()
+
+@property (nonatomic, retain) ZXBinarizer *binarizer;
+@property (nonatomic, retain) ZXBitMatrix *matrix;
+
+@end
+
+@implementation ZXBinaryBitmap
+
+@synthesize binarizer;
+@synthesize matrix;
+
+- (id)initWithBinarizer:(ZXBinarizer *)aBinarizer {
+ if (self = [super init]) {
+ if (aBinarizer == nil) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Binarizer must be non-null."];
+ }
+
+ self.binarizer = aBinarizer;
+ }
+
+ return self;
+}
+
++ (id)binaryBitmapWithBinarizer:(ZXBinarizer *)binarizer {
+ return [[[self alloc] initWithBinarizer:binarizer] autorelease];
+}
+
+- (void)dealloc {
+ [binarizer release];
+ [matrix release];
+
+ [super dealloc];
+}
+
+- (int)width {
+ return self.binarizer.width;
+}
+
+- (int)height {
+ return self.binarizer.height;
+}
+
+
+/**
+ * Converts one row of luminance data to 1 bit data. May actually do the conversion, or return
+ * cached data. Callers should assume this method is expensive and call it as seldom as possible.
+ * This method is intended for decoding 1D barcodes and may choose to apply sharpening.
+ */
+- (ZXBitArray *)blackRow:(int)y row:(ZXBitArray *)row error:(NSError **)error {
+ return [self.binarizer blackRow:y row:row error:error];
+}
+
+
+/**
+ * Converts a 2D array of luminance data to 1 bit. As above, assume this method is expensive
+ * and do not call it repeatedly. This method is intended for decoding 2D barcodes and may or
+ * may not apply sharpening. Therefore, a row from this matrix may not be identical to one
+ * fetched using blackRow(), so don't mix and match between them.
+ */
+- (ZXBitMatrix *)blackMatrixWithError:(NSError **)error {
+ if (self.matrix == nil) {
+ self.matrix = [self.binarizer blackMatrixWithError:error];
+ }
+ return self.matrix;
+}
+
+
+- (BOOL)cropSupported {
+ return [[binarizer luminanceSource] cropSupported];
+}
+
+
+/**
+ * Returns a new object with cropped image data. Implementations may keep a reference to the
+ * original data rather than a copy. Only callable if isCropSupported() is true.
+ */
+- (ZXBinaryBitmap *)crop:(int)left top:(int)top width:(int)aWidth height:(int)aHeight {
+ ZXLuminanceSource *newSource = [[self.binarizer luminanceSource] crop:left top:top width:aWidth height:aHeight];
+ return [[[ZXBinaryBitmap alloc] initWithBinarizer:[self.binarizer createBinarizer:newSource]] autorelease];
+}
+
+- (BOOL)rotateSupported {
+ return [[binarizer luminanceSource] rotateSupported];
+}
+
+
+/**
+ * Returns a new object with rotated image data by 90 degrees counterclockwise.
+ * Only callable if isRotateSupported() is true.
+ */
+- (ZXBinaryBitmap *)rotateCounterClockwise {
+ ZXLuminanceSource *newSource = [[self.binarizer luminanceSource] rotateCounterClockwise];
+ return [[[ZXBinaryBitmap alloc] initWithBinarizer:[self.binarizer createBinarizer:newSource]] autorelease];
+}
+
+- (ZXBinaryBitmap *)rotateCounterClockwise45 {
+ ZXLuminanceSource *newSource = [[self.binarizer luminanceSource] rotateCounterClockwise45];
+ return [[[ZXBinaryBitmap alloc] initWithBinarizer:[self.binarizer createBinarizer:newSource]] autorelease];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXDecodeHints.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXDecodeHints.h
new file mode 100644
index 0000000000000000000000000000000000000000..872475abb116fb6023be1856d8ac43bf4e3c749f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXDecodeHints.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeFormat.h"
+
+@protocol ZXResultPointCallback;
+
+/**
+ * Encapsulates hints that a caller may pass to a barcode reader to help it
+ * more quickly or accurately decode it. It is up to implementations to decide what,
+ * if anything, to do with the information that is supplied.
+ */
+@interface ZXDecodeHints : NSObject <NSCopying>
+
++ (id)hints;
+
+/**
+ * Assume Code 39 codes employ a check digit. Maps to {@link Boolean}.
+ */
+@property (nonatomic, assign) BOOL assumeCode39CheckDigit;
+
+/**
+ * Allowed lengths of encoded data -- reject anything else. Maps to an int[].
+ */
+@property (nonatomic, retain) NSArray *allowedLengths;
+
+/**
+ * Specifies what character encoding to use when decoding, where applicable (type String)
+ */
+@property (nonatomic, assign) NSStringEncoding encoding;
+
+/**
+ * Unspecified, application-specific hint.
+ */
+@property (nonatomic, retain) id other;
+
+/**
+ * Image is a pure monochrome image of a barcode.
+ */
+@property (nonatomic, assign) BOOL pureBarcode;
+
+/**
+ * The caller needs to be notified via callback when a possible {@link ResultPoint}
+ * is found. Maps to a {@link ResultPointCallback}.
+ */
+@property (nonatomic, retain) id <ZXResultPointCallback> resultPointCallback;
+
+/**
+ * Spend more time to try to find a barcode; optimize for accuracy, not speed.
+ */
+@property (nonatomic, assign) BOOL tryHarder;
+
+/**
+ * Image is known to be of one of a few possible formats.
+ */
+- (void)addPossibleFormat:(ZXBarcodeFormat)format;
+- (BOOL)containsFormat:(ZXBarcodeFormat)format;
+- (int)numberOfPossibleFormats;
+- (void)removePossibleFormat:(ZXBarcodeFormat)format;
+
+@end
\ No newline at end of file
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXDecodeHints.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXDecodeHints.m
new file mode 100644
index 0000000000000000000000000000000000000000..14921d9578773540b2614bf07bf64da6e0d7e793
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXDecodeHints.m
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecodeHints.h"
+#import "ZXResultPointCallback.h"
+
+@interface ZXDecodeHints ()
+
+@property (nonatomic, retain) NSMutableArray *barcodeFormats;
+
+@end
+
+@implementation ZXDecodeHints
+
+@synthesize assumeCode39CheckDigit;
+@synthesize allowedLengths;
+@synthesize barcodeFormats;
+@synthesize encoding;
+@synthesize other;
+@synthesize pureBarcode;
+@synthesize resultPointCallback;
+@synthesize tryHarder;
+
+- (id)init {
+ if (self = [super init]) {
+ self.barcodeFormats = [NSMutableArray array];
+ }
+
+ return self;
+}
+
++ (id)hints {
+ return [[[self alloc] init] autorelease];
+}
+
+- (id)copyWithZone:(NSZone *)zone {
+ ZXDecodeHints *result = [[[self class] allocWithZone:zone] init];
+ if (result) {
+ result.assumeCode39CheckDigit = self.assumeCode39CheckDigit;
+ result.allowedLengths = [[self.allowedLengths copy] autorelease];
+
+ for (NSNumber *formatNumber in self.barcodeFormats) {
+ [result addPossibleFormat:[formatNumber intValue]];
+ }
+
+ result.encoding = self.encoding;
+ result.other = self.other;
+ result.pureBarcode = self.pureBarcode;
+ result.resultPointCallback = self.resultPointCallback;
+ result.tryHarder = self.tryHarder;
+ }
+
+ return result;
+}
+
+- (void)dealloc {
+ [allowedLengths release];
+ [barcodeFormats release];
+ [other release];
+ [resultPointCallback release];
+
+ [super dealloc];
+}
+
+- (void)addPossibleFormat:(ZXBarcodeFormat)format {
+ [self.barcodeFormats addObject:[NSNumber numberWithInt:format]];
+}
+
+- (BOOL)containsFormat:(ZXBarcodeFormat)format {
+ return [self.barcodeFormats containsObject:[NSNumber numberWithInt:format]];
+}
+
+- (int)numberOfPossibleFormats {
+ return self.barcodeFormats.count;
+}
+
+- (void)removePossibleFormat:(ZXBarcodeFormat)format {
+ [self.barcodeFormats removeObject:[NSNumber numberWithInt:format]];
+}
+
+@end
\ No newline at end of file
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXDimension.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXDimension.h
new file mode 100644
index 0000000000000000000000000000000000000000..21eaf1a8012b19b9d05673be1856b52d70557695
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXDimension.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Simply encapsulates a width and height.
+ */
+
+@interface ZXDimension : NSObject
+
+@property (nonatomic, assign, readonly) int height;
+@property (nonatomic, assign, readonly) int width;
+
+- (id)initWithWidth:(int)width height:(int)height;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXDimension.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXDimension.m
new file mode 100644
index 0000000000000000000000000000000000000000..b8ddbac1d24af0105f24c7d2010edba68df75cd6
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXDimension.m
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDimension.h"
+
+@interface ZXDimension ()
+
+@property (nonatomic, assign) int height;
+@property (nonatomic, assign) int width;
+
+@end
+
+@implementation ZXDimension
+
+@synthesize width = _width;
+@synthesize height = _height;
+
+- (id)initWithWidth:(int)width height:(int)height {
+ if (width < 0 || height < 0) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Width and height must not be negative"];
+ }
+
+ if (self = [super init]) {
+ _width = width;
+ _height = height;
+ }
+
+ return self;
+}
+
+- (BOOL)isEqual:(id)other {
+ if ([other isKindOfClass:[ZXDimension class]]) {
+ ZXDimension *d = (ZXDimension *)other;
+ return self.width == d.width && self.height == d.height;
+ }
+ return NO;
+}
+
+- (NSUInteger)hash {
+ return self.width * 32713 + self.height;
+}
+
+- (NSString *)description {
+ return [NSString stringWithFormat:@"%dx%d", self.width, self.height];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXEncodeHints.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXEncodeHints.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c91a5f9ed40665a3c1f7c9e04bc6a9399b07f09
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXEncodeHints.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXCompaction.h"
+#import "ZXDimensions.h"
+#import "ZXErrorCorrectionLevel.h"
+#import "ZXSymbolShapeHint.h"
+
+/**
+ * These are a set of hints that you may pass to Writers to specify their behavior.
+ */
+
+@class ZXDimension, ZXSymbolShapeHint;
+
+@interface ZXEncodeHints : NSObject
+
++ (id)hints;
+
+/**
+ * Specifies what character encoding to use where applicable.
+ */
+@property (nonatomic, assign) NSStringEncoding encoding;
+
+/**
+ * Specifies the matrix shape for Data Matrix .
+ */
+@property (nonatomic, retain) ZXSymbolShapeHint *dataMatrixShape;
+
+/**
+ * Specifies a minimum barcode size. Only applicable to Data Matrix now.
+ */
+@property (nonatomic, retain) ZXDimension *minSize;
+
+/**
+ * Specifies a maximum barcode size. Only applicable to Data Matrix now.
+ */
+@property (nonatomic, retain) ZXDimension *maxSize;
+
+/**
+ * Specifies what degree of error correction to use, for example in QR Codes.
+ */
+@property (nonatomic, retain) ZXErrorCorrectionLevel *errorCorrectionLevel;
+
+/**
+ * Specifies margin, in pixels, to use when generating the barcode. The meaning can vary
+ * by format; for example it controls margin before and after the barcode horizontally for
+ * most 1D formats.
+ */
+@property (nonatomic, retain) NSNumber *margin;
+
+/**
+ * Specifies whether to use compact mode for PDF417.
+ */
+@property (nonatomic, assign) BOOL pdf417Compact;
+
+/**
+ * Specifies what compaction mode to use for PDF417.
+ */
+@property (nonatomic, assign) ZXCompaction pdf417Compaction;
+
+/**
+ * Specifies the minimum and maximum number of rows and columns for PDF417.
+ */
+@property (nonatomic, retain) ZXDimensions *pdf417Dimensions;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXEncodeHints.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXEncodeHints.m
new file mode 100644
index 0000000000000000000000000000000000000000..bb69021bc317c5aef182d8694bbb2b515cc10804
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXEncodeHints.m
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXEncodeHints.h"
+
+@implementation ZXEncodeHints
+
+@synthesize encoding;
+@synthesize dataMatrixShape;
+@synthesize minSize;
+@synthesize maxSize;
+@synthesize errorCorrectionLevel;
+@synthesize margin;
+@synthesize pdf417Compact;
+@synthesize pdf417Compaction;
+@synthesize pdf417Dimensions;
+
++ (id)hints {
+ return [[[self alloc] init] autorelease];
+}
+
+- (void)dealloc {
+ [dataMatrixShape release];
+ [minSize release];
+ [maxSize release];
+ [errorCorrectionLevel release];
+ [margin release];
+ [pdf417Dimensions release];
+
+ [super dealloc];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXErrors.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXErrors.h
new file mode 100644
index 0000000000000000000000000000000000000000..2f090c20adb29daa80960121f697734be9ae2648
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXErrors.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define ZXErrorDomain @"ZXErrorDomain"
+
+enum {
+ /**
+ * Thrown when a barcode was successfully detected and decoded, but
+ * was not returned because its checksum feature failed.
+ */
+ ZXChecksumError = 1000,
+
+ /**
+ * Thrown when a barcode was successfully detected, but some aspect of
+ * the content did not conform to the barcode's format rules. This could have
+ * been due to a mis-detection.
+ */
+ ZXFormatError = 1001,
+
+ /**
+ * Thrown when a barcode was not found in the image. It might have been
+ * partially detected but could not be confirmed.
+ */
+ ZXNotFoundError = 1002,
+
+ /**
+ * Thrown when an exception occurs during Reed-Solomon decoding, such as when
+ * there are too many errors to correct.
+ */
+ ZXReedSolomonError = 1003,
+
+ /**
+ * This general error is thrown when something goes wrong during decoding of a barcode.
+ * This includes, but is not limited to, failing checksums / error correction algorithms, being
+ * unable to locate finder timing patterns, and so on.
+ */
+ ZXReaderError = 1004,
+
+ /**
+ * Covers the range of error which may occur when encoding a barcode using the Writer framework.
+ */
+ ZXWriterError = 1005
+};
+
+// Helper methods for error instances
+NSError *ChecksumErrorInstance(void);
+NSError *FormatErrorInstance(void);
+NSError *NotFoundErrorInstance(void);
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXErrors.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXErrors.m
new file mode 100644
index 0000000000000000000000000000000000000000..a660b9f4aa5aa737500980d8cfeba5740cfa34c4
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXErrors.m
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXErrors.h"
+
+NSError *ChecksumErrorInstance() {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"This barcode failed its checksum"
+ forKey:NSLocalizedDescriptionKey];
+
+ return [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXChecksumError userInfo:userInfo] autorelease];
+}
+
+NSError *FormatErrorInstance() {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"This barcode does not confirm to the format's rules"
+ forKey:NSLocalizedDescriptionKey];
+
+ return [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXFormatError userInfo:userInfo] autorelease];
+}
+
+NSError *NotFoundErrorInstance() {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"A barcode was not found in this image"
+ forKey:NSLocalizedDescriptionKey];
+
+ return [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXNotFoundError userInfo:userInfo] autorelease];
+}
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXInvertedLuminanceSource.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXInvertedLuminanceSource.h
new file mode 100644
index 0000000000000000000000000000000000000000..6d5ef105171d7d6915b6ed779ea166789d68c990
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXInvertedLuminanceSource.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXLuminanceSource.h"
+
+/**
+ * A wrapper implementation of ZXLuminanceSource which inverts the luminances it returns -- black becomes
+ * white and vice versa, and each value becomes (255-value).
+ */
+@interface ZXInvertedLuminanceSource : ZXLuminanceSource {
+ ZXLuminanceSource *_delegate;
+}
+
+- (id)initWithDelegate:(ZXLuminanceSource *)delegate;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXInvertedLuminanceSource.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXInvertedLuminanceSource.m
new file mode 100644
index 0000000000000000000000000000000000000000..45e976513ed94d2d052f0ce6d1650a7dfa0b2298
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXInvertedLuminanceSource.m
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXInvertedLuminanceSource.h"
+
+@implementation ZXInvertedLuminanceSource
+
+- (id)initWithDelegate:(ZXLuminanceSource *)delegate {
+ self = [super initWithWidth:delegate.width height:delegate.height];
+ if (self) {
+ _delegate = [delegate retain];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [_delegate release];
+
+ [super dealloc];
+}
+
+- (unsigned char *)row:(int)y {
+ unsigned char *row = [_delegate row:y];
+ for (int i = 0; i < self.width; i++) {
+ row[i] = (unsigned char) (255 - (row[i] & 0xFF));
+ }
+ return row;
+}
+
+- (unsigned char *)matrix {
+ unsigned char *matrix = [_delegate matrix];
+ int length = self.width * self.height;
+ unsigned char *invertedMatrix = (unsigned char *)malloc(length * sizeof(unsigned char));
+ for (int i = 0; i < length; i++) {
+ invertedMatrix[i] = (unsigned char) (255 - (matrix[i] & 0xFF));
+ }
+ free(matrix);
+ return invertedMatrix;
+}
+
+- (BOOL)cropSupported {
+ return _delegate.cropSupported;
+}
+
+- (ZXLuminanceSource *)crop:(int)left top:(int)top width:(int)aWidth height:(int)aHeight {
+ return [[[ZXInvertedLuminanceSource alloc] initWithDelegate:[_delegate crop:left top:top width:aWidth height:aHeight]] autorelease];
+}
+
+- (BOOL)rotateSupported {
+ return _delegate.rotateSupported;
+}
+
+/**
+ * Returns original delegate ZXLuminanceSource since invert undoes itself
+ */
+- (ZXLuminanceSource *)invert {
+ return _delegate;
+}
+
+- (ZXLuminanceSource *)rotateCounterClockwise {
+ return [[[ZXInvertedLuminanceSource alloc] initWithDelegate:[_delegate rotateCounterClockwise]] autorelease];
+}
+
+- (ZXLuminanceSource *)rotateCounterClockwise45 {
+ return [[[ZXInvertedLuminanceSource alloc] initWithDelegate:[_delegate rotateCounterClockwise45]] autorelease];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXLuminanceSource.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXLuminanceSource.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5d7e7f00ea20a08767b405197e0aa97a9cf5f11
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXLuminanceSource.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The purpose of this class hierarchy is to abstract different bitmap implementations across
+ * platforms into a standard interface for requesting greyscale luminance values. The interface
+ * only provides immutable methods; therefore crop and rotation create copies. This is to ensure
+ * that one Reader does not modify the original luminance source and leave it in an unknown state
+ * for other Readers in the chain.
+ */
+
+@interface ZXLuminanceSource : NSObject {
+ int width;
+ int height;
+}
+
+@property (nonatomic, assign, readonly) int width;
+@property (nonatomic, assign, readonly) int height;
+@property (nonatomic, assign, readonly) BOOL cropSupported;
+@property (nonatomic, assign, readonly) BOOL rotateSupported;
+
+- (id)initWithWidth:(int)width height:(int)height;
+- (unsigned char *)row:(int)y;
+- (unsigned char *)matrix;
+- (ZXLuminanceSource *)crop:(int)left top:(int)top width:(int)width height:(int)height;
+- (ZXLuminanceSource *)invert;
+- (ZXLuminanceSource *)rotateCounterClockwise;
+- (ZXLuminanceSource *)rotateCounterClockwise45;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXLuminanceSource.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXLuminanceSource.m
new file mode 100644
index 0000000000000000000000000000000000000000..4bc6bc646b43386872c978f8261124aeaeae2004
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXLuminanceSource.m
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXInvertedLuminanceSource.h"
+#import "ZXLuminanceSource.h"
+
+@interface ZXLuminanceSource ()
+
+@property (nonatomic, assign) int width;
+@property (nonatomic, assign) int height;
+@property (nonatomic, assign) BOOL cropSupported;
+@property (nonatomic, assign) BOOL rotateSupported;
+
+@end
+
+@implementation ZXLuminanceSource
+
+@synthesize width;
+@synthesize height;
+@synthesize cropSupported;
+@synthesize rotateSupported;
+
+- (id)initWithWidth:(int)aWidth height:(int)aHeight {
+ if (self = [super init]) {
+ self.width = aWidth;
+ self.height = aHeight;
+ }
+
+ return self;
+}
+
+
+/**
+ * Fetches one row of luminance data from the underlying platform's bitmap. Values range from
+ * 0 (black) to 255 (white). Because Java does not have an unsigned byte type, callers will have
+ * to bitwise and with 0xff for each value. It is preferable for implementations of this method
+ * to only fetch this row rather than the whole image, since no 2D Readers may be installed and
+ * getMatrix() may never be called.
+ */
+- (unsigned char *)row:(int)y {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+
+/**
+ * Fetches luminance data for the underlying bitmap. Values should be fetched using:
+ * int luminance = array[y * width + x] & 0xff;
+ *
+ * Returns A row-major 2D array of luminance values. Do not use result.length as it may be
+ * larger than width * height bytes on some platforms. Do not modify the contents
+ * of the result.
+ */
+- (unsigned char *)matrix {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+
+/**
+ * Returns a new object with cropped image data. Implementations may keep a reference to the
+ * original data rather than a copy. Only callable if isCropSupported() is true.
+ */
+- (ZXLuminanceSource *)crop:(int)left top:(int)top width:(int)width height:(int)height {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:@"This luminance source does not support cropping."
+ userInfo:nil];
+}
+
+/**
+ * Returns a wrapper of this ZXLuminanceSource which inverts the luminances it returns -- black becomes
+ * white and vice versa, and each value becomes (255-value).
+ */
+- (ZXLuminanceSource *)invert {
+ return [[[ZXInvertedLuminanceSource alloc] initWithDelegate:self] autorelease];
+}
+
+/**
+ * Returns a new object with rotated image data by 90 degrees counterclockwise.
+ * Only callable if isRotateSupported() is true.
+ */
+- (ZXLuminanceSource *)rotateCounterClockwise {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:@"This luminance source does not support rotation by 90 degrees."
+ userInfo:nil];
+}
+
+/**
+ * Returns a new object with rotated image data by 45 degrees counterclockwise.
+ * Only callable if isRotateSupported() is true.
+ */
+- (ZXLuminanceSource *)rotateCounterClockwise45 {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:@"This luminance source does not support rotation by 45 degrees."
+ userInfo:nil];
+}
+
+- (NSString *)description {
+ unsigned char *row = NULL;
+ NSMutableString *result = [NSMutableString stringWithCapacity:height * (width + 1)];
+ for (int y = 0; y < height; y++) {
+ row = [self row:y];
+ for (int x = 0; x < width; x++) {
+ int luminance = row[x] & 0xFF;
+ unichar c;
+ if (luminance < 0x40) {
+ c = '#';
+ } else if (luminance < 0x80) {
+ c = '+';
+ } else if (luminance < 0xC0) {
+ c = '.';
+ } else {
+ c = ' ';
+ }
+ [result appendFormat:@"%C", c];
+ }
+ [result appendString:@"\n"];
+ free(row);
+ row = NULL;
+ }
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXMultiFormatReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXMultiFormatReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..1a6873ce4d86dba50095d7f76e211379ed1c3ef8
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXMultiFormatReader.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXReader.h"
+
+/**
+ * ZXMultiFormatReader is a convenience class and the main entry point into the library for most uses.
+ * By default it attempts to decode all barcode formats that the library supports. Optionally, you
+ * can provide a hints object to request different behavior, for example only decoding QR codes.
+ */
+
+@class ZXDecodeHints;
+
+@interface ZXMultiFormatReader : NSObject <ZXReader>
+
+@property (nonatomic, retain) ZXDecodeHints *hints;
+
++ (id)reader;
+- (ZXResult *)decodeWithState:(ZXBinaryBitmap *)image error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXMultiFormatReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXMultiFormatReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..61efd794dd1f1658c8179b4f68b4f24510db18f4
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXMultiFormatReader.m
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAztecReader.h"
+#import "ZXBinaryBitmap.h"
+#import "ZXDataMatrixReader.h"
+#import "ZXDecodeHints.h"
+#import "ZXErrors.h"
+#import "ZXMaxiCodeReader.h"
+#import "ZXMultiFormatOneDReader.h"
+#import "ZXMultiFormatReader.h"
+#import "ZXPDF417Reader.h"
+#import "ZXQRCodeReader.h"
+#import "ZXResult.h"
+
+@interface ZXMultiFormatReader ()
+
+@property (nonatomic, retain) NSMutableArray *readers;
+
+- (ZXResult *)decodeInternal:(ZXBinaryBitmap *)image error:(NSError **)error;
+
+@end
+
+@implementation ZXMultiFormatReader
+
+@synthesize hints;
+@synthesize readers;
+
+- (id)init {
+ if (self = [super init]) {
+ self.readers = [NSMutableArray array];
+ }
+
+ return self;
+}
+
++ (id)reader {
+ return [[[ZXMultiFormatReader alloc] init] autorelease];
+}
+
+/**
+ * This version of decode honors the intent of Reader.decode(BinaryBitmap) in that it
+ * passes null as a hint to the decoders. However, that makes it inefficient to call repeatedly.
+ * Use setHints() followed by decodeWithState() for continuous scan applications.
+ */
+- (ZXResult *)decode:(ZXBinaryBitmap *)image error:(NSError **)error {
+ self.hints = nil;
+ return [self decodeInternal:image error:error];
+}
+
+
+/**
+ * Decode an image using the hints provided. Does not honor existing state.
+ */
+- (ZXResult *)decode:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)_hints error:(NSError **)error {
+ self.hints = _hints;
+ return [self decodeInternal:image error:error];
+}
+
+
+/**
+ * Decode an image using the state set up by calling setHints() previously. Continuous scan
+ * clients will get a <b>large</b> speed increase by using this instead of decode().
+ */
+- (ZXResult *)decodeWithState:(ZXBinaryBitmap *)image error:(NSError **)error {
+ if (self.readers == nil) {
+ self.hints = nil;
+ }
+ return [self decodeInternal:image error:error];
+}
+
+
+/**
+ * This method adds state to the ZXMultiFormatReader. By setting the hints once, subsequent calls
+ * to decodeWithState(image) can reuse the same set of readers without reallocating memory. This
+ * is important for performance in continuous scan clients.
+ */
+- (void)setHints:(ZXDecodeHints *)_hints {
+ [hints release];
+ hints = [_hints retain];
+
+ BOOL tryHarder = hints != nil && hints.tryHarder;
+ self.readers = [NSMutableArray array];
+ if (hints != nil) {
+ BOOL addZXOneDReader = [hints containsFormat:kBarcodeFormatUPCA] ||
+ [hints containsFormat:kBarcodeFormatUPCE] ||
+ [hints containsFormat:kBarcodeFormatEan13] ||
+ [hints containsFormat:kBarcodeFormatEan8] ||
+ [hints containsFormat:kBarcodeFormatCodabar] ||
+ [hints containsFormat:kBarcodeFormatCode39] ||
+ [hints containsFormat:kBarcodeFormatCode93] ||
+ [hints containsFormat:kBarcodeFormatCode128] ||
+ [hints containsFormat:kBarcodeFormatITF] ||
+ [hints containsFormat:kBarcodeFormatRSS14] ||
+ [hints containsFormat:kBarcodeFormatRSSExpanded];
+ if (addZXOneDReader && !tryHarder) {
+ [self.readers addObject:[[[ZXMultiFormatOneDReader alloc] initWithHints:hints] autorelease]];
+ }
+ if ([hints containsFormat:kBarcodeFormatQRCode]) {
+ [self.readers addObject:[[[ZXQRCodeReader alloc] init] autorelease]];
+ }
+ if ([hints containsFormat:kBarcodeFormatDataMatrix]) {
+ [self.readers addObject:[[[ZXDataMatrixReader alloc] init] autorelease]];
+ }
+ if ([hints containsFormat:kBarcodeFormatAztec]) {
+ [self.readers addObject:[[[ZXAztecReader alloc] init] autorelease]];
+ }
+ if ([hints containsFormat:kBarcodeFormatPDF417]) {
+ [self.readers addObject:[[[ZXPDF417Reader alloc] init] autorelease]];
+ }
+ if ([hints containsFormat:kBarcodeFormatMaxiCode]) {
+ [self.readers addObject:[[[ZXMaxiCodeReader alloc] init] autorelease]];
+ }
+ if (addZXOneDReader && tryHarder) {
+ [self.readers addObject:[[[ZXMultiFormatOneDReader alloc] initWithHints:hints] autorelease]];
+ }
+ }
+ if ([self.readers count] == 0) {
+ if (!tryHarder) {
+ [self.readers addObject:[[[ZXMultiFormatOneDReader alloc] initWithHints:hints] autorelease]];
+ }
+ [self.readers addObject:[[[ZXQRCodeReader alloc] init] autorelease]];
+ [self.readers addObject:[[[ZXDataMatrixReader alloc] init] autorelease]];
+ [self.readers addObject:[[[ZXAztecReader alloc] init] autorelease]];
+ [self.readers addObject:[[[ZXPDF417Reader alloc] init] autorelease]];
+ [self.readers addObject:[[[ZXMaxiCodeReader alloc] init] autorelease]];
+ if (tryHarder) {
+ [self.readers addObject:[[[ZXMultiFormatOneDReader alloc] initWithHints:hints] autorelease]];
+ }
+ }
+}
+
+- (void)reset {
+ if (self.readers != nil) {
+ for (id<ZXReader> reader in self.readers) {
+ [reader reset];
+ }
+ }
+}
+
+- (ZXResult *)decodeInternal:(ZXBinaryBitmap *)image error:(NSError **)error {
+ if (self.readers != nil) {
+ for (id<ZXReader> reader in self.readers) {
+ ZXResult *result = [reader decode:image hints:self.hints error:nil];
+ if (result) {
+ return result;
+ }
+ }
+ }
+
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+}
+
+- (void)dealloc {
+ [hints release];
+ [readers release];
+
+ [super dealloc];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXMultiFormatWriter.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXMultiFormatWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..f83f732bb1cf29b6761100887ef93361effa7e7c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXMultiFormatWriter.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXWriter.h"
+
+/**
+ * This is a factory class which finds the appropriate Writer subclass for the BarcodeFormat
+ * requested and encodes the barcode with the supplied contents.
+ */
+
+@interface ZXMultiFormatWriter : NSObject <ZXWriter>
+
++ (id)writer;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXMultiFormatWriter.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXMultiFormatWriter.m
new file mode 100644
index 0000000000000000000000000000000000000000..646e939d4c549b16df2cb3e6e103b7db03f17cb0
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXMultiFormatWriter.m
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAztecWriter.h"
+#import "ZXBitMatrix.h"
+#import "ZXCodaBarWriter.h"
+#import "ZXCode39Writer.h"
+#import "ZXCode128Writer.h"
+#import "ZXDataMatrixWriter.h"
+#import "ZXEAN8Writer.h"
+#import "ZXEAN13Writer.h"
+#import "ZXITFWriter.h"
+#import "ZXMultiFormatWriter.h"
+#import "ZXPDF417Writer.h"
+#import "ZXQRCodeWriter.h"
+#import "ZXUPCAWriter.h"
+
+@implementation ZXMultiFormatWriter
+
++ (id)writer {
+ return [[[ZXMultiFormatWriter alloc] init] autorelease];
+}
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height error:(NSError **)error {
+ return [self encode:contents format:format width:width height:height hints:nil error:error];
+}
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height hints:(ZXEncodeHints *)hints error:(NSError **)error {
+ id<ZXWriter> writer;
+ switch (format) {
+ case kBarcodeFormatEan8:
+ writer = [[[ZXEAN8Writer alloc] init] autorelease];
+ break;
+
+ case kBarcodeFormatEan13:
+ writer = [[[ZXEAN13Writer alloc] init] autorelease];
+ break;
+
+ case kBarcodeFormatUPCA:
+ writer = [[[ZXUPCAWriter alloc] init] autorelease];
+ break;
+
+ case kBarcodeFormatQRCode:
+ writer = [[[ZXQRCodeWriter alloc] init] autorelease];
+ break;
+
+ case kBarcodeFormatCode39:
+ writer = [[[ZXCode39Writer alloc] init] autorelease];
+ break;
+
+ case kBarcodeFormatCode128:
+ writer = [[[ZXCode128Writer alloc] init] autorelease];
+ break;
+
+ case kBarcodeFormatITF:
+ writer = [[[ZXITFWriter alloc] init] autorelease];
+ break;
+
+ case kBarcodeFormatPDF417:
+ writer = [[[ZXPDF417Writer alloc] init] autorelease];
+ break;
+
+ case kBarcodeFormatCodabar:
+ writer = [[[ZXCodaBarWriter alloc] init] autorelease];
+ break;
+
+ case kBarcodeFormatDataMatrix:
+ writer = [[[ZXDataMatrixWriter alloc] init] autorelease];
+ break;
+
+ case kBarcodeFormatAztec:
+ writer = [[[ZXAztecWriter alloc] init] autorelease];
+ break;
+
+ default:
+ [NSException raise:NSInvalidArgumentException
+ format:@"No encoder available for format"];
+ }
+ return [writer encode:contents format:format width:width height:height hints:hints error:error];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXPlanarYUVLuminanceSource.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXPlanarYUVLuminanceSource.h
new file mode 100644
index 0000000000000000000000000000000000000000..0e0476793ea286fee34cbaafaf00f013eb7cce6f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXPlanarYUVLuminanceSource.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXLuminanceSource.h"
+
+/**
+ * This object extends LuminanceSource around an array of YUV data returned from the camera driver,
+ * with the option to crop to a rectangle within the full data. This can be used to exclude
+ * superfluous pixels around the perimeter and speed up decoding.
+ *
+ * It works for any pixel format where the Y channel is planar and appears first, including
+ * YCbCr_420_SP and YCbCr_422_SP.
+ */
+
+@interface ZXPlanarYUVLuminanceSource : ZXLuminanceSource
+
+@property (nonatomic, assign, readonly) int thumbnailWidth;
+@property (nonatomic, assign, readonly) int thumbnailHeight;
+
+- (id)initWithYuvData:(unsigned char *)yuvData yuvDataLen:(int)yuvDataLen dataWidth:(int)dataWidth
+ dataHeight:(int)dataHeight left:(int)left top:(int)top width:(int)width height:(int)height
+ reverseHorizontal:(BOOL)reverseHorizontal;
+- (int *)renderThumbnail;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXPlanarYUVLuminanceSource.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXPlanarYUVLuminanceSource.m
new file mode 100644
index 0000000000000000000000000000000000000000..c05e3a52bb954e378bc0a0cfed50379610e1f446
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXPlanarYUVLuminanceSource.m
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXPlanarYUVLuminanceSource.h"
+
+const int THUMBNAIL_SCALE_FACTOR = 2;
+
+@interface ZXPlanarYUVLuminanceSource ()
+
+- (void)reverseHorizontal:(int)width height:(int)height;
+
+@end
+
+@implementation ZXPlanarYUVLuminanceSource {
+ unsigned char *yuvData;
+ int yuvDataLen;
+ int dataWidth;
+ int dataHeight;
+ int left;
+ int top;
+}
+
+- (id)initWithYuvData:(unsigned char *)_yuvData yuvDataLen:(int)_yuvDataLen dataWidth:(int)_dataWidth
+ dataHeight:(int)_dataHeight left:(int)_left top:(int)_top width:(int)_width height:(int)_height
+ reverseHorizontal:(BOOL)_reverseHorizontal {
+ if (self = [super initWithWidth:_width height:_height]) {
+ if (_left + _width > _dataWidth || _top + _height > _dataHeight) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Crop rectangle does not fit within image data."];
+
+ }
+
+ yuvDataLen = _yuvDataLen;
+ yuvData = (unsigned char *)malloc(_yuvDataLen * sizeof(unsigned char));
+ memcpy(yuvData, _yuvData, _yuvDataLen);
+ dataWidth = _dataWidth;
+ dataHeight = _dataHeight;
+ left = _left;
+ top = _top;
+ if (_reverseHorizontal) {
+ [self reverseHorizontal:_width height:_height];
+ }
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ if (yuvData != NULL) {
+ free(yuvData);
+ yuvData = NULL;
+ }
+
+ [super dealloc];
+}
+
+- (unsigned char *)row:(int)y {
+ if (y < 0 || y >= self.height) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Requested row is outside the image: %d", y];
+ }
+ unsigned char *row = (unsigned char *)malloc(self.width * sizeof(unsigned char));
+ int offset = (y + top) * dataWidth + left;
+ memcpy(row, yuvData + offset, self.width);
+ return row;
+}
+
+- (unsigned char *)matrix {
+ int area = width * height;
+ unsigned char *matrix = malloc(area * sizeof(unsigned char));
+ int inputOffset = top * dataWidth + left;
+
+ // If the width matches the full width of the underlying data, perform a single copy.
+ if (width == dataWidth) {
+ memcpy(matrix, yuvData + inputOffset, area - inputOffset);
+ return matrix;
+ }
+
+ // Otherwise copy one cropped row at a time.
+ for (int y = 0; y < height; y++) {
+ int outputOffset = y * width;
+ memcpy(matrix + outputOffset, yuvData + inputOffset, self.width);
+ inputOffset += dataWidth;
+ }
+ return matrix;
+}
+
+- (BOOL)cropSupported {
+ return YES;
+}
+
+- (ZXLuminanceSource *)crop:(int)_left top:(int)_top width:(int)_width height:(int)_height {
+ return [[[self class] alloc] initWithYuvData:yuvData yuvDataLen:yuvDataLen dataWidth:dataWidth
+ dataHeight:dataHeight left:left + _left top:top + _top
+ width:_width height:_height reverseHorizontal:NO];
+}
+
+- (int *)renderThumbnail {
+ int thumbWidth = self.width / THUMBNAIL_SCALE_FACTOR;
+ int thumbHeight = self.height / THUMBNAIL_SCALE_FACTOR;
+ int *pixels = (int *)malloc(thumbWidth * thumbHeight * sizeof(int));
+ int inputOffset = top * dataWidth + left;
+
+ for (int y = 0; y < height; y++) {
+ int outputOffset = y * width;
+ for (int x = 0; x < width; x++) {
+ int grey = yuvData[inputOffset + x * THUMBNAIL_SCALE_FACTOR] & 0xff;
+ pixels[outputOffset + x] = 0xFF000000 | (grey * 0x00010101);
+ }
+ inputOffset += dataWidth * THUMBNAIL_SCALE_FACTOR;
+ }
+ return pixels;
+}
+
+- (int)thumbnailWidth {
+ return self.width / THUMBNAIL_SCALE_FACTOR;
+}
+
+- (int)thumbnailHeight {
+ return self.height / THUMBNAIL_SCALE_FACTOR;
+}
+
+- (void)reverseHorizontal:(int)_width height:(int)_height {
+ for (int y = 0, rowStart = top * dataWidth + left; y < _height; y++, rowStart += dataWidth) {
+ int middle = rowStart + _width / 2;
+ for (int x1 = rowStart, x2 = rowStart + _width - 1; x1 < middle; x1++, x2--) {
+ unsigned char temp = yuvData[x1];
+ yuvData[x1] = yuvData[x2];
+ yuvData[x2] = temp;
+ }
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXRGBLuminanceSource.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXRGBLuminanceSource.h
new file mode 100644
index 0000000000000000000000000000000000000000..07a2cb9da09200e239f9f5aed8dc99f61c7fa06f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXRGBLuminanceSource.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXLuminanceSource.h"
+
+/**
+ * This class is used to help decode images from files which arrive as RGB data from
+ * an ARGB pixel array. It does not support rotation.
+ */
+
+@interface ZXRGBLuminanceSource : ZXLuminanceSource
+
+- (id)initWithWidth:(int)width height:(int)height pixels:(int *)pixels pixelsLen:(int)pixelsLen;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXRGBLuminanceSource.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXRGBLuminanceSource.m
new file mode 100644
index 0000000000000000000000000000000000000000..45072562210c6411653fc651dd238680a7169a4c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXRGBLuminanceSource.m
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXRGBLuminanceSource.h"
+
+@interface ZXRGBLuminanceSource ()
+
+@property (nonatomic, assign) unsigned char *luminances;
+@property (nonatomic, assign) int luminancesCount;
+@property (nonatomic, assign) int dataWidth;
+@property (nonatomic, assign) int dataHeight;
+@property (nonatomic, assign) int left;
+@property (nonatomic, assign) int top;
+
+@end
+
+@implementation ZXRGBLuminanceSource
+
+@synthesize luminances;
+@synthesize luminancesCount;
+@synthesize dataWidth;
+@synthesize dataHeight;
+@synthesize left;
+@synthesize top;
+
+- (id)initWithWidth:(int)aWidth height:(int)aHeight pixels:(int *)pixels pixelsLen:(int)pixelsLen {
+ if (self = [super initWithWidth:aWidth height:aHeight]) {
+ self.dataWidth = self.width;
+ self.dataHeight = self.height;
+ self.left = 0;
+ self.top = 0;
+
+ // In order to measure pure decoding speed, we convert the entire image to a greyscale array
+ // up front, which is the same as the Y channel of the YUVLuminanceSource in the real app.
+ self.luminancesCount = self.width * self.height;
+ self.luminances = (unsigned char *)malloc(self.luminancesCount * sizeof(unsigned char));
+ for (int y = 0; y < self.height; y++) {
+ int offset = y * self.width;
+ for (int x = 0; x < self.width; x++) {
+ int pixel = pixels[offset + x];
+ int r = (pixel >> 16) & 0xff;
+ int g = (pixel >> 8) & 0xff;
+ int b = pixel & 0xff;
+ if (r == g && g == b) {
+ // Image is already greyscale, so pick any channel.
+ self.luminances[offset + x] = (char) r;
+ } else {
+ // Calculate luminance cheaply, favoring green.
+ self.luminances[offset + x] = (char) ((r + g + g + b) >> 2);
+ }
+ }
+ }
+ }
+
+ return self;
+}
+
+- (id)initWithPixels:(unsigned char *)pixels pixelsLen:(int)pixelsLen dataWidth:(int)aDataWidth dataHeight:(int)aDataHeight
+ left:(int)aLeft top:(int)aTop width:(int)aWidth height:(int)aHeight {
+ if (self = [super initWithWidth:aWidth height:aHeight]) {
+ if (aLeft + self.width > aDataWidth || aTop + self.height > aDataHeight) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Crop rectangle does not fit within image data."];
+
+ }
+
+ self.luminancesCount = pixelsLen;
+ self.luminances = (unsigned char *)malloc(pixelsLen * sizeof(unsigned char));
+ memcpy(self.luminances, pixels, pixelsLen * sizeof(char));
+
+ self.dataWidth = aDataWidth;
+ self.dataHeight = aDataHeight;
+ self.left = aLeft;
+ self.top = aTop;
+ }
+
+ return self;
+}
+
+- (unsigned char *)row:(int)y {
+ if (y < 0 || y >= self.height) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Requested row is outside the image: %d", y];
+ }
+ unsigned char *row = (unsigned char *)malloc(self.width * sizeof(unsigned char));
+
+ int offset = (y + self.top) * self.dataWidth + self.left;
+ memcpy(row, self.luminances + offset, self.width);
+ return row;
+}
+
+- (unsigned char *)matrix {
+ int area = self.width * self.height;
+ unsigned char *matrix = (unsigned char *)malloc(area * sizeof(unsigned char));
+ int inputOffset = self.top * self.dataWidth + self.left;
+
+ // If the width matches the full width of the underlying data, perform a single copy.
+ if (self.width == self.dataWidth) {
+ memcpy(matrix, self.luminances + inputOffset, area - inputOffset);
+ return matrix;
+ }
+
+ // Otherwise copy one cropped row at a time.
+ for (int y = 0; y < self.height; y++) {
+ int outputOffset = y * self.width;
+ memcpy(matrix + outputOffset, self.luminances + inputOffset, self.width);
+ inputOffset += self.dataWidth;
+ }
+ return matrix;
+}
+
+- (BOOL)cropSupported {
+ return YES;
+}
+
+- (ZXLuminanceSource *)crop:(int)aLeft top:(int)aTop width:(int)aWidth height:(int)aHeight {
+ return [[[[self class] alloc] initWithPixels:self.luminances
+ pixelsLen:self.luminancesCount
+ dataWidth:self.dataWidth
+ dataHeight:self.dataHeight
+ left:self.left + aLeft
+ top:self.top + aTop
+ width:aWidth
+ height:aHeight] autorelease];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..9020725f743dccb2d117f8e71157ad8fac230a76
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXReader.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Implementations of this interface can decode an image of a barcode in some format into
+ * the String it encodes. For example, ZXQRCodeReader can
+ * decode a QR code. The decoder may optionally receive hints from the caller which may help
+ * it decode more quickly or accurately.
+ *
+ * See ZXMultiFormatReader, which attempts to determine what barcode
+ * format is present within the image as well, and then decodes it accordingly.
+ */
+
+@class ZXBinaryBitmap, ZXDecodeHints, ZXResult;
+
+@protocol ZXReader <NSObject>
+
+- (ZXResult *)decode:(ZXBinaryBitmap *)image error:(NSError **)error;
+- (ZXResult *)decode:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error;
+- (void)reset;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..07ed4df187319bca44c87bab9ef105365fc6f5a2
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResult.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeFormat.h"
+#import "ZXResultMetadataType.h"
+
+/**
+ * Encapsulates the result of decoding a barcode within an image.
+ */
+
+@interface ZXResult : NSObject
+
+@property (nonatomic, copy, readonly) NSString *text;
+@property (nonatomic, assign, readonly) unsigned char *rawBytes;
+@property (nonatomic, assign, readonly) int length;
+@property (nonatomic, retain, readonly) NSMutableArray *resultPoints;
+@property (nonatomic, assign, readonly) ZXBarcodeFormat barcodeFormat;
+@property (nonatomic, retain, readonly) NSMutableDictionary *resultMetadata;
+@property (nonatomic, assign, readonly) long timestamp;
+
+- (id)initWithText:(NSString *)text rawBytes:(unsigned char *)rawBytes length:(unsigned int)length resultPoints:(NSArray *)resultPoints format:(ZXBarcodeFormat)format;
+- (id)initWithText:(NSString *)text rawBytes:(unsigned char *)rawBytes length:(unsigned int)length resultPoints:(NSArray *)resultPoints format:(ZXBarcodeFormat)format timestamp:(long)timestamp;
++ (id)resultWithText:(NSString *)text rawBytes:(unsigned char *)rawBytes length:(unsigned int)length resultPoints:(NSArray *)resultPoints format:(ZXBarcodeFormat)format;
++ (id)resultWithText:(NSString *)text rawBytes:(unsigned char *)rawBytes length:(unsigned int)length resultPoints:(NSArray *)resultPoints format:(ZXBarcodeFormat)format timestamp:(long)timestamp;
+- (void)putMetadata:(ZXResultMetadataType)type value:(id)value;
+- (void)putAllMetadata:(NSMutableDictionary *)metadata;
+- (void)addResultPoints:(NSArray *)newPoints;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..50e0bf7a63ebe845c65ed36ff9985a3076346e82
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResult.m
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResult.h"
+
+@interface ZXResult ()
+
+@property (nonatomic, copy) NSString *text;
+@property (nonatomic, assign) unsigned char *rawBytes;
+@property (nonatomic, assign) int length;
+@property (nonatomic, retain) NSMutableArray *resultPoints;
+@property (nonatomic, assign) ZXBarcodeFormat barcodeFormat;
+@property (nonatomic, retain) NSMutableDictionary *resultMetadata;
+@property (nonatomic, assign) long timestamp;
+
+@end
+
+@implementation ZXResult
+
+@synthesize text;
+@synthesize rawBytes;
+@synthesize length;
+@synthesize resultPoints;
+@synthesize barcodeFormat;
+@synthesize resultMetadata;
+@synthesize timestamp;
+
+- (id)initWithText:(NSString *)aText rawBytes:(unsigned char *)aRawBytes length:(unsigned int)aLength resultPoints:(NSArray *)aResultPoints format:(ZXBarcodeFormat)aFormat {
+ return [self initWithText:aText rawBytes:aRawBytes length:aLength resultPoints:aResultPoints format:aFormat timestamp:CFAbsoluteTimeGetCurrent()];
+}
+
+- (id)initWithText:(NSString *)aText rawBytes:(unsigned char *)aRawBytes length:(unsigned int)aLength resultPoints:(NSArray *)aResultPoints format:(ZXBarcodeFormat)aFormat timestamp:(long)aTimestamp {
+ if (self = [super init]) {
+ self.text = aText;
+ if (aRawBytes != NULL && aLength > 0) {
+ self.rawBytes = (unsigned char *)malloc(aLength * sizeof(unsigned char));
+ memcpy(self.rawBytes, aRawBytes, aLength);
+ self.length = aLength;
+ } else {
+ self.rawBytes = NULL;
+ self.length = 0;
+ }
+ self.resultPoints = [[aResultPoints mutableCopy] autorelease];
+ self.barcodeFormat = aFormat;
+ self.resultMetadata = nil;
+ self.timestamp = aTimestamp;
+ }
+
+ return self;
+}
+
++ (id)resultWithText:(NSString *)text rawBytes:(unsigned char *)rawBytes length:(unsigned int)length resultPoints:(NSArray *)resultPoints format:(ZXBarcodeFormat)format {
+ return [[[self alloc] initWithText:text rawBytes:rawBytes length:length resultPoints:resultPoints format:format] autorelease];
+}
+
++ (id)resultWithText:(NSString *)text rawBytes:(unsigned char *)rawBytes length:(unsigned int)length resultPoints:(NSArray *)resultPoints format:(ZXBarcodeFormat)format timestamp:(long)timestamp {
+ return [[[self alloc] initWithText:text rawBytes:rawBytes length:length resultPoints:resultPoints format:format timestamp:timestamp] autorelease];
+}
+
+- (void)dealloc {
+ if (self.rawBytes != NULL) {
+ free(self.rawBytes);
+ self.rawBytes = NULL;
+ }
+
+ [text release];
+ [resultPoints release];
+ [resultMetadata release];
+
+ [super dealloc];
+}
+
+- (void)putMetadata:(ZXResultMetadataType)type value:(id)value {
+ if (self.resultMetadata == nil) {
+ self.resultMetadata = [NSMutableDictionary dictionary];
+ }
+ [self.resultMetadata setObject:[NSNumber numberWithInt:type] forKey:value];
+}
+
+- (void)putAllMetadata:(NSMutableDictionary *)metadata {
+ if (metadata != nil) {
+ if (self.resultMetadata == nil) {
+ self.resultMetadata = metadata;
+ } else {
+ [self.resultMetadata addEntriesFromDictionary:metadata];
+ }
+ }
+}
+
+- (void)addResultPoints:(NSArray *)newPoints {
+ if (self.resultPoints == nil) {
+ self.resultPoints = [[newPoints mutableCopy] autorelease];
+ } else if (newPoints != nil && [newPoints count] > 0) {
+ [self.resultPoints addObjectsFromArray:newPoints];
+ }
+}
+
+- (NSString *)description {
+ return self.text;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResultMetadataType.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResultMetadataType.h
new file mode 100644
index 0000000000000000000000000000000000000000..40684ca375a0ed03b504b60834b384585a22f8bf
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResultMetadataType.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Represents some type of metadata about the result of the decoding that the decoder
+ * wishes to communicate back to the caller.
+ */
+
+typedef enum {
+ /**
+ * Unspecified, application-specific metadata. Maps to an unspecified NSObject.
+ */
+ kResultMetadataTypeOther,
+
+ /**
+ * Denotes the likely approximate orientation of the barcode in the image. This value
+ * is given as degrees rotated clockwise from the normal, upright orientation.
+ * For example a 1D barcode which was found by reading top-to-bottom would be
+ * said to have orientation "90". This key maps to an integer whose
+ * value is in the range [0,360).
+ */
+ kResultMetadataTypeOrientation,
+
+ /**
+ * 2D barcode formats typically encode text, but allow for a sort of 'byte mode'
+ * which is sometimes used to encode binary data. While {@link Result} makes available
+ * the complete raw bytes in the barcode for these formats, it does not offer the bytes
+ * from the byte segments alone.
+ *
+ * This maps to an array of byte arrays corresponding to the
+ * raw bytes in the byte segments in the barcode, in order.
+ */
+ kResultMetadataTypeByteSegments,
+
+ /**
+ * Error correction level used, if applicable. The value type depends on the
+ * format, but is typically a String.
+ */
+ kResultMetadataTypeErrorCorrectionLevel,
+
+ /**
+ * For some periodicals, indicates the issue number as an integer.
+ */
+ kResultMetadataTypeIssueNumber,
+
+ /**
+ * For some products, indicates the suggested retail price in the barcode as a
+ * formatted NSString.
+ */
+ kResultMetadataTypeSuggestedPrice,
+
+ /**
+ * For some products, the possible country of manufacture as NSString denoting the
+ * ISO country code. Some map to multiple possible countries, like "US/CA".
+ */
+ kResultMetadataTypePossibleCountry,
+
+ /**
+ * For some products, the extension text
+ */
+ kResultMetadataTypeUPCEANExtension
+} ZXResultMetadataType;
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResultPoint.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResultPoint.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b25046ae0af30de15ef1ddc06fbed17f144ca33
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResultPoint.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates a point of interest in an image containing a barcode. Typically, this
+ * would be the location of a finder pattern or the corner of the barcode, for example.
+ */
+
+@interface ZXResultPoint : NSObject<NSCopying>
+
+@property (nonatomic, assign, readonly) float x;
+@property (nonatomic, assign, readonly) float y;
+
+- (id)initWithX:(float)x y:(float)y;
++ (id)resultPointWithX:(float)x y:(float)y;
++ (void)orderBestPatterns:(NSMutableArray *)patterns;
++ (float)distance:(ZXResultPoint *)pattern1 pattern2:(ZXResultPoint *)pattern2;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResultPoint.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResultPoint.m
new file mode 100644
index 0000000000000000000000000000000000000000..d8ec2d17b61b9e2684fb4fa5b39c27f31e54f406
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResultPoint.m
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXMathUtils.h"
+#import "ZXResultPoint.h"
+
+@interface ZXResultPoint ()
+
+@property (nonatomic, assign) float x;
+@property (nonatomic, assign) float y;
+
++ (float)crossProductZ:(ZXResultPoint *)pointA pointB:(ZXResultPoint *)pointB pointC:(ZXResultPoint *)pointC;
+
+@end
+
+@implementation ZXResultPoint
+
+@synthesize x;
+@synthesize y;
+
+- (id)initWithX:(float)anX y:(float)aY {
+ if (self = [super init]) {
+ self.x = anX;
+ self.y = aY;
+ }
+
+ return self;
+}
+
++ (id)resultPointWithX:(float)x y:(float)y {
+ return [[[self alloc] initWithX:x y:y] autorelease];
+}
+
+- (id)copyWithZone:(NSZone *)zone {
+ return [[ZXResultPoint allocWithZone:zone] initWithX:x y:y];
+}
+
+- (BOOL)isEqual:(id)other {
+ if ([other isKindOfClass:[ZXResultPoint class]]) {
+ ZXResultPoint *otherPoint = (ZXResultPoint *)other;
+ return self.x == otherPoint.x && self.y == otherPoint.y;
+ }
+ return NO;
+}
+
+- (NSUInteger)hash {
+ return 31 * *((int *)(&x)) + *((int *)(&y));
+}
+
+- (NSString *)description {
+ return [NSString stringWithFormat:@"(%f,%f)", self.x, self.y];
+}
+
+
+/**
+ * Orders an array of three ResultPoints in an order [A,B,C] such that AB < AC and
+ * BC < AC and the angle between BC and BA is less than 180 degrees.
+ */
++ (void)orderBestPatterns:(NSMutableArray *)patterns {
+ float zeroOneDistance = [self distance:[patterns objectAtIndex:0] pattern2:[patterns objectAtIndex:1]];
+ float oneTwoDistance = [self distance:[patterns objectAtIndex:1] pattern2:[patterns objectAtIndex:2]];
+ float zeroTwoDistance = [self distance:[patterns objectAtIndex:0] pattern2:[patterns objectAtIndex:2]];
+ ZXResultPoint *pointA;
+ ZXResultPoint *pointB;
+ ZXResultPoint *pointC;
+ if (oneTwoDistance >= zeroOneDistance && oneTwoDistance >= zeroTwoDistance) {
+ pointB = [patterns objectAtIndex:0];
+ pointA = [patterns objectAtIndex:1];
+ pointC = [patterns objectAtIndex:2];
+ } else if (zeroTwoDistance >= oneTwoDistance && zeroTwoDistance >= zeroOneDistance) {
+ pointB = [patterns objectAtIndex:1];
+ pointA = [patterns objectAtIndex:0];
+ pointC = [patterns objectAtIndex:2];
+ } else {
+ pointB = [patterns objectAtIndex:2];
+ pointA = [patterns objectAtIndex:0];
+ pointC = [patterns objectAtIndex:1];
+ }
+
+ if ([self crossProductZ:pointA pointB:pointB pointC:pointC] < 0.0f) {
+ ZXResultPoint *temp = pointA;
+ pointA = pointC;
+ pointC = temp;
+ }
+ [patterns replaceObjectAtIndex:0 withObject:pointA];
+ [patterns replaceObjectAtIndex:1 withObject:pointB];
+ [patterns replaceObjectAtIndex:2 withObject:pointC];
+}
+
+
+/**
+ * Returns distance between two points
+ */
++ (float)distance:(ZXResultPoint *)pattern1 pattern2:(ZXResultPoint *)pattern2 {
+ return [ZXMathUtils distance:pattern1.x aY:pattern1.y bX:pattern2.x bY:pattern2.y];
+}
+
+
+/**
+ * Returns the z component of the cross product between vectors BC and BA.
+ */
++ (float) crossProductZ:(ZXResultPoint *)pointA pointB:(ZXResultPoint *)pointB pointC:(ZXResultPoint *)pointC {
+ float bX = pointB.x;
+ float bY = pointB.y;
+ return ((pointC.x - bX) * (pointA.y - bY)) - ((pointC.y - bY) * (pointA.x - bX));
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResultPointCallback.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResultPointCallback.h
new file mode 100644
index 0000000000000000000000000000000000000000..f3fa450cc6a14cf41f42d3fc16837f04b07ebe66
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXResultPointCallback.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Callback which is invoked when a possible result point (significant
+ * point in the barcode image such as a corner) is found.
+ */
+
+@class ZXResultPoint;
+
+@protocol ZXResultPointCallback <NSObject>
+
+- (void)foundPossibleResultPoint:(ZXResultPoint *)point;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXWriter.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..6cc9902ed9d90ccfa0591d1dcf6f0c3aa5637029
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXWriter.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeFormat.h"
+
+/**
+ * The base class for all objects which encode/generate a barcode image.
+ */
+
+@class ZXBitMatrix, ZXEncodeHints;
+
+@protocol ZXWriter <NSObject>
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height error:(NSError **)error;
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height hints:(ZXEncodeHints *)hints error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXingObjC.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXingObjC.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b2ba03437367d76a1d435e2a48ab9eeb589a00b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/ZXingObjC.h
@@ -0,0 +1,294 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+// ZXingObjC/aztec/decoder
+#import "ZXAztecDecoder.h"
+
+// ZXingObjC/aztec/detector
+#import "ZXAztecDetector.h"
+
+// ZXingObjC/aztec/encoder
+#import "ZXAztecCode.h"
+#import "ZXAztecEncoder.h"
+#import "ZXAztecWriter.h"
+
+// ZXingObjC/aztec
+#import "ZXAztecDetectorResult.h"
+#import "ZXAztecReader.h"
+
+// ZXingObjC/client/result
+#import "ZXAbstractDoCoMoResultParser.h"
+#import "ZXAddressBookAUResultParser.h"
+#import "ZXAddressBookDoCoMoResultParser.h"
+#import "ZXAddressBookParsedResult.h"
+#import "ZXBizcardResultParser.h"
+#import "ZXBookmarkDoCoMoResultParser.h"
+#import "ZXCalendarParsedResult.h"
+#import "ZXEmailAddressParsedResult.h"
+#import "ZXEmailAddressResultParser.h"
+#import "ZXEmailDoCoMoResultParser.h"
+#import "ZXExpandedProductParsedResult.h"
+#import "ZXExpandedProductResultParser.h"
+#import "ZXGeoParsedResult.h"
+#import "ZXGeoResultParser.h"
+#import "ZXISBNParsedResult.h"
+#import "ZXISBNResultParser.h"
+#import "ZXParsedResult.h"
+#import "ZXParsedResultType.h"
+#import "ZXProductParsedResult.h"
+#import "ZXProductResultParser.h"
+#import "ZXResultParser.h"
+#import "ZXSMSMMSResultParser.h"
+#import "ZXSMSParsedResult.h"
+#import "ZXSMSTOMMSTOResultParser.h"
+#import "ZXSMTPResultParser.h"
+#import "ZXTelParsedResult.h"
+#import "ZXTelResultParser.h"
+#import "ZXTextParsedResult.h"
+#import "ZXURIParsedResult.h"
+#import "ZXURIResultParser.h"
+#import "ZXURLTOResultParser.h"
+#import "ZXVCardResultParser.h"
+#import "ZXVEventResultParser.h"
+#import "ZXWifiParsedResult.h"
+#import "ZXWifiResultParser.h"
+
+// ZXingObjC/client
+#import "ZXCapture.h"
+#import "ZXCaptureDelegate.h"
+#import "ZXCaptureView.h"
+#import "ZXCGImageLuminanceSource.h"
+#import "ZXImage.h"
+#import "ZXView.h"
+
+// ZXingObjC/common/detector
+#import "ZXMathUtils.h"
+#import "ZXMonochromeRectangleDetector.h"
+#import "ZXWhiteRectangleDetector.h"
+
+// ZXingObjC/common/reedsolomon
+#import "ZXGenericGF.h"
+#import "ZXGenericGFPoly.h"
+#import "ZXReedSolomonDecoder.h"
+#import "ZXReedSolomonEncoder.h"
+
+// ZXingObjC/common
+#import "ZXBitArray.h"
+#import "ZXBitMatrix.h"
+#import "ZXBitSource.h"
+#import "ZXCharacterSetECI.h"
+#import "ZXDecoderResult.h"
+#import "ZXDefaultGridSampler.h"
+#import "ZXDetectorResult.h"
+#import "ZXECI.h"
+#import "ZXGlobalHistogramBinarizer.h"
+#import "ZXGridSampler.h"
+#import "ZXHybridBinarizer.h"
+#import "ZXPerspectiveTransform.h"
+#import "ZXStringUtils.h"
+
+// ZXingObjC/datamatrix/decoder
+#import "ZXDataMatrixBitMatrixParser.h"
+#import "ZXDataMatrixDataBlock.h"
+#import "ZXDataMatrixDecodedBitStreamParser.h"
+#import "ZXDataMatrixDecoder.h"
+#import "ZXDataMatrixVersion.h"
+
+// ZXingObjC/datamatrix/detector
+#import "ZXDataMatrixDetector.h"
+
+// ZXingObjC/datamatrix/encoder
+#import "ZXASCIIEncoder.h"
+#import "ZXBase256Encoder.h"
+#import "ZXC40Encoder.h"
+#import "ZXDataMatrixEncoder.h"
+#import "ZXDataMatrixErrorCorrection.h"
+#import "ZXDataMatrixSymbolInfo144.h"
+#import "ZXDefaultPlacement.h"
+#import "ZXEdifactEncoder.h"
+#import "ZXEncoderContext.h"
+#import "ZXHighLevelEncoder.h"
+#import "ZXSymbolInfo.h"
+#import "ZXSymbolShapeHint.h"
+#import "ZXTextEncoder.h"
+#import "ZXX12Encoder.h"
+
+// ZXingObjC/datamatrix
+#import "ZXDataMatrixReader.h"
+#import "ZXDataMatrixWriter.h"
+
+// ZXingObjC/maxicode/decoder
+#import "ZXMaxiCodeBitMatrixParser.h"
+#import "ZXMaxiCodeDecodedBitStreamParser.h"
+#import "ZXMaxiCodeDecoder.h"
+
+// ZXingObjC/maxicode
+#import "ZXMaxiCodeReader.h"
+
+// ZXingObjC/multi/qrcode/detector
+#import "ZXMultiDetector.h"
+#import "ZXMultiFinderPatternFinder.h"
+
+// ZXingObjC/multi/qrcode
+#import "ZXQRCodeMultiReader.h"
+
+// ZXingObjC/multi
+#import "ZXByQuadrantReader.h"
+#import "ZXGenericMultipleBarcodeReader.h"
+#import "ZXMultipleBarcodeReader.h"
+
+// ZXingObjC/oned/rss/expanded/decoders
+#import "ZXAbstractExpandedDecoder.h"
+#import "ZXAI013103decoder.h"
+#import "ZXAI01320xDecoder.h"
+#import "ZXAI01392xDecoder.h"
+#import "ZXAI01393xDecoder.h"
+#import "ZXAI013x0x1xDecoder.h"
+#import "ZXAI013x0xDecoder.h"
+#import "ZXAI01AndOtherAIs.h"
+#import "ZXAI01decoder.h"
+#import "ZXAI01weightDecoder.h"
+#import "ZXAnyAIDecoder.h"
+#import "ZXBlockParsedResult.h"
+#import "ZXCurrentParsingState.h"
+#import "ZXDecodedChar.h"
+#import "ZXDecodedInformation.h"
+#import "ZXDecodedNumeric.h"
+#import "ZXDecodedObject.h"
+#import "ZXFieldParser.h"
+#import "ZXGeneralAppIdDecoder.h"
+
+// ZXingObjC/oned/rss/expanded
+#import "ZXBitArrayBuilder.h"
+#import "ZXExpandedPair.h"
+#import "ZXExpandedRow.h"
+#import "ZXRSSExpandedReader.h"
+
+// ZXingObjC/oned/rss
+#import "ZXAbstractRSSReader.h"
+#import "ZXDataCharacter.h"
+#import "ZXPair.h"
+#import "ZXRSS14Reader.h"
+#import "ZXRSSFinderPattern.h"
+#import "ZXRSSUtils.h"
+
+// ZXingObjC/oned
+#import "ZXCodaBarReader.h"
+#import "ZXCodaBarWriter.h"
+#import "ZXCode128Reader.h"
+#import "ZXCode128Writer.h"
+#import "ZXCode39Reader.h"
+#import "ZXCode39Writer.h"
+#import "ZXCode93Reader.h"
+#import "ZXEAN13Reader.h"
+#import "ZXEAN13Writer.h"
+#import "ZXEAN8Reader.h"
+#import "ZXEAN8Writer.h"
+#import "ZXEANManufacturerOrgSupport.h"
+#import "ZXITFReader.h"
+#import "ZXITFWriter.h"
+#import "ZXMultiFormatOneDReader.h"
+#import "ZXMultiFormatUPCEANReader.h"
+#import "ZXOneDimensionalCodeWriter.h"
+#import "ZXOneDReader.h"
+#import "ZXUPCAReader.h"
+#import "ZXUPCAWriter.h"
+#import "ZXUPCEANExtension2Support.h"
+#import "ZXUPCEANExtension5Support.h"
+#import "ZXUPCEANExtensionSupport.h"
+#import "ZXUPCEANReader.h"
+#import "ZXUPCEANWriter.h"
+#import "ZXUPCEReader.h"
+
+// ZXingObjC/pdf417/decoder/ec
+#import "ZXModulusGF.h"
+#import "ZXModulusPoly.h"
+#import "ZXPDF417ECErrorCorrection.h"
+
+// ZXingObjC/pdf417/decoder
+#import "ZXPDF417BitMatrixParser.h"
+#import "ZXPDF417DecodedBitStreamParser.h"
+#import "ZXPDF417Decoder.h"
+
+// ZXingObjC/pdf417/detector
+#import "ZXPDF417Detector.h"
+
+// ZXingObjC/pdf417/encoder
+#import "ZXBarcodeMatrix.h"
+#import "ZXBarcodeRow.h"
+#import "ZXCompaction.h"
+#import "ZXDimensions.h"
+#import "ZXPDF417.h"
+#import "ZXPDF417ErrorCorrection.h"
+#import "ZXPDF417HighLevelEncoder.h"
+#import "ZXPDF417Writer.h"
+
+// ZXingObjC/pdf417
+#import "ZXPDF417Reader.h"
+
+// ZXingObjC/qrcode/decoder
+#import "ZXDataMask.h"
+#import "ZXErrorCorrectionLevel.h"
+#import "ZXFormatInformation.h"
+#import "ZXMode.h"
+#import "ZXQRCodeBitMatrixParser.h"
+#import "ZXQRCodeDataBlock.h"
+#import "ZXQRCodeDecodedBitStreamParser.h"
+#import "ZXQRCodeDecoder.h"
+#import "ZXQRCodeVersion.h"
+
+// ZXingObjC/qrcode/detector
+#import "ZXAlignmentPattern.h"
+#import "ZXAlignmentPatternFinder.h"
+#import "ZXFinderPatternFinder.h"
+#import "ZXFinderPatternInfo.h"
+#import "ZXQRCodeDetector.h"
+#import "ZXQRCodeFinderPattern.h"
+
+// ZXingObjC/qrcode/encoder
+#import "ZXBlockPair.h"
+#import "ZXByteMatrix.h"
+#import "ZXEncoder.h"
+#import "ZXMaskUtil.h"
+#import "ZXMatrixUtil.h"
+#import "ZXQRCode.h"
+
+// ZXingObjC/qrcode
+#import "ZXQRCodeReader.h"
+#import "ZXQRCodeWriter.h"
+
+// ZXingObjC
+#import "ZXBarcodeFormat.h"
+#import "ZXBinarizer.h"
+#import "ZXBinaryBitmap.h"
+#import "ZXDecodeHints.h"
+#import "ZXDimension.h"
+#import "ZXEncodeHints.h"
+#import "ZXErrors.h"
+#import "ZXInvertedLuminanceSource.h"
+#import "ZXLuminanceSource.h"
+#import "ZXMultiFormatReader.h"
+#import "ZXMultiFormatWriter.h"
+#import "ZXPlanarYUVLuminanceSource.h"
+#import "ZXReader.h"
+#import "ZXResult.h"
+#import "ZXResultMetadataType.h"
+#import "ZXResultPoint.h"
+#import "ZXResultPointCallback.h"
+#import "ZXRGBLuminanceSource.h"
+#import "ZXWriter.h"
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/ZXAztecDetectorResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/ZXAztecDetectorResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..87b5e0c0914c4fe3fe5564afee814e489f302764
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/ZXAztecDetectorResult.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultPoint.h"
+#import "ZXBitMatrix.h"
+#import "ZXDetectorResult.h"
+
+@interface ZXAztecDetectorResult : ZXDetectorResult
+
+@property (nonatomic, readonly) int nbLayers;
+@property (nonatomic, readonly) int nbDatablocks;
+@property (nonatomic, readonly) BOOL compact;
+
+- (id)initWithBits:(ZXBitMatrix *)bits
+ points:(NSArray *)points
+ compact:(BOOL)compact
+ nbDatablocks:(int)nbDatablocks
+ nbLayers:(int)nbLayers;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/ZXAztecDetectorResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/ZXAztecDetectorResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..1efa31858cdeb9fe1484d01a9f3e46d8414a03dc
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/ZXAztecDetectorResult.m
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAztecDetectorResult.h"
+
+@interface ZXAztecDetectorResult ()
+
+@property(nonatomic, readwrite) int nbLayers;
+@property(nonatomic, readwrite) int nbDatablocks;
+@property(nonatomic, readwrite) BOOL compact;
+
+@end
+
+@implementation ZXAztecDetectorResult
+
+@synthesize nbLayers;
+@synthesize nbDatablocks;
+@synthesize compact;
+
+- (id)initWithBits:(ZXBitMatrix *)_bits points:(NSArray *)_points compact:(BOOL)_compact
+ nbDatablocks:(int)_nbDatablocks nbLayers:(int)_nbLayers {
+ if (self = [super initWithBits:_bits points:_points]) {
+ self.compact = _compact;
+ self.nbDatablocks = _nbDatablocks;
+ self.nbLayers = _nbLayers;
+ }
+
+ return self;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/ZXAztecReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/ZXAztecReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..55a95d25757e46a38c883c42de55f95abfc219e7
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/ZXAztecReader.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXReader.h"
+
+@class ZXBinaryBitmap, ZXDecodeHints, ZXResult;
+
+/**
+ * This implementation can detect and decode Aztec codes in an image.
+ */
+@interface ZXAztecReader : NSObject <ZXReader>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/ZXAztecReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/ZXAztecReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..8fa9d5cd6d79305e373e3171a8e1ca24b3ce98b8
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/ZXAztecReader.m
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAztecDecoder.h"
+#import "ZXAztecDetector.h"
+#import "ZXAztecDetectorResult.h"
+#import "ZXAztecReader.h"
+#import "ZXBinaryBitmap.h"
+#import "ZXDecodeHints.h"
+#import "ZXDecoderResult.h"
+#import "ZXReader.h"
+#import "ZXResult.h"
+#import "ZXResultPointCallback.h"
+
+@implementation ZXAztecReader
+
+/**
+ * Locates and decodes a Data Matrix code in an image.
+ */
+- (ZXResult *)decode:(ZXBinaryBitmap *)image error:(NSError **)error {
+ return [self decode:image hints:nil error:error];
+}
+
+- (ZXResult *)decode:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ ZXBitMatrix *matrix = [image blackMatrixWithError:error];
+ if (!matrix) {
+ return nil;
+ }
+
+ ZXAztecDetectorResult *detectorResult = [[[[ZXAztecDetector alloc] initWithImage:matrix] autorelease] detectWithError:error];
+ if (!detectorResult) {
+ return nil;
+ }
+ NSArray *points = [detectorResult points];
+
+ if (hints != nil) {
+ id <ZXResultPointCallback> rpcb = hints.resultPointCallback;
+ if (rpcb != nil) {
+ for (ZXResultPoint *p in points) {
+ [rpcb foundPossibleResultPoint:p];
+ }
+ }
+ }
+
+ ZXDecoderResult *decoderResult = [[[[ZXAztecDecoder alloc] init] autorelease] decode:detectorResult error:error];
+ if (!decoderResult) {
+ return nil;
+ }
+ ZXResult *result = [ZXResult resultWithText:decoderResult.text rawBytes:decoderResult.rawBytes length:decoderResult.length resultPoints:points format:kBarcodeFormatAztec];
+
+ NSMutableArray *byteSegments = decoderResult.byteSegments;
+ if (byteSegments != nil) {
+ [result putMetadata:kResultMetadataTypeByteSegments value:byteSegments];
+ }
+ NSString *ecLevel = decoderResult.ecLevel;
+ if (ecLevel != nil) {
+ [result putMetadata:kResultMetadataTypeErrorCorrectionLevel value:ecLevel];
+ }
+
+ return result;
+}
+
+- (void)reset {
+ // do nothing
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/decoder/ZXAztecDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/decoder/ZXAztecDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..3b550ac5e6d1a446d43c78d19dbfc5a38c36ac5f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/decoder/ZXAztecDecoder.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The main class which implements Aztec Code decoding -- as opposed to locating and extracting
+ * the Aztec Code from an image.
+ */
+
+@class ZXAztecDetectorResult, ZXDecoderResult;
+
+@interface ZXAztecDecoder : NSObject
+
+- (ZXDecoderResult *)decode:(ZXAztecDetectorResult *)detectorResult error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/decoder/ZXAztecDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/decoder/ZXAztecDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..e765b23e3dda34bc14378c8f9b29a3170fd8ab07
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/decoder/ZXAztecDecoder.m
@@ -0,0 +1,496 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAztecDecoder.h"
+#import "ZXAztecDetectorResult.h"
+#import "ZXBitMatrix.h"
+#import "ZXDecoderResult.h"
+#import "ZXErrors.h"
+#import "ZXGenericGF.h"
+#import "ZXReedSolomonDecoder.h"
+
+enum {
+ UPPER = 0,
+ LOWER,
+ MIXED,
+ DIGIT,
+ PUNCT,
+ BINARY
+};
+
+static int NB_BITS_COMPACT[] = {
+ 0, 104, 240, 408, 608
+};
+
+static int NB_BITS[] = {
+ 0, 128, 288, 480, 704, 960, 1248, 1568, 1920, 2304, 2720, 3168, 3648, 4160, 4704, 5280, 5888, 6528,
+ 7200, 7904, 8640, 9408, 10208, 11040, 11904, 12800, 13728, 14688, 15680, 16704, 17760, 18848, 19968
+};
+
+static int NB_DATABLOCK_COMPACT[] = {
+ 0, 17, 40, 51, 76
+};
+
+static int NB_DATABLOCK[] = {
+ 0, 21, 48, 60, 88, 120, 156, 196, 240, 230, 272, 316, 364, 416, 470, 528, 588, 652, 720, 790, 864,
+ 940, 1020, 920, 992, 1066, 1144, 1224, 1306, 1392, 1480, 1570, 1664
+};
+
+static NSString *UPPER_TABLE[] = {
+ @"CTRL_PS", @" ", @"A", @"B", @"C", @"D", @"E", @"F", @"G", @"H", @"I", @"J", @"K", @"L", @"M", @"N", @"O", @"P",
+ @"Q", @"R", @"S", @"T", @"U", @"V", @"W", @"X", @"Y", @"Z", @"CTRL_LL", @"CTRL_ML", @"CTRL_DL", @"CTRL_BS"
+};
+
+static NSString *LOWER_TABLE[] = {
+ @"CTRL_PS", @" ", @"a", @"b", @"c", @"d", @"e", @"f", @"g", @"h", @"i", @"j", @"k", @"l", @"m", @"n", @"o", @"p",
+ @"q", @"r", @"s", @"t", @"u", @"v", @"w", @"x", @"y", @"z", @"CTRL_US", @"CTRL_ML", @"CTRL_DL", @"CTRL_BS"
+};
+
+static NSString *MIXED_TABLE[] = {
+ @"CTRL_PS", @" ", @"\1", @"\2", @"\3", @"\4", @"\5", @"\6", @"\7", @"\b", @"\t", @"\n",
+ @"\13", @"\f", @"\r", @"\33", @"\34", @"\35", @"\36", @"\37", @"@", @"\\", @"^", @"_",
+ @"`", @"|", @"~", @"\177", @"CTRL_LL", @"CTRL_UL", @"CTRL_PL", @"CTRL_BS"
+};
+
+static NSString *PUNCT_TABLE[] = {
+ @"", @"\r", @"\r\n", @". ", @", ", @": ", @"!", @"\"", @"#", @"$", @"%", @"&", @"'", @"(", @")",
+ @"*", @"+", @",", @"-", @".", @"/", @":", @";", @"<", @"=", @">", @"?", @"[", @"]", @"{", @"}", @"CTRL_UL"
+};
+
+static NSString *DIGIT_TABLE[] = {
+ @"CTRL_PS", @" ", @"0", @"1", @"2", @"3", @"4", @"5", @"6", @"7", @"8", @"9", @",", @".", @"CTRL_UL", @"CTRL_US"
+};
+
+@interface ZXAztecDecoder ()
+
+@property (nonatomic, assign) int codewordSize;
+@property (nonatomic, retain) ZXAztecDetectorResult *ddata;
+@property (nonatomic, assign) int invertedBitCount;
+@property (nonatomic, assign) int numCodewords;
+
+- (NSString *)character:(int)table code:(int)code;
+- (NSArray *)correctBits:(NSArray *)rawbits error:(NSError **)error;
+- (NSString *)encodedData:(NSArray *)correctedBits error:(NSError **)error;
+- (NSArray *)extractBits:(ZXBitMatrix *)matrix;
+- (int)readCode:(NSArray *)rawbits startIndex:(int)startIndex length:(unsigned int)length;
+- (ZXBitMatrix *)removeDashedLines:(ZXBitMatrix *)matrix;
+- (int)table:(unichar)t;
+
+@end
+
+@implementation ZXAztecDecoder
+
+@synthesize codewordSize;
+@synthesize ddata;
+@synthesize invertedBitCount;
+@synthesize numCodewords;
+
+- (ZXDecoderResult *)decode:(ZXAztecDetectorResult *)detectorResult error:(NSError **)error {
+ self.ddata = detectorResult;
+ ZXBitMatrix *matrix = [detectorResult bits];
+ if (![ddata compact]) {
+ matrix = [self removeDashedLines:[ddata bits]];
+ }
+ NSArray *rawbits = [self extractBits:matrix];
+ if (!rawbits) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ NSArray *correctedBits = [self correctBits:rawbits error:error];
+ if (!correctedBits) {
+ return nil;
+ }
+ NSString *result = [self encodedData:correctedBits error:error];
+ if (!result) {
+ return nil;
+ }
+ return [[[ZXDecoderResult alloc] initWithRawBytes:NULL length:0 text:result byteSegments:nil ecLevel:nil] autorelease];
+}
+
+
+/**
+ *
+ * Gets the string encoded in the aztec code bits
+ */
+- (NSString *)encodedData:(NSArray *)correctedBits error:(NSError **)error {
+ int endIndex = self.codewordSize * [self.ddata nbDatablocks] - self.invertedBitCount;
+ if (endIndex > [correctedBits count]) {
+ if (error) *error = FormatErrorInstance();
+ }
+ int lastTable = UPPER;
+ int table = UPPER;
+ int startIndex = 0;
+ NSMutableString *result = [NSMutableString stringWithCapacity:20];
+ BOOL end = NO;
+ BOOL shift = NO;
+ BOOL switchShift = NO;
+ BOOL binaryShift = NO;
+
+ while (!end) {
+ if (shift) {
+ switchShift = YES;
+ } else {
+ lastTable = table;
+ }
+
+ int code;
+ if (binaryShift) {
+ if (endIndex - startIndex < 5) {
+ break;
+ }
+
+ int length = [self readCode:correctedBits startIndex:startIndex length:5];
+ startIndex += 5;
+ if (length == 0) {
+ if (endIndex - startIndex < 11) {
+ break;
+ }
+
+ length = [self readCode:correctedBits startIndex:startIndex length:11] + 31;
+ startIndex += 11;
+ }
+ for (int charCount = 0; charCount < length; charCount++) {
+ if (endIndex - startIndex < 8) {
+ end = true;
+ break;
+ }
+
+ code = [self readCode:correctedBits startIndex:startIndex length:8];
+ unichar uCode = (unichar)code;
+ [result appendString:[NSString stringWithCharacters:&uCode length:1]];
+ startIndex += 8;
+ }
+ binaryShift = false;
+ } else {
+ if (table == BINARY) {
+ if (endIndex - startIndex < 8) {
+ break;
+ }
+ code = [self readCode:correctedBits startIndex:startIndex length:8];
+ startIndex += 8;
+
+ unichar uCode = (unichar)code;
+ [result appendString:[NSString stringWithCharacters:&uCode length:1]];
+ } else {
+ int size = 5;
+
+ if (table == DIGIT) {
+ size = 4;
+ }
+
+ if (endIndex - startIndex < size) {
+ break;
+ }
+
+ code = [self readCode:correctedBits startIndex:startIndex length:size];
+ startIndex += size;
+
+ NSString *str = [self character:table code:code];
+ if ([str hasPrefix:@"CTRL_"]) {
+ // Table changes
+ table = [self table:[str characterAtIndex:5]];
+
+ if ([str characterAtIndex:6] == 'S') {
+ shift = YES;
+ if ([str characterAtIndex:5] == 'B') {
+ binaryShift = YES;
+ }
+ }
+ } else {
+ [result appendString:str];
+ }
+ }
+ }
+
+ if (switchShift) {
+ table = lastTable;
+ shift = NO;
+ switchShift = NO;
+ }
+ }
+
+ return result;
+}
+
+
+/**
+ * gets the table corresponding to the char passed
+ */
+- (int)table:(unichar)t {
+ int table = UPPER;
+
+ switch (t) {
+ case 'U':
+ table = UPPER;
+ break;
+ case 'L':
+ table = LOWER;
+ break;
+ case 'P':
+ table = PUNCT;
+ break;
+ case 'M':
+ table = MIXED;
+ break;
+ case 'D':
+ table = DIGIT;
+ break;
+ case 'B':
+ table = BINARY;
+ break;
+ }
+ return table;
+}
+
+
+/**
+ * Gets the character (or string) corresponding to the passed code in the given table
+ */
+- (NSString *)character:(int)table code:(int)code {
+ switch (table) {
+ case UPPER:
+ return UPPER_TABLE[code];
+ case LOWER:
+ return LOWER_TABLE[code];
+ case MIXED:
+ return MIXED_TABLE[code];
+ case PUNCT:
+ return PUNCT_TABLE[code];
+ case DIGIT:
+ return DIGIT_TABLE[code];
+ default:
+ return @"";
+ }
+}
+
+
+/**
+ * Performs RS error correction on an array of bits
+ */
+- (NSArray *)correctBits:(NSArray *)rawbits error:(NSError **)error {
+ ZXGenericGF *gf;
+ if ([self.ddata nbLayers] <= 2) {
+ self.codewordSize = 6;
+ gf = [ZXGenericGF AztecData6];
+ } else if ([ddata nbLayers] <= 8) {
+ self.codewordSize = 8;
+ gf = [ZXGenericGF AztecData8];
+ } else if ([ddata nbLayers] <= 22) {
+ self.codewordSize = 10;
+ gf = [ZXGenericGF AztecData10];
+ } else {
+ self.codewordSize = 12;
+ gf = [ZXGenericGF AztecData12];
+ }
+
+ int numDataCodewords = [self.ddata nbDatablocks];
+ int numECCodewords;
+ int offset;
+
+ if ([self.ddata compact]) {
+ offset = NB_BITS_COMPACT[[self.ddata nbLayers]] - self.numCodewords * self.codewordSize;
+ numECCodewords = NB_DATABLOCK_COMPACT[[ddata nbLayers]] - numDataCodewords;
+ } else {
+ offset = NB_BITS[[ddata nbLayers]] - numCodewords * codewordSize;
+ numECCodewords = NB_DATABLOCK[[ddata nbLayers]] - numDataCodewords;
+ }
+
+ int dataWordsLen = self.numCodewords;
+ int dataWords[dataWordsLen];
+ for (int i = 0; i < dataWordsLen; i++) {
+ dataWords[i] = 0;
+ int flag = 1;
+ for (int j = 1; j <= self.codewordSize; j++) {
+ if ([[rawbits objectAtIndex:codewordSize * i + codewordSize - j + offset] boolValue]) {
+ dataWords[i] += flag;
+ }
+ flag <<= 1;
+ }
+ }
+
+ ZXReedSolomonDecoder *rsDecoder = [[[ZXReedSolomonDecoder alloc] initWithField:gf] autorelease];
+ NSError *decodeError = nil;
+ if (![rsDecoder decode:dataWords receivedLen:dataWordsLen twoS:numECCodewords error:&decodeError]) {
+ if (decodeError.code == ZXReedSolomonError) {
+ if (error) *error = FormatErrorInstance();
+ } else {
+ if (error) *error = decodeError;
+ }
+ return nil;
+ }
+
+ offset = 0;
+ self.invertedBitCount = 0;
+
+ NSMutableArray *correctedBits = [NSMutableArray array];
+ for (int i = 0; i < numDataCodewords*codewordSize; i++) {
+ [correctedBits addObject:[NSNumber numberWithBool:NO]];
+ }
+
+ for (int i = 0; i < numDataCodewords; i++) {
+ BOOL seriesColor = NO;
+ int seriesCount = 0;
+ int flag = 1 << (self.codewordSize - 1);
+
+ for (int j = 0; j < self.codewordSize; j++) {
+ BOOL color = (dataWords[i] & flag) == flag;
+
+ if (seriesCount == self.codewordSize - 1) {
+ if (color == seriesColor) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ seriesColor = NO;
+ seriesCount = 0;
+ offset++;
+ self.invertedBitCount++;
+ } else {
+ if (seriesColor == color) {
+ seriesCount++;
+ } else {
+ seriesCount = 1;
+ seriesColor = color;
+ }
+
+ [correctedBits replaceObjectAtIndex:i * self.codewordSize + j - offset withObject:[NSNumber numberWithBool:color]];
+ }
+
+ flag = (int)(((unsigned int)flag) >> 1);
+ }
+ }
+
+ return correctedBits;
+}
+
+
+/**
+ * Gets the array of bits from an Aztec Code matrix
+ */
+- (NSArray *)extractBits:(ZXBitMatrix *)matrix {
+ NSMutableArray *rawbits;
+ int capacity;
+ if ([self.ddata compact]) {
+ if ([self.ddata nbLayers] > (sizeof(NB_BITS_COMPACT) / sizeof(int))) {
+ return nil;
+ }
+ capacity = NB_BITS_COMPACT[[self.ddata nbLayers]];
+ self.numCodewords = NB_DATABLOCK_COMPACT[[ddata nbLayers]];
+ } else {
+ if ([self.ddata nbLayers] > (sizeof(NB_BITS) / sizeof(int))) {
+ return nil;
+ }
+ capacity = NB_BITS[[self.ddata nbLayers]];
+ self.numCodewords = NB_DATABLOCK[[self.ddata nbLayers]];
+ }
+
+ rawbits = [NSMutableArray arrayWithCapacity:capacity];
+ for (int i = 0; i < capacity; i++) {
+ [rawbits addObject:[NSNumber numberWithBool:NO]];
+ }
+
+ int layer = [self.ddata nbLayers];
+ int size = matrix.height;
+ int rawbitsOffset = 0;
+ int matrixOffset = 0;
+
+ while (layer != 0) {
+ int flip = 0;
+
+ for (int i = 0; i < 2 * size - 4; i++) {
+ [rawbits replaceObjectAtIndex:rawbitsOffset + i
+ withObject:[NSNumber numberWithBool:[matrix getX:matrixOffset + flip y:matrixOffset + i / 2]]];
+
+ [rawbits replaceObjectAtIndex:rawbitsOffset + 2 * size - 4 + i
+ withObject:[NSNumber numberWithBool:[matrix getX:matrixOffset + i / 2 y:matrixOffset + size - 1 - flip]]];
+
+ flip = (flip + 1) % 2;
+ }
+
+ flip = 0;
+ for (int i = 2 * size + 1; i > 5; i--) {
+ [rawbits replaceObjectAtIndex:rawbitsOffset + 4 * size - 8 + (2 * size - i) + 1
+ withObject:[NSNumber numberWithBool:[matrix getX:matrixOffset + size - 1 - flip y:matrixOffset + i / 2 - 1]]];
+
+ [rawbits replaceObjectAtIndex:rawbitsOffset + 6 * size - 12 + (2 * size - i) + 1
+ withObject:[NSNumber numberWithBool:[matrix getX:matrixOffset + i / 2 - 1 y:matrixOffset + flip]]];
+
+ flip = (flip + 1) % 2;
+ }
+
+ matrixOffset += 2;
+ rawbitsOffset += 8 * size - 16;
+ layer--;
+ size -= 4;
+ }
+
+ return rawbits;
+}
+
+
+/**
+ * Transforms an Aztec code matrix by removing the control dashed lines
+ */
+- (ZXBitMatrix *)removeDashedLines:(ZXBitMatrix *)matrix {
+ int nbDashed = 1 + 2 * ((matrix.width - 1) / 2 / 16);
+ ZXBitMatrix *newMatrix = [[[ZXBitMatrix alloc] initWithWidth:matrix.width - nbDashed height:matrix.height - nbDashed] autorelease];
+ int nx = 0;
+
+ for (int x = 0; x < matrix.width; x++) {
+ if ((matrix.width / 2 - x) % 16 == 0) {
+ continue;
+ }
+ int ny = 0;
+
+ for (int y = 0; y < matrix.height; y++) {
+ if ((matrix.width / 2 - y) % 16 == 0) {
+ continue;
+ }
+ if ([matrix getX:x y:y]) {
+ [newMatrix setX:nx y:ny];
+ }
+ ny++;
+ }
+
+ nx++;
+ }
+
+ return newMatrix;
+}
+
+
+/**
+ * Reads a code of given length and at given index in an array of bits
+ */
+- (int)readCode:(NSArray *)rawbits startIndex:(int)startIndex length:(unsigned int)length {
+ int res = 0;
+
+ for (int i = startIndex; i < startIndex + length; i++) {
+ res <<= 1;
+ if ([[rawbits objectAtIndex:i] boolValue]) {
+ res++;
+ }
+ }
+
+ return res;
+}
+
+- (void) dealloc {
+ [ddata release];
+
+ [super dealloc];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/detector/ZXAztecDetector.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/detector/ZXAztecDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..440495d36addca5164a7c6199ad334df43234742
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/detector/ZXAztecDetector.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates logic that can detect an Aztec Code in an image, even if the Aztec Code
+ * is rotated or skewed, or partially obscured.
+ */
+
+@class ZXAztecDetectorResult, ZXBitMatrix;
+
+@interface ZXAztecDetector : NSObject
+
+- (id)initWithImage:(ZXBitMatrix *)image;
+- (ZXAztecDetectorResult *)detectWithError:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/detector/ZXAztecDetector.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/detector/ZXAztecDetector.m
new file mode 100644
index 0000000000000000000000000000000000000000..5f29435060e6447f903f75b171e60ff522baf2b2
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/detector/ZXAztecDetector.m
@@ -0,0 +1,680 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAztecDetector.h"
+#import "ZXAztecDetectorResult.h"
+#import "ZXErrors.h"
+#import "ZXGenericGF.h"
+#import "ZXGridSampler.h"
+#import "ZXMathUtils.h"
+#import "ZXReedSolomonDecoder.h"
+#import "ZXResultPoint.h"
+#import "ZXWhiteRectangleDetector.h"
+
+@interface ZXAztecPoint : NSObject
+
+@property (nonatomic, assign) int x;
+@property (nonatomic, assign) int y;
+
+- (id)initWithX:(int) x y:(int)y;
+- (ZXResultPoint *)toResultPoint;
+
+@end
+
+@implementation ZXAztecPoint
+
+@synthesize x, y;
+
+- (id)initWithX:(int)anX y:(int)aY {
+ if (self = [super init]) {
+ x = anX;
+ y = aY;
+ }
+ return self;
+}
+
+- (ZXResultPoint *)toResultPoint {
+ return [[[ZXResultPoint alloc] initWithX:x y:y] autorelease];
+}
+
+@end
+
+@interface ZXAztecDetector ()
+
+@property (nonatomic, assign) BOOL compact;
+@property (nonatomic, retain) ZXBitMatrix *image;
+@property (nonatomic, assign) int nbCenterLayers;
+@property (nonatomic, assign) int nbDataBlocks;
+@property (nonatomic, assign) int nbLayers;
+@property (nonatomic, assign) int shift;
+
+- (NSArray *)bullEyeCornerPoints:(ZXAztecPoint *)pCenter;
+- (int)color:(ZXAztecPoint *)p1 p2:(ZXAztecPoint *)p2;
+- (BOOL)correctParameterData:(NSMutableArray *)parameterData compact:(BOOL)compact error:(NSError **)error;
+- (float)distance:(ZXAztecPoint *)a b:(ZXAztecPoint *)b;
+- (BOOL)extractParameters:(NSArray *)bullEyeCornerPoints error:(NSError **)error;
+- (ZXAztecPoint *)firstDifferent:(ZXAztecPoint *)init color:(BOOL)color dx:(int)dx dy:(int)dy;
+- (BOOL)isValidX:(int)x y:(int)y;
+- (BOOL)isWhiteOrBlackRectangle:(ZXAztecPoint *)p1 p2:(ZXAztecPoint *)p2 p3:(ZXAztecPoint *)p3 p4:(ZXAztecPoint *)p4;
+- (ZXAztecPoint *)matrixCenterWithError:(NSError **)error;
+- (NSArray *)matrixCornerPoints:(NSArray *)bullEyeCornerPoints;
+- (void)parameters:(NSMutableArray *)parameterData;
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)image
+ topLeft:(ZXResultPoint *)topLeft
+ bottomLeft:(ZXResultPoint *)bottomLeft
+ bottomRight:(ZXResultPoint *)bottomRight
+ topRight:(ZXResultPoint *)topRight
+ error:(NSError **)error;
+- (NSArray *)sampleLine:(ZXAztecPoint *)p1 p2:(ZXAztecPoint *)p2 size:(int)size;
+
+@end
+
+@implementation ZXAztecDetector
+
+@synthesize compact;
+@synthesize image;
+@synthesize nbCenterLayers;
+@synthesize nbDataBlocks;
+@synthesize nbLayers;
+@synthesize shift;
+
+- (id)initWithImage:(ZXBitMatrix *)anImage {
+ if (self = [super init]) {
+ self.image = anImage;
+ }
+ return self;
+}
+
+- (void) dealloc {
+ [image release];
+
+ [super dealloc];
+}
+
+/**
+ * Detects an Aztec Code in an image.
+ */
+- (ZXAztecDetectorResult *)detectWithError:(NSError **)error {
+ // 1. Get the center of the aztec matrix
+ ZXAztecPoint *pCenter = [self matrixCenterWithError:error];
+ if (!pCenter) {
+ return nil;
+ }
+
+ // 2. Get the corners of the center bull's eye
+ NSArray *bullEyeCornerPoints = [self bullEyeCornerPoints:pCenter];
+ if (!bullEyeCornerPoints) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ // 3. Get the size of the matrix from the bull's eye
+ if (![self extractParameters:bullEyeCornerPoints error:error]) {
+ return nil;
+ }
+
+ // 4. Get the corners of the matrix
+ NSArray *corners = [self matrixCornerPoints:bullEyeCornerPoints];
+ if (!corners) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ // 5. Sample the grid
+ ZXBitMatrix *bits = [self sampleGrid:self.image
+ topLeft:[corners objectAtIndex:self.shift % 4]
+ bottomLeft:[corners objectAtIndex:(self.shift + 3) % 4]
+ bottomRight:[corners objectAtIndex:(self.shift + 2) % 4]
+ topRight:[corners objectAtIndex:(self.shift + 1) % 4]
+ error:error];
+ if (!bits) {
+ return nil;
+ }
+
+ return [[[ZXAztecDetectorResult alloc] initWithBits:bits
+ points:corners
+ compact:self.compact
+ nbDatablocks:self.nbDataBlocks
+ nbLayers:self.nbLayers] autorelease];
+}
+
+
+/**
+ * Extracts the number of data layers and data blocks from the layer around the bull's eye
+ */
+- (BOOL)extractParameters:(NSArray *)bullEyeCornerPoints error:(NSError **)error {
+ ZXAztecPoint *p0 = [bullEyeCornerPoints objectAtIndex:0];
+ ZXAztecPoint *p1 = [bullEyeCornerPoints objectAtIndex:1];
+ ZXAztecPoint *p2 = [bullEyeCornerPoints objectAtIndex:2];
+ ZXAztecPoint *p3 = [bullEyeCornerPoints objectAtIndex:3];
+
+ int twoCenterLayers = 2 * self.nbCenterLayers;
+
+ // Get the bits around the bull's eye
+ NSArray *resab = [self sampleLine:p0 p2:p1 size:twoCenterLayers + 1];
+ NSArray *resbc = [self sampleLine:p1 p2:p2 size:twoCenterLayers + 1];
+ NSArray *rescd = [self sampleLine:p2 p2:p3 size:twoCenterLayers + 1];
+ NSArray *resda = [self sampleLine:p3 p2:p0 size:twoCenterLayers + 1];
+
+ // Determine the orientation of the matrix
+ if ([[resab objectAtIndex:0] boolValue] && [[resab objectAtIndex:twoCenterLayers] boolValue]) {
+ self.shift = 0;
+ } else if ([[resbc objectAtIndex:0] boolValue] && [[resbc objectAtIndex:twoCenterLayers] boolValue]) {
+ self.shift = 1;
+ } else if ([[rescd objectAtIndex:0] boolValue] && [[rescd objectAtIndex:twoCenterLayers] boolValue]) {
+ self.shift = 2;
+ } else if ([[resda objectAtIndex:0] boolValue] && [[resda objectAtIndex:twoCenterLayers] boolValue]) {
+ self.shift = 3;
+ } else {
+ if (error) *error = NotFoundErrorInstance();
+ return NO;
+ }
+
+ NSMutableArray *parameterData = [NSMutableArray array];
+ NSMutableArray *shiftedParameterData = [NSMutableArray array];
+ if (self.compact) {
+ for (int i = 0; i < 28; i++) {
+ [shiftedParameterData addObject:[NSNumber numberWithBool:NO]];
+ }
+
+ for (int i = 0; i < 7; i++) {
+ [shiftedParameterData replaceObjectAtIndex:i withObject:[resab objectAtIndex:2+i]];
+ [shiftedParameterData replaceObjectAtIndex:i + 7 withObject:[resbc objectAtIndex:2+i]];
+ [shiftedParameterData replaceObjectAtIndex:i + 14 withObject:[rescd objectAtIndex:2+i]];
+ [shiftedParameterData replaceObjectAtIndex:i + 21 withObject:[resda objectAtIndex:2+i]];
+ }
+
+ for (int i = 0; i < 28; i++) {
+ [parameterData addObject:[shiftedParameterData objectAtIndex:(i + shift * 7) % 28]];
+ }
+ } else {
+ for (int i = 0; i < 40; i++) {
+ [shiftedParameterData addObject:[NSNumber numberWithBool:NO]];
+ }
+
+ for (int i = 0; i < 11; i++) {
+ if (i < 5) {
+ [shiftedParameterData replaceObjectAtIndex:i withObject:[resab objectAtIndex:2 + i]];
+ [shiftedParameterData replaceObjectAtIndex:i + 10 withObject:[resbc objectAtIndex:2 + i]];
+ [shiftedParameterData replaceObjectAtIndex:i + 20 withObject:[rescd objectAtIndex:2 + i]];
+ [shiftedParameterData replaceObjectAtIndex:i + 30 withObject:[resda objectAtIndex:2 + i]];
+ }
+ if (i > 5) {
+ [shiftedParameterData replaceObjectAtIndex:i - 1 withObject:[resab objectAtIndex:2 + i]];
+ [shiftedParameterData replaceObjectAtIndex:i + 9 withObject:[resbc objectAtIndex:2 + i]];
+ [shiftedParameterData replaceObjectAtIndex:i + 19 withObject:[rescd objectAtIndex:2 + i]];
+ [shiftedParameterData replaceObjectAtIndex:i + 29 withObject:[resda objectAtIndex:2 + i]];
+ }
+ }
+
+ for (int i = 0; i < 40; i++) {
+ [parameterData addObject:[shiftedParameterData objectAtIndex:(i + shift * 10) % 40]];
+ }
+ }
+
+ if (![self correctParameterData:parameterData compact:self.compact error:error]) {
+ return NO;
+ }
+ [self parameters:parameterData];
+ return YES;
+}
+
+
+/**
+ * Gets the Aztec code corners from the bull's eye corners and the parameters
+ */
+- (NSArray *)matrixCornerPoints:(NSArray *)bullEyeCornerPoints {
+ ZXAztecPoint *p0 = [bullEyeCornerPoints objectAtIndex:0];
+ ZXAztecPoint *p1 = [bullEyeCornerPoints objectAtIndex:1];
+ ZXAztecPoint *p2 = [bullEyeCornerPoints objectAtIndex:2];
+ ZXAztecPoint *p3 = [bullEyeCornerPoints objectAtIndex:3];
+
+ float ratio = (2 * self.nbLayers + (self.nbLayers > 4 ? 1 : 0) + (self.nbLayers - 4) / 8) / (2.0f * self.nbCenterLayers);
+
+ int dx = p0.x - p2.x;
+ dx += dx > 0 ? 1 : -1;
+ int dy = p0.y - p2.y;
+ dy += dy > 0 ? 1 : -1;
+
+ int targetcx = [ZXMathUtils round:p2.x - ratio * dx];
+ int targetcy = [ZXMathUtils round:p2.y - ratio * dy];
+
+ int targetax = [ZXMathUtils round:p0.x + ratio * dx];
+ int targetay = [ZXMathUtils round:p0.y + ratio * dy];
+
+ dx = p1.x - p3.x;
+ dx += dx > 0 ? 1 : -1;
+ dy = p1.y - p3.y;
+ dy += dy > 0 ? 1 : -1;
+
+ int targetdx = [ZXMathUtils round:p3.x - ratio * dx];
+ int targetdy = [ZXMathUtils round:p3.y - ratio * dy];
+ int targetbx = [ZXMathUtils round:p1.x + ratio * dx];
+ int targetby = [ZXMathUtils round:p1.y + ratio * dy];
+
+ if (![self isValidX:targetax y:targetay] ||
+ ![self isValidX:targetbx y:targetby] ||
+ ![self isValidX:targetcx y:targetcy] ||
+ ![self isValidX:targetdx y:targetdy]) {
+ return nil;
+ }
+
+ return [NSArray arrayWithObjects:
+ [[[ZXResultPoint alloc] initWithX:targetax y:targetay] autorelease],
+ [[[ZXResultPoint alloc] initWithX:targetbx y:targetby] autorelease],
+ [[[ZXResultPoint alloc] initWithX:targetcx y:targetcy] autorelease],
+ [[[ZXResultPoint alloc] initWithX:targetdx y:targetdy] autorelease], nil];
+}
+
+
+/**
+ * Corrects the parameter bits using Reed-Solomon algorithm
+ */
+- (BOOL)correctParameterData:(NSMutableArray *)parameterData compact:(BOOL)isCompact error:(NSError **)error {
+ int numCodewords;
+ int numDataCodewords;
+
+ if (isCompact) {
+ numCodewords = 7;
+ numDataCodewords = 2;
+ } else {
+ numCodewords = 10;
+ numDataCodewords = 4;
+ }
+
+ int numECCodewords = numCodewords - numDataCodewords;
+ int parameterWordsLen = numCodewords;
+ int parameterWords[parameterWordsLen];
+
+ int codewordSize = 4;
+ for (int i = 0; i < parameterWordsLen; i++) {
+ parameterWords[i] = 0;
+ int flag = 1;
+ for (int j = 1; j <= codewordSize; j++) {
+ if ([[parameterData objectAtIndex:codewordSize * i + codewordSize - j] boolValue]) {
+ parameterWords[i] += flag;
+ }
+ flag <<= 1;
+ }
+ }
+
+ ZXReedSolomonDecoder *rsDecoder = [[[ZXReedSolomonDecoder alloc] initWithField:[ZXGenericGF AztecParam]] autorelease];
+ NSError *decodeError = nil;
+ if (![rsDecoder decode:parameterWords receivedLen:parameterWordsLen twoS:numECCodewords error:error]) {
+ if (decodeError.code == ZXReedSolomonError) {
+ if (error) *error = NotFoundErrorInstance();
+ return NO;
+ } else {
+ return NO;
+ }
+ }
+
+ for (int i = 0; i < numDataCodewords; i++) {
+ int flag = 1;
+ for (int j = 1; j <= codewordSize; j++) {
+ [parameterData replaceObjectAtIndex:i * codewordSize + codewordSize - j
+ withObject:[NSNumber numberWithBool:(parameterWords[i] & flag) == flag]];
+ flag <<= 1;
+ }
+ }
+ return YES;
+}
+
+
+/**
+ * Finds the corners of a bull-eye centered on the passed point
+ */
+- (NSArray *)bullEyeCornerPoints:(ZXAztecPoint *)pCenter {
+ ZXAztecPoint *pina = pCenter;
+ ZXAztecPoint *pinb = pCenter;
+ ZXAztecPoint *pinc = pCenter;
+ ZXAztecPoint *pind = pCenter;
+
+ BOOL color = YES;
+
+ for (self.nbCenterLayers = 1; self.nbCenterLayers < 9; self.nbCenterLayers++) {
+ ZXAztecPoint *pouta = [self firstDifferent:pina color:color dx:1 dy:-1];
+ ZXAztecPoint *poutb = [self firstDifferent:pinb color:color dx:1 dy:1];
+ ZXAztecPoint *poutc = [self firstDifferent:pinc color:color dx:-1 dy:1];
+ ZXAztecPoint *poutd = [self firstDifferent:pind color:color dx:-1 dy:-1];
+
+ if (self.nbCenterLayers > 2) {
+ float q = [self distance:poutd b:pouta] * self.nbCenterLayers / ([self distance:pind b:pina] * (self.nbCenterLayers + 2));
+ if (q < 0.75 || q > 1.25 || ![self isWhiteOrBlackRectangle:pouta p2:poutb p3:poutc p4:poutd]) {
+ break;
+ }
+ }
+
+ pina = pouta;
+ pinb = poutb;
+ pinc = poutc;
+ pind = poutd;
+
+ color = !color;
+ }
+
+ if (nbCenterLayers != 5 && nbCenterLayers != 7) {
+ return nil;
+ }
+
+ self.compact = self.nbCenterLayers == 5;
+
+ float ratio = 0.75f * 2 / (2 * nbCenterLayers - 3);
+
+ int dx = pina.x - pinc.x;
+ int dy = pina.y - pinc.y;
+ int targetcx = [ZXMathUtils round:pinc.x - ratio * dx];
+ int targetcy = [ZXMathUtils round:pinc.y - ratio * dy];
+ int targetax = [ZXMathUtils round:pina.x + ratio * dx];
+ int targetay = [ZXMathUtils round:pina.y + ratio * dy];
+
+ dx = pinb.x - pind.x;
+ dy = pinb.y - pind.y;
+
+ int targetdx = [ZXMathUtils round:pind.x - ratio * dx];
+ int targetdy = [ZXMathUtils round:pind.y - ratio * dy];
+ int targetbx = [ZXMathUtils round:pinb.x + ratio * dx];
+ int targetby = [ZXMathUtils round:pinb.y + ratio * dy];
+
+ if (![self isValidX:targetax y:targetay] ||
+ ![self isValidX:targetbx y:targetby] ||
+ ![self isValidX:targetcx y:targetcy] ||
+ ![self isValidX:targetdx y:targetdy]) {
+ return nil;
+ }
+
+ ZXAztecPoint *pa = [[[ZXAztecPoint alloc] initWithX:targetax y:targetay] autorelease];
+ ZXAztecPoint *pb = [[[ZXAztecPoint alloc] initWithX:targetbx y:targetby] autorelease];
+ ZXAztecPoint *pc = [[[ZXAztecPoint alloc] initWithX:targetcx y:targetcy] autorelease];
+ ZXAztecPoint *pd = [[[ZXAztecPoint alloc] initWithX:targetdx y:targetdy] autorelease];
+
+ return [NSArray arrayWithObjects:pa, pb, pc, pd, nil];
+}
+
+
+/**
+ * Finds a candidate center point of an Aztec code from an image
+ */
+- (ZXAztecPoint *)matrixCenterWithError:(NSError **)error {
+ ZXResultPoint *pointA;
+ ZXResultPoint *pointB;
+ ZXResultPoint *pointC;
+ ZXResultPoint *pointD;
+
+ NSError *detectorError = nil;
+ ZXWhiteRectangleDetector *detector = [[[ZXWhiteRectangleDetector alloc] initWithImage:self.image error:&detectorError] autorelease];
+ NSArray *cornerPoints = nil;
+ if (detector) {
+ cornerPoints = [detector detectWithError:&detectorError];
+ }
+
+ if (detectorError && detectorError.code == ZXNotFoundError) {
+ int cx = self.image.width / 2;
+ int cy = self.image.height / 2;
+ pointA = [[self firstDifferent:[[[ZXAztecPoint alloc] initWithX:cx + 7 y:cy - 7] autorelease] color:NO dx:1 dy:-1] toResultPoint];
+ pointB = [[self firstDifferent:[[[ZXAztecPoint alloc] initWithX:cx + 7 y:cy + 7] autorelease] color:NO dx:1 dy:1] toResultPoint];
+ pointC = [[self firstDifferent:[[[ZXAztecPoint alloc] initWithX:cx - 7 y:cy + 7] autorelease] color:NO dx:-1 dy:1] toResultPoint];
+ pointD = [[self firstDifferent:[[[ZXAztecPoint alloc] initWithX:cx - 7 y:cy - 7] autorelease] color:NO dx:-1 dy:-1] toResultPoint];
+ } else if (detectorError) {
+ if (error) *error = detectorError;
+ return nil;
+ } else {
+ pointA = [cornerPoints objectAtIndex:0];
+ pointB = [cornerPoints objectAtIndex:1];
+ pointC = [cornerPoints objectAtIndex:2];
+ pointD = [cornerPoints objectAtIndex:3];
+ }
+
+ int cx = [ZXMathUtils round:([pointA x] + [pointD x] + [pointB x] + [pointC x]) / 4.0f];
+ int cy = [ZXMathUtils round:([pointA y] + [pointD y] + [pointB y] + [pointC y]) / 4.0f];
+
+ detectorError = nil;
+ detector = [[[ZXWhiteRectangleDetector alloc] initWithImage:self.image initSize:15 x:cx y:cy error:&detectorError] autorelease];
+ if (detector) {
+ cornerPoints = [detector detectWithError:&detectorError];
+ }
+
+ if (detectorError && detectorError.code == ZXNotFoundError) {
+ pointA = [[self firstDifferent:[[[ZXAztecPoint alloc] initWithX:cx + 7 y:cy - 7] autorelease] color:NO dx:1 dy:-1] toResultPoint];
+ pointB = [[self firstDifferent:[[[ZXAztecPoint alloc] initWithX:cx + 7 y:cy + 7] autorelease] color:NO dx:1 dy:1] toResultPoint];
+ pointC = [[self firstDifferent:[[[ZXAztecPoint alloc] initWithX:cx - 7 y:cy + 7] autorelease] color:NO dx:-1 dy:1] toResultPoint];
+ pointD = [[self firstDifferent:[[[ZXAztecPoint alloc] initWithX:cx - 7 y:cy - 7] autorelease] color:NO dx:-1 dy:-1] toResultPoint];
+ } else if (detectorError) {
+ if (error) *error = detectorError;
+ return nil;
+ } else {
+ pointA = [cornerPoints objectAtIndex:0];
+ pointB = [cornerPoints objectAtIndex:1];
+ pointC = [cornerPoints objectAtIndex:2];
+ pointD = [cornerPoints objectAtIndex:3];
+ }
+
+ cx = [ZXMathUtils round:([pointA x] + [pointD x] + [pointB x] + [pointC x]) / 4];
+ cy = [ZXMathUtils round:([pointA y] + [pointD y] + [pointB y] + [pointC y]) / 4];
+
+ return [[[ZXAztecPoint alloc] initWithX:cx y:cy] autorelease];
+}
+
+
+/**
+ * Samples an Aztec matrix from an image
+ */
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)anImage
+ topLeft:(ZXResultPoint *)topLeft
+ bottomLeft:(ZXResultPoint *)bottomLeft
+ bottomRight:(ZXResultPoint *)bottomRight
+ topRight:(ZXResultPoint *)topRight
+ error:(NSError **)error {
+ int dimension;
+ if (self.compact) {
+ dimension = 4 * self.nbLayers + 11;
+ } else {
+ if (self.nbLayers <= 4) {
+ dimension = 4 * self.nbLayers + 15;
+ } else {
+ dimension = 4 * self.nbLayers + 2 * ((self.nbLayers - 4) / 8 + 1) + 15;
+ }
+ }
+
+ ZXGridSampler *sampler = [ZXGridSampler instance];
+
+ return [sampler sampleGrid:anImage
+ dimensionX:dimension
+ dimensionY:dimension
+ p1ToX:0.5f
+ p1ToY:0.5f
+ p2ToX:dimension - 0.5f
+ p2ToY:0.5f
+ p3ToX:dimension - 0.5f
+ p3ToY:dimension - 0.5f
+ p4ToX:0.5f
+ p4ToY:dimension - 0.5f
+ p1FromX:topLeft.x
+ p1FromY:topLeft.y
+ p2FromX:topRight.x
+ p2FromY:topRight.y
+ p3FromX:bottomRight.x
+ p3FromY:bottomRight.y
+ p4FromX:bottomLeft.x
+ p4FromY:bottomLeft.y
+ error:error];
+}
+
+
+/**
+ * Sets number of layers and number of data blocks from parameter bits
+ */
+- (void)parameters:(NSArray *)parameterData {
+ int nbBitsForNbLayers;
+ int nbBitsForNbDatablocks;
+
+ if (self.compact) {
+ nbBitsForNbLayers = 2;
+ nbBitsForNbDatablocks = 6;
+ } else {
+ nbBitsForNbLayers = 5;
+ nbBitsForNbDatablocks = 11;
+ }
+
+ for (int i = 0; i < nbBitsForNbLayers; i++) {
+ self.nbLayers <<= 1;
+ if ([[parameterData objectAtIndex:i] boolValue]) {
+ self.nbLayers++;
+ }
+ }
+
+ for (int i = nbBitsForNbLayers; i < nbBitsForNbLayers + nbBitsForNbDatablocks; i++) {
+ self.nbDataBlocks <<= 1;
+ if ([[parameterData objectAtIndex:i] boolValue]) {
+ self.nbDataBlocks++;
+ }
+ }
+
+ self.nbLayers++;
+ self.nbDataBlocks++;
+}
+
+
+/**
+ * Samples a line
+ */
+- (NSArray *)sampleLine:(ZXAztecPoint *)p1 p2:(ZXAztecPoint *)p2 size:(int)size {
+ NSMutableArray *res = [NSMutableArray arrayWithCapacity:size];
+ float d = [self distance:p1 b:p2];
+ float moduleSize = d / (size - 1);
+ float dx = moduleSize * (p2.x - p1.x) / d;
+ float dy = moduleSize * (p2.y - p1.y) / d;
+
+ float px = p1.x;
+ float py = p1.y;
+
+ for (int i = 0; i < size; i++) {
+ [res addObject:[NSNumber numberWithBool:[self.image getX:[ZXMathUtils round:px] y:[ZXMathUtils round:py]]]];
+ px += dx;
+ py += dy;
+ }
+
+ return res;
+}
+
+
+/**
+ * return true if the border of the rectangle passed in parameter is compound of white points only
+ * or black points only
+ */
+- (BOOL)isWhiteOrBlackRectangle:(ZXAztecPoint *)p1 p2:(ZXAztecPoint *)p2 p3:(ZXAztecPoint *)p3 p4:(ZXAztecPoint *)p4 {
+ int corr = 3;
+
+ p1 = [[[ZXAztecPoint alloc] initWithX:p1.x - corr y:p1.y + corr] autorelease];
+ p2 = [[[ZXAztecPoint alloc] initWithX:p2.x - corr y:p2.y - corr] autorelease];
+ p3 = [[[ZXAztecPoint alloc] initWithX:p3.x + corr y:p3.y - corr] autorelease];
+ p4 = [[[ZXAztecPoint alloc] initWithX:p4.x + corr y:p4.y + corr] autorelease];
+
+ int cInit = [self color:p4 p2:p1];
+
+ if (cInit == 0) {
+ return NO;
+ }
+
+ int c = [self color:p1 p2:p2];
+
+ if (c != cInit) {
+ return NO;
+ }
+
+ c = [self color:p2 p2:p3];
+
+ if (c != cInit) {
+ return NO;
+ }
+
+ c = [self color:p3 p2:p4];
+
+ return c == cInit;
+}
+
+
+/**
+ * Gets the color of a segment
+ * return 1 if segment more than 90% black, -1 if segment is more than 90% white, 0 else
+ */
+- (int)color:(ZXAztecPoint *)p1 p2:(ZXAztecPoint *)p2 {
+ float d = [self distance:p1 b:p2];
+ float dx = (p2.x - p1.x) / d;
+ float dy = (p2.y - p1.y) / d;
+ int error = 0;
+
+ float px = p1.x;
+ float py = p1.y;
+
+ BOOL colorModel = [self.image getX:p1.x y:p1.y];
+
+ for (int i = 0; i < d; i++) {
+ px += dx;
+ py += dy;
+ if ([self.image getX:[ZXMathUtils round:px] y:[ZXMathUtils round:py]] != colorModel) {
+ error++;
+ }
+ }
+
+ float errRatio = (float)error / d;
+
+ if (errRatio > 0.1f && errRatio < 0.9f) {
+ return 0;
+ }
+
+ return (errRatio <= 0.1f) == colorModel ? 1 : -1;
+}
+
+
+/**
+ * Gets the coordinate of the first point with a different color in the given direction
+ */
+- (ZXAztecPoint *)firstDifferent:(ZXAztecPoint *)init color:(BOOL)color dx:(int)dx dy:(int)dy {
+ int x = init.x + dx;
+ int y = init.y + dy;
+
+ while ([self isValidX:x y:y] && [self.image getX:x y:y] == color) {
+ x += dx;
+ y += dy;
+ }
+
+ x -= dx;
+ y -= dy;
+
+ while ([self isValidX:x y:y] && [self.image getX:x y:y] == color) {
+ x += dx;
+ }
+ x -= dx;
+
+ while ([self isValidX:x y:y] && [self.image getX:x y:y] == color) {
+ y += dy;
+ }
+ y -= dy;
+
+ return [[[ZXAztecPoint alloc] initWithX:x y:y] autorelease];
+}
+
+- (BOOL) isValidX:(int)x y:(int)y {
+ return x >= 0 && x < self.image.width && y > 0 && y < self.image.height;
+}
+
+
+- (float)distance:(ZXAztecPoint *)a b:(ZXAztecPoint *)b {
+ return [ZXMathUtils distance:a.x aY:a.y bX:b.x bY:b.y];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecCode.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecCode.h
new file mode 100644
index 0000000000000000000000000000000000000000..5bcf6dfd2a162ab150a06a07aaeede23e3e652ad
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecCode.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXBitMatrix;
+
+/**
+ * Aztec 2D code representation
+ */
+@interface ZXAztecCode : NSObject
+
+/**
+ * Number of data codewords
+ */
+@property (nonatomic, assign) int codeWords;
+
+/**
+ * Compact or full symbol indicator
+ */
+@property (nonatomic, assign) BOOL compact;
+
+/**
+ * Number of levels
+ */
+@property (nonatomic, assign) int layers;
+
+/**
+ * The symbol image
+ */
+@property (nonatomic, retain) ZXBitMatrix *matrix;
+
+/**
+ * Size in pixels (width and height)
+ */
+@property (nonatomic, assign) int size;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecCode.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecCode.m
new file mode 100644
index 0000000000000000000000000000000000000000..86dcd58503b76ac7bdb8961e0d5f4317f016a5b0
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecCode.m
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAztecCode.h"
+
+@implementation ZXAztecCode
+
+@synthesize codeWords;
+@synthesize compact;
+@synthesize matrix;
+@synthesize layers;
+@synthesize size;
+
+- (void)dealloc {
+ [matrix release];
+
+ [super dealloc];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecEncoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecEncoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..79feb0bc6c5f0465d2b97197bd320a3b15c81484
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecEncoder.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+extern int ZX_DEFAULT_AZTEC_EC_PERCENT;
+
+@class ZXAztecCode, ZXBitArray, ZXGenericGF;
+
+@interface ZXAztecEncoder : NSObject
+
++ (ZXAztecCode *)encode:(unsigned char *)data len:(int)len;
++ (ZXAztecCode *)encode:(unsigned char *)data len:(int)len minECCPercent:(int)minECCPercent;
++ (void)drawBullsEye:(ZXBitMatrix *)matrix center:(int)center size:(int)size;
++ (ZXBitArray *)generateModeMessageCompact:(BOOL)compact layers:(int)layers messageSizeInWords:(int)messageSizeInWords;
++ (void)drawModeMessage:(ZXBitMatrix *)matrix compact:(BOOL)compact matrixSize:(int)matrixSize modeMessage:(ZXBitArray *)modeMessage;
++ (ZXBitArray *)generateCheckWords:(ZXBitArray *)stuffedBits totalSymbolBits:(int)totalSymbolBits wordSize:(int)wordSize;
++ (void)bitsToWords:(ZXBitArray *)stuffedBits wordSize:(int)wordSize totalWords:(int)totalWords message:(int **)message;
++ (ZXGenericGF *)getGF:(int)wordSize;
++ (ZXBitArray *)stuffBits:(ZXBitArray *)bits wordSize:(int)wordSize;
++ (ZXBitArray *)highLevelEncode:(unsigned char *)data len:(int)len;
++ (void)outputWord:(ZXBitArray *)bits mode:(int)mode value:(int)value;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecEncoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecEncoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..971bbd8d1dc9b59147a2f80b261103404a795eee
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecEncoder.m
@@ -0,0 +1,589 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAztecCode.h"
+#import "ZXAztecEncoder.h"
+#import "ZXBitArray.h"
+#import "ZXBitMatrix.h"
+#import "ZXGenericGF.h"
+#import "ZXReedSolomonEncoder.h"
+
+int ZX_DEFAULT_AZTEC_EC_PERCENT = 33;
+
+const int TABLE_UPPER = 0; // 5 bits
+const int TABLE_LOWER = 1; // 5 bits
+const int TABLE_DIGIT = 2; // 4 bits
+const int TABLE_MIXED = 3; // 5 bits
+const int TABLE_PUNCT = 4; // 5 bits
+const int TABLE_BINARY = 5; // 8 bits
+
+static int CHAR_MAP[5][256]; // reverse mapping ASCII -> table offset, per table
+static int SHIFT_TABLE[6][6]; // mode shift codes, per table
+static int LATCH_TABLE[6][6]; // mode latch codes, per table
+
+const int NB_BITS_LEN = 33;
+static int NB_BITS[NB_BITS_LEN]; // total bits per compact symbol for a given number of layers
+
+const int NB_BITS_COMPACT_LEN = 5;
+static int NB_BITS_COMPACT[NB_BITS_COMPACT_LEN]; // total bits per full symbol for a given number of layers
+
+static int WORD_SIZE[33] = {
+ 4, 6, 6, 8, 8, 8, 8, 8, 8, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+ 12, 12, 12, 12, 12, 12, 12, 12, 12, 12
+};
+
+@implementation ZXAztecEncoder
+
++ (void)initialize {
+ CHAR_MAP[TABLE_UPPER][' '] = 1;
+ for (int c = 'A'; c <= 'Z'; c++) {
+ CHAR_MAP[TABLE_UPPER][c] = c - 'A' + 2;
+ }
+ CHAR_MAP[TABLE_LOWER][' '] = 1;
+ for (int c = 'a'; c <= 'z'; c++) {
+ CHAR_MAP[TABLE_LOWER][c] = c - 'a' + 2;
+ }
+ CHAR_MAP[TABLE_DIGIT][' '] = 1;
+ for (int c = '0'; c <= '9'; c++) {
+ CHAR_MAP[TABLE_DIGIT][c] = c - '0' + 2;
+ }
+ CHAR_MAP[TABLE_DIGIT][','] = 12;
+ CHAR_MAP[TABLE_DIGIT]['.'] = 13;
+
+ const int mixedTableLen = 28;
+ int mixedTable[mixedTableLen] = {
+ '\0', ' ', '\1', '\2', '\3', '\4', '\5', '\6', '\7', '\b', '\t', '\n', '\13', '\f', '\r',
+ '\33', '\34', '\35', '\36', '\37', '@', '\\', '^', '_', '`', '|', '~', '\177'
+ };
+ for (int i = 0; i < 28; i++) {
+ CHAR_MAP[TABLE_MIXED][mixedTable[i]] = i;
+ }
+ const int punctTableLen = 31;
+ int punctTable[punctTableLen] = {
+ '\0', '\r', '\0', '\0', '\0', '\0', '!', '\'', '#', '$', '%', '&', '\'', '(', ')', '*', '+',
+ ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '[', ']', '{', '}'
+ };
+ for (int i = 0; i < punctTableLen; i++) {
+ if (punctTable[i] > 0) {
+ CHAR_MAP[TABLE_PUNCT][punctTable[i]] = i;
+ }
+ }
+ for (int i = 0; i < 6; i++) {
+ for (int j = 0; j < 6; j++) {
+ SHIFT_TABLE[i][j] = -1;
+ LATCH_TABLE[i][j] = -1;
+ }
+ }
+ SHIFT_TABLE[TABLE_UPPER][TABLE_PUNCT] = 0;
+ LATCH_TABLE[TABLE_UPPER][TABLE_LOWER] = 28;
+ LATCH_TABLE[TABLE_UPPER][TABLE_MIXED] = 29;
+ LATCH_TABLE[TABLE_UPPER][TABLE_DIGIT] = 30;
+ SHIFT_TABLE[TABLE_UPPER][TABLE_BINARY] = 31;
+ SHIFT_TABLE[TABLE_LOWER][TABLE_PUNCT] = 0;
+ SHIFT_TABLE[TABLE_LOWER][TABLE_UPPER] = 28;
+ LATCH_TABLE[TABLE_LOWER][TABLE_MIXED] = 29;
+ LATCH_TABLE[TABLE_LOWER][TABLE_DIGIT] = 30;
+ SHIFT_TABLE[TABLE_LOWER][TABLE_BINARY] = 31;
+ SHIFT_TABLE[TABLE_MIXED][TABLE_PUNCT] = 0;
+ LATCH_TABLE[TABLE_MIXED][TABLE_LOWER] = 28;
+ LATCH_TABLE[TABLE_MIXED][TABLE_UPPER] = 29;
+ LATCH_TABLE[TABLE_MIXED][TABLE_PUNCT] = 30;
+ SHIFT_TABLE[TABLE_MIXED][TABLE_BINARY] = 31;
+ LATCH_TABLE[TABLE_PUNCT][TABLE_UPPER] = 31;
+ SHIFT_TABLE[TABLE_DIGIT][TABLE_PUNCT] = 0;
+ LATCH_TABLE[TABLE_DIGIT][TABLE_UPPER] = 30;
+ SHIFT_TABLE[TABLE_DIGIT][TABLE_UPPER] = 31;
+ for (int i = 1; i < NB_BITS_COMPACT_LEN; i++) {
+ NB_BITS_COMPACT[i] = (88 + 16 * i) * i;
+ }
+ for (int i = 1; i < NB_BITS_LEN; i++) {
+ NB_BITS[i] = (112 + 16 * i) * i;
+ }
+}
+
+/**
+ * Encodes the given binary content as an Aztec symbol
+ */
++ (ZXAztecCode *)encode:(unsigned char *)data len:(int)len {
+ return [self encode:data len:len minECCPercent:ZX_DEFAULT_AZTEC_EC_PERCENT];
+}
+
+/**
+ * Encodes the given binary content as an Aztec symbol
+ */
++ (ZXAztecCode *)encode:(unsigned char *)data len:(int)len minECCPercent:(int)minECCPercent {
+ // High-level encode
+ ZXBitArray *bits = [self highLevelEncode:data len:len];
+
+ // stuff bits and choose symbol size
+ int eccBits = bits.size * minECCPercent / 100 + 11;
+ int totalSizeBits = bits.size + eccBits;
+ int layers;
+ int wordSize = 0;
+ int totalSymbolBits = 0;
+ ZXBitArray *stuffedBits = nil;
+ for (layers = 1; layers < NB_BITS_COMPACT_LEN; layers++) {
+ if (NB_BITS_COMPACT[layers] >= totalSizeBits) {
+ if (wordSize != WORD_SIZE[layers]) {
+ wordSize = WORD_SIZE[layers];
+ stuffedBits = [self stuffBits:bits wordSize:wordSize];
+ }
+ totalSymbolBits = NB_BITS_COMPACT[layers];
+ if (stuffedBits.size + eccBits <= NB_BITS_COMPACT[layers]) {
+ break;
+ }
+ }
+ }
+ BOOL compact = YES;
+ if (layers == NB_BITS_COMPACT_LEN) {
+ compact = false;
+ for (layers = 1; layers < NB_BITS_LEN; layers++) {
+ if (NB_BITS[layers] >= totalSizeBits) {
+ if (wordSize != WORD_SIZE[layers]) {
+ wordSize = WORD_SIZE[layers];
+ stuffedBits = [self stuffBits:bits wordSize:wordSize];
+ }
+ totalSymbolBits = NB_BITS[layers];
+ if (stuffedBits.size + eccBits <= NB_BITS[layers]) {
+ break;
+ }
+ }
+ }
+ }
+ if (layers == NB_BITS_LEN) {
+ [NSException raise:NSInvalidArgumentException format:@"Data too large for an Aztec code"];
+ }
+
+ // pad the end
+ int messageSizeInWords = (stuffedBits.size + wordSize - 1) / wordSize;
+ for (int i = messageSizeInWords * wordSize - stuffedBits.size; i > 0; i--) {
+ [stuffedBits appendBit:YES];
+ }
+
+ // generate check words
+ ZXReedSolomonEncoder *rs = [[[ZXReedSolomonEncoder alloc] initWithField:[self getGF:wordSize]] autorelease];
+ int totalSizeInFullWords = totalSymbolBits / wordSize;
+
+ int messageWords[totalSizeInFullWords];
+ [self bitsToWords:stuffedBits wordSize:wordSize totalWords:totalSizeInFullWords message:(int **)&messageWords];
+ [rs encode:messageWords toEncodeLen:totalSizeInFullWords ecBytes:totalSizeInFullWords - messageSizeInWords];
+
+ // convert to bit array and pad in the beginning
+ int startPad = totalSymbolBits % wordSize;
+ ZXBitArray *messageBits = [[[ZXBitArray alloc] init] autorelease];
+ [messageBits appendBits:0 numBits:startPad];
+ for (int i = 0; i < totalSizeInFullWords; i++) {
+ [messageBits appendBits:messageWords[i] numBits:wordSize];
+ }
+
+ // generate mode message
+ ZXBitArray *modeMessage = [self generateModeMessageCompact:compact layers:layers messageSizeInWords:messageSizeInWords];
+
+ // allocate symbol
+ int baseMatrixSize = compact ? 11 + layers * 4 : 14 + layers * 4; // not including alignment lines
+ int alignmentMap[baseMatrixSize];
+ int matrixSize;
+ if (compact) {
+ // no alignment marks in compact mode, alignmentMap is a no-op
+ matrixSize = baseMatrixSize;
+ for (int i = 0; i < baseMatrixSize; i++) {
+ alignmentMap[i] = i;
+ }
+ } else {
+ matrixSize = baseMatrixSize + 1 + 2 * ((baseMatrixSize / 2 - 1) / 15);
+ int origCenter = baseMatrixSize / 2;
+ int center = matrixSize / 2;
+ for (int i = 0; i < origCenter; i++) {
+ int newOffset = i + i / 15;
+ alignmentMap[origCenter - i - 1] = center - newOffset - 1;
+ alignmentMap[origCenter + i] = center + newOffset + 1;
+ }
+ }
+ ZXBitMatrix *matrix = [[[ZXBitMatrix alloc] initWithDimension:matrixSize] autorelease];
+
+ // draw mode and data bits
+ for (int i = 0, rowOffset = 0; i < layers; i++) {
+ int rowSize = compact ? (layers - i) * 4 + 9 : (layers - i) * 4 + 12;
+ for (int j = 0; j < rowSize; j++) {
+ int columnOffset = j * 2;
+ for (int k = 0; k < 2; k++) {
+ if ([messageBits get:rowOffset + columnOffset + k]) {
+ [matrix setX:alignmentMap[i * 2 + k] y:alignmentMap[i * 2 + j]];
+ }
+ if ([messageBits get:rowOffset + rowSize * 2 + columnOffset + k]) {
+ [matrix setX:alignmentMap[i * 2 + j] y:alignmentMap[baseMatrixSize - 1 - i * 2 - k]];
+ }
+ if ([messageBits get:rowOffset + rowSize * 4 + columnOffset + k]) {
+ [matrix setX:alignmentMap[baseMatrixSize - 1 - i * 2 - k] y:alignmentMap[baseMatrixSize - 1 - i * 2 - j]];
+ }
+ if ([messageBits get:rowOffset + rowSize * 6 + columnOffset + k]) {
+ [matrix setX:alignmentMap[baseMatrixSize - 1 - i * 2 - j] y:alignmentMap[i * 2 + k]];
+ }
+ }
+ }
+ rowOffset += rowSize * 8;
+ }
+ [self drawModeMessage:matrix compact:compact matrixSize:matrixSize modeMessage:modeMessage];
+
+ // draw alignment marks
+ if (compact) {
+ [self drawBullsEye:matrix center:matrixSize / 2 size:5];
+ } else {
+ [self drawBullsEye:matrix center:matrixSize / 2 size:7];
+ for (int i = 0, j = 0; i < baseMatrixSize / 2 - 1; i += 15, j += 16) {
+ for (int k = (matrixSize / 2) & 1; k < matrixSize; k += 2) {
+ [matrix setX:matrixSize / 2 - j y:k];
+ [matrix setX:matrixSize / 2 + j y:k];
+ [matrix setX:k y:matrixSize / 2 - j];
+ [matrix setX:k y:matrixSize / 2 + j];
+ }
+ }
+ }
+
+ ZXAztecCode *aztec = [[[ZXAztecCode alloc] init] autorelease];
+ aztec.compact = compact;
+ aztec.size = matrixSize;
+ aztec.layers = layers;
+ aztec.codeWords = messageSizeInWords;
+ aztec.matrix = matrix;
+ return aztec;
+}
+
++ (void)drawBullsEye:(ZXBitMatrix *)matrix center:(int)center size:(int)size {
+ for (int i = 0; i < size; i += 2) {
+ for (int j = center - i; j <= center + i; j++) {
+ [matrix setX:j y:center - i];
+ [matrix setX:j y:center + i];
+ [matrix setX:center - i y:j];
+ [matrix setX:center + i y:j];
+ }
+ }
+ [matrix setX:center - size y:center - size];
+ [matrix setX:center - size + 1 y:center - size];
+ [matrix setX:center - size y:center - size + 1];
+ [matrix setX:center + size y:center - size];
+ [matrix setX:center + size y:center - size + 1];
+ [matrix setX:center + size y:center + size - 1];
+}
+
++ (ZXBitArray *)generateModeMessageCompact:(BOOL)compact layers:(int)layers messageSizeInWords:(int)messageSizeInWords {
+ ZXBitArray *modeMessage = [[[ZXBitArray alloc] init] autorelease];
+ if (compact) {
+ [modeMessage appendBits:layers - 1 numBits:2];
+ [modeMessage appendBits:messageSizeInWords - 1 numBits:6];
+ modeMessage = [self generateCheckWords:modeMessage totalSymbolBits:28 wordSize:4];
+ } else {
+ [modeMessage appendBits:layers - 1 numBits:5];
+ [modeMessage appendBits:messageSizeInWords - 1 numBits:11];
+ modeMessage = [self generateCheckWords:modeMessage totalSymbolBits:40 wordSize:4];
+ }
+ return modeMessage;
+}
+
++ (void)drawModeMessage:(ZXBitMatrix *)matrix compact:(BOOL)compact matrixSize:(int)matrixSize modeMessage:(ZXBitArray *)modeMessage {
+ if (compact) {
+ for (int i = 0; i < 7; i++) {
+ if ([modeMessage get:i]) {
+ [matrix setX:matrixSize / 2 - 3 + i y:matrixSize / 2 - 5];
+ }
+ if ([modeMessage get:i + 7]) {
+ [matrix setX:matrixSize / 2 + 5 y:matrixSize / 2 - 3 + i];
+ }
+ if ([modeMessage get:20 - i]) {
+ [matrix setX:matrixSize / 2 - 3 + i y:matrixSize / 2 + 5];
+ }
+ if ([modeMessage get:27 - i]) {
+ [matrix setX:matrixSize / 2 - 5 y:matrixSize / 2 - 3 + i];
+ }
+ }
+ } else {
+ for (int i = 0; i < 10; i++) {
+ if ([modeMessage get:i]) {
+ [matrix setX:matrixSize / 2 - 5 + i + i / 5 y:matrixSize / 2 - 7];
+ }
+ if ([modeMessage get:i + 10]) {
+ [matrix setX:matrixSize / 2 + 7 y:matrixSize / 2 - 5 + i + i / 5];
+ }
+ if ([modeMessage get:29 - i]) {
+ [matrix setX:matrixSize / 2 - 5 + i + i / 5 y:matrixSize / 2 + 7];
+ }
+ if ([modeMessage get:39 - i]) {
+ [matrix setX:matrixSize / 2 - 7 y:matrixSize / 2 - 5 + i + i / 5];
+ }
+ }
+ }
+}
+
++ (ZXBitArray *)generateCheckWords:(ZXBitArray *)stuffedBits totalSymbolBits:(int)totalSymbolBits wordSize:(int)wordSize {
+ int messageSizeInWords = (stuffedBits.size + wordSize - 1) / wordSize;
+ for (int i = messageSizeInWords * wordSize - stuffedBits.size; i > 0; i--) {
+ [stuffedBits appendBit:YES];
+ }
+ ZXReedSolomonEncoder *rs = [[[ZXReedSolomonEncoder alloc] initWithField:[self getGF:wordSize]] autorelease];
+ int totalSizeInFullWords = totalSymbolBits / wordSize;
+
+ int messageWords[totalSizeInFullWords];
+ [self bitsToWords:stuffedBits wordSize:wordSize totalWords:totalSizeInFullWords message:(int **)&messageWords];
+
+ [rs encode:messageWords toEncodeLen:totalSizeInFullWords ecBytes:totalSizeInFullWords - messageSizeInWords];
+ int startPad = totalSymbolBits % wordSize;
+ ZXBitArray *messageBits = [[[ZXBitArray alloc] init] autorelease];
+ [messageBits appendBits:0 numBits:startPad];
+ for (int i = 0; i < totalSizeInFullWords; i++) {
+ [messageBits appendBits:messageWords[i] numBits:wordSize];
+ }
+ return messageBits;
+}
+
++ (void)bitsToWords:(ZXBitArray *)stuffedBits wordSize:(int)wordSize totalWords:(int)totalWords message:(int **)message {
+ int i;
+ int n;
+ for (i = 0, n = stuffedBits.size / wordSize; i < n; i++) {
+ int value = 0;
+ for (int j = 0; j < wordSize; j++) {
+ value |= [stuffedBits get:i * wordSize + j] ? (1 << wordSize - j - 1) : 0;
+ }
+ message[i] = value;
+ }
+}
+
++ (ZXGenericGF *)getGF:(int)wordSize {
+ switch (wordSize) {
+ case 4:
+ return [ZXGenericGF AztecParam];
+ case 6:
+ return [ZXGenericGF AztecData6];
+ case 8:
+ return [ZXGenericGF AztecData8];
+ case 10:
+ return [ZXGenericGF AztecData10];
+ case 12:
+ return [ZXGenericGF AztecData12];
+ default:
+ return nil;
+ }
+}
+
++ (ZXBitArray *)stuffBits:(ZXBitArray *)bits wordSize:(int)wordSize {
+ ZXBitArray *arrayOut = [[[ZXBitArray alloc] init] autorelease];
+
+ // 1. stuff the bits
+ int n = bits.size;
+ int mask = (1 << wordSize) - 2;
+ for (int i = 0; i < n; i += wordSize) {
+ int word = 0;
+ for (int j = 0; j < wordSize; j++) {
+ if (i + j >= n || [bits get:i + j]) {
+ word |= 1 << (wordSize - 1 - j);
+ }
+ }
+ if ((word & mask) == mask) {
+ [arrayOut appendBits:word & mask numBits:wordSize];
+ i--;
+ } else if ((word & mask) == 0) {
+ [arrayOut appendBits:word | 1 numBits:wordSize];
+ i--;
+ } else {
+ [arrayOut appendBits:word numBits:wordSize];
+ }
+ }
+
+ // 2. pad last word to wordSize
+ n = arrayOut.size;
+ int remainder = n % wordSize;
+ if (remainder != 0) {
+ int j = 1;
+ for (int i = 0; i < remainder; i++) {
+ if (![arrayOut get:n - 1 - i]) {
+ j = 0;
+ }
+ }
+ for (int i = remainder; i < wordSize - 1; i++) {
+ [arrayOut appendBit:YES];
+ }
+ [arrayOut appendBit:j == 0];
+ }
+ return arrayOut;
+}
+
++ (ZXBitArray *)highLevelEncode:(unsigned char *)data len:(int)len {
+ ZXBitArray *bits = [[[ZXBitArray alloc] init] autorelease];
+ int mode = TABLE_UPPER;
+ int idx[5] = {0, 0, 0, 0, 0};
+ int idxnext[5] = {0, 0, 0, 0, 0};
+
+ for (int i = 0; i < len; i++) {
+ int c = data[i] & 0xFF;
+ int next = i < len - 1 ? data[i + 1] & 0xFF : 0;
+ int punctWord = 0;
+ // special case: double-character codes
+ if (c == '\r' && next == '\n') {
+ punctWord = 2;
+ } else if (c == '.' && next == ' ') {
+ punctWord = 3;
+ } else if (c == ',' && next == ' ') {
+ punctWord = 4;
+ } else if (c == ':' && next == ' ') {
+ punctWord = 5;
+ }
+ if (punctWord > 0) {
+ if (mode == TABLE_PUNCT) {
+ [self outputWord:bits mode:TABLE_PUNCT value:punctWord];
+ i++;
+ continue;
+ } else if (SHIFT_TABLE[mode][TABLE_PUNCT] >= 0) {
+ [self outputWord:bits mode:mode value:SHIFT_TABLE[mode][TABLE_PUNCT]];
+ [self outputWord:bits mode:TABLE_PUNCT value:punctWord];
+ i++;
+ continue;
+ } else if (LATCH_TABLE[mode][TABLE_PUNCT] >= 0) {
+ [self outputWord:bits mode:mode value:LATCH_TABLE[mode][TABLE_PUNCT]];
+ [self outputWord:bits mode:TABLE_PUNCT value:punctWord];
+ mode = TABLE_PUNCT;
+ i++;
+ continue;
+ }
+ }
+ // find the best matching table, taking current mode and next character into account
+ int firstMatch = -1;
+ int shiftMode = -1;
+ int latchMode = -1;
+ int j;
+ for (j = 0; j < TABLE_BINARY; j++) {
+ idx[j] = CHAR_MAP[j][c];
+ if (idx[j] > 0 && firstMatch < 0) {
+ firstMatch = j;
+ }
+ if (shiftMode < 0 && idx[j] > 0 && SHIFT_TABLE[mode][j] >= 0) {
+ shiftMode = j;
+ }
+ idxnext[j] = CHAR_MAP[j][next];
+ if (latchMode < 0 && idx[j] > 0 && (next == 0 || idxnext[j] > 0) && LATCH_TABLE[mode][j] >= 0) {
+ latchMode = j;
+ }
+ }
+ if (shiftMode < 0 && latchMode < 0) {
+ for (j = 0; j < TABLE_BINARY; j++) {
+ if (idx[j] > 0 && LATCH_TABLE[mode][j] >= 0) {
+ latchMode = j;
+ break;
+ }
+ }
+ }
+ if (idx[mode] > 0) {
+ // found character in current table - stay in current table
+ [self outputWord:bits mode:mode value:idx[mode]];
+ } else {
+ if (latchMode >= 0) {
+ // latch into mode latchMode
+ [self outputWord:bits mode:mode value:LATCH_TABLE[mode][latchMode]];
+ [self outputWord:bits mode:latchMode value:idx[latchMode]];
+ mode = latchMode;
+ } else if (shiftMode >= 0) {
+ // shift into shiftMode
+ [self outputWord:bits mode:mode value:SHIFT_TABLE[mode][shiftMode]];
+ [self outputWord:bits mode:shiftMode value:idx[shiftMode]];
+ } else {
+ if (firstMatch >= 0) {
+ // can't switch into this mode from current mode - switch in two steps
+ if (mode == TABLE_PUNCT) {
+ [self outputWord:bits mode:TABLE_PUNCT value:LATCH_TABLE[TABLE_PUNCT][TABLE_UPPER]];
+ mode = TABLE_UPPER;
+ i--;
+ continue;
+ } else if (mode == TABLE_DIGIT) {
+ [self outputWord:bits mode:TABLE_DIGIT value:LATCH_TABLE[TABLE_DIGIT][TABLE_UPPER]];
+ mode = TABLE_UPPER;
+ i--;
+ continue;
+ }
+ }
+ // use binary table
+ // find the binary string length
+ int k;
+ int lookahead;
+ for (k = i + 1, lookahead = 0; k < len; k++) {
+ next = data[k] & 0xFF;
+ BOOL binary = YES;
+ for (j = 0; j < TABLE_BINARY; j++) {
+ if (CHAR_MAP[j][next] > 0) {
+ binary = NO;
+ break;
+ }
+ }
+ if (binary) {
+ lookahead = 0;
+ } else {
+ // skip over single character in between binary bytes
+ if (lookahead >= 1) {
+ k -= lookahead;
+ break;
+ }
+ lookahead++;
+ }
+ }
+ k -= i;
+ // switch into binary table
+ switch (mode) {
+ case TABLE_UPPER:
+ case TABLE_LOWER:
+ case TABLE_MIXED:
+ [self outputWord:bits mode:mode value:SHIFT_TABLE[mode][TABLE_BINARY]];
+ break;
+ case TABLE_DIGIT:
+ [self outputWord:bits mode:mode value:LATCH_TABLE[mode][TABLE_UPPER]];
+ mode = TABLE_UPPER;
+ [self outputWord:bits mode:mode value:SHIFT_TABLE[mode][TABLE_BINARY]];
+ break;
+ case TABLE_PUNCT:
+ [self outputWord:bits mode:mode value:LATCH_TABLE[mode][TABLE_UPPER]];
+ mode = TABLE_UPPER;
+ [self outputWord:bits mode:mode value:SHIFT_TABLE[mode][TABLE_BINARY]];
+ break;
+ }
+ if (k >= 32 && k < 63) { // optimization: split one long form into two short forms, saves 1 bit
+ k = 31;
+ }
+ if (k > 542) { // maximum encodable binary length in long form is 511 + 31
+ k = 542;
+ }
+ if (k < 32) {
+ [bits appendBits:k numBits:5];
+ } else {
+ [bits appendBits:k - 31 numBits:16];
+ }
+ for (; k > 0; k--, i++) {
+ [bits appendBits:data[i] numBits:8];
+ }
+ i--;
+ }
+ }
+ }
+ return bits;
+
+}
+
++ (void)outputWord:(ZXBitArray *)bits mode:(int)mode value:(int)value {
+ if (mode == TABLE_DIGIT) {
+ [bits appendBits:value numBits:4];
+ } else if (mode < TABLE_BINARY) {
+ [bits appendBits:value numBits:5];
+ } else {
+ [bits appendBits:value numBits:8];
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecWriter.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd032e2118a9a7a5b461e2b51b5fb2877ebc31b9
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecWriter.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXWriter.h"
+
+@interface ZXAztecWriter : NSObject <ZXWriter>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecWriter.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecWriter.m
new file mode 100644
index 0000000000000000000000000000000000000000..75b3621658a3114ad19e6da3879c81273cd2a443
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/aztec/encoder/ZXAztecWriter.m
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAztecCode.h"
+#import "ZXAztecEncoder.h"
+#import "ZXAztecWriter.h"
+
+@implementation ZXAztecWriter
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height error:(NSError **)error {
+ char bytes[4096];
+ [contents getCString:bytes maxLength:4096 encoding:NSISOLatin1StringEncoding];
+ int bytesLen = [contents lengthOfBytesUsingEncoding:NSISOLatin1StringEncoding];
+
+ ZXAztecCode *aztec = [ZXAztecEncoder encode:(unsigned char *)bytes len:bytesLen minECCPercent:30];
+ return aztec.matrix;
+}
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height hints:(ZXEncodeHints *)hints error:(NSError **)error {
+ return [self encode:contents format:format width:width height:height error:error];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCGImageLuminanceSource.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCGImageLuminanceSource.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa8cfffcffe6bbd9065bac9632c213ffebc98e94
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCGImageLuminanceSource.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <CoreVideo/CoreVideo.h>
+#import "ZXLuminanceSource.h"
+
+@class ZXImage;
+
+@interface ZXCGImageLuminanceSource : ZXLuminanceSource {
+ CGImageRef image;
+ unsigned char *data;
+ int left;
+ int top;
+}
+
++ (CGImageRef)createImageFromBuffer:(CVImageBufferRef)buffer;
++ (CGImageRef)createImageFromBuffer:(CVImageBufferRef)buffer
+ left:(size_t)left
+ top:(size_t)top
+ width:(size_t)width
+ height:(size_t)height;
+
+- (id)initWithZXImage:(ZXImage *)image
+ left:(size_t)left
+ top:(size_t)top
+ width:(size_t)width
+ height:(size_t)height;
+
+- (id)initWithZXImage:(ZXImage *)image;
+
+- (id)initWithCGImage:(CGImageRef)image
+ left:(size_t)left
+ top:(size_t)top
+ width:(size_t)width
+ height:(size_t)height;
+
+- (id)initWithCGImage:(CGImageRef)image;
+
+- (id)initWithBuffer:(CVPixelBufferRef)buffer
+ left:(size_t)left
+ top:(size_t)top
+ width:(size_t)width
+ height:(size_t)height;
+
+- (id)initWithBuffer:(CVPixelBufferRef)buffer;
+
+- (CGImageRef)image;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCGImageLuminanceSource.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCGImageLuminanceSource.m
new file mode 100644
index 0000000000000000000000000000000000000000..b603af139ec8ba42b734bd3b3b4f6d606a3c7b7f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCGImageLuminanceSource.m
@@ -0,0 +1,296 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <CoreVideo/CoreVideo.h>
+#import "ZXCGImageLuminanceSource.h"
+#import "ZXImage.h"
+
+@interface ZXCGImageLuminanceSource ()
+
+- (void)initializeWithImage:(CGImageRef)image left:(int)left top:(int)top width:(int)width height:(int)height;
+
+@end
+
+@implementation ZXCGImageLuminanceSource
+
++ (CGImageRef)createImageFromBuffer:(CVImageBufferRef)buffer {
+ return [self createImageFromBuffer:buffer
+ left:0
+ top:0
+ width:CVPixelBufferGetWidth(buffer)
+ height:CVPixelBufferGetHeight(buffer)];
+}
+
++ (CGImageRef)createImageFromBuffer:(CVImageBufferRef)buffer
+ left:(size_t)left
+ top:(size_t)top
+ width:(size_t)width
+ height:(size_t)height {
+ int bytesPerRow = (int)CVPixelBufferGetBytesPerRow(buffer);
+ int dataWidth = (int)CVPixelBufferGetWidth(buffer);
+ int dataHeight = (int)CVPixelBufferGetHeight(buffer);
+
+ if (left + width > dataWidth ||
+ top + height > dataHeight) {
+ [NSException raise:NSInvalidArgumentException format:@"Crop rectangle does not fit within image data."];
+ }
+
+ int newBytesPerRow = ((width*4+0xf)>>4)<<4;
+
+ CVPixelBufferLockBaseAddress(buffer,0);
+
+ unsigned char *baseAddress =
+ (unsigned char *)CVPixelBufferGetBaseAddress(buffer);
+
+ int size = newBytesPerRow*height;
+ unsigned char *bytes = (unsigned char*)malloc(size);
+ if (newBytesPerRow == bytesPerRow) {
+ memcpy(bytes, baseAddress+top*bytesPerRow, size);
+ } else {
+ for(int y=0; y<height; y++) {
+ memcpy(bytes+y*newBytesPerRow,
+ baseAddress+left*4+(top+y)*bytesPerRow,
+ newBytesPerRow);
+ }
+ }
+ CVPixelBufferUnlockBaseAddress(buffer, 0);
+
+ CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+ CGContextRef newContext = CGBitmapContextCreate(bytes,
+ width,
+ height,
+ 8,
+ newBytesPerRow,
+ colorSpace,
+ kCGBitmapByteOrder32Little|
+ kCGImageAlphaNoneSkipFirst);
+ CGColorSpaceRelease(colorSpace);
+
+ CGImageRef result = CGBitmapContextCreateImage(newContext);
+ [NSMakeCollectable(result) autorelease];
+
+ CGContextRelease(newContext);
+
+ free(bytes);
+
+ return result;
+}
+
+- (id)initWithZXImage:(ZXImage *)_image
+ left:(size_t)_left
+ top:(size_t)_top
+ width:(size_t)_width
+ height:(size_t)_height {
+ self = [self initWithCGImage:_image.cgimage left:(int)_left top:(int)_top width:(int)_width height:(int)_height];
+
+ return self;
+}
+
+- (id)initWithZXImage:(ZXImage *)_image {
+ self = [self initWithCGImage:_image.cgimage];
+
+ return self;
+}
+
+- (id)initWithCGImage:(CGImageRef)_image
+ left:(size_t)_left
+ top:(size_t)_top
+ width:(size_t)_width
+ height:(size_t)_height {
+ if (self = [super init]) {
+ [self initializeWithImage:_image left:(int)_left top:(int)_top width:(int)_width height:(int)_height];
+ }
+
+ return self;
+}
+
+- (id)initWithCGImage:(CGImageRef)_image {
+ self = [self initWithCGImage:_image left:0 top:0 width:(int)CGImageGetWidth(_image) height:(int)CGImageGetHeight(_image)];
+
+ return self;
+}
+
+- (id)initWithBuffer:(CVPixelBufferRef)buffer
+ left:(size_t)_left
+ top:(size_t)_top
+ width:(size_t)_width
+ height:(size_t)_height {
+ CGImageRef _image = [ZXCGImageLuminanceSource createImageFromBuffer:buffer left:(int)_left top:(int)_top width:(int)_width height:(int)_height];
+
+ self = [self initWithCGImage:_image];
+
+ return self;
+}
+
+- (id )initWithBuffer:(CVPixelBufferRef)buffer {
+ CGImageRef _image = [ZXCGImageLuminanceSource createImageFromBuffer:buffer];
+
+ self = [self initWithCGImage:_image];
+
+ return self;
+}
+
+- (CGImageRef)image {
+ return image;
+}
+
+- (void)dealloc {
+ if (image) {
+ CGImageRelease(image);
+ }
+ if (data) {
+ free(data);
+ }
+
+ [super dealloc];
+}
+
+- (unsigned char *)row:(int)y {
+ if (y < 0 || y >= self.height) {
+ [NSException raise:NSInvalidArgumentException format:@"Requested row is outside the image: %d", y];
+ }
+
+ unsigned char *row = (unsigned char *)malloc(self.width * sizeof(unsigned char));
+
+ int offset = y * self.width;
+ memcpy(row, data + offset, self.width);
+ return row;
+}
+
+- (unsigned char *)matrix {
+ int area = self.width * self.height;
+
+ unsigned char *result = (unsigned char *)malloc(area * sizeof(unsigned char));
+ memcpy(result, data, area * sizeof(unsigned char));
+ return result;
+}
+
+- (void)initializeWithImage:(CGImageRef)cgimage left:(int)_left top:(int)_top width:(int)_width height:(int)_height {
+ data = 0;
+ image = CGImageRetain(cgimage);
+ left = _left;
+ top = _top;
+ self->width = _width;
+ self->height = _height;
+ int sourceWidth = (int)CGImageGetWidth(cgimage);
+ int sourceHeight = (int)CGImageGetHeight(cgimage);
+
+ if (left + self.width > sourceWidth ||
+ top + self.height > sourceHeight ||
+ top < 0 ||
+ left < 0) {
+ [NSException raise:NSInvalidArgumentException format:@"Crop rectangle does not fit within image data."];
+ }
+
+ CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+ CGContextRef context = CGBitmapContextCreate(0, self.width, self.height, 8, self.width * 4, colorSpace, kCGBitmapByteOrder32Little | kCGImageAlphaPremultipliedLast);
+ CGContextSetAllowsAntialiasing(context, FALSE);
+ CGContextSetInterpolationQuality(context, kCGInterpolationNone);
+
+ if (top || left) {
+ CGContextClipToRect(context, CGRectMake(0, 0, self.width, self.height));
+ }
+
+ CGContextDrawImage(context, CGRectMake(-left, -top, self.width, self.height), image);
+
+ uint32_t *pixelData = (uint32_t *) malloc(self.width * self.height * sizeof(uint32_t));
+ memcpy(pixelData, CGBitmapContextGetData(context), self.width * self.height * sizeof(uint32_t));
+ CGContextRelease(context);
+ CGColorSpaceRelease(colorSpace);
+
+ data = (unsigned char *)malloc(self.width * self.height * sizeof(unsigned char));
+
+ for (int i = 0; i < self.height * self.width; i++) {
+ uint32_t rgbPixel=pixelData[i];
+
+ float red = (rgbPixel>>24)&0xFF;
+ float green = (rgbPixel>>16)&0xFF;
+ float blue = (rgbPixel>>8)&0xFF;
+ float alpha = (float)(rgbPixel & 0xFF) / 255.0f;
+
+ // ImageIO premultiplies all PNGs, so we have to "un-premultiply them":
+ // http://code.google.com/p/cocos2d-iphone/issues/detail?id=697#c26
+ red = round((red / alpha) - 0.001f);
+ green = round((green / alpha) - 0.001f);
+ blue = round((blue / alpha) - 0.001f);
+
+ if (red == green && green == blue) {
+ data[i] = red;
+ } else {
+ data[i] = (306 * (int)red +
+ 601 * (int)green +
+ 117 * (int)blue +
+ (0x200)) >> 10; // 0x200 = 1<<9, half an lsb of the result to force rounding
+ }
+ }
+
+ free(pixelData);
+
+ top = _top;
+ left = _left;
+}
+
+- (BOOL)rotateSupported {
+ return YES;
+}
+
+- (ZXLuminanceSource *)rotateCounterClockwise {
+ double radians = 270.0f * M_PI / 180;
+
+#if TARGET_OS_EMBEDDED || TARGET_IPHONE_SIMULATOR
+ radians = -1 * radians;
+#endif
+
+ int sourceWidth = self.width;
+ int sourceHeight = self.height;
+
+ CGRect imgRect = CGRectMake(0, 0, sourceWidth, sourceHeight);
+ CGAffineTransform transform = CGAffineTransformMakeRotation(radians);
+ CGRect rotatedRect = CGRectApplyAffineTransform(imgRect, transform);
+
+ CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+ CGContextRef context = CGBitmapContextCreate(NULL,
+ rotatedRect.size.width,
+ rotatedRect.size.height,
+ CGImageGetBitsPerComponent(self.image),
+ 0,
+ colorSpace,
+ kCGImageAlphaPremultipliedFirst);
+ CGContextSetAllowsAntialiasing(context, FALSE);
+ CGContextSetInterpolationQuality(context, kCGInterpolationNone);
+ CGColorSpaceRelease(colorSpace);
+
+ CGContextTranslateCTM(context,
+ +(rotatedRect.size.width/2),
+ +(rotatedRect.size.height/2));
+ CGContextRotateCTM(context, radians);
+
+ CGContextDrawImage(context, CGRectMake(-imgRect.size.width/2,
+ -imgRect.size.height/2,
+ imgRect.size.width,
+ imgRect.size.height),
+ self.image);
+
+ CGImageRef rotatedImage = CGBitmapContextCreateImage(context);
+ [NSMakeCollectable(rotatedImage) autorelease];
+
+ CFRelease(context);
+
+ int _width = self.width;
+ return [[[ZXCGImageLuminanceSource alloc] initWithCGImage:rotatedImage left:top top:sourceWidth - (left + _width) width:self.height height:_width] autorelease];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCapture.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCapture.h
new file mode 100644
index 0000000000000000000000000000000000000000..eedfec01a414861a33c9b012f6a91d60aa1bc162
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCapture.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <QuartzCore/QuartzCore.h>
+#import "ZXCaptureDelegate.h"
+
+@protocol ZXReader;
+@class ZXDecodeHints;
+
+#if !TARGET_IPHONE_SIMULATOR
+#if TARGET_OS_EMBEDDED
+#include <AVFoundation/AVFoundation.h>
+#define ZX(x) x
+#define ZXAV(x) x
+#define ZXAVC(x) ,x
+#define ZXQT(x)
+#define ZXCaptureSession AVCaptureSession
+#define ZXCaptureVideoPreviewLayer AVCaptureVideoPreviewLayer
+#define ZXCaptureDevice AVCaptureDevice
+#define ZXCaptureDeviceInput AVCaptureDeviceInput
+#define ZXCaptureVideoOutput AVCaptureVideoDataOutput
+#else
+#import <QTKit/QTKit.h>
+#define ZX(x) x
+#define ZXAV(x)
+#define ZXAVC(x)
+#define ZXQT(x) x
+#define ZXCaptureSession QTCaptureSession
+#define ZXCaptureVideoPreviewLayer QTCaptureLayer
+#define ZXCaptureDevice QTCaptureDevice
+#define ZXCaptureDeviceInput QTCaptureDeviceInput
+#define ZXCaptureVideoOutput QTCaptureDecompressedVideoOutput
+#endif
+
+@interface ZXCapture
+ : NSObject
+ZX(<CAAction ZXAVC(AVCaptureVideoDataOutputSampleBufferDelegate)>) {
+ ZX(
+ ZXCaptureSession *session;
+ ZXCaptureVideoPreviewLayer *layer;
+ ZXCaptureDevice *capture_device;
+ ZXCaptureDeviceInput *input;
+ ZXCaptureVideoOutput *output;
+ id<ZXCaptureDelegate> delegate;
+ )
+
+ int order_in_skip;
+ int order_out_skip;
+ BOOL running;
+ BOOL on_screen;
+ CALayer *luminance;
+ CALayer *binary;
+ size_t width;
+ size_t height;
+ size_t reported_width;
+ size_t reported_height;
+ NSString *captureToFilename;
+ BOOL hard_stop;
+ int camera;
+ BOOL torch;
+ BOOL mirror;
+ int capture_device_index;
+ CGAffineTransform transform;
+ BOOL cameraIsReady;
+}
+
+@property (nonatomic, assign) id<ZXCaptureDelegate> delegate;
+@property (nonatomic, copy) NSString *captureToFilename;
+@property (nonatomic) CGAffineTransform transform;
+@property (nonatomic, readonly) ZXCaptureVideoOutput *output;
+@property (nonatomic, readonly) CALayer *layer;
+@property (nonatomic, retain) ZXCaptureDevice *captureDevice;
+@property (nonatomic, assign) BOOL mirror;
+@property (nonatomic, readonly) BOOL running;
+@property (nonatomic, retain) id<ZXReader> reader;
+@property (nonatomic, retain) ZXDecodeHints *hints;
+@property (nonatomic, assign) CGFloat rotation;
+
+- (id)init;
+- (CALayer *)luminance;
+- (void)setLuminance:(BOOL)on_off;
+- (CALayer *)binary;
+- (void)setBinary:(BOOL)on_off;
+- (void)start;
+- (void)stop;
+- (void)hard_stop;
+- (void)order_skip;
+
+@property (nonatomic, readonly) BOOL hasFront;
+@property (nonatomic, readonly) BOOL hasBack;
+@property (nonatomic, readonly) BOOL hasTorch;
+
+@property (nonatomic, readonly) int front;
+@property (nonatomic, readonly) int back;
+
+@property (nonatomic) int camera;
+@property (nonatomic) BOOL torch;
+
+@end
+
+#else
+
+@interface ZXCapture : NSObject {
+}
+
+@property (nonatomic,assign) id<ZXCaptureDelegate> delegate;
+@property (nonatomic,copy) NSString *captureToFilename;
+@property (nonatomic) CGAffineTransform transform;
+@property (nonatomic, readonly) void *output;
+@property (nonatomic, readonly) CALayer *layer;
+@property (nonatomic, retain) id<ZXReader> reader;
+@property (nonatomic, retain) ZXDecodeHints *hints;
+@property (nonatomic, assign) CGFloat rotation;
+
+- (id)init;
+- (CALayer *)luminance;
+- (void)setLuminance:(BOOL)on_off;
+- (CALayer *)binary;
+- (void)setBinary:(BOOL)on_off;
+- (void)start;
+- (void)stop;
+- (void)hard_stop;
+- (void)order_skip;
+
+@property (nonatomic,readonly) BOOL hasFront;
+@property (nonatomic,readonly) BOOL hasBack;
+@property (nonatomic,readonly) BOOL hasTorch;
+
+@property (nonatomic,readonly) int front;
+@property (nonatomic,readonly) int back;
+
+@property (nonatomic) int camera;
+@property (nonatomic) BOOL torch;
+
+@property (nonatomic, assign) BOOL mirror;
+
+@end
+
+#endif
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCapture.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCapture.m
new file mode 100644
index 0000000000000000000000000000000000000000..1f4e6d9334122fbb67d75118d7e3c86b8cbe324c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCapture.m
@@ -0,0 +1,786 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ZXCapture.h"
+
+#if !TARGET_IPHONE_SIMULATOR
+#include "ZXCGImageLuminanceSource.h"
+#include "ZXBinaryBitmap.h"
+#include "ZXDecodeHints.h"
+#include "ZXHybridBinarizer.h"
+#include "ZXMultiFormatReader.h"
+#include "ZXReader.h"
+#include "ZXResult.h"
+
+#if TARGET_OS_EMBEDDED || TARGET_IPHONE_SIMULATOR
+#import <UIKit/UIKit.h>
+#define ZXCaptureOutput AVCaptureOutput
+#define ZXMediaTypeVideo AVMediaTypeVideo
+#define ZXCaptureConnection AVCaptureConnection
+#else
+#define ZXCaptureOutput QTCaptureOutput
+#define ZXCaptureConnection QTCaptureConnection
+#define ZXMediaTypeVideo QTMediaTypeVideo
+#endif
+
+#if ZXAV(1)+0
+static bool isIPad();
+#endif
+
+@implementation ZXCapture
+
+@synthesize delegate;
+@synthesize transform;
+@synthesize captureToFilename;
+@synthesize reader;
+@synthesize hints;
+@synthesize rotation;
+
+// Adapted from http://blog.coriolis.ch/2009/09/04/arbitrary-rotation-of-a-cgimage/ and https://github.com/JanX2/CreateRotateWriteCGImage
+- (CGImageRef)rotateImage:(CGImageRef)original degrees:(float)degrees {
+ if (degrees == 0.0f) {
+ return original;
+ } else {
+ double radians = degrees * M_PI / 180;
+
+#if TARGET_OS_EMBEDDED || TARGET_IPHONE_SIMULATOR
+ radians = -1 * radians;
+#endif
+
+ size_t _width = CGImageGetWidth(original);
+ size_t _height = CGImageGetHeight(original);
+
+ CGRect imgRect = CGRectMake(0, 0, _width, _height);
+ CGAffineTransform _transform = CGAffineTransformMakeRotation(radians);
+ CGRect rotatedRect = CGRectApplyAffineTransform(imgRect, _transform);
+
+ CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+ CGContextRef context = CGBitmapContextCreate(NULL,
+ rotatedRect.size.width,
+ rotatedRect.size.height,
+ CGImageGetBitsPerComponent(original),
+ 0,
+ colorSpace,
+ kCGImageAlphaPremultipliedFirst);
+ CGContextSetAllowsAntialiasing(context, FALSE);
+ CGContextSetInterpolationQuality(context, kCGInterpolationNone);
+ CGColorSpaceRelease(colorSpace);
+
+ CGContextTranslateCTM(context,
+ +(rotatedRect.size.width/2),
+ +(rotatedRect.size.height/2));
+ CGContextRotateCTM(context, radians);
+
+ CGContextDrawImage(context, CGRectMake(-imgRect.size.width/2,
+ -imgRect.size.height/2,
+ imgRect.size.width,
+ imgRect.size.height),
+ original);
+
+ CGImageRef rotatedImage = CGBitmapContextCreateImage(context);
+ [NSMakeCollectable(rotatedImage) autorelease];
+
+ CFRelease(context);
+
+ return rotatedImage;
+ }
+}
+
+- (ZXCapture *)init {
+ if ((self = [super init])) {
+ on_screen = running = NO;
+ reported_width = 0;
+ reported_height = 0;
+ width = 1920;
+ height = 1080;
+ hard_stop = false;
+ capture_device = 0;
+ capture_device_index = -1;
+ order_in_skip = 0;
+ order_out_skip = 0;
+ transform = CGAffineTransformIdentity;
+ rotation = 0.0f;
+ ZXQT({
+ transform.a = -1;
+ });
+ self.reader = [ZXMultiFormatReader reader];
+ self.hints = [ZXDecodeHints hints];
+ }
+ return self;
+}
+
+- (BOOL)running {return running;}
+
+- (BOOL)mirror {
+ return mirror;
+}
+
+- (void)setMirror:(BOOL)mirror_ {
+ if (mirror != mirror_) {
+ mirror = mirror_;
+ if (layer) {
+ transform.a = -transform.a;
+ [layer setAffineTransform:transform];
+ }
+ }
+}
+
+- (void)order_skip {
+ order_out_skip = order_in_skip = 1;
+}
+
+- (ZXCaptureDevice *)device {
+ if (capture_device) {
+ return capture_device;
+ }
+
+ ZXCaptureDevice *zxd = nil;
+
+#if ZXAV(1)+0
+ NSArray *devices =
+ [ZXCaptureDevice
+ ZXAV(devicesWithMediaType:)
+ ZXQT(inputDevicesWithMediaType:) ZXMediaTypeVideo];
+
+ if ([devices count] > 0) {
+ if (capture_device_index == -1) {
+ AVCaptureDevicePosition position = AVCaptureDevicePositionBack;
+ if (camera == self.front) {
+ position = AVCaptureDevicePositionFront;
+ }
+
+ for(unsigned int i=0; i < [devices count]; ++i) {
+ ZXCaptureDevice *dev = [devices objectAtIndex:i];
+ if (dev.position == position) {
+ capture_device_index = i;
+ zxd = dev;
+ break;
+ }
+ }
+ }
+
+ if (!zxd && capture_device_index != -1) {
+ zxd = [devices objectAtIndex:capture_device_index];
+ }
+ }
+#endif
+
+ if (!zxd) {
+ zxd =
+ [ZXCaptureDevice
+ ZXAV(defaultDeviceWithMediaType:)
+ ZXQT(defaultInputDeviceWithMediaType:) ZXMediaTypeVideo];
+ }
+
+ capture_device = [zxd retain];
+
+ return zxd;
+}
+
+- (ZXCaptureDevice *)captureDevice {
+ return capture_device;
+}
+
+- (void)setCaptureDevice:(ZXCaptureDevice *)device {
+ if (device == capture_device) {
+ return;
+ }
+
+ if(capture_device) {
+ ZXQT({
+ if ([capture_device isOpen]) {
+ [capture_device close];
+ }});
+ [capture_device release];
+ }
+
+ capture_device = [device retain];
+}
+
+- (void)replaceInput {
+ if ([session respondsToSelector:@selector(beginConfiguration)]) {
+ [session beginConfiguration];
+ }
+
+ if (session && input) {
+ [session removeInput:input];
+ [input release];
+ input = nil;
+ }
+
+ ZXCaptureDevice *zxd = [self device];
+ ZXQT([zxd open:nil]);
+
+ if (zxd) {
+ input =
+ [ZXCaptureDeviceInput deviceInputWithDevice:zxd
+ ZXAV(error:nil)];
+ [input retain];
+ }
+
+ if (input) {
+ ZXAV({
+ NSString *preset = 0;
+ if (!preset &&
+ NSClassFromString(@"NSOrderedSet") && // Proxy for "is this iOS 5" ...
+ [UIScreen mainScreen].scale > 1 &&
+ isIPad() &&
+ &AVCaptureSessionPresetiFrame960x540 != nil &&
+ [zxd supportsAVCaptureSessionPreset:AVCaptureSessionPresetiFrame960x540]) {
+ // NSLog(@"960");
+ preset = AVCaptureSessionPresetiFrame960x540;
+ }
+ if (!preset) {
+ // NSLog(@"MED");
+ preset = AVCaptureSessionPresetMedium;
+ }
+ session.sessionPreset = preset;
+ });
+ [session addInput:input ZXQT(error:nil)];
+ }
+
+ if ([session respondsToSelector:@selector(commitConfiguration)]) {
+ [session commitConfiguration];
+ }
+}
+
+- (ZXCaptureSession *)session {
+ if (session == 0) {
+ session = [[ZXCaptureSession alloc] init];
+ [self replaceInput];
+ }
+ return session;
+}
+
+- (void)stop {
+ // NSLog(@"stop");
+
+ if (!running) {
+ return;
+ }
+
+ if (true ZXAV(&& self.session.running)) {
+ // NSLog(@"stop running");
+ [self.session stopRunning];
+ } else {
+ // NSLog(@"already stopped");
+ }
+ running = false;
+}
+
+- (void)setOutputAttributes {
+ NSString *key = (NSString *)kCVPixelBufferPixelFormatTypeKey;
+ NSNumber *value = [NSNumber numberWithUnsignedInt:kCVPixelFormatType_32BGRA];
+ NSMutableDictionary *attributes =
+ [NSMutableDictionary dictionaryWithObject:value forKey:key];
+ key = (NSString *)kCVPixelBufferWidthKey;
+ value = [NSNumber numberWithUnsignedLong:width];
+ [attributes setObject:value forKey:key];
+ key = (NSString *)kCVPixelBufferHeightKey;
+ value = [NSNumber numberWithUnsignedLong:height];
+ [attributes setObject:value forKey:key];
+ [output ZXQT(setPixelBufferAttributes:)ZXAV(setVideoSettings:)attributes];
+}
+
+- (ZXCaptureVideoOutput *)output {
+ if (!output) {
+ output = [[ZXCaptureVideoOutput alloc] init];
+ [self setOutputAttributes];
+ [output ZXQT(setAutomaticallyDropsLateVideoFrames:)
+ ZXAV(setAlwaysDiscardsLateVideoFrames:)YES];
+ [output ZXQT(setDelegate:)ZXAV(setSampleBufferDelegate:)self
+ ZXAV(queue:dispatch_get_main_queue())];
+ [self.session addOutput:output ZXQT(error:nil)];
+ }
+ return output;
+}
+
+- (void)start {
+ // NSLog(@"start %@ %d %@ %@", self.session, running, output, delegate);
+
+ if (hard_stop) {
+ return;
+ }
+
+ if (delegate || luminance || binary) {
+ // for side effects
+ [self output];
+ }
+
+ if (false ZXAV(|| self.session.running)) {
+ // NSLog(@"already running");
+ } else {
+
+ static int i = 0;
+ if (++i == -2) {
+ abort();
+ }
+
+ // NSLog(@"start running");
+ [self.session startRunning];
+ }
+ running = true;
+}
+
+- (void)start_stop {
+ // NSLog(@"ss %d %@ %d %@ %@ %@", running, delegate, on_screen, output, luminanceLayer, binary);
+ if ((!running && (delegate || on_screen)) ||
+ (!output &&
+ (delegate ||
+ (on_screen && (luminance || binary))))) {
+ [self start];
+ }
+ if (running && !delegate && !on_screen) {
+ [self stop];
+ }
+}
+
+- (void)setDelegate:(id<ZXCaptureDelegate>)_delegate {
+ delegate = _delegate;
+ if (delegate) {
+ hard_stop = false;
+ }
+ [self start_stop];
+}
+
+- (void)hard_stop {
+ hard_stop = true;
+ if (running) {
+ [self stop];
+ }
+}
+
+- (void)setLuminance:(BOOL)on {
+ if (on && !luminance) {
+ [luminance release];
+ luminance = [[CALayer layer] retain];
+ } else if (!on && luminance) {
+ [luminance release];
+ luminance = nil;
+ }
+}
+
+- (CALayer *)luminance {
+ return luminance;
+}
+
+- (void)setBinary:(BOOL)on {
+ if (on && !binary) {
+ [binary release];
+ binary = [[CALayer layer] retain];
+ } else if (!on && binary) {
+ [binary release];
+ binary = nil;
+ }
+}
+
+- (CALayer *)binary {
+ return binary;
+}
+
+- (CALayer *)layer {
+ if (!layer) {
+ layer = [[ZXCaptureVideoPreviewLayer alloc] initWithSession:self.session];
+
+ ZXAV(layer.videoGravity = AVLayerVideoGravityResizeAspect);
+ ZXAV(layer.videoGravity = AVLayerVideoGravityResizeAspectFill);
+
+ [layer setAffineTransform:transform];
+ layer.delegate = self;
+
+ ZXQT({
+ ProcessSerialNumber psn;
+ GetCurrentProcess(&psn);
+ TransformProcessType(&psn, 1);
+ });
+ }
+ return layer;
+}
+
+- (void)runActionForKey:(NSString *)key
+ object:(id)anObject
+ arguments:(NSDictionary *)dict {
+ // NSLog(@" rAFK %@ %@ %@", key, anObject, dict);
+ (void)anObject;
+ (void)dict;
+ if ([key isEqualToString:kCAOnOrderIn]) {
+
+ if (order_in_skip) {
+ --order_in_skip;
+ // NSLog(@"order in skip");
+ return;
+ }
+
+ // NSLog(@"order in");
+
+ on_screen = true;
+ if (luminance && luminance.superlayer != layer) {
+ // [layer addSublayer:luminance];
+ }
+ if (binary && binary.superlayer != layer) {
+ // [layer addSublayer:binary];
+ }
+ [self start_stop];
+ } else if ([key isEqualToString:kCAOnOrderOut]) {
+ if (order_out_skip) {
+ --order_out_skip;
+ // NSLog(@"order out skip");
+ return;
+ }
+
+ on_screen = false;
+ // NSLog(@"order out");
+ [self start_stop];
+ }
+}
+
+- (id<CAAction>)actionForLayer:(CALayer *)_layer forKey:(NSString *)event {
+ (void)_layer;
+
+ // NSLog(@"layer event %@", event);
+
+ // never animate
+ [CATransaction setValue:[NSNumber numberWithFloat:0.0f]
+ forKey:kCATransactionAnimationDuration];
+
+ // NSLog(@"afl %@ %@", _layer, event);
+ if ([event isEqualToString:kCAOnOrderIn]
+ || [event isEqualToString:kCAOnOrderOut]
+ // || ([event isEqualToString:@"bounds"] && (binary || luminance))
+ // || ([event isEqualToString:@"onLayout"] && (binary || luminance))
+ ) {
+ return self;
+ } else if ([event isEqualToString:@"contents"] ) {
+ } else if ([event isEqualToString:@"sublayers"] ) {
+ } else if ([event isEqualToString:@"onLayout"] ) {
+ } else if ([event isEqualToString:@"position"] ) {
+ } else if ([event isEqualToString:@"bounds"] ) {
+ } else if ([event isEqualToString:@"layoutManager"] ) {
+ } else if ([event isEqualToString:@"transform"] ) {
+ } else {
+ NSLog(@"afl %@ %@", _layer, event);
+ }
+ return nil;
+}
+
+- (void)dealloc {
+ if (input && session) {
+ [session removeInput:input];
+ }
+ if (output && session) {
+ [session removeOutput:output];
+ }
+ [captureToFilename release];
+ [binary release];
+ [luminance release];
+ [output release];
+ [input release];
+ [layer release];
+ [session release];
+ [reader release];
+ [hints release];
+ [super dealloc];
+}
+
+- (void)captureOutput:(ZXCaptureOutput *)captureOutput
+ZXQT(didOutputVideoFrame:(CVImageBufferRef)videoFrame
+ withSampleBuffer:(QTSampleBuffer *)sampleBuffer)
+ZXAV(didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer)
+ fromConnection:(ZXCaptureConnection *)connection {
+
+ if (!cameraIsReady)
+ {
+ cameraIsReady = YES;
+ if ([self.delegate respondsToSelector:@selector(captureCameraIsReady:)])
+ {
+ [self.delegate captureCameraIsReady:self];
+ }
+ }
+
+ if (!captureToFilename && !luminance && !binary && !delegate) {
+ // NSLog(@"skipping capture");
+ return;
+ }
+
+ // NSLog(@"received frame");
+
+ ZXAV(CVImageBufferRef videoFrame = CMSampleBufferGetImageBuffer(sampleBuffer));
+
+ // NSLog(@"%ld %ld", CVPixelBufferGetWidth(videoFrame), CVPixelBufferGetHeight(videoFrame));
+ // NSLog(@"delegate %@", delegate);
+
+ ZXQT({
+ if (!reported_width || !reported_height) {
+ NSSize size =
+ [[[[input.device.formatDescriptions objectAtIndex:0]
+ formatDescriptionAttributes] objectForKey:@"videoEncodedPixelsSize"] sizeValue];
+ width = size.width;
+ height = size.height;
+ // NSLog(@"reported: %f x %f", size.width, size.height);
+ [self performSelectorOnMainThread:@selector(setOutputAttributes) withObject:nil waitUntilDone:NO];
+ reported_width = size.width;
+ reported_height = size.height;
+ if ([delegate respondsToSelector:@selector(captureSize:width:height:)]) {
+ [delegate captureSize:self
+ width:[NSNumber numberWithFloat:size.width]
+ height:[NSNumber numberWithFloat:size.height]];
+ }
+ }});
+
+ (void)sampleBuffer;
+
+ NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+
+ (void)captureOutput;
+ (void)connection;
+
+#if !TARGET_OS_EMBEDDED
+ // The routines don't exist in iOS. There are alternatives, but a good
+ // solution would have to figure out a reasonable path and might be
+ // better as a post to url
+
+ if (captureToFilename) {
+ CGImageRef image =
+ [ZXCGImageLuminanceSource createImageFromBuffer:videoFrame];
+ NSURL *url = [NSURL fileURLWithPath:captureToFilename];
+ CGImageDestinationRef dest =
+ CGImageDestinationCreateWithURL((CFURLRef)url, kUTTypePNG, 1, nil);
+ CGImageDestinationAddImage(dest, image, nil);
+ CGImageDestinationFinalize(dest);
+ CGImageRelease(image);
+ CFRelease(dest);
+ self.captureToFilename = nil;
+ }
+#endif
+
+ CGImageRef videoFrameImage = [ZXCGImageLuminanceSource createImageFromBuffer:videoFrame];
+ CGImageRef rotatedImage = [self rotateImage:videoFrameImage degrees:rotation];
+
+ ZXCGImageLuminanceSource *source
+ = [[[ZXCGImageLuminanceSource alloc]
+ initWithCGImage:rotatedImage]
+ autorelease];
+
+ if (luminance) {
+ CGImageRef image = source.image;
+ CGImageRetain(image);
+ dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 0), dispatch_get_main_queue(), ^{
+ luminance.contents = (id)image;
+ CGImageRelease(image);
+ });
+ }
+
+ if (binary || delegate) {
+ ZXHybridBinarizer *binarizer = [ZXHybridBinarizer alloc];
+ [[binarizer initWithSource:source] autorelease];
+
+ if (binary) {
+ CGImageRef image = binarizer.createImage;
+ dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 0), dispatch_get_main_queue(), ^{
+ binary.contents = (id)image;
+ CGImageRelease(image);
+ });
+ }
+
+ if (delegate) {
+ ZXBinaryBitmap *bitmap =
+ [[[ZXBinaryBitmap alloc] initWithBinarizer:binarizer] autorelease];
+
+ NSError *error;
+ ZXResult *result = [self.reader decode:bitmap hints:hints error:&error];
+ if (result) {
+ [delegate captureResult:self result:result];
+ }
+ }
+ }
+
+ [pool drain];
+}
+
+- (BOOL)hasFront {
+ NSArray *devices =
+ [ZXCaptureDevice
+ ZXAV(devicesWithMediaType:)
+ ZXQT(inputDevicesWithMediaType:) ZXMediaTypeVideo];
+ return [devices count] > 1;
+}
+
+- (BOOL)hasBack {
+ NSArray *devices =
+ [ZXCaptureDevice
+ ZXAV(devicesWithMediaType:)
+ ZXQT(inputDevicesWithMediaType:) ZXMediaTypeVideo];
+ return [devices count] > 0;
+}
+
+- (BOOL)hasTorch {
+ if ([self device]) {
+ return false ZXAV(|| [self device].hasTorch);
+ } else {
+ return NO;
+ }
+}
+
+- (int)front {
+ return 0;
+}
+
+- (int)back {
+ return 1;
+}
+
+- (int)camera {
+ return camera;
+}
+
+- (BOOL)torch {
+ return torch;
+}
+
+- (void)setCamera:(int)camera_ {
+ if (camera != camera_) {
+ camera = camera_;
+ capture_device_index = -1;
+ [capture_device release];
+ capture_device = 0;
+ [self replaceInput];
+ }
+}
+
+- (void)setTorch:(BOOL)torch_ {
+ (void)torch_;
+ ZXAV({
+ [input.device lockForConfiguration:nil];
+ switch(input.device.torchMode) {
+ case AVCaptureTorchModeOff:
+ case AVCaptureTorchModeAuto:
+ default:
+ input.device.torchMode = AVCaptureTorchModeOn;
+ break;
+ case AVCaptureTorchModeOn:
+ input.device.torchMode = AVCaptureTorchModeOff;
+ break;
+ }
+ [input.device unlockForConfiguration];
+ });
+}
+
+- (void)setTransform:(CGAffineTransform)transform_ {
+ transform = transform_;
+ [layer setAffineTransform:transform];
+}
+
+@end
+
+// If you try to define this higher, there (seem to be) clashes with something(s) defined
+// in the includes ...
+
+#if ZXAV(1)+0
+#include <sys/types.h>
+#include <sys/sysctl.h>
+// Gross, I know, but ...
+static bool isIPad() {
+ static int is_ipad = -1;
+ if (is_ipad < 0) {
+ size_t size;
+ sysctlbyname("hw.machine", NULL, &size, NULL, 0); // Get size of data to be returned.
+ char *name = (char *)malloc(size);
+ sysctlbyname("hw.machine", name, &size, NULL, 0);
+ NSString *machine = [NSString stringWithCString:name encoding:NSASCIIStringEncoding];
+ free(name);
+ is_ipad = [machine hasPrefix:@"iPad"];
+ }
+ return !!is_ipad;
+}
+#endif
+
+#else
+
+@implementation ZXCapture
+
+@synthesize delegate;
+@synthesize transform;
+@synthesize captureToFilename;
+@synthesize mirror;
+@synthesize reader;
+@synthesize hints;
+@synthesize rotation;
+
+- (id)init {
+ if ((self = [super init])) {
+ [self release];
+ }
+ return 0;
+}
+
+- (BOOL)running {return NO;}
+
+- (CALayer *)layer {
+ return 0;
+}
+
+- (CALayer *)luminance {
+ return 0;
+}
+
+- (CALayer *)binary {
+ return 0;
+}
+
+- (void)setLuminance:(BOOL)on {}
+- (void)setBinary:(BOOL)on {}
+
+- (void)hard_stop {
+}
+
+- (BOOL)hasFront {
+ return YES;
+}
+
+- (BOOL)hasBack {
+ return NO;
+}
+
+- (BOOL)hasTorch {
+ return NO;
+}
+
+- (int)front {
+ return 0;
+}
+
+- (int)back {
+ return 1;
+}
+
+- (int)camera {
+ return self.front;
+}
+
+- (BOOL)torch {
+ return NO;
+}
+
+- (void)setCamera:(int)camera_ {}
+- (void)setTorch:(BOOL)torch {}
+- (void)order_skip {}
+- (void)start {}
+- (void)stop {}
+- (void *)output {return 0;}
+
+@end
+
+#endif
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCaptureDelegate.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCaptureDelegate.h
new file mode 100644
index 0000000000000000000000000000000000000000..33a7f486aaa6dc3ff83e6da1666ba1193e8f85ad
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCaptureDelegate.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXCapture;
+@class ZXResult;
+
+@protocol ZXCaptureDelegate <NSObject>
+
+- (void)captureResult:(ZXCapture *)capture result:(ZXResult *)result;
+
+@optional
+- (void)captureSize:(ZXCapture *)capture
+ width:(NSNumber *)width
+ height:(NSNumber *)height;
+
+- (void)captureCameraIsReady:(ZXCapture *)capture;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCaptureView.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCaptureView.h
new file mode 100644
index 0000000000000000000000000000000000000000..23f994624cb3a3df68dbf4f3b06764935adeb3a3
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCaptureView.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ZXView.h"
+
+@interface ZXCaptureView : ZXView
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCaptureView.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCaptureView.m
new file mode 100644
index 0000000000000000000000000000000000000000..17fc3aafe0b87de713b1bea595e824a25b8fac7b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXCaptureView.m
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ZXCaptureView.h"
+
+@implementation ZXCaptureView
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXImage.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXImage.h
new file mode 100644
index 0000000000000000000000000000000000000000..f7508100e2cbac8c9d0ceb1dc28c029f15a78a2f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXImage.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <QuartzCore/QuartzCore.h>
+
+@class ZXBitMatrix;
+
+@interface ZXImage : NSObject
+
+@property (assign, readonly) CGImageRef cgimage;
+
+- (ZXImage *)initWithCGImageRef:(CGImageRef)image;
+- (ZXImage *)initWithURL:(NSURL const *)url;
+- (size_t)width;
+- (size_t)height;
++ (ZXImage *)imageWithMatrix:(ZXBitMatrix *)matrix;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXImage.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXImage.m
new file mode 100644
index 0000000000000000000000000000000000000000..32a7ae92f747416d9eb7b3a44190b027033f965f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXImage.m
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXImage.h"
+
+#if TARGET_OS_EMBEDDED || TARGET_IPHONE_SIMULATOR
+#import <ImageIO/ImageIO.h>
+#endif
+
+@implementation ZXImage
+
+@synthesize cgimage;
+
+- (ZXImage *)initWithCGImageRef:(CGImageRef)image {
+ if (self = [super init]) {
+ cgimage = CGImageRetain(image);
+ }
+
+ return self;
+}
+
+- (ZXImage *)initWithURL:(NSURL const *)url {
+ if (self = [super init]) {
+ CGDataProviderRef provider = CGDataProviderCreateWithURL((CFURLRef)url);
+
+ if (provider) {
+ CGImageSourceRef source = CGImageSourceCreateWithDataProvider(provider, 0);
+
+ if (source) {
+ cgimage = CGImageSourceCreateImageAtIndex(source, 0, 0);
+
+ CFRelease(source);
+ }
+
+ CGDataProviderRelease(provider);
+ }
+ }
+
+ return self;
+}
+
+- (size_t)width {
+ return CGImageGetWidth(cgimage);
+}
+
+- (size_t)height {
+ return CGImageGetHeight(cgimage);
+}
+
+- (void)dealloc {
+ if (cgimage) {
+ CGImageRelease(cgimage);
+ }
+ [super dealloc];
+}
+
++ (ZXImage *)imageWithMatrix:(ZXBitMatrix *)matrix {
+ int width = matrix.width;
+ int height = matrix.height;
+ unsigned char *bytes = (unsigned char *)malloc(width * height * 4);
+ for(int y = 0; y < height; y++) {
+ for(int x = 0; x < width; x++) {
+ BOOL bit = [matrix getX:x y:y];
+ unsigned char intensity = bit ? 0 : 255;
+ for(int i = 0; i < 3; i++) {
+ bytes[y * width * 4 + x * 4 + i] = intensity;
+ }
+ bytes[y * width * 4 + x * 4 + 3] = 255;
+ }
+ }
+
+ CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+ CGContextRef c = CGBitmapContextCreate(bytes, width, height, 8, 4 * width, colorSpace, kCGImageAlphaPremultipliedLast);
+ CFRelease(colorSpace);
+ CGImageRef image = CGBitmapContextCreateImage(c);
+ [NSMakeCollectable(image) autorelease];
+ CFRelease(c);
+ free(bytes);
+
+ return [[[ZXImage alloc] initWithCGImageRef:image] autorelease];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXView.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXView.h
new file mode 100644
index 0000000000000000000000000000000000000000..88a093f676958224f89772ce6bf913b0e36c53a3
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/ZXView.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if TARGET_OS_EMBEDDED || TARGET_IPHONE_SIMULATOR
+#import <UIKit/UIKit.h>
+#define ZXView UIView
+#else
+#import <Cocoa/Cocoa.h>
+#define ZXView NSView
+#endif
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAbstractDoCoMoResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAbstractDoCoMoResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..30f35032adf1abd0e2a175142c5b01da5a5bc0d9
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAbstractDoCoMoResultParser.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * See DoCoMo's documentation http://www.nttdocomo.co.jp/english/service/imode/make/content/barcode/about/s2.html
+ * about the result types represented by subclasses of this class.
+ */
+
+@interface ZXAbstractDoCoMoResultParser : ZXResultParser
+
++ (NSArray *)matchDoCoMoPrefixedField:(NSString *)prefix rawText:(NSString *)rawText trim:(BOOL)trim;
++ (NSString *)matchSingleDoCoMoPrefixedField:(NSString *)prefix rawText:(NSString *)rawText trim:(BOOL)trim;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAbstractDoCoMoResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAbstractDoCoMoResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..3fdcd36cb204c3dc4228eabfe9d2522d5fae012d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAbstractDoCoMoResultParser.m
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractDoCoMoResultParser.h"
+
+@implementation ZXAbstractDoCoMoResultParser
+
++ (NSArray *) matchDoCoMoPrefixedField:(NSString *)prefix rawText:(NSString *)rawText trim:(BOOL)trim {
+ return [self matchPrefixedField:prefix rawText:rawText endChar:';' trim:trim];
+}
+
++ (NSString *) matchSingleDoCoMoPrefixedField:(NSString *)prefix rawText:(NSString *)rawText trim:(BOOL)trim {
+ return [self matchSinglePrefixedField:prefix rawText:rawText endChar:';' trim:trim];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookAUResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookAUResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..461f9d1c2df7ce7a7108fbee86670835ab20ffdf
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookAUResultParser.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Implements KDDI AU's address book format. See http://www.au.kddi.com/ezfactory/tec/two_dimensions/index.html.
+ * (Thanks to Yuzo for translating!)
+ */
+
+@interface ZXAddressBookAUResultParser : ZXResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookAUResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookAUResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..12f5c50b7867641097add4eace8f81e743e6f7ef
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookAUResultParser.m
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAddressBookAUResultParser.h"
+#import "ZXAddressBookParsedResult.h"
+#import "ZXResult.h"
+
+@interface ZXAddressBookAUResultParser ()
+
+- (NSArray *)matchMultipleValuePrefix:(NSString *)prefix max:(int)max rawText:(NSString *)rawText trim:(BOOL)trim;
+
+@end
+
+@implementation ZXAddressBookAUResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+
+ if ([rawText rangeOfString:@"MEMORY"].location == NSNotFound ||
+ [rawText rangeOfString:@"\r\n"].location == NSNotFound) {
+ return nil;
+ }
+
+ NSString *name = [[self class] matchSinglePrefixedField:@"NAME1:" rawText:rawText endChar:'\r' trim:YES];
+ NSString *pronunciation = [[self class] matchSinglePrefixedField:@"NAME2:" rawText:rawText endChar:'\r' trim:YES];
+ NSArray *phoneNumbers = [self matchMultipleValuePrefix:@"TEL" max:3 rawText:rawText trim:YES];
+ NSArray *emails = [self matchMultipleValuePrefix:@"MAIL" max:3 rawText:rawText trim:YES];
+ NSString *note = [[self class] matchSinglePrefixedField:@"MEMORY:" rawText:rawText endChar:'\r' trim:NO];
+ NSString *address = [[self class] matchSinglePrefixedField:@"ADD:" rawText:rawText endChar:'\r' trim:YES];
+ NSArray *addresses = address == nil ? nil : [NSArray arrayWithObjects:address, nil];
+
+ return [ZXAddressBookParsedResult addressBookParsedResultWithNames:[self maybeWrap:name]
+ nicknames:nil
+ pronunciation:pronunciation
+ phoneNumbers:phoneNumbers
+ phoneTypes:nil
+ emails:emails
+ emailTypes:nil
+ instantMessenger:nil
+ note:note
+ addresses:addresses
+ addressTypes:nil
+ org:nil
+ birthday:nil
+ title:nil
+ urls:nil
+ geo:nil];
+}
+
+- (NSArray *)matchMultipleValuePrefix:(NSString *)prefix max:(int)max rawText:(NSString *)rawText trim:(BOOL)trim {
+ NSMutableArray *values = nil;
+
+ for (int i = 1; i <= max; i++) {
+ NSString *value = [[self class] matchSinglePrefixedField:[NSString stringWithFormat:@"%@%d:", prefix, i]
+ rawText:rawText
+ endChar:'\r'
+ trim:trim];
+ if (value == nil) {
+ break;
+ }
+ if (values == nil) {
+ values = [[[NSMutableArray alloc] initWithCapacity:max] autorelease];
+ }
+ [values addObject:value];
+ }
+
+ if (values == nil) {
+ return nil;
+ }
+ return values;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookDoCoMoResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookDoCoMoResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..d6a4b2045d5bba5c9e1eda4f130e370dc5dfa7fe
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookDoCoMoResultParser.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractDoCoMoResultParser.h"
+#import "ZXResult.h"
+
+/**
+ * Implements the "MECARD" address book entry format.
+ *
+ * Supported keys: N, SOUND, TEL, EMAIL, NOTE, ADR, BDAY, URL, plus ORG
+ * Unsupported keys: TEL-AV, NICKNAME
+ *
+ * Except for TEL, multiple values for keys are also not supported;
+ * the first one found takes precedence.
+ *
+ * Our understanding of the MECARD format is based on this document:
+ *
+ * http://www.mobicode.org.tw/files/OMIA%20Mobile%20Bar%20Code%20Standard%20v3.2.1.doc
+ */
+
+@interface ZXAddressBookDoCoMoResultParser : ZXAbstractDoCoMoResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookDoCoMoResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookDoCoMoResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..38041ed23c15f11cc96a38bfc3351b74090e33b0
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookDoCoMoResultParser.m
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAddressBookDoCoMoResultParser.h"
+#import "ZXAddressBookParsedResult.h"
+#import "ZXResult.h"
+
+@interface ZXAddressBookDoCoMoResultParser ()
+
+- (NSString *)parseName:(NSString *)name;
+
+@end
+
+@implementation ZXAddressBookDoCoMoResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+ if (![rawText hasPrefix:@"MECARD:"]) {
+ return nil;
+ }
+ NSArray *rawName = [[self class] matchDoCoMoPrefixedField:@"N:" rawText:rawText trim:YES];
+ if (rawName == nil) {
+ return nil;
+ }
+ NSString *name = [self parseName:[rawName objectAtIndex:0]];
+ NSString *pronunciation = [[self class] matchSingleDoCoMoPrefixedField:@"SOUND:" rawText:rawText trim:YES];
+ NSArray *phoneNumbers = [[self class] matchDoCoMoPrefixedField:@"TEL:" rawText:rawText trim:YES];
+ NSArray *emails = [[self class] matchDoCoMoPrefixedField:@"EMAIL:" rawText:rawText trim:YES];
+ NSString *note = [[self class] matchSingleDoCoMoPrefixedField:@"NOTE:" rawText:rawText trim:NO];
+ NSArray *addresses = [[self class] matchDoCoMoPrefixedField:@"ADR:" rawText:rawText trim:YES];
+ NSString *birthday = [[self class] matchSingleDoCoMoPrefixedField:@"BDAY:" rawText:rawText trim:YES];
+ if (birthday != nil && ![[self class] isStringOfDigits:birthday length:8]) {
+ birthday = nil;
+ }
+ NSArray *urls = [[self class] matchDoCoMoPrefixedField:@"URL:" rawText:rawText trim:YES];
+ NSString *org = [[self class] matchSingleDoCoMoPrefixedField:@"ORG:" rawText:rawText trim:YES];
+
+ return [ZXAddressBookParsedResult addressBookParsedResultWithNames:[self maybeWrap:name]
+ nicknames:nil
+ pronunciation:pronunciation
+ phoneNumbers:phoneNumbers
+ phoneTypes:nil
+ emails:emails
+ emailTypes:nil
+ instantMessenger:nil
+ note:note
+ addresses:addresses
+ addressTypes:nil
+ org:org
+ birthday:birthday
+ title:nil
+ urls:urls
+ geo:nil];
+}
+
+- (NSString *)parseName:(NSString *)name {
+ int comma = [name rangeOfString:@","].location;
+ if (comma != NSNotFound) {
+ return [NSString stringWithFormat:@"%@ %@", [name substringFromIndex:comma + 1], [name substringToIndex:comma]];
+ }
+ return name;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..2e7678d010ff36389dc2d11fd789988b4b023193
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookParsedResult.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResult.h"
+
+@interface ZXAddressBookParsedResult : ZXParsedResult
+
+@property (nonatomic, readonly, retain) NSArray *names;
+@property (nonatomic, readonly, retain) NSArray *nicknames;
+@property (nonatomic, readonly, copy) NSString *pronunciation;
+@property (nonatomic, readonly, retain) NSArray *phoneNumbers;
+@property (nonatomic, readonly, retain) NSArray *phoneTypes;
+@property (nonatomic, readonly, retain) NSArray *emails;
+@property (nonatomic, readonly, retain) NSArray *emailTypes;
+@property (nonatomic, readonly, copy) NSString *instantMessenger;
+@property (nonatomic, readonly, copy) NSString *note;
+@property (nonatomic, readonly, retain) NSArray *addresses;
+@property (nonatomic, readonly, retain) NSArray *addressTypes;
+@property (nonatomic, readonly, copy) NSString *title;
+@property (nonatomic, readonly, copy) NSString *org;
+@property (nonatomic, readonly, retain) NSArray *urls;
+@property (nonatomic, readonly, copy) NSString *birthday;
+@property (nonatomic, readonly, retain) NSArray *geo;
+
+- (id)initWithNames:(NSArray *)names phoneNumbers:(NSArray *)phoneNumbers
+ phoneTypes:(NSArray *)phoneTypes emails:(NSArray *)emails emailTypes:(NSArray *)emailTypes
+ addresses:(NSArray *)addresses addressTypes:(NSArray *)addressTypes;
+
+- (id)initWithNames:(NSArray *)names nicknames:(NSArray *)nicknames pronunciation:(NSString *)pronunciation
+ phoneNumbers:(NSArray *)phoneNumbers phoneTypes:(NSArray *)phoneTypes emails:(NSArray *)emails emailTypes:(NSArray *)emailTypes
+ instantMessenger:(NSString *)instantMessenger note:(NSString *)note addresses:(NSArray *)addresses
+ addressTypes:(NSArray *)addressTypes org:(NSString *)org birthday:(NSString *)birthday
+ title:(NSString *)title urls:(NSArray *)urls geo:(NSArray *)geo;
+
++ (id)addressBookParsedResultWithNames:(NSArray *)names phoneNumbers:(NSArray *)phoneNumbers
+ phoneTypes:(NSArray *)phoneTypes emails:(NSArray *)emails emailTypes:(NSArray *)emailTypes
+ addresses:(NSArray *)addresses addressTypes:(NSArray *)addressTypes;
+
++ (id)addressBookParsedResultWithNames:(NSArray *)names nicknames:(NSArray *)nicknames pronunciation:(NSString *)pronunciation
+ phoneNumbers:(NSArray *)phoneNumbers phoneTypes:(NSArray *)phoneTypes emails:(NSArray *)emails emailTypes:(NSArray *)emailTypes
+ instantMessenger:(NSString *)instantMessenger note:(NSString *)note addresses:(NSArray *)addresses
+ addressTypes:(NSArray *)addressTypes org:(NSString *)org birthday:(NSString *)birthday
+ title:(NSString *)title urls:(NSArray *)urls geo:(NSArray *)geo;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..d976e4a9f03ee277568feb78dc4fb88547c5dadc
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXAddressBookParsedResult.m
@@ -0,0 +1,153 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAddressBookParsedResult.h"
+#import "ZXParsedResultType.h"
+
+@interface ZXAddressBookParsedResult ()
+
+@property (nonatomic, retain) NSArray *names;
+@property (nonatomic, retain) NSArray *nicknames;
+@property (nonatomic, copy) NSString *pronunciation;
+@property (nonatomic, retain) NSArray *phoneNumbers;
+@property (nonatomic, retain) NSArray *phoneTypes;
+@property (nonatomic, retain) NSArray *emails;
+@property (nonatomic, retain) NSArray *emailTypes;
+@property (nonatomic, copy) NSString *instantMessenger;
+@property (nonatomic, copy) NSString *note;
+@property (nonatomic, retain) NSArray *addresses;
+@property (nonatomic, retain) NSArray *addressTypes;
+@property (nonatomic, copy) NSString *title;
+@property (nonatomic, copy) NSString *org;
+@property (nonatomic, retain) NSArray *urls;
+@property (nonatomic, copy) NSString *birthday;
+@property (nonatomic, retain) NSArray *geo;
+
+@end
+
+@implementation ZXAddressBookParsedResult
+
+@synthesize names;
+@synthesize nicknames;
+@synthesize pronunciation;
+@synthesize phoneNumbers;
+@synthesize phoneTypes;
+@synthesize emails;
+@synthesize emailTypes;
+@synthesize instantMessenger;
+@synthesize note;
+@synthesize addresses;
+@synthesize addressTypes;
+@synthesize title;
+@synthesize org;
+@synthesize urls;
+@synthesize birthday;
+@synthesize geo;
+
+- (id)initWithNames:(NSArray *)_names phoneNumbers:(NSArray *)_phoneNumbers
+ phoneTypes:(NSArray *)_phoneTypes emails:(NSArray *)_emails emailTypes:(NSArray *)_emailTypes
+ addresses:(NSArray *)_addresses addressTypes:(NSArray *)_addressTypes {
+ return [self initWithNames:_names nicknames:nil pronunciation:nil phoneNumbers:_phoneNumbers phoneTypes:_phoneNumbers
+ emails:_emails emailTypes:_emailTypes instantMessenger:nil note:nil
+ addresses:_addresses addressTypes:_addressTypes org:nil birthday:nil title:nil urls:nil geo:nil];
+}
+
+- (id)initWithNames:(NSArray *)_names nicknames:(NSArray *)_nicknames pronunciation:(NSString *)_pronunciation
+ phoneNumbers:(NSArray *)_phoneNumbers phoneTypes:(NSArray *)_phoneTypes emails:(NSArray *)_emails emailTypes:(NSArray *)_emailTypes
+ instantMessenger:(NSString *)_instantMessenger note:(NSString *)_note addresses:(NSArray *)_addresses
+ addressTypes:(NSArray *)_addressTypes org:(NSString *)_org birthday:(NSString *)_birthday
+ title:(NSString *)_title urls:(NSArray *)_urls geo:(NSArray *)_geo {
+ if (self = [super initWithType:kParsedResultTypeAddressBook]) {
+ self.names = _names;
+ self.nicknames = _nicknames;
+ self.pronunciation = _pronunciation;
+ self.phoneNumbers = _phoneNumbers;
+ self.phoneTypes = _phoneTypes;
+ self.emails = _emails;
+ self.emailTypes = _emailTypes;
+ self.instantMessenger = _instantMessenger;
+ self.note = _note;
+ self.addresses = _addresses;
+ self.addressTypes = _addressTypes;
+ self.org = _org;
+ self.birthday = _birthday;
+ self.title = _title;
+ self.urls = _urls;
+ self.geo = _geo;
+ }
+
+ return self;
+}
+
++ (id)addressBookParsedResultWithNames:(NSArray *)names phoneNumbers:(NSArray *)phoneNumbers
+ phoneTypes:(NSArray *)phoneTypes emails:(NSArray *)emails emailTypes:(NSArray *)emailTypes
+ addresses:(NSArray *)addresses addressTypes:(NSArray *)addressTypes {
+ return [[self alloc] initWithNames:names phoneNumbers:phoneNumbers phoneTypes:phoneTypes emails:emails
+ emailTypes:emailTypes addresses:addresses addressTypes:addressTypes];
+}
+
+
++ (id)addressBookParsedResultWithNames:(NSArray *)names nicknames:(NSArray *)nicknames
+ pronunciation:(NSString *)pronunciation phoneNumbers:(NSArray *)phoneNumbers phoneTypes:(NSArray *)phoneTypes
+ emails:(NSArray *)emails emailTypes:(NSArray *)emailTypes instantMessenger:(NSString *)instantMessenger
+ note:(NSString *)note addresses:(NSArray *)addresses addressTypes:(NSArray *)addressTypes org:(NSString *)org
+ birthday:(NSString *)birthday title:(NSString *)title urls:(NSArray *)urls geo:(NSArray *)geo {
+ return [[[self alloc] initWithNames:names nicknames:nicknames pronunciation:pronunciation phoneNumbers:phoneNumbers
+ phoneTypes:phoneTypes emails:emails emailTypes:emailTypes
+ instantMessenger:instantMessenger note:note addresses:addresses
+ addressTypes:addressTypes org:org birthday:birthday title:title urls:urls geo:geo] autorelease];
+}
+
+- (void)dealloc {
+ [names release];
+ [nicknames release];
+ [pronunciation release];
+ [phoneNumbers release];
+ [phoneTypes release];
+ [emails release];
+ [emailTypes release];
+ [instantMessenger release];
+ [note release];
+ [addresses release];
+ [addressTypes release];
+ [org release];
+ [birthday release];
+ [title release];
+ [urls release];
+ [geo release];
+
+ [super dealloc];
+}
+
+- (NSString *)displayResult {
+ NSMutableString *result = [NSMutableString string];
+ [ZXParsedResult maybeAppendArray:self.names result:result];
+ [ZXParsedResult maybeAppendArray:self.nicknames result:result];
+ [ZXParsedResult maybeAppend:self.pronunciation result:result];
+ [ZXParsedResult maybeAppend:self.title result:result];
+ [ZXParsedResult maybeAppend:self.org result:result];
+ [ZXParsedResult maybeAppendArray:self.addresses result:result];
+ [ZXParsedResult maybeAppendArray:self.phoneNumbers result:result];
+ [ZXParsedResult maybeAppendArray:self.emails result:result];
+ [ZXParsedResult maybeAppend:self.instantMessenger result:result];
+ [ZXParsedResult maybeAppendArray:self.urls result:result];
+ [ZXParsedResult maybeAppend:self.birthday result:result];
+ [ZXParsedResult maybeAppendArray:self.geo result:result];
+ [ZXParsedResult maybeAppend:self.note result:result];
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXBizcardResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXBizcardResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..42d7f0a48c567db82490dcff29b36989cf1093b4
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXBizcardResultParser.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractDoCoMoResultParser.h"
+
+/**
+ * Implements the "BIZCARD" address book entry format, though this has been
+ * largely reverse-engineered from examples observed in the wild -- still
+ * looking for a definitive reference.
+ */
+
+@interface ZXBizcardResultParser : ZXAbstractDoCoMoResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXBizcardResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXBizcardResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..e9868b00b9bdec250dcf34230b2bc6ef9856b733
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXBizcardResultParser.m
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAddressBookParsedResult.h"
+#import "ZXBizcardResultParser.h"
+#import "ZXResult.h"
+
+@interface ZXBizcardResultParser ()
+
+- (NSString *)buildName:(NSString *)firstName lastName:(NSString *)lastName;
+- (NSArray *)buildPhoneNumbers:(NSString *)number1 number2:(NSString *)number2 number3:(NSString *)number3;
+
+@end
+
+@implementation ZXBizcardResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+ if (![rawText hasPrefix:@"BIZCARD:"]) {
+ return nil;
+ }
+ NSString *firstName = [[self class] matchSingleDoCoMoPrefixedField:@"N:" rawText:rawText trim:YES];
+ NSString *lastName = [[self class] matchSingleDoCoMoPrefixedField:@"X:" rawText:rawText trim:YES];
+ NSString *fullName = [self buildName:firstName lastName:lastName];
+ NSString *title = [[self class] matchSingleDoCoMoPrefixedField:@"T:" rawText:rawText trim:YES];
+ NSString *org = [[self class] matchSingleDoCoMoPrefixedField:@"C:" rawText:rawText trim:YES];
+ NSArray *addresses = [[self class] matchDoCoMoPrefixedField:@"A:" rawText:rawText trim:YES];
+ NSString *phoneNumber1 = [[self class] matchSingleDoCoMoPrefixedField:@"B:" rawText:rawText trim:YES];
+ NSString *phoneNumber2 = [[self class] matchSingleDoCoMoPrefixedField:@"M:" rawText:rawText trim:YES];
+ NSString *phoneNumber3 = [[self class] matchSingleDoCoMoPrefixedField:@"F:" rawText:rawText trim:YES];
+ NSString *email = [[self class] matchSingleDoCoMoPrefixedField:@"E:" rawText:rawText trim:YES];
+
+ return [ZXAddressBookParsedResult addressBookParsedResultWithNames:[self maybeWrap:fullName]
+ nicknames:nil
+ pronunciation:nil
+ phoneNumbers:[self buildPhoneNumbers:phoneNumber1 number2:phoneNumber2 number3:phoneNumber3]
+ phoneTypes:nil
+ emails:[self maybeWrap:email]
+ emailTypes:nil
+ instantMessenger:nil
+ note:nil
+ addresses:addresses
+ addressTypes:nil
+ org:org
+ birthday:nil
+ title:title
+ urls:nil
+ geo:nil];
+}
+
+- (NSArray *)buildPhoneNumbers:(NSString *)number1 number2:(NSString *)number2 number3:(NSString *)number3 {
+ NSMutableArray *numbers = [NSMutableArray arrayWithCapacity:3];
+ if (number1 != nil) {
+ [numbers addObject:number1];
+ }
+ if (number2 != nil) {
+ [numbers addObject:number2];
+ }
+ if (number3 != nil) {
+ [numbers addObject:number3];
+ }
+ int size = [numbers count];
+ if (size == 0) {
+ return nil;
+ }
+ NSMutableArray *result = [NSMutableArray arrayWithCapacity:size];
+ for (int i = 0; i < size; i++) {
+ [result addObject:[numbers objectAtIndex:i]];
+ }
+ return result;
+}
+
+- (NSString *)buildName:(NSString *)firstName lastName:(NSString *)lastName {
+ if (firstName == nil) {
+ return lastName;
+ } else {
+ return lastName == nil ? firstName : [[firstName stringByAppendingString:@" "] stringByAppendingString:lastName];
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXBookmarkDoCoMoResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXBookmarkDoCoMoResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb9ca2d5e02e32be379e54595f5abbabe968251e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXBookmarkDoCoMoResultParser.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractDoCoMoResultParser.h"
+
+@interface ZXBookmarkDoCoMoResultParser : ZXAbstractDoCoMoResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXBookmarkDoCoMoResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXBookmarkDoCoMoResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..ce547ecb51de2d84be442ea2380d1dbf7d68e342
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXBookmarkDoCoMoResultParser.m
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBookmarkDoCoMoResultParser.h"
+#import "ZXResult.h"
+#import "ZXURIParsedResult.h"
+#import "ZXURIResultParser.h"
+
+@implementation ZXBookmarkDoCoMoResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [result text];
+ if (![rawText hasPrefix:@"MEBKM:"]) {
+ return nil;
+ }
+ NSString *title = [[self class] matchSingleDoCoMoPrefixedField:@"TITLE:" rawText:rawText trim:YES];
+ NSArray *rawUri = [[self class] matchDoCoMoPrefixedField:@"URL:" rawText:rawText trim:YES];
+ if (rawUri == nil) {
+ return nil;
+ }
+ NSString *uri = [rawUri objectAtIndex:0];
+ if (![ZXURIResultParser isBasicallyValidURI:uri]) {
+ return nil;
+ }
+ return [ZXURIParsedResult uriParsedResultWithUri:uri title:title];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXCalendarParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXCalendarParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..69aa575861148569125e01721bc89693a1585a30
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXCalendarParsedResult.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResult.h"
+
+@interface ZXCalendarParsedResult : ZXParsedResult
+
+@property (nonatomic, retain, readonly) NSString *summary;
+@property (nonatomic, retain, readonly) NSDate *start;
+@property (nonatomic, readonly) BOOL startAllDay;
+@property (nonatomic, retain, readonly) NSDate *end;
+@property (nonatomic, readonly) BOOL endAllDay;
+@property (nonatomic, retain, readonly) NSString *location;
+@property (nonatomic, retain, readonly) NSString *organizer;
+@property (nonatomic, retain, readonly) NSArray *attendees;
+@property (nonatomic, retain, readonly) NSString *description;
+@property (nonatomic, readonly) double latitude;
+@property (nonatomic, readonly) double longitude;
+
+- (id)initWithSummary:(NSString *)summary startString:(NSString *)startString endString:(NSString *)endString durationString:(NSString *)durationString
+ location:(NSString *)location organizer:(NSString *)organizer attendees:(NSArray *)attendees description:(NSString *)description latitude:(double)latitude longitude:(double)longitude;
++ (id)calendarParsedResultWithSummary:(NSString *)summary startString:(NSString *)startString endString:(NSString *)endString durationString:(NSString *)durationString
+ location:(NSString *)location organizer:(NSString *)organizer attendees:(NSArray *)attendees description:(NSString *)description latitude:(double)latitude longitude:(double)longitude;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXCalendarParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXCalendarParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..b33ab2d2a237e4ee0189bcc4cefaa59b67ee03d0
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXCalendarParsedResult.m
@@ -0,0 +1,190 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXCalendarParsedResult.h"
+
+@interface ZXCalendarParsedResult ()
+
+@property(nonatomic, retain) NSString *summary;
+@property(nonatomic, retain) NSDate *start;
+@property(nonatomic) BOOL startAllDay;
+@property(nonatomic, retain) NSDate *end;
+@property(nonatomic) BOOL endAllDay;
+@property(nonatomic, retain) NSString *location;
+@property(nonatomic, retain) NSString *organizer;
+@property(nonatomic, retain) NSArray *attendees;
+@property(nonatomic, retain) NSString *description;
+@property(nonatomic) double latitude;
+@property(nonatomic) double longitude;
+
+- (NSDate *)parseDate:(NSString *)when;
+- (NSString *)format:(BOOL)allDay date:(NSDate *)date;
+- (long)parseDurationMS:(NSString *)durationString;
+
+@end
+
+static NSRegularExpression *DATE_TIME = nil;
+static NSRegularExpression *RFC2445_DURATION = nil;
+static NSDateFormatter *DATE_FORMAT = nil;
+static NSDateFormatter *DATE_TIME_FORMAT = nil;
+
+const int RFC2445_DURATION_FIELD_UNITS_LEN = 5;
+const long RFC2445_DURATION_FIELD_UNITS[RFC2445_DURATION_FIELD_UNITS_LEN] = {
+ 7 * 24 * 60 * 60 * 1000, // 1 week
+ 24 * 60 * 60 * 1000, // 1 day
+ 60 * 60 * 1000, // 1 hour
+ 60 * 1000, // 1 minute
+ 1000, // 1 second
+};
+
+@implementation ZXCalendarParsedResult
+
+@synthesize summary;
+@synthesize start;
+@synthesize end;
+@synthesize location;
+@synthesize organizer;
+@synthesize attendees;
+@synthesize description;
+@synthesize latitude;
+@synthesize longitude;
+
++ (void)initialize {
+ DATE_TIME = [[NSRegularExpression alloc] initWithPattern:@"[0-9]{8}(T[0-9]{6}Z?)?"
+ options:0
+ error:nil];
+
+ RFC2445_DURATION = [[NSRegularExpression alloc] initWithPattern:@"P(?:(\\d+)W)?(?:(\\d+)D)?(?:T(?:(\\d+)H)?(?:(\\d+)M)?(?:(\\d+)S)?)?"
+ options:NSRegularExpressionCaseInsensitive
+ error:nil];
+
+ DATE_FORMAT = [[NSDateFormatter alloc] init];
+ DATE_FORMAT.dateFormat = @"yyyyMMdd";
+
+ DATE_TIME_FORMAT = [[NSDateFormatter alloc] init];
+ DATE_TIME_FORMAT.dateFormat = @"yyyyMMdd'T'HHmmss";
+}
+
+- (id)initWithSummary:(NSString *)aSummary startString:(NSString *)aStartString endString:(NSString *)anEndString durationString:(NSString *)aDurationString
+ location:(NSString *)aLocation organizer:(NSString *)anOrganizer attendees:(NSArray *)anAttendees description:(NSString *)aDescription latitude:(double)aLatitude longitude:(double)aLongitude {
+ if (self = [super initWithType:kParsedResultTypeCalendar]) {
+ self.summary = aSummary;
+ self.start = [self parseDate:aStartString];
+
+ if (anEndString == nil) {
+ long durationMS = [self parseDurationMS:aDurationString];
+ self.end = durationMS < 0 ? nil : [NSDate dateWithTimeIntervalSince1970:[start timeIntervalSince1970] + durationMS / 1000];
+ } else {
+ self.end = [self parseDate:anEndString];
+ }
+
+ self.startAllDay = aStartString.length == 8;
+ self.endAllDay = anEndString != nil && anEndString.length == 8;
+
+ self.location = aLocation;
+ self.organizer = anOrganizer;
+ self.attendees = anAttendees;
+ self.description = aDescription;
+ self.latitude = aLatitude;
+ self.longitude = aLongitude;
+ }
+ return self;
+}
+
++ (id)calendarParsedResultWithSummary:(NSString *)summary startString:(NSString *)startString endString:(NSString *)endString durationString:(NSString *)durationString
+ location:(NSString *)location organizer:(NSString *)organizer attendees:(NSArray *)attendees description:(NSString *)description latitude:(double)latitude longitude:(double)longitude {
+ return [[[self alloc] initWithSummary:summary startString:startString endString:endString durationString:durationString location:location organizer:organizer attendees:attendees
+ description:description latitude:latitude longitude:longitude] autorelease];
+}
+
+- (void)dealloc {
+ [summary release];
+ [start release];
+ [end release];
+ [location release];
+ [organizer release];
+ [attendees release];
+ [description release];
+ [super dealloc];
+}
+
+- (NSString *)displayResult {
+ NSMutableString *result = [NSMutableString stringWithCapacity:100];
+ [ZXParsedResult maybeAppend:self.summary result:result];
+ [ZXParsedResult maybeAppend:[self format:self.startAllDay date:self.start] result:result];
+ [ZXParsedResult maybeAppend:[self format:self.endAllDay date:self.end] result:result];
+ [ZXParsedResult maybeAppend:self.location result:result];
+ [ZXParsedResult maybeAppend:self.organizer result:result];
+ [ZXParsedResult maybeAppendArray:self.attendees result:result];
+ [ZXParsedResult maybeAppend:self.description result:result];
+ return result;
+}
+
+
+/**
+ * Parses a string as a date. RFC 2445 allows the start and end fields to be of type DATE (e.g. 20081021)
+ * or DATE-TIME (e.g. 20081021T123000 for local time, or 20081021T123000Z for UTC).
+ */
+- (NSDate *)parseDate:(NSString *)when {
+ NSArray *matches = [DATE_TIME matchesInString:when options:0 range:NSMakeRange(0, when.length)];
+ if (matches.count == 0) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Invalid date"];
+ }
+ if (when.length == 8) {
+ // Show only year/month/day
+ return [DATE_FORMAT dateFromString:when];
+ } else {
+ // The when string can be local time, or UTC if it ends with a Z
+ if (when.length == 16 && [when characterAtIndex:15] == 'Z') {
+ return [DATE_TIME_FORMAT dateFromString:[when substringToIndex:15]];
+ } else {
+ return [DATE_TIME_FORMAT dateFromString:when];
+ }
+ }
+}
+
+- (NSString *)format:(BOOL)allDay date:(NSDate *)date {
+ if (date == nil) {
+ return nil;
+ }
+ NSDateFormatter *format = [[NSDateFormatter alloc] init];
+ format.dateFormat = allDay ? @"MMM d, yyyy" : @"MMM d, yyyy hh:mm:ss a";
+ return [format stringFromDate:date];
+}
+
+- (long)parseDurationMS:(NSString *)durationString {
+ if (durationString == nil) {
+ return -1;
+ }
+ NSArray *m = [RFC2445_DURATION matchesInString:durationString options:0 range:NSMakeRange(0, durationString.length)];
+ if (m.count == 0) {
+ return -1;
+ }
+ long durationMS = 0;
+ NSTextCheckingResult *match = [m objectAtIndex:0];
+ for (int i = 0; i < RFC2445_DURATION_FIELD_UNITS_LEN; i++) {
+ if ([match rangeAtIndex:i + 1].location != NSNotFound) {
+ NSString *fieldValue = [durationString substringWithRange:[match rangeAtIndex:i + 1]];
+ if (fieldValue != nil) {
+ durationMS += RFC2445_DURATION_FIELD_UNITS[i] * [fieldValue intValue];
+ }
+ }
+ }
+ return durationMS;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailAddressParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailAddressParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f84189c166cc36da1a830ada53289984458eb7f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailAddressParsedResult.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResult.h"
+
+@interface ZXEmailAddressParsedResult : ZXParsedResult
+
+@property (nonatomic, copy, readonly) NSString *emailAddress;
+@property (nonatomic, copy, readonly) NSString *subject;
+@property (nonatomic, copy, readonly) NSString *body;
+@property (nonatomic, copy, readonly) NSString *mailtoURI;
+
+- (id)initWithEmailAddress:(NSString *)emailAddress subject:(NSString *)subject body:(NSString *)body mailtoURI:(NSString *)mailtoURI;
++ (id)emailAddressParsedResultWithEmailAddress:(NSString *)emailAddress subject:(NSString *)subject body:(NSString *)body mailtoURI:(NSString *)mailtoURI;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailAddressParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailAddressParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..5351c407af5f14d5144934d95d9f64a4614d6a30
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailAddressParsedResult.m
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXEmailAddressParsedResult.h"
+#import "ZXParsedResultType.h"
+
+@interface ZXEmailAddressParsedResult ()
+
+@property (nonatomic, copy) NSString *emailAddress;
+@property (nonatomic, copy) NSString *subject;
+@property (nonatomic, copy) NSString *body;
+@property (nonatomic, copy) NSString *mailtoURI;
+
+@end
+
+@implementation ZXEmailAddressParsedResult
+
+@synthesize emailAddress;
+@synthesize subject;
+@synthesize body;
+@synthesize mailtoURI;
+
+- (id)initWithEmailAddress:(NSString *)anEmailAddress subject:(NSString *)aSubject body:(NSString *)aBody mailtoURI:(NSString *)aMailtoURI {
+ if (self = [super initWithType:kParsedResultTypeEmailAddress]) {
+ self.emailAddress = anEmailAddress;
+ self.subject = aSubject;
+ self.body = aBody;
+ self.mailtoURI = aMailtoURI;
+ }
+
+ return self;
+}
+
++ (id)emailAddressParsedResultWithEmailAddress:(NSString *)emailAddress subject:(NSString *)subject body:(NSString *)body mailtoURI:(NSString *)mailtoURI {
+ return [[[self alloc] initWithEmailAddress:emailAddress subject:subject body:body mailtoURI:mailtoURI] autorelease];
+}
+
+- (void)dealloc {
+ [emailAddress release];
+ [subject release];
+ [body release];
+ [mailtoURI release];
+
+ [super dealloc];
+}
+
+- (NSString *)displayResult {
+ NSMutableString *result = [NSMutableString stringWithCapacity:30];
+ [ZXParsedResult maybeAppend:emailAddress result:result];
+ [ZXParsedResult maybeAppend:subject result:result];
+ [ZXParsedResult maybeAppend:body result:result];
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailAddressResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailAddressResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..827673f2957451a13ff861f11803d2d3556d0ab9
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailAddressResultParser.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Represents a result that encodes an e-mail address, either as a plain address
+ * like "joe@example.org" or a mailto: URL like "mailto:joe@example.org".
+ */
+
+@interface ZXEmailAddressResultParser : ZXResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailAddressResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailAddressResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..f3ea039cb176df5b78839042d7146df413fd8d7b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailAddressResultParser.m
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXEmailAddressParsedResult.h"
+#import "ZXEmailAddressResultParser.h"
+#import "ZXEmailDoCoMoResultParser.h"
+#import "ZXResult.h"
+
+@implementation ZXEmailAddressResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+ NSString *emailAddress;
+ if ([rawText hasPrefix:@"mailto:"] || [rawText hasPrefix:@"MAILTO:"]) {
+ emailAddress = [rawText substringFromIndex:7];
+ int queryStart = [emailAddress rangeOfString:@"?"].location;
+ if (queryStart != NSNotFound) {
+ emailAddress = [emailAddress substringToIndex:queryStart];
+ }
+ emailAddress = [[self class] urlDecode:emailAddress];
+ NSMutableDictionary *nameValues = [self parseNameValuePairs:rawText];
+ NSString *subject = nil;
+ NSString *body = nil;
+ if (nameValues != nil) {
+ if ([emailAddress length] == 0) {
+ emailAddress = [nameValues objectForKey:@"to"];
+ }
+ subject = [nameValues objectForKey:@"subject"];
+ body = [nameValues objectForKey:@"body"];
+ }
+ return [ZXEmailAddressParsedResult emailAddressParsedResultWithEmailAddress:emailAddress
+ subject:subject
+ body:body
+ mailtoURI:rawText];
+ } else {
+ if (![ZXEmailDoCoMoResultParser isBasicallyValidEmailAddress:rawText]) {
+ return nil;
+ }
+ emailAddress = rawText;
+ return [ZXEmailAddressParsedResult emailAddressParsedResultWithEmailAddress:emailAddress
+ subject:nil
+ body:nil
+ mailtoURI:[@"mailto:" stringByAppendingString:emailAddress]];
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailDoCoMoResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailDoCoMoResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..838b5587dffca29643b920d7135fdd27e149d2c8
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailDoCoMoResultParser.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractDoCoMoResultParser.h"
+
+/**
+ * Implements the "MATMSG" email message entry format.
+ *
+ * Supported keys: TO, SUB, BODY
+ */
+
+@interface ZXEmailDoCoMoResultParser : ZXAbstractDoCoMoResultParser
+
++ (BOOL)isBasicallyValidEmailAddress:(NSString *)email;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailDoCoMoResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailDoCoMoResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..b983474563d05cba1c92176375016e8c62eb18ec
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXEmailDoCoMoResultParser.m
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXEmailAddressParsedResult.h"
+#import "ZXEmailDoCoMoResultParser.h"
+#import "ZXResult.h"
+
+static NSRegularExpression *ATEXT_ALPHANUMERIC = nil;
+
+@implementation ZXEmailDoCoMoResultParser
+
++ (void)initialize {
+ ATEXT_ALPHANUMERIC = [[NSRegularExpression alloc] initWithPattern:@"^[a-zA-Z0-9@.!#$%&'*+\\-/=?^_`{|}~]+$"
+ options:0 error:nil];
+}
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+ if (![rawText hasPrefix:@"MATMSG:"]) {
+ return nil;
+ }
+ NSArray *rawTo = [[self class] matchDoCoMoPrefixedField:@"TO:" rawText:rawText trim:YES];
+ if (rawTo == nil) {
+ return nil;
+ }
+ NSString *to = [rawTo objectAtIndex:0];
+ if (![[self class] isBasicallyValidEmailAddress:to]) {
+ return nil;
+ }
+ NSString *subject = [[self class] matchSingleDoCoMoPrefixedField:@"SUB:" rawText:rawText trim:NO];
+ NSString *body = [[self class] matchSingleDoCoMoPrefixedField:@"BODY:" rawText:rawText trim:NO];
+
+ return [ZXEmailAddressParsedResult emailAddressParsedResultWithEmailAddress:to
+ subject:subject
+ body:body
+ mailtoURI:[@"mailto:" stringByAppendingString:to]];
+}
+
+
+/**
+ * This implements only the most basic checking for an email address's validity -- that it contains
+ * an '@' and contains no characters disallowed by RFC 2822. This is an overly lenient definition of
+ * validity. We want to generally be lenient here since this class is only intended to encapsulate what's
+ * in a barcode, not "judge" it.
+ */
++ (BOOL)isBasicallyValidEmailAddress:(NSString *)email {
+ return email != nil && [ATEXT_ALPHANUMERIC numberOfMatchesInString:email options:0 range:NSMakeRange(0, email.length)] > 0 && [email rangeOfString:@"@"].location != NSNotFound;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXExpandedProductParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXExpandedProductParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..199839e5c031a5287a361f0ec5c6b090c39701fe
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXExpandedProductParsedResult.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResult.h"
+
+extern NSString *const KILOGRAM;
+extern NSString *const POUND;
+
+@interface ZXExpandedProductParsedResult : ZXParsedResult
+
+@property (nonatomic, copy, readonly) NSString *rawText;
+@property (nonatomic, copy, readonly) NSString *productID;
+@property (nonatomic, copy, readonly) NSString *sscc;
+@property (nonatomic, copy, readonly) NSString *lotNumber;
+@property (nonatomic, copy, readonly) NSString *productionDate;
+@property (nonatomic, copy, readonly) NSString *packagingDate;
+@property (nonatomic, copy, readonly) NSString *bestBeforeDate;
+@property (nonatomic, copy, readonly) NSString *expirationDate;
+@property (nonatomic, copy, readonly) NSString *weight;
+@property (nonatomic, copy, readonly) NSString *weightType;
+@property (nonatomic, copy, readonly) NSString *weightIncrement;
+@property (nonatomic, copy, readonly) NSString *price;
+@property (nonatomic, copy, readonly) NSString *priceIncrement;
+@property (nonatomic, copy, readonly) NSString *priceCurrency;
+@property (nonatomic, retain, readonly) NSMutableDictionary *uncommonAIs;
+
+- (id)initWithRawText:(NSString *)rawText productID:(NSString *)productID sscc:(NSString *)sscc lotNumber:(NSString *)lotNumber
+ productionDate:(NSString *)productionDate packagingDate:(NSString *)packagingDate bestBeforeDate:(NSString *)bestBeforeDate
+ expirationDate:(NSString *)expirationDate weight:(NSString *)weight weightType:(NSString *)weightType
+ weightIncrement:(NSString *)weightIncrement price:(NSString *)price priceIncrement:(NSString *)priceIncrement
+ priceCurrency:(NSString *)priceCurrency uncommonAIs:(NSMutableDictionary *)uncommonAIs;
++ (id)expandedProductParsedResultWithRawText:(NSString *)rawText productID:(NSString *)productID sscc:(NSString *)sscc lotNumber:(NSString *)lotNumber
+ productionDate:(NSString *)productionDate packagingDate:(NSString *)packagingDate bestBeforeDate:(NSString *)bestBeforeDate
+ expirationDate:(NSString *)expirationDate weight:(NSString *)weight weightType:(NSString *)weightType
+ weightIncrement:(NSString *)weightIncrement price:(NSString *)price priceIncrement:(NSString *)priceIncrement
+ priceCurrency:(NSString *)priceCurrency uncommonAIs:(NSMutableDictionary *)uncommonAIs;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXExpandedProductParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXExpandedProductParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..0891a754b10d3ea00e9105d44f317e5d32257514
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXExpandedProductParsedResult.m
@@ -0,0 +1,173 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXExpandedProductParsedResult.h"
+
+NSString *const KILOGRAM = @"KG";
+NSString *const POUND = @"LB";
+
+@interface ZXExpandedProductParsedResult ()
+
+@property (nonatomic, copy) NSString *rawText;
+@property (nonatomic, copy) NSString *productID;
+@property (nonatomic, copy) NSString *sscc;
+@property (nonatomic, copy) NSString *lotNumber;
+@property (nonatomic, copy) NSString *productionDate;
+@property (nonatomic, copy) NSString *packagingDate;
+@property (nonatomic, copy) NSString *bestBeforeDate;
+@property (nonatomic, copy) NSString *expirationDate;
+@property (nonatomic, copy) NSString *weight;
+@property (nonatomic, copy) NSString *weightType;
+@property (nonatomic, copy) NSString *weightIncrement;
+@property (nonatomic, copy) NSString *price;
+@property (nonatomic, copy) NSString *priceIncrement;
+@property (nonatomic, copy) NSString *priceCurrency;
+@property (nonatomic, retain) NSMutableDictionary *uncommonAIs;
+
+- (BOOL)equalsOrNil:(id)o1 o2:(id)o2;
+
+@end
+
+@implementation ZXExpandedProductParsedResult
+
+@synthesize rawText;
+@synthesize productID;
+@synthesize sscc;
+@synthesize lotNumber;
+@synthesize productionDate;
+@synthesize packagingDate;
+@synthesize bestBeforeDate;
+@synthesize expirationDate;
+@synthesize weight;
+@synthesize weightType;
+@synthesize weightIncrement;
+@synthesize price;
+@synthesize priceIncrement;
+@synthesize priceCurrency;
+@synthesize uncommonAIs;
+
+- (id)init {
+ return [self initWithRawText:@"" productID:@"" sscc:@"" lotNumber:@"" productionDate:@"" packagingDate:@"" bestBeforeDate:@""
+ expirationDate:@"" weight:@"" weightType:@"" weightIncrement:@"" price:@"" priceIncrement:@""
+ priceCurrency:@"" uncommonAIs:[NSMutableDictionary dictionary]];
+}
+
+- (id)initWithRawText:(NSString *)aRawText productID:(NSString *)aProductID sscc:(NSString *)anSscc lotNumber:(NSString *)aLotNumber
+ productionDate:(NSString *)aProductionDate packagingDate:(NSString *)aPackagingDate bestBeforeDate:(NSString *)aBestBeforeDate
+ expirationDate:(NSString *)anExpirationDate weight:(NSString *)aWeight weightType:(NSString *)aWeightType
+ weightIncrement:(NSString *)aWeightIncrement price:(NSString *)aPrice priceIncrement:(NSString *)aPriceIncrement
+ priceCurrency:(NSString *)aPriceCurrency uncommonAIs:(NSMutableDictionary *)theUncommonAIs {
+ if (self = [super initWithType:kParsedResultTypeProduct]) {
+ self.rawText = aRawText;
+ self.productID = aProductID;
+ self.sscc = anSscc;
+ self.lotNumber = aLotNumber;
+ self.productionDate = aProductionDate;
+ self.packagingDate = aPackagingDate;
+ self.bestBeforeDate = aBestBeforeDate;
+ self.expirationDate = anExpirationDate;
+ self.weight = aWeight;
+ self.weightType = aWeightType;
+ self.weightIncrement = aWeightIncrement;
+ self.price = aPrice;
+ self.priceIncrement = aPriceIncrement;
+ self.priceCurrency = aPriceCurrency;
+ self.uncommonAIs = theUncommonAIs;
+ }
+
+ return self;
+}
+
++ (id)expandedProductParsedResultWithRawText:(NSString *)rawText productID:(NSString *)productID sscc:(NSString *)sscc lotNumber:(NSString *)lotNumber
+ productionDate:(NSString *)productionDate packagingDate:(NSString *)packagingDate bestBeforeDate:(NSString *)bestBeforeDate
+ expirationDate:(NSString *)expirationDate weight:(NSString *)weight weightType:(NSString *)weightType
+ weightIncrement:(NSString *)weightIncrement price:(NSString *)price priceIncrement:(NSString *)priceIncrement
+ priceCurrency:(NSString *)priceCurrency uncommonAIs:(NSMutableDictionary *)uncommonAIs {
+ return [[[self alloc] initWithRawText:rawText productID:productID sscc:sscc lotNumber:lotNumber productionDate:productionDate
+ packagingDate:packagingDate bestBeforeDate:bestBeforeDate expirationDate:expirationDate
+ weight:weight weightType:weightType weightIncrement:weightIncrement price:price
+ priceIncrement:priceIncrement priceCurrency:priceCurrency uncommonAIs:uncommonAIs] autorelease];
+}
+
+- (void)dealloc {
+ [rawText release];
+ [productID release];
+ [sscc release];
+ [lotNumber release];
+ [productionDate release];
+ [packagingDate release];
+ [bestBeforeDate release];
+ [expirationDate release];
+ [weight release];
+ [weightType release];
+ [weightIncrement release];
+ [price release];
+ [priceIncrement release];
+ [priceCurrency release];
+ [uncommonAIs release];
+
+ [super dealloc];
+}
+
+- (BOOL)isEqual:(id)o {
+ if (![o isKindOfClass:[self class]]) {
+ return NO;
+ }
+
+ ZXExpandedProductParsedResult *other = (ZXExpandedProductParsedResult *)o;
+
+ return [self equalsOrNil:productID o2:other.productID]
+ && [self equalsOrNil:sscc o2:other.sscc]
+ && [self equalsOrNil:lotNumber o2:other.lotNumber]
+ && [self equalsOrNil:productionDate o2:other.productionDate]
+ && [self equalsOrNil:bestBeforeDate o2:other.bestBeforeDate]
+ && [self equalsOrNil:expirationDate o2:other.expirationDate]
+ && [self equalsOrNil:weight o2:other.weight]
+ && [self equalsOrNil:weightType o2:other.weightType]
+ && [self equalsOrNil:weightIncrement o2:other.weightIncrement]
+ && [self equalsOrNil:price o2:other.price]
+ && [self equalsOrNil:priceIncrement o2:other.priceIncrement]
+ && [self equalsOrNil:priceCurrency o2:other.priceCurrency]
+ && [self equalsOrNil:uncommonAIs o2:other.uncommonAIs];
+}
+
+- (BOOL)equalsOrNil:(id)o1 o2:(id)o2 {
+ return o1 == nil ? o2 == nil : [o1 isEqual:o2];
+}
+
+- (NSUInteger)hash {
+ int hash = 0;
+ hash ^= [productID hash];
+ hash ^= [sscc hash];
+ hash ^= [lotNumber hash];
+ hash ^= [productionDate hash];
+ hash ^= [bestBeforeDate hash];
+ hash ^= [expirationDate hash];
+ hash ^= [weight hash];
+ hash ^= [weightType hash];
+ hash ^= [weightIncrement hash];
+ hash ^= [price hash];
+ hash ^= [priceIncrement hash];
+ hash ^= [priceCurrency hash];
+ hash ^= [uncommonAIs hash];
+ return hash;
+}
+
+- (NSString *)displayResult {
+ return self.rawText;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXExpandedProductResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXExpandedProductResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7049c8c447986bf404fb82f3b33e834c188664d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXExpandedProductResultParser.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Parses strings of digits that represent a RSS Extended code.
+ */
+
+@interface ZXExpandedProductResultParser : ZXResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXExpandedProductResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXExpandedProductResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..1703258a1a1ea6e3c2ee8a2969601360b3509026
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXExpandedProductResultParser.m
@@ -0,0 +1,164 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXExpandedProductResultParser.h"
+#import "ZXExpandedProductParsedResult.h"
+#import "ZXResult.h"
+
+@interface ZXExpandedProductResultParser ()
+
+- (NSString *)findAIvalue:(int)i rawText:(NSString *)rawText;
+- (NSString *)findValue:(int)i rawText:(NSString *)rawText;
+
+@end
+
+@implementation ZXExpandedProductResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ ZXBarcodeFormat format = [result barcodeFormat];
+ if (kBarcodeFormatRSSExpanded != format) {
+ return nil;
+ }
+ NSString *rawText = [ZXResultParser massagedText:result];
+ if (rawText == nil) {
+ return nil;
+ }
+
+ NSString *productID = nil;
+ NSString *sscc = nil;
+ NSString *lotNumber = nil;
+ NSString *productionDate = nil;
+ NSString *packagingDate = nil;
+ NSString *bestBeforeDate = nil;
+ NSString *expirationDate = nil;
+ NSString *weight = nil;
+ NSString *weightType = nil;
+ NSString *weightIncrement = nil;
+ NSString *price = nil;
+ NSString *priceIncrement = nil;
+ NSString *priceCurrency = nil;
+ NSMutableDictionary *uncommonAIs = [NSMutableDictionary dictionary];
+
+ int i = 0;
+
+ while (i < [rawText length]) {
+ NSString *ai = [self findAIvalue:i rawText:rawText];
+ if (ai == nil) {
+ // Error. Code doesn't match with RSS expanded pattern
+ // ExtendedProductParsedResult NOT created. Not match with RSS Expanded pattern
+ return nil;
+ }
+ i += [ai length] + 2;
+ NSString *value = [self findValue:i rawText:rawText];
+ i += [value length];
+
+ if ([@"00" isEqualToString:ai]) {
+ sscc = value;
+ } else if ([@"01" isEqualToString:ai]) {
+ productID = value;
+ } else if ([@"10" isEqualToString:ai]) {
+ lotNumber = value;
+ } else if ([@"11" isEqualToString:ai]) {
+ productionDate = value;
+ } else if ([@"13" isEqualToString:ai]) {
+ packagingDate = value;
+ } else if ([@"15" isEqualToString:ai]) {
+ bestBeforeDate = value;
+ } else if ([@"17" isEqualToString:ai]) {
+ expirationDate = value;
+ } else if ([@"3100" isEqualToString:ai] || [@"3101" isEqualToString:ai] || [@"3102" isEqualToString:ai] || [@"3103" isEqualToString:ai] || [@"3104" isEqualToString:ai] || [@"3105" isEqualToString:ai] || [@"3106" isEqualToString:ai] || [@"3107" isEqualToString:ai] || [@"3108" isEqualToString:ai] || [@"3109" isEqualToString:ai]) {
+ weight = value;
+ weightType = KILOGRAM;
+ weightIncrement = [ai substringFromIndex:3];
+ } else if ([@"3200" isEqualToString:ai] || [@"3201" isEqualToString:ai] || [@"3202" isEqualToString:ai] || [@"3203" isEqualToString:ai] || [@"3204" isEqualToString:ai] || [@"3205" isEqualToString:ai] || [@"3206" isEqualToString:ai] || [@"3207" isEqualToString:ai] || [@"3208" isEqualToString:ai] || [@"3209" isEqualToString:ai]) {
+ weight = value;
+ weightType = POUND;
+ weightIncrement = [ai substringFromIndex:3];
+ } else if ([@"3920" isEqualToString:ai] || [@"3921" isEqualToString:ai] || [@"3922" isEqualToString:ai] || [@"3923" isEqualToString:ai]) {
+ price = value;
+ priceIncrement = [ai substringFromIndex:3];
+ } else if ([@"3930" isEqualToString:ai] || [@"3931" isEqualToString:ai] || [@"3932" isEqualToString:ai] || [@"3933" isEqualToString:ai]) {
+ if ([value length] < 4) {
+ return nil;
+ }
+ price = [value substringFromIndex:3];
+ priceCurrency = [value substringToIndex:3];
+ priceIncrement = [ai substringFromIndex:3];
+ } else {
+ [uncommonAIs setObject:value forKey:ai];
+ }
+ }
+
+ return [ZXExpandedProductParsedResult expandedProductParsedResultWithRawText:rawText
+ productID:productID
+ sscc:sscc
+ lotNumber:lotNumber
+ productionDate:productionDate
+ packagingDate:packagingDate
+ bestBeforeDate:bestBeforeDate
+ expirationDate:expirationDate
+ weight:weight
+ weightType:weightType
+ weightIncrement:weightIncrement
+ price:price
+ priceIncrement:priceIncrement
+ priceCurrency:priceCurrency
+ uncommonAIs:uncommonAIs];
+}
+
+- (NSString *)findAIvalue:(int)i rawText:(NSString *)rawText {
+ unichar c = [rawText characterAtIndex:i];
+ if (c != '(') {
+ return nil;
+ }
+
+ NSString *rawTextAux = [rawText substringFromIndex:i + 1];
+
+ NSMutableString *buf = [NSMutableString string];
+ for (int index = 0; index < [rawTextAux length]; index++) {
+ unichar currentChar = [rawTextAux characterAtIndex:index];
+ if (currentChar == ')') {
+ return buf;
+ } else if (currentChar >= '0' && currentChar <= '9') {
+ [buf appendFormat:@"%C", currentChar];
+ } else {
+ return nil;
+ }
+ }
+ return buf;
+}
+
+- (NSString *)findValue:(int)i rawText:(NSString *)rawText {
+ NSMutableString *buf = [NSMutableString string];
+ NSString *rawTextAux = [rawText substringFromIndex:i];
+
+ for (int index = 0; index < [rawTextAux length]; index++) {
+ unichar c = [rawTextAux characterAtIndex:index];
+ if (c == '(') {
+ if ([self findAIvalue:index rawText:rawTextAux] == nil) {
+ [buf appendString:@"("];
+ } else {
+ break;
+ }
+ } else {
+ [buf appendFormat:@"%C", c];
+ }
+ }
+
+ return buf;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXGeoParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXGeoParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..aa44a03296ba5123b0eabfb8b41f8b1297619727
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXGeoParsedResult.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResult.h"
+
+@interface ZXGeoParsedResult : ZXParsedResult
+
+@property (nonatomic, readonly) double latitude;
+@property (nonatomic, readonly) double longitude;
+@property (nonatomic, readonly) double altitude;
+@property (nonatomic, copy, readonly) NSString *query;
+
+- (id)initWithLatitude:(double)latitude longitude:(double)longitude altitude:(double)altitude query:(NSString *)query;
++ (id)geoParsedResultWithLatitude:(double)latitude longitude:(double)longitude altitude:(double)altitude query:(NSString *)query;
+- (NSString *)geoURI;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXGeoParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXGeoParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..976a80e2d163ff77743391a35fa2eb115f8a376e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXGeoParsedResult.m
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXGeoParsedResult.h"
+#import "ZXParsedResultType.h"
+
+@interface ZXGeoParsedResult ()
+
+@property (nonatomic) double latitude;
+@property (nonatomic) double longitude;
+@property (nonatomic) double altitude;
+@property (nonatomic, copy) NSString *query;
+
+@end
+
+@implementation ZXGeoParsedResult
+
+@synthesize latitude;
+@synthesize longitude;
+@synthesize altitude;
+@synthesize query;
+
+- (id)initWithLatitude:(double)aLatitude longitude:(double)aLongitude altitude:(double)anAltitude query:(NSString *)aQuery {
+ if (self = [super initWithType:kParsedResultTypeGeo]) {
+ self.latitude = aLatitude;
+ self.longitude = aLongitude;
+ self.altitude = anAltitude;
+ self.query = aQuery;
+ }
+
+ return self;
+}
+
++ (id)geoParsedResultWithLatitude:(double)latitude longitude:(double)longitude altitude:(double)altitude query:(NSString *)query {
+ return [[[self alloc] initWithLatitude:latitude longitude:longitude altitude:altitude query:query] autorelease];
+}
+
+- (void)dealloc {
+ [query release];
+
+ [super dealloc];
+}
+
+- (NSString *)geoURI {
+ NSMutableString *result = [NSMutableString string];
+ [result appendFormat:@"geo:%f,%f", self.latitude, self.longitude];
+ if (self.altitude > 0) {
+ [result appendFormat:@",%f", self.altitude];
+ }
+ if (self.query != nil) {
+ [result appendFormat:@"?%@", query];
+ }
+ return result;
+}
+
+- (NSString *)displayResult {
+ NSMutableString *result = [NSMutableString string];
+ [result appendFormat:@"%f, %f", self.latitude, self.longitude];
+ if (self.altitude > 0.0) {
+ [result appendFormat:@", %f", self.altitude];
+ [result appendString:@"m"];
+ }
+ if (self.query != nil) {
+ [result appendFormat:@" (%@)", self.query];
+ }
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXGeoResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXGeoResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..751897a389c0b91349a7b5c12d814e6897c7c8da
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXGeoResultParser.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Parses a "geo:" URI result, which specifies a location on the surface of
+ * the Earth as well as an optional altitude above the surface. See
+ * http://tools.ietf.org/html/draft-mayrhofer-geo-uri-00.
+ */
+
+@interface ZXGeoResultParser : ZXResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXGeoResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXGeoResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..28f7c2b7f0bff75c94b8554d395d7542c396dda8
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXGeoResultParser.m
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXGeoParsedResult.h"
+#import "ZXGeoResultParser.h"
+
+static NSRegularExpression *GEO_URL_PATTERN = nil;
+
+@implementation ZXGeoResultParser
+
++ (void)initialize {
+ GEO_URL_PATTERN = [[NSRegularExpression alloc] initWithPattern:@"geo:([\\-0-9.]+),([\\-0-9.]+)(?:,([\\-0-9.]+))?(?:\\?(.*))?"
+ options:NSRegularExpressionCaseInsensitive error:nil];
+
+}
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+ if (rawText == nil || (![rawText hasPrefix:@"geo:"] && ![rawText hasPrefix:@"GEO:"])) {
+ return nil;
+ }
+
+ NSArray *matches = [GEO_URL_PATTERN matchesInString:rawText options:0 range:NSMakeRange(0, rawText.length)];
+ if (matches.count == 0) {
+ return nil;
+ }
+
+ NSTextCheckingResult *match = [matches objectAtIndex:0];
+ NSString *query = nil;
+ if ([match rangeAtIndex:4].location != NSNotFound) {
+ query = [rawText substringWithRange:[match rangeAtIndex:4]];
+ }
+
+ double latitude = [[rawText substringWithRange:[match rangeAtIndex:1]] doubleValue];
+ if (latitude > 90.0 || latitude < -90.0) {
+ return nil;
+ }
+ double longitude = [[rawText substringWithRange:[match rangeAtIndex:2]] doubleValue];
+ if (longitude > 180.0 || longitude < -180.0) {
+ return nil;
+ }
+ double altitude;
+ if ([match rangeAtIndex:3].location == NSNotFound) {
+ altitude = 0.0;
+ } else {
+ altitude = [[rawText substringWithRange:[match rangeAtIndex:3]] doubleValue];
+ if (altitude < 0.0) {
+ return nil;
+ }
+ }
+
+ return [ZXGeoParsedResult geoParsedResultWithLatitude:latitude longitude:longitude altitude:altitude query:query];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXISBNParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXISBNParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..76adecbd3984ccdffbe41c98e9247fd1e54d2b3d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXISBNParsedResult.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResult.h"
+
+@interface ZXISBNParsedResult : ZXParsedResult
+
+@property (nonatomic, copy, readonly) NSString *isbn;
+
+- (id)initWithIsbn:(NSString *)isbn;
++ (id)isbnParsedResultWithIsbn:(NSString *)isbn;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXISBNParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXISBNParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..e91d5eca0303128747b45141b0f6ba44080e7bcd
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXISBNParsedResult.m
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXISBNParsedResult.h"
+
+@interface ZXISBNParsedResult ()
+
+@property (nonatomic, copy) NSString *isbn;
+
+@end
+
+@implementation ZXISBNParsedResult
+
+@synthesize isbn;
+
+- (id)initWithIsbn:(NSString *)anIsbn {
+ if (self = [super initWithType:kParsedResultTypeISBN]) {
+ self.isbn = anIsbn;
+ }
+
+ return self;
+}
+
++ (id)isbnParsedResultWithIsbn:(NSString *)isbn {
+ return [[[self alloc] initWithIsbn:isbn] autorelease];
+}
+
+- (void)dealloc {
+ [isbn release];
+
+ [super dealloc];
+}
+
+- (NSString *)displayResult {
+ return self.isbn;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXISBNResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXISBNResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..84c75edabead6811e599f0a5c3ce1ca5611b661e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXISBNResultParser.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Parses strings of digits that represent a ISBN.
+ */
+
+@interface ZXISBNResultParser : ZXResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXISBNResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXISBNResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..2fbad3b12a9262c7fa69a9cc11574a6c1bd6eca0
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXISBNResultParser.m
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXISBNParsedResult.h"
+#import "ZXISBNResultParser.h"
+
+@implementation ZXISBNResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ ZXBarcodeFormat format = [result barcodeFormat];
+ if (format != kBarcodeFormatEan13) {
+ return nil;
+ }
+ NSString *rawText = [ZXResultParser massagedText:result];
+ int length = [rawText length];
+ if (length != 13) {
+ return nil;
+ }
+ if (![rawText hasPrefix:@"978"] && ![rawText hasPrefix:@"979"]) {
+ return nil;
+ }
+ return [ZXISBNParsedResult isbnParsedResultWithIsbn:rawText];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..a460130c2f52565f66bcf587331fca6820b8c9ad
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXParsedResult.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResultType.h"
+#import "ZXResult.h"
+
+/**
+ * Abstract class representing the result of decoding a barcode, as more than
+ * a String -- as some type of structured data. This might be a subclass which represents
+ * a URL, or an e-mail address. parseResult() will turn a raw
+ * decoded string into the most appropriate type of structured representation.
+ *
+ * Thanks to Jeff Griffin for proposing rewrite of these classes that relies less
+ * on exception-based mechanisms during parsing.
+ */
+
+@interface ZXParsedResult : NSObject
+
+@property (nonatomic, readonly) ZXParsedResultType type;
+
+- (id)initWithType:(ZXParsedResultType)type;
++ (id)parsedResultWithType:(ZXParsedResultType)type;
+- (NSString *)displayResult;
++ (void)maybeAppend:(NSString *)value result:(NSMutableString *)result;
++ (void)maybeAppendArray:(NSArray *)value result:(NSMutableString *)result;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..cf72a93e0ec8917f87a2f2d97908edce20186b5d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXParsedResult.m
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResult.h"
+
+@interface ZXParsedResult ()
+
+@property (nonatomic) ZXParsedResultType type;
+
+@end
+
+@implementation ZXParsedResult
+
+@synthesize type;
+
+- (id)initWithType:(ZXParsedResultType)aType {
+ if (self = [super init]) {
+ self.type = aType;
+ }
+
+ return self;
+}
+
++ (id)parsedResultWithType:(ZXParsedResultType)type {
+ return [[[self alloc] initWithType:type] autorelease];
+}
+
+- (NSString *)displayResult {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+- (NSString *)description {
+ return [self displayResult];
+}
+
++ (void)maybeAppend:(NSString *)value result:(NSMutableString *)result {
+ if (value != nil && [value length] > 0) {
+ if ([result length] > 0) {
+ [result appendString:@"\n"];
+ }
+ [result appendString:value];
+ }
+}
+
++ (void)maybeAppendArray:(NSArray *)values result:(NSMutableString *)result {
+ if (values != nil) {
+ for (NSString *value in values) {
+ [self maybeAppend:value result:result];
+ }
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXParsedResultType.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXParsedResultType.h
new file mode 100644
index 0000000000000000000000000000000000000000..c097c19bd81b490cdf12d14e715087035f9c70c6
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXParsedResultType.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Represents the type of data encoded by a barcode -- from plain text, to a
+ * URI, to an e-mail address, etc.
+ */
+typedef enum {
+ kParsedResultTypeAddressBook,
+ kParsedResultTypeEmailAddress,
+ kParsedResultTypeProduct,
+ kParsedResultTypeURI,
+ kParsedResultTypeText,
+ kParsedResultTypeAndroidIntent,
+ kParsedResultTypeGeo,
+ kParsedResultTypeTel,
+ kParsedResultTypeSMS,
+ kParsedResultTypeCalendar,
+ kParsedResultTypeWifi,
+ kParsedResultTypeNDEFSMartPoster,
+ kParsedResultTypeMobiletagRichWeb,
+ kParsedResultTypeISBN
+} ZXParsedResultType;
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXProductParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXProductParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..b2039c0f09da8b1dbc19acbab0e7c361717be876
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXProductParsedResult.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResult.h"
+
+@interface ZXProductParsedResult : ZXParsedResult
+
+@property (nonatomic, copy, readonly) NSString *normalizedProductID;
+@property (nonatomic, copy, readonly) NSString *productID;
+
+- (id)initWithProductID:(NSString *)productID;
+- (id)initWithProductID:(NSString *)productID normalizedProductID:(NSString *)normalizedProductID;
++ (id)productParsedResultWithProductID:(NSString *)productID;
++ (id)productParsedResultWithProductID:(NSString *)productID normalizedProductID:(NSString *)normalizedProductID;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXProductParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXProductParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..0d3ed664f6da20a8da85fb66b2d85a2a6536e025
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXProductParsedResult.m
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXProductParsedResult.h"
+
+@interface ZXProductParsedResult ()
+
+@property (nonatomic, copy) NSString *normalizedProductID;
+@property (nonatomic, copy) NSString *productID;
+
+@end
+
+@implementation ZXProductParsedResult
+
+@synthesize normalizedProductID;
+@synthesize productID;
+
+- (id)initWithProductID:(NSString *)aProductID {
+ return [self initWithProductID:aProductID normalizedProductID:aProductID];
+}
+
+- (id)initWithProductID:(NSString *)aProductID normalizedProductID:(NSString *)aNormalizedProductID {
+ if (self = [super initWithType:kParsedResultTypeProduct]) {
+ self.normalizedProductID = aNormalizedProductID;
+ self.productID = aProductID;
+ }
+
+ return self;
+}
+
++ (id)productParsedResultWithProductID:(NSString *)productID {
+ return [[[self alloc] initWithProductID:productID] autorelease];
+}
+
++ (id)productParsedResultWithProductID:(NSString *)productID normalizedProductID:(NSString *)normalizedProductID {
+ return [[[self alloc] initWithProductID:productID normalizedProductID:normalizedProductID] autorelease];
+}
+
+- (void)dealloc {
+ [productID release];
+ [normalizedProductID release];
+
+ [super dealloc];
+}
+
+- (NSString *)displayResult {
+ return self.productID;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXProductResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXProductResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..b2bbf801ff42f0819c2943bca0e773456cb5d261
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXProductResultParser.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Parses strings of digits that represent a UPC code.
+ */
+
+@interface ZXProductResultParser : ZXResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXProductResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXProductResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..64c1f7a244a19dd2a9784cbbe2d9653ed430235f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXProductResultParser.m
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeFormat.h"
+#import "ZXProductParsedResult.h"
+#import "ZXProductResultParser.h"
+#import "ZXUPCEReader.h"
+
+@implementation ZXProductResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ ZXBarcodeFormat format = [result barcodeFormat];
+ if (!(format == kBarcodeFormatUPCA || format == kBarcodeFormatUPCE || format == kBarcodeFormatEan8 || format == kBarcodeFormatEan13)) {
+ return nil;
+ }
+ NSString *rawText = [ZXResultParser massagedText:result];
+ int length = [rawText length];
+ for (int x = 0; x < length; x++) {
+ unichar c = [rawText characterAtIndex:x];
+ if (c < '0' || c > '9') {
+ return nil;
+ }
+ }
+
+ NSString *normalizedProductID;
+ if (format == kBarcodeFormatUPCE) {
+ normalizedProductID = [ZXUPCEReader convertUPCEtoUPCA:rawText];
+ } else {
+ normalizedProductID = rawText;
+ }
+ return [ZXProductParsedResult productParsedResultWithProductID:rawText normalizedProductID:normalizedProductID];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..240153fab2f31deea0442f81cf00365a39a96e8e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXResultParser.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Abstract class representing the result of decoding a barcode, as more than
+ * a String -- as some type of structured data. This might be a subclass which represents
+ * a URL, or an e-mail address. parseResult() will turn a raw
+ * decoded string into the most appropriate type of structured representation.
+ *
+ * Thanks to Jeff Griffin for proposing rewrite of these classes that relies less
+ * on exception-based mechanisms during parsing.
+ */
+
+@class ZXParsedResult, ZXResult;
+
+@interface ZXResultParser : NSObject
+
++ (NSString *)massagedText:(ZXResult *)result;
+- (ZXParsedResult *)parse:(ZXResult *)result;
++ (ZXParsedResult *)parseResult:(ZXResult *)theResult;
+- (void)maybeAppend:(NSString *)value result:(NSMutableString *)result;
+- (void)maybeAppendArray:(NSArray *)value result:(NSMutableString *)result;
+- (NSArray *)maybeWrap:(NSString *)value;
++ (BOOL)isStringOfDigits:(NSString *)value length:(unsigned int)length;
++ (BOOL)isSubstringOfDigits:(NSString *)value offset:(int)offset length:(unsigned int)length;
++ (BOOL)isSubstringOfAlphaNumeric:(NSString *)value offset:(int)offset length:(unsigned int)length;
++ (int)parseHexDigit:(unichar)c;
+- (NSMutableDictionary *)parseNameValuePairs:(NSString *)uri;
++ (NSString *)urlDecode:(NSString *)encoded;
++ (NSArray *)matchPrefixedField:(NSString *)prefix rawText:(NSString *)rawText endChar:(unichar)endChar trim:(BOOL)trim;
++ (NSString *)matchSinglePrefixedField:(NSString *)prefix rawText:(NSString *)rawText endChar:(unichar)endChar trim:(BOOL)trim;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..740fe544d64a4bf420219e3fb4eefa21c31a2fcc
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXResultParser.m
@@ -0,0 +1,318 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAddressBookAUResultParser.h"
+#import "ZXAddressBookDoCoMoResultParser.h"
+#import "ZXAddressBookParsedResult.h"
+#import "ZXBizcardResultParser.h"
+#import "ZXBookmarkDoCoMoResultParser.h"
+#import "ZXCalendarParsedResult.h"
+#import "ZXEmailAddressParsedResult.h"
+#import "ZXEmailAddressResultParser.h"
+#import "ZXEmailDoCoMoResultParser.h"
+#import "ZXExpandedProductParsedResult.h"
+#import "ZXExpandedProductResultParser.h"
+#import "ZXGeoParsedResult.h"
+#import "ZXGeoResultParser.h"
+#import "ZXISBNParsedResult.h"
+#import "ZXISBNResultParser.h"
+#import "ZXParsedResult.h"
+#import "ZXProductParsedResult.h"
+#import "ZXProductResultParser.h"
+#import "ZXResult.h"
+#import "ZXResultParser.h"
+#import "ZXSMSMMSResultParser.h"
+#import "ZXSMSParsedResult.h"
+#import "ZXSMSTOMMSTOResultParser.h"
+#import "ZXSMTPResultParser.h"
+#import "ZXTelParsedResult.h"
+#import "ZXTelResultParser.h"
+#import "ZXTextParsedResult.h"
+#import "ZXURIParsedResult.h"
+#import "ZXURIResultParser.h"
+#import "ZXURLTOResultParser.h"
+#import "ZXVCardResultParser.h"
+#import "ZXVEventResultParser.h"
+#import "ZXWifiParsedResult.h"
+#import "ZXWifiResultParser.h"
+
+@interface ZXResultParser ()
+
++ (NSString *)unescapeBackslash:(NSString *)escaped;
+- (void)appendKeyValue:(NSString *)keyValue result:(NSMutableDictionary *)result;
+- (NSString *)urlDecode:(NSString *)escaped;
+- (int)findFirstEscape:(NSString *)escaped;
+
+@end
+
+static NSArray *PARSERS = nil;
+static NSRegularExpression *DIGITS = nil;
+static NSRegularExpression *ALPHANUM = nil;
+static NSString *AMPERSAND = @"&";
+static NSString *EQUALS = @"=";
+static unichar BYTE_ORDER_MARK = L'\ufeff';
+
+@implementation ZXResultParser
+
++ (void)initialize {
+ PARSERS = [[NSArray alloc] initWithObjects:
+ [[[ZXBookmarkDoCoMoResultParser alloc] init] autorelease],
+ [[[ZXAddressBookDoCoMoResultParser alloc] init] autorelease],
+ [[[ZXEmailDoCoMoResultParser alloc] init] autorelease],
+ [[[ZXAddressBookAUResultParser alloc] init] autorelease],
+ [[[ZXVCardResultParser alloc] init] autorelease],
+ [[[ZXBizcardResultParser alloc] init] autorelease],
+ [[[ZXVEventResultParser alloc] init] autorelease],
+ [[[ZXEmailAddressResultParser alloc] init] autorelease],
+ [[[ZXSMTPResultParser alloc] init] autorelease],
+ [[[ZXTelResultParser alloc] init] autorelease],
+ [[[ZXSMSMMSResultParser alloc] init] autorelease],
+ [[[ZXSMSTOMMSTOResultParser alloc] init] autorelease],
+ [[[ZXGeoResultParser alloc] init] autorelease],
+ [[[ZXWifiResultParser alloc] init] autorelease],
+ [[[ZXURLTOResultParser alloc] init] autorelease],
+ [[[ZXURIResultParser alloc] init] autorelease],
+ [[[ZXISBNResultParser alloc] init] autorelease],
+ [[[ZXProductResultParser alloc] init] autorelease],
+ [[[ZXExpandedProductResultParser alloc] init] autorelease], nil];
+ DIGITS = [[NSRegularExpression alloc] initWithPattern:@"^\\d*$" options:0 error:nil];
+ ALPHANUM = [[NSRegularExpression alloc] initWithPattern:@"^[a-zA-Z0-9]*$" options:0 error:nil];
+}
+
++ (NSString *)massagedText:(ZXResult *)result {
+ NSString *text = result.text;
+ if (text.length > 0 && [text characterAtIndex:0] == BYTE_ORDER_MARK) {
+ text = [text substringFromIndex:1];
+ }
+ return text;
+}
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
++ (ZXParsedResult *)parseResult:(ZXResult *)theResult {
+ for (ZXResultParser *parser in PARSERS) {
+ ZXParsedResult *result = [parser parse:theResult];
+ if (result != nil) {
+ return result;
+ }
+ }
+ return [ZXTextParsedResult textParsedResultWithText:[theResult text] language:nil];
+}
+
+- (void)maybeAppend:(NSString *)value result:(NSMutableString *)result {
+ if (value != nil) {
+ [result appendFormat:@"\n%@", value];
+ }
+}
+
+- (void)maybeAppendArray:(NSArray *)value result:(NSMutableString *)result {
+ if (value != nil) {
+ for (NSString *s in value) {
+ [result appendFormat:@"\n%@", s];
+ }
+ }
+}
+
+- (NSArray *)maybeWrap:(NSString *)value {
+ return value == nil ? nil : [NSArray arrayWithObjects:value, nil];
+}
+
++ (NSString *)unescapeBackslash:(NSString *)escaped {
+ int backslash = [escaped rangeOfString:@"\\"].location;
+ if (backslash == NSNotFound) {
+ return escaped;
+ }
+ int max = [escaped length];
+ NSMutableString *unescaped = [NSMutableString stringWithCapacity:max - 1];
+ [unescaped appendString:[escaped substringToIndex:backslash]];
+ BOOL nextIsEscaped = NO;
+ for (int i = backslash; i < max; i++) {
+ unichar c = [escaped characterAtIndex:i];
+ if (nextIsEscaped || c != '\\') {
+ [unescaped appendFormat:@"%C", c];
+ nextIsEscaped = NO;
+ } else {
+ nextIsEscaped = YES;
+ }
+ }
+ return unescaped;
+}
+
++ (int)parseHexDigit:(unichar)c {
+ if (c >= '0' && c <= '9') {
+ return c - '0';
+ }
+ if (c >= 'a' && c <= 'f') {
+ return 10 + (c - 'a');
+ }
+ if (c >= 'A' && c <= 'F') {
+ return 10 + (c - 'A');
+ }
+ return -1;
+}
+
++ (BOOL)isStringOfDigits:(NSString *)value length:(unsigned int)length {
+ return value != nil && length == value.length && [DIGITS numberOfMatchesInString:value options:0 range:NSMakeRange(0, value.length)] > 0;
+}
+
+- (NSString *)urlDecode:(NSString *)escaped {
+ if (escaped == nil) {
+ return nil;
+ }
+
+ int first = [self findFirstEscape:escaped];
+ if (first == NSNotFound) {
+ return escaped;
+ }
+
+ int max = [escaped length];
+ NSMutableString *unescaped = [NSMutableString stringWithCapacity:max - 2];
+ [unescaped appendString:[escaped substringToIndex:first]];
+
+ for (int i = first; i < max; i++) {
+ unichar c = [escaped characterAtIndex:i];
+ switch (c) {
+ case '+':
+ [unescaped appendString:@" "];
+ break;
+ case '%':
+ if (i >= max - 2) {
+ [unescaped appendString:@"%"];
+ } else {
+ int firstDigitValue = [[self class] parseHexDigit:[escaped characterAtIndex:++i]];
+ int secondDigitValue = [[self class] parseHexDigit:[escaped characterAtIndex:++i]];
+ if (firstDigitValue < 0 || secondDigitValue < 0) {
+ [unescaped appendFormat:@"%%%C%C", [escaped characterAtIndex:i - 1], [escaped characterAtIndex:i]];
+ }
+ [unescaped appendFormat:@"%C", (unichar)((firstDigitValue << 4) + secondDigitValue)];
+ }
+ break;
+ default:
+ [unescaped appendFormat:@"%C", c];
+ break;
+ }
+ }
+
+ return unescaped;
+}
+
+- (int)findFirstEscape:(NSString *)escaped {
+ int max = [escaped length];
+ for (int i = 0; i < max; i++) {
+ unichar c = [escaped characterAtIndex:i];
+ if (c == '+' || c == '%') {
+ return i;
+ }
+ }
+
+ return NSNotFound;
+}
+
++ (BOOL)isSubstringOfDigits:(NSString *)value offset:(int)offset length:(unsigned int)length {
+ if (value == nil) {
+ return NO;
+ }
+ int max = offset + length;
+ return value.length >= max && [DIGITS numberOfMatchesInString:value options:0 range:NSMakeRange(offset, max - offset)] > 0;
+}
+
++ (BOOL)isSubstringOfAlphaNumeric:(NSString *)value offset:(int)offset length:(unsigned int)length {
+ if (value == nil) {
+ return NO;
+ }
+ int max = offset + length;
+ return value.length >= max && [ALPHANUM numberOfMatchesInString:value options:0 range:NSMakeRange(offset, max - offset)] > 0;
+}
+
+- (NSMutableDictionary *)parseNameValuePairs:(NSString *)uri {
+ int paramStart = [uri rangeOfString:@"?"].location;
+ if (paramStart == NSNotFound) {
+ return nil;
+ }
+ NSMutableDictionary *result = [NSMutableDictionary dictionaryWithCapacity:3];
+ for (NSString *keyValue in [[uri substringFromIndex:paramStart + 1] componentsSeparatedByString:AMPERSAND]) {
+ [self appendKeyValue:keyValue result:result];
+ }
+ return result;
+}
+
+- (void)appendKeyValue:(NSString *)keyValue result:(NSMutableDictionary *)result {
+ NSRange equalsRange = [keyValue rangeOfString:EQUALS];
+ if (equalsRange.location != NSNotFound) {
+ NSString *key = [keyValue substringToIndex:equalsRange.location];
+ NSString *value = [keyValue substringFromIndex:equalsRange.location + 1];
+ value = [self urlDecode:value];
+ [result setObject:value forKey:key];
+ }
+}
+
++ (NSString *)urlDecode:(NSString *)encoded {
+ NSString *result = [encoded stringByReplacingOccurrencesOfString:@"+" withString:@" "];
+ result = [result stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
+ return result;
+}
+
++ (NSArray *)matchPrefixedField:(NSString *)prefix rawText:(NSString *)rawText endChar:(unichar)endChar trim:(BOOL)trim {
+ NSMutableArray *matches = nil;
+ int i = 0;
+ int max = [rawText length];
+ while (i < max) {
+ i = [rawText rangeOfString:prefix options:NSLiteralSearch range:NSMakeRange(i, [rawText length] - i - 1)].location;
+ if (i == NSNotFound) {
+ break;
+ }
+ i += [prefix length];
+ int start = i;
+ BOOL more = YES;
+ while (more) {
+ i = [rawText rangeOfString:[NSString stringWithFormat:@"%C", endChar] options:NSLiteralSearch range:NSMakeRange(i, [rawText length] - i)].location;
+ if (i == NSNotFound) {
+ i = [rawText length];
+ more = NO;
+ } else if ([rawText characterAtIndex:i - 1] == '\\') {
+ i++;
+ } else {
+ if (matches == nil) {
+ matches = [NSMutableArray arrayWithCapacity:3];
+ }
+ NSString *element = [self unescapeBackslash:[rawText substringWithRange:NSMakeRange(start, i - start)]];
+ if (trim) {
+ element = [element stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+ }
+ if (element.length > 0) {
+ [matches addObject:element];
+ }
+ i++;
+ more = NO;
+ }
+ }
+ }
+ if (matches == nil || [matches count] == 0) {
+ return nil;
+ }
+ return matches;
+}
+
++ (NSString *)matchSinglePrefixedField:(NSString *)prefix rawText:(NSString *)rawText endChar:(unichar)endChar trim:(BOOL)trim {
+ NSArray *matches = [self matchPrefixedField:prefix rawText:rawText endChar:endChar trim:trim];
+ return matches == nil ? nil : [matches objectAtIndex:0];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSMMSResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSMMSResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..99b3fac6a4bb92278d0c22e0cdcd0eb0ee439fc2
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSMMSResultParser.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Parses an "sms:" URI result, which specifies a number to SMS.
+ * See http://tools.ietf.org/html/rfc5724 on this.
+ *
+ * This class supports "via" syntax for numbers, which is not part of the spec.
+ * For example "+12125551212;via=+12124440101" may appear as a number.
+ * It also supports a "subject" query parameter, which is not mentioned in the spec.
+ * These are included since they were mentioned in earlier IETF drafts and might be
+ * used.
+ *
+ * This actually also parses URIs starting with "mms:" and treats them all the same way,
+ * and effectively converts them to an "sms:" URI for purposes of forwarding to the platform.
+ */
+
+@interface ZXSMSMMSResultParser : ZXResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSMMSResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSMMSResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..711041659e3592b7428ac501c7794fff7c3f33ea
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSMMSResultParser.m
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResult.h"
+#import "ZXSMSMMSResultParser.h"
+#import "ZXSMSParsedResult.h"
+
+@interface ZXSMSMMSResultParser ()
+
+- (void)addNumberVia:(NSMutableArray *)numbers vias:(NSMutableArray *)vias numberPart:(NSString *)numberPart;
+
+@end
+
+@implementation ZXSMSMMSResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+ if (!([rawText hasPrefix:@"sms:"] || [rawText hasPrefix:@"SMS:"] || [rawText hasPrefix:@"mms:"] || [rawText hasPrefix:@"MMS:"])) {
+ return nil;
+ }
+
+ NSMutableDictionary *nameValuePairs = [self parseNameValuePairs:rawText];
+ NSString *subject = nil;
+ NSString *body = nil;
+ BOOL querySyntax = NO;
+ if (nameValuePairs != nil && [nameValuePairs count] > 0) {
+ subject = [nameValuePairs objectForKey:@"subject"];
+ body = [nameValuePairs objectForKey:@"body"];
+ querySyntax = YES;
+ }
+
+ int queryStart = [rawText rangeOfString:@"?" options:NSLiteralSearch range:NSMakeRange(4, [rawText length] - 4)].location;
+ NSString *smsURIWithoutQuery;
+ if (queryStart == NSNotFound || !querySyntax) {
+ smsURIWithoutQuery = [rawText substringFromIndex:4];
+ } else {
+ smsURIWithoutQuery = [rawText substringWithRange:NSMakeRange(4, queryStart - 4)];
+ }
+
+ int lastComma = -1;
+ int comma;
+ NSMutableArray *numbers = [NSMutableArray arrayWithCapacity:1];
+ NSMutableArray *vias = [NSMutableArray arrayWithCapacity:1];
+ while ((comma = [smsURIWithoutQuery rangeOfString:@"," options:NSLiteralSearch range:NSMakeRange(lastComma + 1, [smsURIWithoutQuery length] - lastComma - 1)].location) > lastComma && comma != NSNotFound) {
+ NSString *numberPart = [smsURIWithoutQuery substringWithRange:NSMakeRange(lastComma + 1, comma - lastComma - 1)];
+ [self addNumberVia:numbers vias:vias numberPart:numberPart];
+ lastComma = comma;
+ }
+ [self addNumberVia:numbers vias:vias numberPart:[smsURIWithoutQuery substringFromIndex:lastComma + 1]];
+
+ return [ZXSMSParsedResult smsParsedResultWithNumbers:numbers
+ vias:vias
+ subject:subject
+ body:body];
+}
+
+- (void)addNumberVia:(NSMutableArray *)numbers vias:(NSMutableArray *)vias numberPart:(NSString *)numberPart {
+ int numberEnd = [numberPart rangeOfString:@";"].location;
+ if (numberEnd == NSNotFound) {
+ [numbers addObject:numberPart];
+ [vias addObject:[NSNull null]];
+ } else {
+ [numbers addObject:[numberPart substringToIndex:numberEnd]];
+ NSString *maybeVia = [numberPart substringFromIndex:numberEnd + 1];
+ NSString *via;
+ if ([maybeVia hasPrefix:@"via="]) {
+ via = [maybeVia substringFromIndex:4];
+ } else {
+ via = nil;
+ }
+ [vias addObject:via];
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..15e686b69501de713b3b99d47cb24545d8914b30
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSParsedResult.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResult.h"
+
+@interface ZXSMSParsedResult : ZXParsedResult
+
+@property (nonatomic, retain, readonly) NSArray *numbers;
+@property (nonatomic, retain, readonly) NSArray *vias;
+@property (nonatomic, copy, readonly) NSString *subject;
+@property (nonatomic, copy, readonly) NSString *body;
+
+- (id)initWithNumber:(NSString *)number via:(NSString *)via subject:(NSString *)subject body:(NSString *)body;
+- (id)initWithNumbers:(NSArray *)numbers vias:(NSArray *)vias subject:(NSString *)subject body:(NSString *)body;
++ (id)smsParsedResultWithNumber:(NSString *)number via:(NSString *)via subject:(NSString *)subject body:(NSString *)body;
++ (id)smsParsedResultWithNumbers:(NSArray *)numbers vias:(NSArray *)vias subject:(NSString *)subject body:(NSString *)body;
+- (NSString *)sMSURI;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..eb74c414f0a1d28e9599c11ae9e778ee35cec1e2
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSParsedResult.m
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXSMSParsedResult.h"
+
+@interface ZXSMSParsedResult ()
+
+@property (nonatomic, retain) NSArray *numbers;
+@property (nonatomic, retain) NSArray *vias;
+@property (nonatomic, copy) NSString *subject;
+@property (nonatomic, copy) NSString *body;
+
+@end
+
+@implementation ZXSMSParsedResult
+
+@synthesize numbers;
+@synthesize vias;
+@synthesize subject;
+@synthesize body;
+
+- (id)initWithNumber:(NSString *)aNumber via:(NSString *)aVia subject:(NSString *)aSubject body:(NSString *)aBody {
+ NSArray *theNumbers = nil;
+ if (aNumber) {
+ theNumbers = [NSArray arrayWithObject:aNumber];
+ }
+
+ NSArray *theVias = nil;
+ if (aVia) {
+ theVias = [NSArray arrayWithObject:aVia];
+ }
+
+ return [self initWithNumbers:theNumbers vias:theVias subject:aSubject body:aBody];
+}
+
+- (id)initWithNumbers:(NSArray *)theNumbers vias:(NSArray *)theVias subject:(NSString *)aSubject body:(NSString *)aBody {
+ if (self = [super initWithType:kParsedResultTypeSMS]) {
+ self.numbers = theNumbers;
+ self.vias = theVias;
+ self.subject = aSubject;
+ self.body = aBody;
+ }
+
+ return self;
+}
+
++ (id)smsParsedResultWithNumber:(NSString *)number via:(NSString *)via subject:(NSString *)subject body:(NSString *)body {
+ return [[[self alloc] initWithNumber:number via:via subject:subject body:body] autorelease];
+}
+
++ (id)smsParsedResultWithNumbers:(NSArray *)numbers vias:(NSArray *)vias subject:(NSString *)subject body:(NSString *)body {
+ return [[[self alloc] initWithNumbers:numbers vias:vias subject:subject body:body] autorelease];
+}
+
+- (void)dealloc {
+ [numbers release];
+ [vias release];
+ [subject release];
+ [body release];
+
+ [super dealloc];
+}
+
+- (NSString *)sMSURI {
+ NSMutableString *result = [NSMutableString stringWithString:@"sms:"];
+ BOOL first = YES;
+ for (int i = 0; i < self.numbers.count; i++) {
+ if (first) {
+ first = NO;
+ } else {
+ [result appendString:@","];
+ }
+ [result appendString:[numbers objectAtIndex:i]];
+ if (vias != nil && [vias objectAtIndex:i] != nil) {
+ [result appendString:@";via="];
+ [result appendString:[vias objectAtIndex:i]];
+ }
+ }
+
+ BOOL hasBody = body != nil;
+ BOOL hasSubject = subject != nil;
+ if (hasBody || hasSubject) {
+ [result appendString:@"?"];
+ if (hasBody) {
+ [result appendString:@"body="];
+ [result appendString:body];
+ }
+ if (hasSubject) {
+ if (hasBody) {
+ [result appendString:@"&"];
+ }
+ [result appendString:@"subject="];
+ [result appendString:subject];
+ }
+ }
+ return result;
+}
+
+- (NSString *)displayResult {
+ NSMutableString *result = [NSMutableString stringWithCapacity:100];
+ [ZXParsedResult maybeAppendArray:numbers result:result];
+ [ZXParsedResult maybeAppend:subject result:result];
+ [ZXParsedResult maybeAppend:body result:result];
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSTOMMSTOResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSTOMMSTOResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..2a1bcd67a3e4323c1088533f5bdedeb49b6dca7c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSTOMMSTOResultParser.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Parses an "smsto:" URI result, whose format is not standardized but appears to be like:
+ * smsto:number(:body).
+ *
+ * This actually also parses URIs starting with "smsto:", "mmsto:", "SMSTO:", and
+ * "MMSTO:", and treats them all the same way, and effectively converts them to an "sms:" URI
+ * for purposes of forwarding to the platform.
+ */
+
+@interface ZXSMSTOMMSTOResultParser : ZXResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSTOMMSTOResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSTOMMSTOResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..e5db26441cd396b70408520ce08bb3f21e536391
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMSTOMMSTOResultParser.m
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResult.h"
+#import "ZXSMSTOMMSTOResultParser.h"
+#import "ZXSMSParsedResult.h"
+
+@implementation ZXSMSTOMMSTOResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+ if (!([rawText hasPrefix:@"smsto:"] || [rawText hasPrefix:@"SMSTO:"] || [rawText hasPrefix:@"mmsto:"] || [rawText hasPrefix:@"MMSTO:"])) {
+ return nil;
+ }
+ NSString *number = [rawText substringFromIndex:6];
+ NSString *body = nil;
+ int bodyStart = [number rangeOfString:@":"].location;
+ if (bodyStart != NSNotFound) {
+ body = [number substringFromIndex:bodyStart + 1];
+ number = [number substringToIndex:bodyStart];
+ }
+ return [ZXSMSParsedResult smsParsedResultWithNumber:number via:nil subject:nil body:body];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMTPResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMTPResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..0c3b5f7271b0c544caa147b36b9d9299f357cce2
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMTPResultParser.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Parses an "smtp:" URI result, whose format is not standardized but appears to be like:
+ * smtp(:subject(:body)).
+ *
+ * See http://code.google.com/p/zxing/issues/detail?id=536
+ */
+
+@interface ZXSMTPResultParser : ZXResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMTPResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMTPResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..c5563b114b663b3ba931f244651cf3666f8692ef
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXSMTPResultParser.m
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXEmailAddressParsedResult.h"
+#import "ZXResult.h"
+#import "ZXSMTPResultParser.h"
+
+@implementation ZXSMTPResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+ if (!([rawText hasPrefix:@"smtp:"] || [rawText hasPrefix:@"SMTP:"])) {
+ return nil;
+ }
+ NSString *emailAddress = [rawText substringFromIndex:5];
+ NSString *subject = nil;
+ NSString *body = nil;
+ int colon = [emailAddress rangeOfString:@":"].location;
+ if (colon != NSNotFound) {
+ subject = [emailAddress substringFromIndex:colon + 1];
+ emailAddress = [emailAddress substringToIndex:colon];
+ colon = [subject rangeOfString:@":"].location;
+ if (colon != NSNotFound) {
+ body = [subject substringFromIndex:colon + 1];
+ subject = [subject substringToIndex:colon];
+ }
+ }
+ NSString *mailtoURI = [@"mailto:" stringByAppendingString:emailAddress];
+ return [ZXEmailAddressParsedResult emailAddressParsedResultWithEmailAddress:emailAddress
+ subject:subject
+ body:body
+ mailtoURI:mailtoURI];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTelParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTelParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..7c5d2d117cf499a11642b0c2762d234f05597126
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTelParsedResult.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResult.h"
+
+@interface ZXTelParsedResult : ZXParsedResult
+
+@property (nonatomic, copy, readonly) NSString *number;
+@property (nonatomic, copy, readonly) NSString *telURI;
+@property (nonatomic, copy, readonly) NSString *title;
+
+- (id)initWithNumber:(NSString *)number telURI:(NSString *)telURI title:(NSString *)title;
++ (id)telParsedResultWithNumber:(NSString *)number telURI:(NSString *)telURI title:(NSString *)title;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTelParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTelParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..3a3d17f8bf62fcad97a0b0729485f2a8c6f29a40
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTelParsedResult.m
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXTelParsedResult.h"
+
+@interface ZXTelParsedResult ()
+
+@property (nonatomic, copy) NSString *number;
+@property (nonatomic, copy) NSString *telURI;
+@property (nonatomic, copy) NSString *title;
+
+@end
+
+@implementation ZXTelParsedResult
+
+@synthesize number;
+@synthesize telURI;
+@synthesize title;
+
+- (id)initWithNumber:(NSString *)aNumber telURI:(NSString *)aTelURI title:(NSString *)aTitle {
+ if (self = [super initWithType:kParsedResultTypeTel]) {
+ self.number = aNumber;
+ self.telURI = aTelURI;
+ self.title = aTitle;
+ }
+
+ return self;
+}
+
++ (id)telParsedResultWithNumber:(NSString *)number telURI:(NSString *)telURI title:(NSString *)title {
+ return [[[self alloc] initWithNumber:number telURI:telURI title:title] autorelease];
+}
+
+- (void)dealloc {
+ [number release];
+ [telURI release];
+ [title release];
+
+ [super dealloc];
+}
+
+- (NSString *)displayResult {
+ NSMutableString *result = [NSMutableString stringWithCapacity:20];
+ [ZXParsedResult maybeAppend:number result:result];
+ [ZXParsedResult maybeAppend:title result:result];
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTelResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTelResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..cb4175b54fbcc606469b58c5285517d8e6c4ac6c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTelResultParser.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Parses a "tel:" URI result, which specifies a phone number.
+ */
+
+@interface ZXTelResultParser : ZXResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTelResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTelResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..a75a40161e5d00894771fade3ad449957713af65
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTelResultParser.m
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXTelParsedResult.h"
+#import "ZXTelResultParser.h"
+
+@implementation ZXTelResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+ if (![rawText hasPrefix:@"tel:"] && ![rawText hasPrefix:@"TEL:"]) {
+ return nil;
+ }
+ NSString *telURI = [rawText hasPrefix:@"TEL:"] ? [@"tel:" stringByAppendingString:[rawText substringFromIndex:4]] : rawText;
+ int queryStart = [rawText rangeOfString:@"?" options:NSLiteralSearch range:NSMakeRange(4, [rawText length] - 4)].location;
+ NSString *number = queryStart == NSNotFound ? [rawText substringFromIndex:4] : [rawText substringWithRange:NSMakeRange(4, [rawText length] - queryStart)];
+ return [ZXTelParsedResult telParsedResultWithNumber:number telURI:telURI title:nil];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTextParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTextParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..f01b21c2bb4513b6ac14eb83c79cf4a1dcd77ade
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTextParsedResult.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResult.h"
+
+/**
+ * A simple result type encapsulating a string that has no further
+ * interpretation.
+ */
+
+@interface ZXTextParsedResult : ZXParsedResult
+
+@property (nonatomic, copy, readonly) NSString *text;
+@property (nonatomic, copy, readonly) NSString *language;
+
+- (id)initWithText:(NSString *)text language:(NSString *)language;
++ (id)textParsedResultWithText:(NSString *)text language:(NSString *)language;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTextParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTextParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..dc927bd261ce949c6b4ec2c3c40c2a3d359caf3c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXTextParsedResult.m
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResultType.h"
+#import "ZXTextParsedResult.h"
+
+@interface ZXTextParsedResult ()
+
+@property (nonatomic, copy) NSString *text;
+@property (nonatomic, copy) NSString *language;
+
+@end
+
+@implementation ZXTextParsedResult
+
+@synthesize text;
+@synthesize language;
+
+- (id)initWithText:(NSString *)aText language:(NSString *)aLanguage {
+ if (self = [super initWithType:kParsedResultTypeText]) {
+ self.text = aText;
+ self.language = aLanguage;
+ }
+
+ return self;
+}
+
++ (id)textParsedResultWithText:(NSString *)text language:(NSString *)language {
+ return [[[self alloc] initWithText:text language:language] autorelease];
+}
+
+- (void)dealloc {
+ [text release];
+ [language release];
+
+ [super dealloc];
+}
+
+- (NSString *)displayResult {
+ return self.text;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURIParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURIParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb7a69c5e2e0702ee26560ef02d0aa0d0d2271ce
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURIParsedResult.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResult.h"
+
+@interface ZXURIParsedResult : ZXParsedResult
+
+@property (nonatomic, copy, readonly) NSString *uri;
+@property (nonatomic, copy, readonly) NSString *title;
+
+- (id)initWithUri:(NSString *)uri title:(NSString *)title;
++ (id)uriParsedResultWithUri:(NSString *)uri title:(NSString *)title;
+- (BOOL)possiblyMaliciousURI;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURIParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURIParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..926d12e9b8b1e6902f4be5a1a079a0c68443e954
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURIParsedResult.m
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXURIParsedResult.h"
+
+static NSRegularExpression *USER_IN_HOST = nil;
+
+@interface ZXURIParsedResult ()
+
+@property (nonatomic, copy) NSString *uri;
+@property (nonatomic, copy) NSString *title;
+
+- (BOOL)isColonFollowedByPortNumber:(NSString *)uri protocolEnd:(int)protocolEnd;
+- (NSString *)massageURI:(NSString *)uri;
+
+@end
+
+@implementation ZXURIParsedResult
+
+@synthesize uri;
+@synthesize title;
+
++ (void)initialize {
+ USER_IN_HOST = [[NSRegularExpression alloc] initWithPattern:@":/*([^/@]+)@[^/]+" options:0 error:nil];
+}
+
+- (id)initWithUri:(NSString *)aUri title:(NSString *)aTitle {
+ if (self = [super initWithType:kParsedResultTypeURI]) {
+ self.uri = [self massageURI:aUri];
+ self.title = aTitle;
+ }
+
+ return self;
+}
+
++ (id)uriParsedResultWithUri:(NSString *)uri title:(NSString *)title {
+ return [[[self alloc] initWithUri:uri title:title] autorelease];
+}
+
+- (void)dealloc {
+ [uri release];
+ [title release];
+
+ [super dealloc];
+}
+
+
+/**
+ * Returns true if the URI contains suspicious patterns that may suggest it intends to
+ * mislead the user about its true nature. At the moment this looks for the presence
+ * of user/password syntax in the host/authority portion of a URI which may be used
+ * in attempts to make the URI's host appear to be other than it is. Example:
+ * http://yourbank.com@phisher.com This URI connects to phisher.com but may appear
+ * to connect to yourbank.com at first glance.
+ */
+- (BOOL)possiblyMaliciousURI {
+ return [USER_IN_HOST numberOfMatchesInString:uri options:0 range:NSMakeRange(0, uri.length)] > 0;
+}
+
+- (NSString *)displayResult {
+ NSMutableString *result = [NSMutableString stringWithCapacity:30];
+ [ZXParsedResult maybeAppend:title result:result];
+ [ZXParsedResult maybeAppend:uri result:result];
+ return result;
+}
+
+/**
+ * Transforms a string that represents a URI into something more proper, by adding or canonicalizing
+ * the protocol.
+ */
+- (NSString *)massageURI:(NSString *)aUri {
+ NSString *_uri = [aUri stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+ int protocolEnd = [_uri rangeOfString:@":"].location;
+ if (protocolEnd == NSNotFound) {
+ // No protocol, assume http
+ _uri = [NSString stringWithFormat:@"http://%@", _uri];
+ } else if ([self isColonFollowedByPortNumber:_uri protocolEnd:protocolEnd]) {
+ // Found a colon, but it looks like it is after the host, so the protocol is still missing
+ _uri = [NSString stringWithFormat:@"http://%@", _uri];
+ }
+ return _uri;
+}
+
+- (BOOL)isColonFollowedByPortNumber:(NSString *)aUri protocolEnd:(int)protocolEnd {
+ int nextSlash = [aUri rangeOfString:@"/" options:0 range:NSMakeRange(protocolEnd + 1, [aUri length] - protocolEnd - 1)].location;
+ if (nextSlash == NSNotFound) {
+ nextSlash = [aUri length];
+ }
+ if (nextSlash <= protocolEnd + 1) {
+ return NO;
+ }
+
+ for (int x = protocolEnd + 1; x < nextSlash; x++) {
+ if ([aUri characterAtIndex:x] < '0' || [aUri characterAtIndex:x] > '9') {
+ return NO;
+ }
+ }
+
+ return YES;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURIResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURIResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2dda20d818962390051abee702c736bbf0a9398
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURIResultParser.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Tries to parse results that are a URI of some kind.
+ */
+
+@interface ZXURIResultParser : ZXResultParser
+
++ (BOOL)isBasicallyValidURI:(NSString *)uri;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURIResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURIResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..a4dc43251199790f5106bebb450d0eac8154dae7
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURIResultParser.m
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXURIResultParser.h"
+#import "ZXResult.h"
+#import "ZXURIParsedResult.h"
+
+static NSString *ALPHANUM_PART = @"[a-zA-Z0-9\\-]";
+static NSRegularExpression *URL_WITH_PROTOCOL_PATTERN = nil;
+static NSRegularExpression *URL_WITHOUT_PROTOCOL_PATTERN = nil;
+
+@implementation ZXURIResultParser
+
++ (void)initialize {
+ URL_WITH_PROTOCOL_PATTERN = [[NSRegularExpression alloc] initWithPattern:@"^[a-zA-Z0-9]{2,}:"
+ options:0
+ error:nil];
+ URL_WITHOUT_PROTOCOL_PATTERN = [[NSRegularExpression alloc] initWithPattern:
+ [[[NSString stringWithFormat:@"(%@+\\.)+%@{2,}", ALPHANUM_PART, ALPHANUM_PART] // host name elements
+ stringByAppendingString:@"(:\\d{1,5})?"] // maybe port
+ stringByAppendingString:@"(/|\\?|$)"] // query, path or nothing
+ options:0
+ error:nil];
+}
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+ // We specifically handle the odd "URL" scheme here for simplicity and add "URI" for fun
+ // Assume anything starting this way really means to be a URI
+ if ([rawText hasPrefix:@"URL:"] || [rawText hasPrefix:@"URI:"]) {
+ return [[ZXURIParsedResult alloc] initWithUri:[[rawText substringFromIndex:4] stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]
+ title:nil];
+ }
+ rawText = [rawText stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+ return [[self class] isBasicallyValidURI:rawText] ? [ZXURIParsedResult uriParsedResultWithUri:rawText title:nil] : nil;
+}
+
+
++ (BOOL)isBasicallyValidURI:(NSString *)uri {
+ if ([uri rangeOfString:@" "].location != NSNotFound) {
+ // Quick hack check for a common case
+ return NO;
+ }
+
+ if ([URL_WITH_PROTOCOL_PATTERN numberOfMatchesInString:uri options:NSMatchingWithoutAnchoringBounds range:NSMakeRange(0, uri.length)] > 0) { // match at start only
+ return YES;
+ }
+ return [URL_WITHOUT_PROTOCOL_PATTERN numberOfMatchesInString:uri options:NSMatchingWithoutAnchoringBounds range:NSMakeRange(0, uri.length)] > 0;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURLTOResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURLTOResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..9f78f913b749e61ea1268c3631460dbef40e77e0
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURLTOResultParser.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Parses the "URLTO" result format, which is of the form "URLTO:[title]:[url]".
+ * This seems to be used sometimes, but I am not able to find documentation
+ * on its origin or official format?
+ */
+
+@interface ZXURLTOResultParser : ZXResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURLTOResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURLTOResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..95ab8dab28eb1020003fd5f68b8c1666ee6bfa70
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXURLTOResultParser.m
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResult.h"
+#import "ZXURIParsedResult.h"
+#import "ZXURLTOResultParser.h"
+
+@implementation ZXURLTOResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+ if (![rawText hasPrefix:@"urlto:"] && ![rawText hasPrefix:@"URLTO:"]) {
+ return nil;
+ }
+ int titleEnd = [rawText rangeOfString:@":" options:NSLiteralSearch range:NSMakeRange(6, [rawText length] - 6)].location;
+ if (titleEnd == NSNotFound) {
+ return nil;
+ }
+ NSString *title = titleEnd <= 6 ? nil : [rawText substringWithRange:NSMakeRange(6, titleEnd - 6)];
+ NSString *uri = [rawText substringFromIndex:titleEnd + 1];
+ return [ZXURIParsedResult uriParsedResultWithUri:uri title:title];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXVCardResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXVCardResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..5df6b849d79d22a560c04d377f0a1d4a584f4162
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXVCardResultParser.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Parses contact information formatted according to the VCard (2.1) format. This is not a complete
+ * implementation but should parse information as commonly encoded in 2D barcodes.
+ */
+
+@interface ZXVCardResultParser : ZXResultParser
+
++ (NSArray *)matchSingleVCardPrefixedField:(NSString *)prefix rawText:(NSString *)rawText trim:(BOOL)trim parseFieldDivider:(BOOL)parseFieldDivider;
++ (NSMutableArray *)matchVCardPrefixedField:(NSString *)prefix rawText:(NSString *)rawText trim:(BOOL)trim parseFieldDivider:(BOOL)parseFieldDivider;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXVCardResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXVCardResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..c60cb8b2a081f9d9667f50e6a6e7327f2ee81e0a
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXVCardResultParser.m
@@ -0,0 +1,355 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAddressBookParsedResult.h"
+#import "ZXResult.h"
+#import "ZXVCardResultParser.h"
+
+static NSRegularExpression *BEGIN_VCARD = nil;
+static NSRegularExpression *VCARD_LIKE_DATE = nil;
+static NSRegularExpression *CR_LF_SPACE_TAB = nil;
+static NSRegularExpression *NEWLINE_ESCAPE = nil;
+static NSRegularExpression *VCARD_ESCAPES = nil;
+static NSString *EQUALS = @"=";
+static NSString *SEMICOLON = @";";
+static NSRegularExpression *UNESCAPED_SEMICOLONS = nil;
+static NSCharacterSet *COMMA = nil;
+static NSCharacterSet *SEMICOLON_OR_COMMA = nil;
+
+@interface ZXVCardResultParser ()
+
++ (NSString *)decodeQuotedPrintable:(NSString *)value charset:(NSString *)charset;
+- (void)formatNames:(NSMutableArray *)names;
+- (BOOL)isLikeVCardDate:(NSString *)value;
++ (void)maybeAppendFragment:(NSMutableData *)fragmentBuffer charset:(NSString *)charset result:(NSMutableString *)result;
+- (void)maybeAppendComponent:(NSArray *)components i:(int)i newName:(NSMutableString *)newName;
+- (NSString *)toPrimaryValue:(NSArray *)list;
+- (NSArray *)toPrimaryValues:(NSArray *)lists;
+- (NSArray *)toTypes:(NSArray *)lists;
+
+@end
+
+@implementation ZXVCardResultParser
+
++ (void)initialize {
+ BEGIN_VCARD = [[NSRegularExpression alloc] initWithPattern:@"BEGIN:VCARD" options:NSRegularExpressionCaseInsensitive error:nil];
+ VCARD_LIKE_DATE = [[NSRegularExpression alloc] initWithPattern:@"\\d{4}-?\\d{2}-?\\d{2}" options:0 error:nil];
+ CR_LF_SPACE_TAB = [[NSRegularExpression alloc] initWithPattern:@"\r\n[ \t]" options:0 error:nil];
+ NEWLINE_ESCAPE = [[NSRegularExpression alloc] initWithPattern:@"\\\\[nN]" options:0 error:nil];
+ VCARD_ESCAPES = [[NSRegularExpression alloc] initWithPattern:@"\\\\([,;\\\\])" options:0 error:nil];
+ UNESCAPED_SEMICOLONS = [[NSRegularExpression alloc] initWithPattern:@"(?<!\\\\);+" options:0 error:nil];
+ COMMA = [[NSCharacterSet characterSetWithCharactersInString:@","] retain];
+ SEMICOLON_OR_COMMA = [[NSCharacterSet characterSetWithCharactersInString:@";,"] retain];
+}
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ // Although we should insist on the raw text ending with "END:VCARD", there's no reason
+ // to throw out everything else we parsed just because this was omitted. In fact, Eclair
+ // is doing just that, and we can't parse its contacts without this leniency.
+ NSString *rawText = [ZXResultParser massagedText:result];
+ if ([BEGIN_VCARD numberOfMatchesInString:rawText options:0 range:NSMakeRange(0, rawText.length)] == 0) {
+ return nil;
+ }
+ NSMutableArray *names = [[self class] matchVCardPrefixedField:@"FN" rawText:rawText trim:YES parseFieldDivider:NO];
+ if (names == nil) {
+ // If no display names found, look for regular name fields and format them
+ names = [[self class] matchVCardPrefixedField:@"N" rawText:rawText trim:YES parseFieldDivider:NO];
+ [self formatNames:names];
+ }
+ NSArray *nicknameString = [[self class] matchSingleVCardPrefixedField:@"NICKNAME" rawText:rawText trim:YES parseFieldDivider:NO];
+ NSArray *nicknames = nicknameString == nil ? nil : [[nicknameString objectAtIndex:0] componentsSeparatedByCharactersInSet:COMMA];
+ NSArray *phoneNumbers = [[self class] matchVCardPrefixedField:@"TEL" rawText:rawText trim:YES parseFieldDivider:NO];
+ NSArray *emails = [[self class] matchVCardPrefixedField:@"EMAIL" rawText:rawText trim:YES parseFieldDivider:NO];
+ NSArray *note = [[self class] matchSingleVCardPrefixedField:@"NOTE" rawText:rawText trim:NO parseFieldDivider:NO];
+ NSMutableArray *addresses = [[self class] matchVCardPrefixedField:@"ADR" rawText:rawText trim:YES parseFieldDivider:YES];
+ NSArray *org = [[self class] matchSingleVCardPrefixedField:@"ORG" rawText:rawText trim:YES parseFieldDivider:YES];
+ NSArray *birthday = [[self class] matchSingleVCardPrefixedField:@"BDAY" rawText:rawText trim:YES parseFieldDivider:NO];
+ if (birthday != nil && ![self isLikeVCardDate:[birthday objectAtIndex:0]]) {
+ birthday = nil;
+ }
+ NSArray *title = [[self class] matchSingleVCardPrefixedField:@"TITLE" rawText:rawText trim:YES parseFieldDivider:NO];
+ NSArray *urls = [[self class] matchVCardPrefixedField:@"URL" rawText:rawText trim:YES parseFieldDivider:NO];
+ NSArray *instantMessenger = [[self class] matchSingleVCardPrefixedField:@"IMPP" rawText:rawText trim:YES parseFieldDivider:NO];
+ NSArray *geoString = [[self class] matchSingleVCardPrefixedField:@"GEO" rawText:rawText trim:YES parseFieldDivider:NO];
+ NSArray *geo = geoString == nil ? nil : [[geoString objectAtIndex:0] componentsSeparatedByCharactersInSet:SEMICOLON_OR_COMMA];
+ if (geo != nil && geo.count != 2) {
+ geo = nil;
+ }
+ return [ZXAddressBookParsedResult addressBookParsedResultWithNames:[self toPrimaryValues:names]
+ nicknames:nicknames
+ pronunciation:nil
+ phoneNumbers:[self toPrimaryValues:phoneNumbers]
+ phoneTypes:[self toTypes:phoneNumbers]
+ emails:[self toPrimaryValues:emails]
+ emailTypes:[self toTypes:emails]
+ instantMessenger:[self toPrimaryValue:instantMessenger]
+ note:[self toPrimaryValue:note]
+ addresses:[self toPrimaryValues:addresses]
+ addressTypes:[self toTypes:addresses]
+ org:[self toPrimaryValue:org]
+ birthday:[self toPrimaryValue:birthday]
+ title:[self toPrimaryValue:title]
+ urls:[self toPrimaryValues:urls]
+ geo:geo];
+}
+
++ (NSMutableArray *)matchVCardPrefixedField:(NSString *)prefix rawText:(NSString *)rawText trim:(BOOL)trim parseFieldDivider:(BOOL)parseFieldDivider {
+ NSMutableArray *matches = nil;
+ int i = 0;
+ int max = [rawText length];
+
+ while (i < max) {
+ // At start or after newling, match prefix, followed by optional metadata
+ // (led by ;) ultimately ending in colon
+ NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:[NSString stringWithFormat:@"(?:^|\n)%@(?:;([^:]*))?:", prefix]
+ options:NSRegularExpressionCaseInsensitive error:nil];
+ if (i > 0) {
+ i--; // Find from i-1 not i since looking at the preceding character
+ }
+ NSArray *regexMatches = [regex matchesInString:rawText options:0 range:NSMakeRange(i, rawText.length - i)];
+ if (regexMatches.count == 0) {
+ break;
+ }
+ NSRange matchRange = [[regexMatches objectAtIndex:0] range];
+ i = matchRange.location + matchRange.length;
+
+ NSString *metadataString = nil;
+ if ([[regexMatches objectAtIndex:0] rangeAtIndex:1].location != NSNotFound) {
+ metadataString = [rawText substringWithRange:[[regexMatches objectAtIndex:0] rangeAtIndex:1]];
+ }
+ NSMutableArray *metadata = nil;
+ BOOL quotedPrintable = NO;
+ NSString *quotedPrintableCharset = nil;
+ if (metadataString != nil) {
+ for (NSString *metadatum in [metadataString componentsSeparatedByString:SEMICOLON]) {
+ if (metadata == nil) {
+ metadata = [NSMutableArray array];
+ }
+ [metadata addObject:metadatum];
+ int equals = [metadatum rangeOfString:EQUALS].location;
+ if (equals != NSNotFound) {
+ NSString *key = [metadatum substringToIndex:equals];
+ NSString *value = [metadatum substringFromIndex:equals + 1];
+ if ([@"ENCODING" caseInsensitiveCompare:key] == NSOrderedSame &&
+ [@"QUOTED-PRINTABLE" caseInsensitiveCompare:value] == NSOrderedSame) {
+ quotedPrintable = YES;
+ } else if ([@"CHARSET" caseInsensitiveCompare:key] == NSOrderedSame) {
+ quotedPrintableCharset = value;
+ }
+ }
+ }
+ }
+
+ int matchStart = i; // Found the start of a match here
+
+ while ((i = [rawText rangeOfString:@"\n" options:NSLiteralSearch range:NSMakeRange(i, [rawText length] - i)].location) != NSNotFound) { // Really, end in \r\n
+ if (i < [rawText length] - 1 && // But if followed by tab or space,
+ ([rawText characterAtIndex:i + 1] == ' ' || // this is only a continuation
+ [rawText characterAtIndex:i + 1] == '\t')) {
+ i += 2; // Skip \n and continutation whitespace
+ } else if (quotedPrintable && // If preceded by = in quoted printable
+ ((i >= 1 && [rawText characterAtIndex:i - 1] == '=') || // this is a continuation
+ (i >= 2 && [rawText characterAtIndex:i - 2] == '='))) {
+ i++; // Skip \n
+ } else {
+ break;
+ }
+ }
+
+ if (i < 0) {
+ // No terminating end character? uh, done. Set i such that loop terminates and break
+ i = max;
+ } else if (i > matchStart) {
+ // found a match
+ if (matches == nil) {
+ matches = [NSMutableArray arrayWithCapacity:1];
+ }
+ if (i >= 1 && [rawText characterAtIndex:i-1] == '\r') {
+ i--; // Back up over \r, which really should be there
+ }
+ NSString *element = [rawText substringWithRange:NSMakeRange(matchStart, i - matchStart)];
+ if (trim) {
+ element = [element stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+ }
+ if (quotedPrintable) {
+ element = [self decodeQuotedPrintable:element charset:quotedPrintableCharset];
+ if (parseFieldDivider) {
+ element = [[UNESCAPED_SEMICOLONS stringByReplacingMatchesInString:element options:0 range:NSMakeRange(0, element.length) withTemplate:@"\n"]
+ stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+ }
+ } else {
+ if (parseFieldDivider) {
+ element = [[UNESCAPED_SEMICOLONS stringByReplacingMatchesInString:element options:0 range:NSMakeRange(0, element.length) withTemplate:@"\n"]
+ stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+ }
+ element = [CR_LF_SPACE_TAB stringByReplacingMatchesInString:element options:0 range:NSMakeRange(0, element.length) withTemplate:@""];
+ element = [NEWLINE_ESCAPE stringByReplacingMatchesInString:element options:0 range:NSMakeRange(0, element.length) withTemplate:@"\n"];
+ element = [VCARD_ESCAPES stringByReplacingMatchesInString:element options:0 range:NSMakeRange(0, element.length) withTemplate:@"$1"];
+ }
+ if (metadata == nil) {
+ NSMutableArray *match = [NSMutableArray arrayWithObject:element];
+ [match addObject:element];
+ [matches addObject:match];
+ } else {
+ [metadata insertObject:element atIndex:0];
+ [matches addObject:metadata];
+ }
+ i++;
+ } else {
+ i++;
+ }
+ }
+
+ return matches;
+}
+
++ (NSString *)decodeQuotedPrintable:(NSString *)value charset:(NSString *)charset {
+ int length = [value length];
+ NSMutableString *result = [NSMutableString stringWithCapacity:length];
+ NSMutableData *fragmentBuffer = [NSMutableData data];
+
+ for (int i = 0; i < length; i++) {
+ unichar c = [value characterAtIndex:i];
+
+ switch (c) {
+ case '\r':
+ case '\n':
+ break;
+ case '=':
+ if (i < length - 2) {
+ unichar nextChar = [value characterAtIndex:i + 1];
+ if (nextChar != '\r' && nextChar != '\n') {
+ unichar nextNextChar = [value characterAtIndex:i + 2];
+ int firstDigit = [self parseHexDigit:nextChar];
+ int secondDigit = [self parseHexDigit:nextNextChar];
+ if (firstDigit >= 0 && secondDigit >= 0) {
+ int encodedByte = (firstDigit << 4) + secondDigit;
+ [fragmentBuffer appendBytes:&encodedByte length:1];
+ } // else ignore it, assume it was incorrectly encoded
+ i += 2;
+ }
+ }
+ break;
+ default:
+ [self maybeAppendFragment:fragmentBuffer charset:charset result:result];
+ [result appendFormat:@"%C", c];
+ }
+ }
+
+ [self maybeAppendFragment:fragmentBuffer charset:charset result:result];
+ return result;
+}
+
++ (void)maybeAppendFragment:(NSMutableData *)fragmentBuffer charset:(NSString *)charset result:(NSMutableString *)result {
+ if ([fragmentBuffer length] > 0) {
+ NSString *fragment;
+ if (charset == nil || CFStringConvertIANACharSetNameToEncoding((CFStringRef)charset) == kCFStringEncodingInvalidId) {
+ fragment = [[[NSString alloc] initWithData:fragmentBuffer encoding:NSUTF8StringEncoding] autorelease];
+ } else {
+ fragment = [[[NSString alloc] initWithData:fragmentBuffer encoding:CFStringConvertEncodingToNSStringEncoding(CFStringConvertIANACharSetNameToEncoding((CFStringRef)charset))] autorelease];
+ }
+ [fragmentBuffer setLength:0];
+ [result appendString:fragment];
+ }
+}
+
++ (NSArray *)matchSingleVCardPrefixedField:(NSString *)prefix rawText:(NSString *)rawText trim:(BOOL)trim parseFieldDivider:(BOOL)parseFieldDivider {
+ NSArray *values = [self matchVCardPrefixedField:prefix rawText:rawText trim:trim parseFieldDivider:parseFieldDivider];
+ return values == nil ? nil : [values objectAtIndex:0];
+}
+
+- (NSString *)toPrimaryValue:(NSArray *)list {
+ return list == nil || list.count == 0 ? nil : [list objectAtIndex:0];
+}
+
+- (NSArray *)toPrimaryValues:(NSArray *)lists {
+ if (lists == nil || lists.count == 0) {
+ return nil;
+ }
+ NSMutableArray *result = [NSMutableArray arrayWithCapacity:lists.count];
+ for (NSArray *list in lists) {
+ NSString *value = [list objectAtIndex:0];
+ if (value != nil && value.length > 0) {
+ [result addObject:value];
+ }
+ }
+ return result;
+}
+
+- (NSArray *)toTypes:(NSArray *)lists {
+ if (lists == nil || lists.count == 0) {
+ return nil;
+ }
+ NSMutableArray *result = [NSMutableArray arrayWithCapacity:lists.count];
+ for (NSArray *list in lists) {
+ NSString *type = nil;
+ for (int i = 1; i < list.count; i++) {
+ NSString *metadatum = [list objectAtIndex:i];
+ int equals = [metadatum rangeOfString:@"=" options:NSCaseInsensitiveSearch].location;
+ if (equals == NSNotFound) {
+ // take the whole thing as a usable label
+ type = metadatum;
+ break;
+ }
+ if ([@"TYPE" isEqualToString:[[metadatum substringToIndex:equals] uppercaseString]]) {
+ type = [metadatum substringFromIndex:equals + 1];
+ break;
+ }
+ }
+ [result addObject:type];
+ }
+ return result;
+}
+
+- (BOOL)isLikeVCardDate:(NSString *)value {
+ return value == nil || [VCARD_LIKE_DATE numberOfMatchesInString:value options:0 range:NSMakeRange(0, value.length)] > 0;
+}
+
+/**
+ * Formats name fields of the form "Public;John;Q.;Reverend;III" into a form like
+ * "Reverend John Q. Public III".
+ */
+- (void)formatNames:(NSMutableArray *)names {
+ if (names != nil) {
+ for (NSMutableArray *list in names) {
+ NSString *name = [list objectAtIndex:0];
+ NSMutableArray *components = [NSMutableArray arrayWithCapacity:5];
+ int start = 0;
+ int end;
+ while ((end = [name rangeOfString:@";" options:NSLiteralSearch range:NSMakeRange(start, [name length] - start)].location) != NSNotFound && end > 0) {
+ [components addObject:[name substringWithRange:NSMakeRange(start, [name length] - end - 1)]];
+ start = end + 1;
+ }
+
+ [components addObject:[name substringFromIndex:start]];
+ NSMutableString *newName = [NSMutableString stringWithCapacity:100];
+ [self maybeAppendComponent:components i:3 newName:newName];
+ [self maybeAppendComponent:components i:1 newName:newName];
+ [self maybeAppendComponent:components i:2 newName:newName];
+ [self maybeAppendComponent:components i:0 newName:newName];
+ [self maybeAppendComponent:components i:4 newName:newName];
+ [list replaceObjectAtIndex:0 withObject:[newName stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]];
+ }
+ }
+}
+
+- (void)maybeAppendComponent:(NSArray *)components i:(int)i newName:(NSMutableString *)newName {
+ if ([components count] > i && [components objectAtIndex:i]) {
+ [newName appendFormat:@" %@", [components objectAtIndex:i]];
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXVEventResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXVEventResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..839f72fefe56682837ba78ad1412bc002cbde573
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXVEventResultParser.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Partially implements the iCalendar format's "VEVENT" format for specifying a
+ * calendar event. See RFC 2445. This supports SUMMARY, LOCATION, GEO, DTSTART and DTEND fields.
+ */
+
+@interface ZXVEventResultParser : ZXResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXVEventResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXVEventResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..bf514685396c8c8b07dbf5d8655c14d3bbf9eeb9
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXVEventResultParser.m
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXCalendarParsedResult.h"
+#import "ZXResult.h"
+#import "ZXVCardResultParser.h"
+#import "ZXVEventResultParser.h"
+
+@interface ZXVEventResultParser ()
+
+- (NSString *)matchSingleVCardPrefixedField:(NSString *)prefix rawText:(NSString *)rawText trim:(BOOL)trim;
+- (NSMutableArray *)matchVCardPrefixedField:(NSString *)prefix rawText:(NSString *)rawText trim:(BOOL)trim;
+
+@end
+
+@implementation ZXVEventResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+ if (rawText == nil) {
+ return nil;
+ }
+ int vEventStart = [rawText rangeOfString:@"BEGIN:VEVENT"].location;
+ if (vEventStart == NSNotFound) {
+ return nil;
+ }
+
+ NSString *summary = [self matchSingleVCardPrefixedField:@"SUMMARY" rawText:rawText trim:YES];
+ NSString *start = [self matchSingleVCardPrefixedField:@"DTSTART" rawText:rawText trim:YES];
+ if (start == nil) {
+ return nil;
+ }
+ NSString *end = [self matchSingleVCardPrefixedField:@"DTEND" rawText:rawText trim:YES];
+ NSString *duration = [self matchSingleVCardPrefixedField:@"DURATION" rawText:rawText trim:YES];
+ NSString *location = [self matchSingleVCardPrefixedField:@"LOCATION" rawText:rawText trim:YES];
+ NSString *organizer = [self stripMailto:[self matchSingleVCardPrefixedField:@"ORGANIZER" rawText:rawText trim:YES]];
+
+ NSMutableArray *attendees = [self matchVCardPrefixedField:@"ATTENDEE" rawText:rawText trim:YES];
+ if (attendees != nil) {
+ for (int i = 0; i < attendees.count; i++) {
+ [attendees replaceObjectAtIndex:i withObject:[self stripMailto:[attendees objectAtIndex:i]]];
+ }
+ }
+ NSString *description = [self matchSingleVCardPrefixedField:@"DESCRIPTION" rawText:rawText trim:YES];
+
+ NSString *geoString = [self matchSingleVCardPrefixedField:@"GEO" rawText:rawText trim:YES];
+ double latitude;
+ double longitude;
+ if (geoString == nil) {
+ latitude = NAN;
+ longitude = NAN;
+ } else {
+ int semicolon = [geoString rangeOfString:@";"].location;
+ latitude = [[geoString substringToIndex:semicolon] doubleValue];
+ longitude = [[geoString substringFromIndex:semicolon + 1] doubleValue];
+ }
+
+ @try {
+ return [ZXCalendarParsedResult calendarParsedResultWithSummary:summary
+ startString:start
+ endString:end
+ durationString:duration
+ location:location
+ organizer:organizer
+ attendees:attendees
+ description:description
+ latitude:latitude
+ longitude:longitude];
+ } @catch (NSException *iae) {
+ return nil;
+ }
+}
+
+- (NSString *)matchSingleVCardPrefixedField:(NSString *)prefix rawText:(NSString *)rawText trim:(BOOL)trim {
+ NSArray *values = [ZXVCardResultParser matchSingleVCardPrefixedField:prefix rawText:rawText trim:trim parseFieldDivider:NO];
+ return values == nil || values.count == 0 ? nil : [values objectAtIndex:0];
+}
+
+- (NSMutableArray *)matchVCardPrefixedField:(NSString *)prefix rawText:(NSString *)rawText trim:(BOOL)trim {
+ NSMutableArray *values = [ZXVCardResultParser matchVCardPrefixedField:prefix rawText:rawText trim:trim parseFieldDivider:NO];
+ if (values == nil || values.count == 0) {
+ return nil;
+ }
+ int size = values.count;
+ NSMutableArray *result = [NSMutableArray arrayWithCapacity:size];
+ for (int i = 0; i < size; i++) {
+ [result addObject:[[values objectAtIndex:i] objectAtIndex:0]];
+ }
+ return result;
+}
+
+- (NSString *)stripMailto:(NSString *)s {
+ if (s != nil && ([s hasPrefix:@"mailto:"] || [s hasPrefix:@"MAILTO:"])) {
+ s = [s substringFromIndex:7];
+ }
+ return s;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXWifiParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXWifiParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..708a1df299f0e7a945587e46e158602bededa315
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXWifiParsedResult.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResult.h"
+
+@interface ZXWifiParsedResult : ZXParsedResult
+
+@property (nonatomic, copy, readonly) NSString *ssid;
+@property (nonatomic, copy, readonly) NSString *networkEncryption;
+@property (nonatomic, copy, readonly) NSString *password;
+@property (nonatomic, assign, readonly) BOOL hidden;
+
+- (id)initWithNetworkEncryption:(NSString *)networkEncryption ssid:(NSString *)ssid password:(NSString *)password;
+- (id)initWithNetworkEncryption:(NSString *)networkEncryption ssid:(NSString *)ssid password:(NSString *)password hidden:(BOOL)hidden;
++ (id)wifiParsedResultWithNetworkEncryption:(NSString *)networkEncryption ssid:(NSString *)ssid password:(NSString *)password;
++ (id)wifiParsedResultWithNetworkEncryption:(NSString *)networkEncryption ssid:(NSString *)ssid password:(NSString *)password hidden:(BOOL)hidden;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXWifiParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXWifiParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..3ca03d3b15ea26cc778bf894a8a8ae73b8c85d96
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXWifiParsedResult.m
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXParsedResultType.h"
+#import "ZXWifiParsedResult.h"
+
+@interface ZXWifiParsedResult ()
+
+@property (nonatomic, copy) NSString *ssid;
+@property (nonatomic, copy) NSString *networkEncryption;
+@property (nonatomic, copy) NSString *password;
+@property (nonatomic, assign) BOOL hidden;
+
+@end
+
+@implementation ZXWifiParsedResult
+
+@synthesize ssid;
+@synthesize networkEncryption;
+@synthesize password;
+@synthesize hidden;
+
+- (id)initWithNetworkEncryption:(NSString *)aNetworkEncryption ssid:(NSString *)anSsid password:(NSString *)aPassword {
+ return [self initWithNetworkEncryption:aNetworkEncryption ssid:anSsid password:aPassword];
+}
+
+- (id)initWithNetworkEncryption:(NSString *)aNetworkEncryption ssid:(NSString *)anSsid password:(NSString *)aPassword hidden:(BOOL)isHidden {
+ if (self = [super initWithType:kParsedResultTypeWifi]) {
+ self.ssid = anSsid;
+ self.networkEncryption = aNetworkEncryption;
+ self.password = aPassword;
+ self.hidden = isHidden;
+ }
+
+ return self;
+}
+
++ (id)wifiParsedResultWithNetworkEncryption:(NSString *)networkEncryption ssid:(NSString *)ssid password:(NSString *)password {
+ return [[[self alloc] initWithNetworkEncryption:networkEncryption ssid:ssid password:password] autorelease];
+}
+
++ (id)wifiParsedResultWithNetworkEncryption:(NSString *)networkEncryption ssid:(NSString *)ssid password:(NSString *)password hidden:(BOOL)hidden {
+ return [[[self alloc] initWithNetworkEncryption:networkEncryption ssid:ssid password:password hidden:hidden] autorelease];
+}
+
+- (void)dealloc {
+ [ssid release];
+ [networkEncryption release];
+ [password release];
+
+ [super dealloc];
+}
+
+- (NSString *)displayResult {
+ NSMutableString *result = [NSMutableString stringWithCapacity:80];
+ [ZXParsedResult maybeAppend:ssid result:result];
+ [ZXParsedResult maybeAppend:networkEncryption result:result];
+ [ZXParsedResult maybeAppend:password result:result];
+ [ZXParsedResult maybeAppend:[[NSNumber numberWithBool:hidden] stringValue] result:result];
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXWifiResultParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXWifiResultParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..39293f715dfee7d0ebb13d6f778f109319396d8b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXWifiResultParser.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultParser.h"
+
+/**
+ * Parses a WIFI configuration string. Strings will be of the form:
+ * WIFI:T:[network type];S:[SSID];P:[network password];H:[hidden?];;
+ *
+ * The fields can appear in any order. Only "S:" is required.
+ */
+
+@interface ZXWifiResultParser : ZXResultParser
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXWifiResultParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXWifiResultParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..3b70ed2a0ad1e3b1a78f2fad73a9240d98a25253
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/client/result/ZXWifiResultParser.m
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResult.h"
+#import "ZXWifiResultParser.h"
+#import "ZXWifiParsedResult.h"
+
+@implementation ZXWifiResultParser
+
+- (ZXParsedResult *)parse:(ZXResult *)result {
+ NSString *rawText = [ZXResultParser massagedText:result];
+ if (![rawText hasPrefix:@"WIFI:"]) {
+ return nil;
+ }
+ NSString *ssid = [[self class] matchSinglePrefixedField:@"S:" rawText:rawText endChar:';' trim:NO];
+ if (ssid == nil || ssid.length == 0) {
+ return nil;
+ }
+ NSString *pass = [[self class] matchSinglePrefixedField:@"P:" rawText:rawText endChar:';' trim:NO];
+ NSString *type = [[self class] matchSinglePrefixedField:@"T:" rawText:rawText endChar:';' trim:NO];
+ if (type == nil) {
+ type = @"nopass";
+ }
+
+ BOOL hidden = [[[self class] matchSinglePrefixedField:@"H:" rawText:rawText endChar:';' trim:NO] boolValue];
+ return [ZXWifiParsedResult wifiParsedResultWithNetworkEncryption:type ssid:ssid password:pass hidden:hidden];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitArray.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitArray.h
new file mode 100644
index 0000000000000000000000000000000000000000..da4ae6f82c4dce03e4cdfd845216f2a37cfe4f7c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitArray.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * A simple, fast array of bits, represented compactly by an array of ints internally.
+ */
+
+@interface ZXBitArray : NSObject
+
+@property (nonatomic, readonly) int size;
+@property (nonatomic, readonly) int *bits;
+
+- (id)initWithSize:(int)size;
+- (int)sizeInBytes;
+- (BOOL)get:(int)i;
+- (void)set:(int)i;
+- (void)flip:(int)i;
+- (int)nextSet:(int)from;
+- (int)nextUnset:(int)from;
+- (void)setBulk:(int)i newBits:(int)newBits;
+- (void)setRange:(int)start end:(int)end;
+- (void)clear;
+- (BOOL)isRange:(int)start end:(int)end value:(BOOL)value;
+- (void)appendBit:(BOOL)bit;
+- (void)appendBits:(int)value numBits:(int)numBits;
+- (void)appendBitArray:(ZXBitArray *)other;
+- (void)xor:(ZXBitArray *)other;
+- (void)toBytes:(int)bitOffset array:(unsigned char *)array offset:(int)offset numBytes:(int)numBytes;
+- (void)reverse;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitArray.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitArray.m
new file mode 100644
index 0000000000000000000000000000000000000000..64874f09758404a35d05ff74c0b22915e9e9e38b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitArray.m
@@ -0,0 +1,334 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+
+@interface ZXBitArray ()
+
+@property (nonatomic, assign) int size;
+@property (nonatomic, assign) int *bits;
+@property (nonatomic, assign) int bitsLength;
+
+- (void)ensureCapacity:(int)aSize;
+- (int *)makeArray:(int)size;
+- (int)numberOfTrailingZeros:(int)i;
+
+@end
+
+@implementation ZXBitArray
+
+@synthesize bits;
+@synthesize bitsLength;
+@synthesize size;
+
+- (id)init {
+ if (self = [super init]) {
+ self.size = 0;
+ self.bits = (int *)malloc(1 * sizeof(int));
+ self.bitsLength = 1;
+ self.bits[0] = 0;
+ }
+
+ return self;
+}
+
+- (id)initWithSize:(int)aSize {
+ if (self = [super init]) {
+ self.size = aSize;
+ self.bits = [self makeArray:aSize];
+ self.bitsLength = (aSize + 31) >> 5;
+ }
+
+ return self;
+}
+
+
+- (void)dealloc {
+ if (bits != NULL) {
+ free(bits);
+ bits = NULL;
+ }
+
+ [super dealloc];
+}
+
+- (int)sizeInBytes {
+ return (self.size + 7) >> 3;
+}
+
+- (void)ensureCapacity:(int)aSize {
+ if (aSize > self.bitsLength << 5) {
+ int *newBits = [self makeArray:aSize];
+
+ for (int i = 0; i < self.bitsLength; i++) {
+ newBits[i] = self.bits[i];
+ }
+
+ if (self.bits != NULL) {
+ free(self.bits);
+ self.bits = NULL;
+ }
+ self.bits = newBits;
+ self.bitsLength = (aSize + 31) >> 5;
+ }
+}
+
+
+- (BOOL)get:(int)i {
+ return (self.bits[i >> 5] & (1 << (i & 0x1F))) != 0;
+}
+
+
+- (void)set:(int)i {
+ self.bits[i >> 5] |= 1 << (i & 0x1F);
+}
+
+
+/**
+ * Flips bit i.
+ */
+- (void)flip:(int)i {
+ self.bits[i >> 5] ^= 1 << (i & 0x1F);
+}
+
+- (int)nextSet:(int)from {
+ if (from >= self.size) {
+ return self.size;
+ }
+ int bitsOffset = from >> 5;
+ int currentBits = self.bits[bitsOffset];
+ // mask off lesser bits first
+ currentBits &= ~((1 << (from & 0x1F)) - 1);
+ while (currentBits == 0) {
+ if (++bitsOffset == self.bitsLength) {
+ return self.size;
+ }
+ currentBits = self.bits[bitsOffset];
+ }
+ int result = (bitsOffset << 5) + [self numberOfTrailingZeros:currentBits];
+ return result > self.size ? self.size : result;
+}
+
+- (int)nextUnset:(int)from {
+ if (from >= self.size) {
+ return self.size;
+ }
+ int bitsOffset = from >> 5;
+ int currentBits = ~self.bits[bitsOffset];
+ // mask off lesser bits first
+ currentBits &= ~((1 << (from & 0x1F)) - 1);
+ while (currentBits == 0) {
+ if (++bitsOffset == self.bitsLength) {
+ return size;
+ }
+ currentBits = ~self.bits[bitsOffset];
+ }
+ int result = (bitsOffset << 5) + [self numberOfTrailingZeros:currentBits];
+ return result > self.size ? self.size : result;
+}
+
+/**
+ * Sets a block of 32 bits, starting at bit i.
+ *
+ * newBits is the new value of the next 32 bits. Note again that the least-significant bit
+ * corresponds to bit i, the next-least-significant to i+1, and so on.
+ */
+- (void)setBulk:(int)i newBits:(int)newBits {
+ self.bits[i >> 5] = newBits;
+}
+
+/**
+ * Sets a range of bits.
+ */
+- (void)setRange:(int)start end:(int)end {
+ if (end < start) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"Start greater than end" userInfo:nil];
+ }
+ if (end == start) {
+ return;
+ }
+ end--; // will be easier to treat this as the last actually set bit -- inclusive
+ int firstInt = start >> 5;
+ int lastInt = end >> 5;
+ for (int i = firstInt; i <= lastInt; i++) {
+ int firstBit = i > firstInt ? 0 : start & 0x1F;
+ int lastBit = i < lastInt ? 31 : end & 0x1F;
+ int mask;
+ if (firstBit == 0 && lastBit == 31) {
+ mask = -1;
+ } else {
+ mask = 0;
+ for (int j = firstBit; j <= lastBit; j++) {
+ mask |= 1 << j;
+ }
+ }
+ self.bits[i] |= mask;
+ }
+}
+
+/**
+ * Clears all bits (sets to false).
+ */
+- (void)clear {
+ memset(self.bits, 0, self.bitsLength * sizeof(int));
+}
+
+/**
+ * Efficient method to check if a range of bits is set, or not set.
+ */
+- (BOOL)isRange:(int)start end:(int)end value:(BOOL)value {
+ if (end < start) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"Start greater than end" userInfo:nil];
+ }
+ if (end == start) {
+ return YES;
+ }
+ end--;
+ int firstInt = start >> 5;
+ int lastInt = end >> 5;
+
+ for (int i = firstInt; i <= lastInt; i++) {
+ int firstBit = i > firstInt ? 0 : start & 0x1F;
+ int lastBit = i < lastInt ? 31 : end & 0x1F;
+ int mask;
+ if (firstBit == 0 && lastBit == 31) {
+ mask = -1;
+ } else {
+ mask = 0;
+
+ for (int j = firstBit; j <= lastBit; j++) {
+ mask |= 1 << j;
+ }
+ }
+ if ((self.bits[i] & mask) != (value ? mask : 0)) {
+ return NO;
+ }
+ }
+
+ return YES;
+}
+
+- (void)appendBit:(BOOL)bit {
+ [self ensureCapacity:self.size + 1];
+ if (bit) {
+ self.bits[self.size >> 5] |= 1 << (self.size & 0x1F);
+ }
+ self.size++;
+}
+
+/**
+ * Appends the least-significant bits, from value, in order from most-significant to
+ * least-significant. For example, appending 6 bits from 0x000001E will append the bits
+ * 0, 1, 1, 1, 1, 0 in that order.
+ */
+- (void)appendBits:(int)value numBits:(int)numBits {
+ if (numBits < 0 || numBits > 32) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:@"Num bits must be between 0 and 32"
+ userInfo:nil];
+ }
+ [self ensureCapacity:self.size + numBits];
+ for (int numBitsLeft = numBits; numBitsLeft > 0; numBitsLeft--) {
+ [self appendBit:((value >> (numBitsLeft - 1)) & 0x01) == 1];
+ }
+}
+
+- (void)appendBitArray:(ZXBitArray *)other {
+ int otherSize = [other size];
+ [self ensureCapacity:self.size + otherSize];
+
+ for (int i = 0; i < otherSize; i++) {
+ [self appendBit:[other get:i]];
+ }
+}
+
+- (void)xor:(ZXBitArray *)other {
+ if (self.bitsLength != other->bitsLength) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:@"Sizes don't match"
+ userInfo:nil];
+ }
+
+ for (int i = 0; i < self.bitsLength; i++) {
+ self.bits[i] ^= other.bits[i];
+ }
+}
+
+
+- (void)toBytes:(int)bitOffset array:(unsigned char *)array offset:(int)offset numBytes:(int)numBytes {
+ for (int i = 0; i < numBytes; i++) {
+ int theByte = 0;
+ for (int j = 0; j < 8; j++) {
+ if ([self get:bitOffset]) {
+ theByte |= 1 << (7 - j);
+ }
+ bitOffset++;
+ }
+ array[offset + i] = (char)theByte;
+ }
+}
+
+/**
+ * Reverses all bits in the array.
+ */
+- (void)reverse {
+ int *newBits = (int *)malloc(self.size * sizeof(int));
+ for (int i = 0; i < self.size; i++) {
+ newBits[i] = 0;
+ if ([self get:self.size - i - 1]) {
+ newBits[i >> 5] |= 1 << (i & 0x1F);
+ }
+ }
+
+ if (self.bits != NULL) {
+ free(self.bits);
+ }
+ self.bits = newBits;
+}
+
+- (int *)makeArray:(int)aSize {
+ int arraySize = (aSize + 31) >> 5;
+ int *newArray = (int *)malloc(arraySize * sizeof(int));
+ memset(newArray, 0, arraySize * sizeof(int));
+ return newArray;
+}
+
+- (NSString *)description {
+ NSMutableString *result = [NSMutableString string];
+
+ for (int i = 0; i < size; i++) {
+ if ((i & 0x07) == 0) {
+ [result appendString:@" "];
+ }
+ [result appendString:[self get:i] ? @"X" : @"."];
+ }
+
+ return result;
+}
+
+// Ported from OpenJDK Integer.numberOfTrailingZeros implementation
+- (int)numberOfTrailingZeros:(int)i {
+ int y;
+ if (i == 0) return 32;
+ int n = 31;
+ y = i <<16; if (y != 0) { n = n -16; i = y; }
+ y = i << 8; if (y != 0) { n = n - 8; i = y; }
+ y = i << 4; if (y != 0) { n = n - 4; i = y; }
+ y = i << 2; if (y != 0) { n = n - 2; i = y; }
+ return n - (int)(((unsigned int)(i << 1)) >> 31);
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitMatrix.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitMatrix.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5af4810096ffa9387fa767ef627e7deda1ca8f3
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitMatrix.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Represents a 2D matrix of bits. In function arguments below, and throughout the common
+ * module, x is the column position, and y is the row position. The ordering is always x, y.
+ * The origin is at the top-left.
+ *
+ * Internally the bits are represented in a 1-D array of 32-bit ints. However, each row begins
+ * with a new int. This is done intentionally so that we can copy out a row into a BitArray very
+ * efficiently.
+ *
+ * The ordering of bits is row-major. Within each int, the least significant bits are used first,
+ * meaning they represent lower x values. This is compatible with BitArray's implementation.
+ */
+
+@class ZXBitArray;
+
+@interface ZXBitMatrix : NSObject
+
+@property (nonatomic, readonly) int width;
+@property (nonatomic, readonly) int height;
+@property (nonatomic, readonly) int *bits;
+
++ (ZXBitMatrix *)bitMatrixWithDimension:(int)dimension;
++ (ZXBitMatrix *)bitMatrixWithWidth:(int)width height:(int)height;
+
+- (id)initWithDimension:(int)dimension;
+- (id)initWithWidth:(int)width height:(int)height;
+
+- (BOOL)getX:(int)x y:(int)y;
+- (void)setX:(int)x y:(int)y;
+- (void)flipX:(int)x y:(int)y;
+- (void)clear;
+- (void)setRegionAtLeft:(int)left top:(int)top width:(int)width height:(int)height;
+- (ZXBitArray *)rowAtY:(int)y row:(ZXBitArray *)row;
+- (void)setRowAtY:(int)y row:(ZXBitArray *)row;
+- (NSArray *)enclosingRectangle;
+- (NSArray *)topLeftOnBit;
+- (NSArray *)bottomRightOnBit;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitMatrix.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitMatrix.m
new file mode 100644
index 0000000000000000000000000000000000000000..47ae654a8cf5728b08077cf0ebdc882be718fbd8
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitMatrix.m
@@ -0,0 +1,299 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXBitMatrix.h"
+
+@interface ZXBitMatrix ()
+
+@property (nonatomic) int width;
+@property (nonatomic) int height;
+@property (nonatomic) int *bits;
+@property (nonatomic) int rowSize;
+@property (nonatomic) int bitsSize;
+
+@end
+
+@implementation ZXBitMatrix
+
+@synthesize width;
+@synthesize height;
+@synthesize bits;
+@synthesize rowSize;
+@synthesize bitsSize;
+
++ (ZXBitMatrix *)bitMatrixWithDimension:(int)dimension {
+ return [[[self alloc] initWithDimension:dimension] autorelease];
+}
+
++ (ZXBitMatrix *)bitMatrixWithWidth:(int)width height:(int)height {
+ return [[[self alloc] initWithWidth:width height:height] autorelease];
+}
+
+- (id)initWithDimension:(int)dimension {
+ return [self initWithWidth:dimension height:dimension];
+}
+
+- (id)initWithWidth:(int)aWidth height:(int)aHeight {
+ if (self = [super init]) {
+ if (aWidth < 1 || aHeight < 1) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:@"Both dimensions must be greater than 0"
+ userInfo:nil];
+ }
+ self.width = aWidth;
+ self.height = aHeight;
+ self.rowSize = (self.width + 31) >> 5;
+ self.bitsSize = self.rowSize * self.height;
+ self.bits = (int *)malloc(self.bitsSize * sizeof(int));
+ [self clear];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ if (self.bits != NULL) {
+ free(self.bits);
+ self.bits = NULL;
+ }
+
+ [super dealloc];
+}
+
+/**
+ * Gets the requested bit, where true means black.
+ */
+- (BOOL)getX:(int)x y:(int)y {
+ int offset = y * self.rowSize + (x >> 5);
+ return ((int)((unsigned int)self.bits[offset] >> (x & 0x1f)) & 1) != 0;
+}
+
+/**
+ * Sets the given bit to true.
+ */
+- (void)setX:(int)x y:(int)y {
+ int offset = y * self.rowSize + (x >> 5);
+ self.bits[offset] |= 1 << (x & 0x1f);
+}
+
+/**
+ * Flips the given bit.
+ */
+- (void)flipX:(int)x y:(int)y {
+ int offset = y * self.rowSize + (x >> 5);
+ self.bits[offset] ^= 1 << (x & 0x1f);
+}
+
+/**
+ * Clears all bits (sets to false).
+ */
+- (void)clear {
+ int max = self.bitsSize;
+ memset(self.bits, 0, max * sizeof(int));
+}
+
+/**
+ * Sets a square region of the bit matrix to true.
+ */
+- (void)setRegionAtLeft:(int)left top:(int)top width:(int)aWidth height:(int)aHeight {
+ if (top < 0 || left < 0) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:@"Left and top must be nonnegative"
+ userInfo:nil];
+ }
+ if (aHeight < 1 || aWidth < 1) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:@"Height and width must be at least 1"
+ userInfo:nil];
+ }
+ int right = left + aWidth;
+ int bottom = top + aHeight;
+ if (bottom > self.height || right > self.width) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:@"The region must fit inside the matrix"
+ userInfo:nil];
+ }
+ for (int y = top; y < bottom; y++) {
+ int offset = y * self.rowSize;
+ for (int x = left; x < right; x++) {
+ self.bits[offset + (x >> 5)] |= 1 << (x & 0x1f);
+ }
+ }
+}
+
+/**
+ * A fast method to retrieve one row of data from the matrix as a BitArray.
+ */
+- (ZXBitArray *)rowAtY:(int)y row:(ZXBitArray *)row {
+ if (row == nil || [row size] < self.width) {
+ row = [[[ZXBitArray alloc] initWithSize:self.width] autorelease];
+ }
+ int offset = y * self.rowSize;
+ for (int x = 0; x < self.rowSize; x++) {
+ [row setBulk:x << 5 newBits:self.bits[offset + x]];
+ }
+
+ return row;
+}
+
+- (void)setRowAtY:(int)y row:(ZXBitArray *)row {
+ for (int i = 0; i > self.rowSize; i++) {
+ self.bits[y * self.rowSize + i] = row.bits[y * self.rowSize + i];
+ }
+}
+
+/**
+ * This is useful in detecting the enclosing rectangle of a 'pure' barcode.
+ *
+ * Returns {left,top,width,height} enclosing rectangle of all 1 bits, or null if it is all white
+ */
+- (NSArray *)enclosingRectangle {
+ int left = self.width;
+ int top = self.height;
+ int right = -1;
+ int bottom = -1;
+
+ for (int y = 0; y < self.height; y++) {
+ for (int x32 = 0; x32 < self.rowSize; x32++) {
+ int theBits = self.bits[y * self.rowSize + x32];
+ if (theBits != 0) {
+ if (y < top) {
+ top = y;
+ }
+ if (y > bottom) {
+ bottom = y;
+ }
+ if (x32 * 32 < left) {
+ int bit = 0;
+ while ((theBits << (31 - bit)) == 0) {
+ bit++;
+ }
+ if ((x32 * 32 + bit) < left) {
+ left = x32 * 32 + bit;
+ }
+ }
+ if (x32 * 32 + 31 > right) {
+ int bit = 31;
+ while ((int)((unsigned int)theBits >> bit) == 0) {
+ bit--;
+ }
+ if ((x32 * 32 + bit) > right) {
+ right = x32 * 32 + bit;
+ }
+ }
+ }
+ }
+ }
+
+ int _width = right - left;
+ int _height = bottom - top;
+
+ if (_width < 0 || _height < 0) {
+ return nil;
+ }
+
+ return [NSArray arrayWithObjects:[NSNumber numberWithInt:left],
+ [NSNumber numberWithInt:top], [NSNumber numberWithInt:_width],
+ [NSNumber numberWithInt:_height], nil];
+}
+
+/**
+ * This is useful in detecting a corner of a 'pure' barcode.
+ *
+ * Returns {x,y} coordinate of top-left-most 1 bit, or null if it is all white
+ */
+- (NSArray *)topLeftOnBit {
+ int bitsOffset = 0;
+ while (bitsOffset < self.bitsSize && self.bits[bitsOffset] == 0) {
+ bitsOffset++;
+ }
+ if (bitsOffset == self.bitsSize) {
+ return nil;
+ }
+ int y = bitsOffset / self.rowSize;
+ int x = (bitsOffset % self.rowSize) << 5;
+
+ int theBits = self.bits[bitsOffset];
+ int bit = 0;
+ while ((theBits << (31 - bit)) == 0) {
+ bit++;
+ }
+ x += bit;
+ return [NSArray arrayWithObjects:[NSNumber numberWithInt:x], [NSNumber numberWithInt:y], nil];
+}
+
+- (NSArray *)bottomRightOnBit {
+ int bitsOffset = self.bitsSize - 1;
+ while (bitsOffset >= 0 && self.bits[bitsOffset] == 0) {
+ bitsOffset--;
+ }
+ if (bitsOffset < 0) {
+ return nil;
+ }
+
+ int y = bitsOffset / self.rowSize;
+ int x = (bitsOffset % self.rowSize) << 5;
+
+ int theBits = self.bits[bitsOffset];
+ int bit = 31;
+ while ((int)((unsigned int)theBits >> bit) == 0) {
+ bit--;
+ }
+ x += bit;
+
+ return [NSArray arrayWithObjects:[NSNumber numberWithInt:x], [NSNumber numberWithInt:y], nil];
+}
+
+- (BOOL)isEqual:(NSObject *)o {
+ if (!([o isKindOfClass:[ZXBitMatrix class]])) {
+ return NO;
+ }
+ ZXBitMatrix *other = (ZXBitMatrix *)o;
+ if (self.width != other.width || self.height != other.height || self.rowSize != other->rowSize || self.bitsSize != other->bitsSize) {
+ return NO;
+ }
+ for (int i = 0; i < self.bitsSize; i++) {
+ if (self.bits[i] != other->bits[i]) {
+ return NO;
+ }
+ }
+ return YES;
+}
+
+- (NSUInteger)hash {
+ int hash = self.width;
+ hash = 31 * hash + self.width;
+ hash = 31 * hash + self.height;
+ hash = 31 * hash + self.rowSize;
+ for (int i = 0; i < self.bitsSize; i++) {
+ hash = 31 * hash + self.bits[i];
+ }
+ return hash;
+}
+
+- (NSString *)description {
+ NSMutableString *result = [NSMutableString stringWithCapacity:self.height * (self.width + 1)];
+ for (int y = 0; y < self.height; y++) {
+ for (int x = 0; x < self.width; x++) {
+ [result appendString:[self getX:x y:y] ? @"X " : @" "];
+ }
+ [result appendString:@"\n"];
+ }
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitSource.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitSource.h
new file mode 100644
index 0000000000000000000000000000000000000000..c4c31601048cf0289f0a3d9ea2dac699073f3adf
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitSource.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This provides an easy abstraction to read bits at a time from a sequence of bytes, where the
+ * number of bits read is not often a multiple of 8.
+ *
+ * This class is thread-safe but not reentrant -- unless the caller modifies the bytes array
+ * it passed in, in which case all bets are off.
+ */
+
+@interface ZXBitSource : NSObject
+
+@property (nonatomic, assign, readonly) int bitOffset;
+@property (nonatomic, assign, readonly) int byteOffset;
+
+- (id)initWithBytes:(unsigned char *)bytes length:(unsigned int)length;
+- (int)readBits:(int)numBits;
+- (int)available;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitSource.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitSource.m
new file mode 100644
index 0000000000000000000000000000000000000000..d00943a3ae25fad00ffbe5066c23a3000df4de5a
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXBitSource.m
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitSource.h"
+
+@interface ZXBitSource ()
+
+@property (nonatomic, assign) unsigned char *bytes;
+@property (nonatomic, assign) int byteOffset;
+@property (nonatomic, assign) int bitOffset;
+@property (nonatomic, assign) int length;
+
+@end
+
+@implementation ZXBitSource
+
+@synthesize bytes;
+@synthesize byteOffset;
+@synthesize bitOffset;
+@synthesize length;
+
+/**
+ * bytes is the bytes from which this will read bits. Bits will be read from the first byte first.
+ * Bits are read within a byte from most-significant to least-significant bit.
+ */
+- (id)initWithBytes:(unsigned char *)aBytes length:(unsigned int)aLength {
+ if (self = [super init]) {
+ self.bytes = aBytes;
+ self.length = aLength;
+ }
+ return self;
+}
+
+
+- (int)readBits:(int)numBits {
+ if (numBits < 1 || numBits > 32 || numBits > self.available) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Invalid number of bits: %d", numBits];
+ }
+ int result = 0;
+ if (self.bitOffset > 0) {
+ int bitsLeft = 8 - self.bitOffset;
+ int toRead = numBits < bitsLeft ? numBits : bitsLeft;
+ int bitsToNotRead = bitsLeft - toRead;
+ int mask = (0xFF >> (8 - toRead)) << bitsToNotRead;
+ result = (self.bytes[self.byteOffset] & mask) >> bitsToNotRead;
+ numBits -= toRead;
+ self.bitOffset += toRead;
+ if (self.bitOffset == 8) {
+ self.bitOffset = 0;
+ self.byteOffset++;
+ }
+ }
+
+ if (numBits > 0) {
+ while (numBits >= 8) {
+ result = (result << 8) | (self.bytes[self.byteOffset] & 0xFF);
+ self.byteOffset++;
+ numBits -= 8;
+ }
+
+ if (numBits > 0) {
+ int bitsToNotRead = 8 - numBits;
+ int mask = (0xFF >> bitsToNotRead) << bitsToNotRead;
+ result = (result << numBits) | ((self.bytes[self.byteOffset] & mask) >> bitsToNotRead);
+ self.bitOffset += numBits;
+ }
+ }
+ return result;
+}
+
+- (int)available {
+ return 8 * (self.length - self.byteOffset) - self.bitOffset;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXCharacterSetECI.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXCharacterSetECI.h
new file mode 100644
index 0000000000000000000000000000000000000000..b5a1f8ebe4f1bdc1ab43f60d147bce089e442d3c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXCharacterSetECI.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXECI.h"
+
+/**
+ * Encapsulates a Character Set ECI, according to "Extended Channel Interpretations" 5.3.1.1
+ * of ISO 18004.
+ */
+
+@interface ZXCharacterSetECI : ZXECI
+
+@property (nonatomic, readonly) NSStringEncoding encoding;
+
++ (ZXCharacterSetECI *)characterSetECIByValue:(int)value;
++ (ZXCharacterSetECI *)characterSetECIByEncoding:(NSStringEncoding)encoding;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXCharacterSetECI.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXCharacterSetECI.m
new file mode 100644
index 0000000000000000000000000000000000000000..a185a80946b1e546b470d874f368322fb3ddad53
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXCharacterSetECI.m
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXCharacterSetECI.h"
+#import "ZXErrors.h"
+
+static NSMutableDictionary *VALUE_TO_ECI = nil;
+static NSMutableDictionary *ENCODING_TO_ECI = nil;
+
+@interface ZXCharacterSetECI ()
+
+@property (nonatomic) NSStringEncoding encoding;
+
++ (void)addCharacterSet:(int)value encoding:(NSStringEncoding)encoding;
+
+@end
+
+@implementation ZXCharacterSetECI
+
+@synthesize encoding;
+
++ (void)initialize {
+ VALUE_TO_ECI = [[NSMutableDictionary alloc] initWithCapacity:29];
+ ENCODING_TO_ECI = [[NSMutableDictionary alloc] initWithCapacity:29];
+ [self addCharacterSet:0 encoding:(NSStringEncoding) 0x80000400];
+ [self addCharacterSet:1 encoding:NSISOLatin1StringEncoding];
+ [self addCharacterSet:2 encoding:(NSStringEncoding) 0x80000400];
+ [self addCharacterSet:3 encoding:NSISOLatin1StringEncoding];
+ [self addCharacterSet:4 encoding:NSISOLatin2StringEncoding];
+ [self addCharacterSet:5 encoding:(NSStringEncoding) 0x80000203];
+ [self addCharacterSet:6 encoding:(NSStringEncoding) 0x80000204];
+ [self addCharacterSet:7 encoding:(NSStringEncoding) 0x80000205];
+ [self addCharacterSet:8 encoding:(NSStringEncoding) 0x80000206];
+ [self addCharacterSet:9 encoding:(NSStringEncoding) 0x80000207];
+ [self addCharacterSet:10 encoding:(NSStringEncoding) 0x80000208];
+ [self addCharacterSet:11 encoding:(NSStringEncoding) 0x80000209];
+ [self addCharacterSet:12 encoding:(NSStringEncoding) 0x8000020A];
+ [self addCharacterSet:13 encoding:(NSStringEncoding) 0x8000020B];
+ [self addCharacterSet:15 encoding:(NSStringEncoding) 0x8000020D];
+ [self addCharacterSet:16 encoding:(NSStringEncoding) 0x8000020E];
+ [self addCharacterSet:17 encoding:(NSStringEncoding) 0x8000020F];
+ [self addCharacterSet:18 encoding:(NSStringEncoding) 0x80000210];
+ [self addCharacterSet:20 encoding:NSShiftJISStringEncoding];
+ [self addCharacterSet:21 encoding:NSWindowsCP1250StringEncoding];
+ [self addCharacterSet:22 encoding:NSWindowsCP1251StringEncoding];
+ [self addCharacterSet:23 encoding:NSWindowsCP1252StringEncoding];
+ [self addCharacterSet:24 encoding:(NSStringEncoding) 0x80000505];
+ [self addCharacterSet:25 encoding:NSUTF16BigEndianStringEncoding];
+ [self addCharacterSet:26 encoding:NSUTF8StringEncoding];
+ [self addCharacterSet:27 encoding:NSASCIIStringEncoding];
+ [self addCharacterSet:28 encoding:(NSStringEncoding) 0x80000A03];
+ [self addCharacterSet:29 encoding:(NSStringEncoding) 0x80000632];
+ [self addCharacterSet:30 encoding:(NSStringEncoding) 0x80000940];
+ [self addCharacterSet:170 encoding:NSASCIIStringEncoding];
+}
+
+- (id)initWithValue:(int)value encoding:(NSStringEncoding)anEncoding {
+ if (self = [super initWithValue:value]) {
+ self.encoding = anEncoding;
+ }
+
+ return self;
+}
+
++ (void)addCharacterSet:(int)value encoding:(NSStringEncoding)encoding {
+ ZXCharacterSetECI *eci = [[[ZXCharacterSetECI alloc] initWithValue:value encoding:encoding] autorelease];
+ [VALUE_TO_ECI setObject:eci forKey:[NSNumber numberWithInt:value]];
+ [ENCODING_TO_ECI setObject:eci forKey:[NSNumber numberWithUnsignedInteger:encoding]];
+}
+
++ (ZXCharacterSetECI *)characterSetECIByValue:(int)value {
+ if (VALUE_TO_ECI == nil) {
+ [self initialize];
+ }
+ if (value < 0 || value >= 900) {
+ return nil;
+ }
+ return [VALUE_TO_ECI objectForKey:[NSNumber numberWithInt:value]];
+}
+
+
++ (ZXCharacterSetECI *)characterSetECIByEncoding:(NSStringEncoding)encoding {
+ if (ENCODING_TO_ECI == nil) {
+ [self initialize];
+ }
+ return [ENCODING_TO_ECI objectForKey:[NSNumber numberWithUnsignedInteger:encoding]];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDecoderResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDecoderResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..5f7301c4ed54fdd64a7d138b4e95385ab37687fa
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDecoderResult.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates the result of decoding a matrix of bits. This typically
+ * applies to 2D barcode formats. For now it contains the raw bytes obtained,
+ * as well as a String interpretation of those bytes, if applicable.
+ */
+
+@interface ZXDecoderResult : NSObject
+
+@property (nonatomic, assign, readonly) unsigned char *rawBytes;
+@property (nonatomic, assign, readonly) int length;
+@property (nonatomic, copy, readonly) NSString *text;
+@property (nonatomic, retain, readonly) NSMutableArray *byteSegments;
+@property (nonatomic, copy, readonly) NSString *ecLevel;
+
+- (id)initWithRawBytes:(unsigned char *)rawBytes
+ length:(unsigned int)length
+ text:(NSString *)text
+ byteSegments:(NSMutableArray *)byteSegments
+ ecLevel:(NSString *)ecLevel;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDecoderResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDecoderResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..f9c66bbfc600fbef64515c85cc182042ea32d510
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDecoderResult.m
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecoderResult.h"
+
+@interface ZXDecoderResult ()
+
+@property (nonatomic, assign) unsigned char *rawBytes;
+@property (nonatomic, assign) int length;
+@property (nonatomic, copy) NSString *text;
+@property (nonatomic, retain) NSMutableArray *byteSegments;
+@property (nonatomic, copy) NSString *ecLevel;
+
+@end
+
+@implementation ZXDecoderResult
+
+@synthesize rawBytes;
+@synthesize length;
+@synthesize text;
+@synthesize byteSegments;
+@synthesize ecLevel;
+
+- (id)initWithRawBytes:(unsigned char *)theRawBytes
+ length:(unsigned int)aLength
+ text:(NSString *)theText
+ byteSegments:(NSMutableArray *)theByteSegments
+ ecLevel:(NSString *)anEcLevel {
+ if (self = [super init]) {
+ self.rawBytes = theRawBytes;
+ self.length = aLength;
+ self.text = theText;
+ self.byteSegments = theByteSegments;
+ self.ecLevel = anEcLevel;
+ }
+
+ return self;
+}
+
+- (void) dealloc {
+ [text release];
+ [byteSegments release];
+ [ecLevel release];
+
+ [super dealloc];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDefaultGridSampler.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDefaultGridSampler.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7776cc10141bc723b051d785c73a7e9d0e2ccdc
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDefaultGridSampler.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXGridSampler.h"
+
+@class ZXBitMatrix, ZXPerspectiveTransform;
+
+@interface ZXDefaultGridSampler : ZXGridSampler
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDefaultGridSampler.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDefaultGridSampler.m
new file mode 100644
index 0000000000000000000000000000000000000000..a491e846ecdc50f8121ac7b595bde7314661dea1
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDefaultGridSampler.m
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXDefaultGridSampler.h"
+#import "ZXErrors.h"
+#import "ZXPerspectiveTransform.h"
+
+@implementation ZXDefaultGridSampler
+
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)image
+ dimensionX:(int)dimensionX
+ dimensionY:(int)dimensionY
+ p1ToX:(float)p1ToX p1ToY:(float)p1ToY
+ p2ToX:(float)p2ToX p2ToY:(float)p2ToY
+ p3ToX:(float)p3ToX p3ToY:(float)p3ToY
+ p4ToX:(float)p4ToX p4ToY:(float)p4ToY
+ p1FromX:(float)p1FromX p1FromY:(float)p1FromY
+ p2FromX:(float)p2FromX p2FromY:(float)p2FromY
+ p3FromX:(float)p3FromX p3FromY:(float)p3FromY
+ p4FromX:(float)p4FromX p4FromY:(float)p4FromY
+ error:(NSError **)error {
+ ZXPerspectiveTransform *transform =
+ [ZXPerspectiveTransform quadrilateralToQuadrilateral:p1ToX y0:p1ToY
+ x1:p2ToX y1:p2ToY
+ x2:p3ToX y2:p3ToY
+ x3:p4ToX y3:p4ToY
+ x0p:p1FromX y0p:p1FromY
+ x1p:p2FromX y1p:p2FromY
+ x2p:p3FromX y2p:p3FromY
+ x3p:p4FromX y3p:p4FromY];
+ return [self sampleGrid:image dimensionX:dimensionX dimensionY:dimensionY transform:transform error:error];
+}
+
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)image
+ dimensionX:(int)dimensionX
+ dimensionY:(int)dimensionY
+ transform:(ZXPerspectiveTransform *)transform
+ error:(NSError **)error {
+ if (dimensionX <= 0 || dimensionY <= 0) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ ZXBitMatrix *bits = [[[ZXBitMatrix alloc] initWithWidth:dimensionX height:dimensionY] autorelease];
+ int pointsLen = dimensionX << 1;
+ float pointsf[pointsLen];
+ memset(pointsf, 0, pointsLen * sizeof(float));
+
+ for (int y = 0; y < dimensionY; y++) {
+ int max = dimensionX << 1;
+ float iValue = (float)y + 0.5f;
+ for (int x = 0; x < max; x += 2) {
+ pointsf[x] = (float) (x >> 1) + 0.5f;
+ pointsf[x + 1] = iValue;
+ }
+ [transform transformPoints:pointsf pointsLen:pointsLen];
+
+ if (![ZXGridSampler checkAndNudgePoints:image points:pointsf pointsLen:pointsLen error:error]) {
+ return nil;
+ }
+ for (int x = 0; x < max; x += 2) {
+ int xx = (int)pointsf[x];
+ int yy = (int)pointsf[x + 1];
+ if (xx < 0 || yy < 0 || xx >= image.width || yy >= image.height) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ if ([image getX:xx y:yy]) {
+ [bits setX:x >> 1 y:y];
+ }
+ }
+ }
+
+ return bits;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDetectorResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDetectorResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..b824ada9912d5865c980fbc9cfa1b03354c18d62
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDetectorResult.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates the result of detecting a barcode in an image. This includes the raw
+ * matrix of black/white pixels corresponding to the barcode, and possibly points of interest
+ * in the image, like the location of finder patterns or corners of the barcode in the image.
+ */
+
+@class ZXBitMatrix;
+
+@interface ZXDetectorResult : NSObject
+
+@property (nonatomic, retain, readonly) ZXBitMatrix *bits;
+@property (nonatomic, retain, readonly) NSArray *points;
+
+- (id)initWithBits:(ZXBitMatrix *)bits points:(NSArray *)points;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDetectorResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDetectorResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..3067cbdccf7d65944de945ef33d83dcf268b8bd9
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXDetectorResult.m
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXDetectorResult.h"
+
+@interface ZXDetectorResult ()
+
+@property (nonatomic, retain) ZXBitMatrix *bits;
+@property (nonatomic, retain) NSArray *points;
+
+@end
+
+@implementation ZXDetectorResult
+
+@synthesize bits;
+@synthesize points;
+
+- (id)initWithBits:(ZXBitMatrix *)theBits points:(NSArray *)thePoints {
+ if (self = [super init]) {
+ self.bits = theBits;
+ self.points = thePoints;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [bits release];
+ [points release];
+
+ [super dealloc];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXECI.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXECI.h
new file mode 100644
index 0000000000000000000000000000000000000000..2dd563b4087e9d98c446aa99d9d57732832057be
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXECI.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Superclass of classes encapsulating types ECIs, according to "Extended Channel Interpretations"
+ * 5.3 of ISO 18004.
+ */
+
+@interface ZXECI : NSObject
+
+@property (nonatomic, readonly) int value;
+
+- (id)initWithValue:(int)value;
++ (ZXECI *)eciByValue:(int)value;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXECI.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXECI.m
new file mode 100644
index 0000000000000000000000000000000000000000..35941b7ca3a3d75e59aeaf3d640912b261b9ed98
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXECI.m
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXCharacterSetECI.h"
+#import "ZXECI.h"
+
+@interface ZXECI ()
+
+@property (nonatomic) int value;
+
+@end
+
+
+@implementation ZXECI
+
+@synthesize value;
+
+- (id)initWithValue:(int)aValue {
+ if (self = [super init]) {
+ self.value = aValue;
+ }
+
+ return self;
+}
+
+
++ (ZXECI *)eciByValue:(int)value {
+ if (value < 0 || value > 999999) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:[NSString stringWithFormat:@"Bad ECI value: %d", value]
+ userInfo:nil];
+ }
+ if (value < 900) {
+ return [ZXCharacterSetECI characterSetECIByValue:value];
+ }
+ return nil;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXGlobalHistogramBinarizer.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXGlobalHistogramBinarizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..d7b54ed8c6d6d2ac30714f992ed66e137e7cb3a5
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXGlobalHistogramBinarizer.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBinarizer.h"
+
+/**
+ * This Binarizer implementation uses the old ZXing global histogram approach. It is suitable
+ * for low-end mobile devices which don't have enough CPU or memory to use a local thresholding
+ * algorithm. However, because it picks a global black point, it cannot handle difficult shadows
+ * and gradients.
+ *
+ * Faster mobile devices and all desktop applications should probably use ZXHybridBinarizer instead.
+ */
+
+@class ZXBitArray, ZXBitMatrix, ZXLuminanceSource;
+
+@interface ZXGlobalHistogramBinarizer : ZXBinarizer
+
+- (ZXBitArray *)blackRow:(int)y row:(ZXBitArray *)row error:(NSError **)error;
+- (ZXBinarizer *)createBinarizer:(ZXLuminanceSource *)source;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXGlobalHistogramBinarizer.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXGlobalHistogramBinarizer.m
new file mode 100644
index 0000000000000000000000000000000000000000..25c2c50a50b3a7f497837d0742f9cdb78ea398b1
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXGlobalHistogramBinarizer.m
@@ -0,0 +1,210 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXGlobalHistogramBinarizer.h"
+#import "ZXBitArray.h"
+#import "ZXBitMatrix.h"
+#import "ZXErrors.h"
+#import "ZXLuminanceSource.h"
+
+int const LUMINANCE_BITS = 5;
+int const LUMINANCE_SHIFT = 8 - LUMINANCE_BITS;
+int const LUMINANCE_BUCKETS = 1 << LUMINANCE_BITS;
+
+@interface ZXGlobalHistogramBinarizer ()
+
+@property (nonatomic, assign) unsigned char *luminances;
+@property (nonatomic, assign) int luminancesCount;
+@property (nonatomic, retain) NSMutableArray *buckets;
+
+- (void)initArrays:(int)luminanceSize;
+- (int)estimateBlackPoint:(NSArray *)buckets;
+
+@end
+
+@implementation ZXGlobalHistogramBinarizer
+
+@synthesize luminances;
+@synthesize luminancesCount;
+@synthesize buckets;
+
+- (id)initWithSource:(ZXLuminanceSource *)source {
+ if (self = [super initWithSource:source]) {
+ self.luminances = NULL;
+ self.luminancesCount = 0;
+ self.buckets = [NSMutableArray arrayWithCapacity:LUMINANCE_BUCKETS];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ if (luminances != NULL) {
+ free(luminances);
+ luminances = NULL;
+ }
+ [buckets release];
+
+ [super dealloc];
+}
+
+- (ZXBitArray *)blackRow:(int)y row:(ZXBitArray *)row error:(NSError **)error {
+ ZXLuminanceSource *source = self.luminanceSource;
+ int width = source.width;
+ if (row == nil || row.size < width) {
+ row = [[[ZXBitArray alloc] initWithSize:width] autorelease];
+ } else {
+ [row clear];
+ }
+
+ [self initArrays:width];
+ unsigned char *localLuminances = [source row:y];
+ NSMutableArray *localBuckets = [NSMutableArray arrayWithArray:buckets];
+ for (int x = 0; x < width; x++) {
+ int pixel = localLuminances[x] & 0xff;
+ [localBuckets replaceObjectAtIndex:pixel >> LUMINANCE_SHIFT
+ withObject:[NSNumber numberWithInt:[[localBuckets objectAtIndex:pixel >> LUMINANCE_SHIFT] intValue] + 1]];
+ }
+ int blackPoint = [self estimateBlackPoint:localBuckets];
+ if (blackPoint == -1) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ int left = localLuminances[0] & 0xff;
+ int center = localLuminances[1] & 0xff;
+ for (int x = 1; x < width - 1; x++) {
+ int right = localLuminances[x + 1] & 0xff;
+ int luminance = ((center << 2) - left - right) >> 1;
+ if (luminance < blackPoint) {
+ [row set:x];
+ }
+ left = center;
+ center = right;
+ }
+
+ return row;
+}
+
+- (ZXBitMatrix *)blackMatrixWithError:(NSError **)error {
+ ZXLuminanceSource *source = self.luminanceSource;
+ int width = source.width;
+ int height = source.height;
+ ZXBitMatrix *matrix = [[[ZXBitMatrix alloc] initWithWidth:width height:height] autorelease];
+
+ [self initArrays:width];
+ NSMutableArray *localBuckets = [NSMutableArray arrayWithArray:self.buckets];
+ for (int y = 1; y < 5; y++) {
+ int row = height * y / 5;
+ unsigned char *localLuminances = [source row:row];
+ int right = (width << 2) / 5;
+ for (int x = width / 5; x < right; x++) {
+ int pixel = localLuminances[x] & 0xff;
+ [localBuckets replaceObjectAtIndex:pixel >> LUMINANCE_SHIFT
+ withObject:[NSNumber numberWithInt:[[localBuckets objectAtIndex:pixel >> LUMINANCE_SHIFT] intValue] + 1]];
+ }
+ }
+ int blackPoint = [self estimateBlackPoint:localBuckets];
+ if (blackPoint == -1) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ unsigned char *localLuminances = source.matrix;
+ for (int y = 0; y < height; y++) {
+ int offset = y * width;
+ for (int x = 0; x < width; x++) {
+ int pixel = localLuminances[offset + x] & 0xff;
+ if (pixel < blackPoint) {
+ [matrix setX:x y:y];
+ }
+ }
+ }
+
+ return matrix;
+}
+
+- (ZXBinarizer *)createBinarizer:(ZXLuminanceSource *)source {
+ return [[[ZXGlobalHistogramBinarizer alloc] initWithSource:source] autorelease];
+}
+
+- (void)initArrays:(int)luminanceSize {
+ if (self.luminances == NULL || self.luminancesCount < luminanceSize) {
+ if (self.luminances != NULL) {
+ free(self.luminances);
+ }
+ self.luminances = (unsigned char *)malloc(luminanceSize * sizeof(unsigned char));
+ self.luminancesCount = luminanceSize;
+ }
+
+ self.buckets = [NSMutableArray arrayWithCapacity:LUMINANCE_BUCKETS];
+ for (int x = 0; x < LUMINANCE_BUCKETS; x++) {
+ [self.buckets addObject:[NSNumber numberWithInt:0]];
+ }
+}
+
+- (int)estimateBlackPoint:(NSArray *)otherBuckets {
+ int numBuckets = [otherBuckets count];
+ int maxBucketCount = 0;
+ int firstPeak = 0;
+ int firstPeakSize = 0;
+
+ for (int x = 0; x < numBuckets; x++) {
+ if ([[otherBuckets objectAtIndex:x] intValue] > firstPeakSize) {
+ firstPeak = x;
+ firstPeakSize = [[otherBuckets objectAtIndex:x] intValue];
+ }
+ if ([[otherBuckets objectAtIndex:x] intValue] > maxBucketCount) {
+ maxBucketCount = [[otherBuckets objectAtIndex:x] intValue];
+ }
+ }
+
+ int secondPeak = 0;
+ int secondPeakScore = 0;
+ for (int x = 0; x < numBuckets; x++) {
+ int distanceToBiggest = x - firstPeak;
+ int score = [[otherBuckets objectAtIndex:x] intValue] * distanceToBiggest * distanceToBiggest;
+ if (score > secondPeakScore) {
+ secondPeak = x;
+ secondPeakScore = score;
+ }
+ }
+
+ if (firstPeak > secondPeak) {
+ int temp = firstPeak;
+ firstPeak = secondPeak;
+ secondPeak = temp;
+ }
+
+ if (secondPeak - firstPeak <= numBuckets >> 4) {
+ return -1;
+ }
+
+ int bestValley = secondPeak - 1;
+ int bestValleyScore = -1;
+ for (int x = secondPeak - 1; x > firstPeak; x--) {
+ int fromFirst = x - firstPeak;
+ int score = fromFirst * fromFirst * (secondPeak - x) * (maxBucketCount - [[otherBuckets objectAtIndex:x] intValue]);
+ if (score > bestValleyScore) {
+ bestValley = x;
+ bestValleyScore = score;
+ }
+ }
+
+ return bestValley << LUMINANCE_SHIFT;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXGridSampler.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXGridSampler.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d331a132b923bfdf862de04e06c715f8fce46f7
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXGridSampler.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Implementations of this class can, given locations of finder patterns for a QR code in an
+ * image, sample the right points in the image to reconstruct the QR code, accounting for
+ * perspective distortion. It is abstracted since it is relatively expensive and should be allowed
+ * to take advantage of platform-specific optimized implementations, like Sun's Java Advanced
+ * Imaging library, but which may not be available in other environments such as J2ME, and vice
+ * versa.
+ *
+ * The implementation used can be controlled by calling {@link #setGridSampler(GridSampler)}
+ * with an instance of a class which implements this interface.
+ */
+
+@class ZXBitMatrix, ZXPerspectiveTransform;
+
+@interface ZXGridSampler : NSObject
+
++ (ZXGridSampler *)instance;
++ (void)setGridSampler:(ZXGridSampler *)newGridSampler;
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)image
+ dimensionX:(int)dimensionX
+ dimensionY:(int)dimensionY
+ p1ToX:(float)p1ToX p1ToY:(float)p1ToY
+ p2ToX:(float)p2ToX p2ToY:(float)p2ToY
+ p3ToX:(float)p3ToX p3ToY:(float)p3ToY
+ p4ToX:(float)p4ToX p4ToY:(float)p4ToY
+ p1FromX:(float)p1FromX p1FromY:(float)p1FromY
+ p2FromX:(float)p2FromX p2FromY:(float)p2FromY
+ p3FromX:(float)p3FromX p3FromY:(float)p3FromY
+ p4FromX:(float)p4FromX p4FromY:(float)p4FromY
+ error:(NSError **)error;
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)image
+ dimensionX:(int)dimensionX
+ dimensionY:(int)dimensionY
+ transform:(ZXPerspectiveTransform *)transform
+ error:(NSError **)error;
++ (BOOL)checkAndNudgePoints:(ZXBitMatrix *)image points:(float *)points pointsLen:(int)pointsLen error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXGridSampler.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXGridSampler.m
new file mode 100644
index 0000000000000000000000000000000000000000..527d040c86b2b86a6cd7f87697bfe1ec48179553
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXGridSampler.m
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXDefaultGridSampler.h"
+#import "ZXErrors.h"
+#import "ZXGridSampler.h"
+#import "ZXPerspectiveTransform.h"
+
+static ZXGridSampler *gridSampler = nil;
+
+@implementation ZXGridSampler
+
+/**
+ * Sets the implementation of GridSampler used by the library. One global
+ * instance is stored, which may sound problematic. But, the implementation provided
+ * ought to be appropriate for the entire platform, and all uses of this library
+ * in the whole lifetime of the JVM. For instance, an Android activity can swap in
+ * an implementation that takes advantage of native platform libraries.
+ */
++ (void) setGridSampler:(ZXGridSampler *)newGridSampler {
+ gridSampler = newGridSampler;
+}
+
++ (ZXGridSampler *)instance {
+ if (!gridSampler) {
+ gridSampler = [[ZXDefaultGridSampler alloc] init];
+ }
+
+ return gridSampler;
+}
+
+/**
+ * Samples an image for a rectangular matrix of bits of the given dimension.
+ */
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)image
+ dimensionX:(int)dimensionX
+ dimensionY:(int)dimensionY
+ p1ToX:(float)p1ToX p1ToY:(float)p1ToY
+ p2ToX:(float)p2ToX p2ToY:(float)p2ToY
+ p3ToX:(float)p3ToX p3ToY:(float)p3ToY
+ p4ToX:(float)p4ToX p4ToY:(float)p4ToY
+ p1FromX:(float)p1FromX p1FromY:(float)p1FromY
+ p2FromX:(float)p2FromX p2FromY:(float)p2FromY
+ p3FromX:(float)p3FromX p3FromY:(float)p3FromY
+ p4FromX:(float)p4FromX p4FromY:(float)p4FromY
+ error:(NSError **)error {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)image
+ dimensionX:(int)dimensionX
+ dimensionY:(int)dimensionY
+ transform:(ZXPerspectiveTransform *)transform
+ error:(NSError **)error {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+
+/**
+ * Checks a set of points that have been transformed to sample points on an image against
+ * the image's dimensions to see if the point are even within the image.
+ *
+ * This method will actually "nudge" the endpoints back onto the image if they are found to be
+ * barely (less than 1 pixel) off the image. This accounts for imperfect detection of finder
+ * patterns in an image where the QR Code runs all the way to the image border.
+ *
+ * For efficiency, the method will check points from either end of the line until one is found
+ * to be within the image. Because the set of points are assumed to be linear, this is valid.
+ */
++ (BOOL)checkAndNudgePoints:(ZXBitMatrix *)image points:(float *)points pointsLen:(int)pointsLen error:(NSError **)error {
+ int width = image.width;
+ int height = image.height;
+
+ BOOL nudged = YES;
+ for (int offset = 0; offset < pointsLen && nudged; offset += 2) {
+ int x = (int) points[offset];
+ int y = (int) points[offset + 1];
+ if (x < -1 || x > width || y < -1 || y > height) {
+ if (error) *error = NotFoundErrorInstance();
+ return NO;
+ }
+ nudged = NO;
+ if (x == -1) {
+ points[offset] = 0.0f;
+ nudged = YES;
+ } else if (x == width) {
+ points[offset] = width - 1;
+ nudged = YES;
+ }
+ if (y == -1) {
+ points[offset + 1] = 0.0f;
+ nudged = YES;
+ } else if (y == height) {
+ points[offset + 1] = height - 1;
+ nudged = YES;
+ }
+ }
+
+ nudged = YES;
+ for (int offset = pointsLen - 2; offset >= 0 && nudged; offset -= 2) {
+ int x = (int) points[offset];
+ int y = (int) points[offset + 1];
+ if (x < -1 || x > width || y < -1 || y > height) {
+ if (error) *error = NotFoundErrorInstance();
+ return NO;
+ }
+ nudged = NO;
+ if (x == -1) {
+ points[offset] = 0.0f;
+ nudged = YES;
+ } else if (x == width) {
+ points[offset] = width - 1;
+ nudged = YES;
+ }
+ if (y == -1) {
+ points[offset + 1] = 0.0f;
+ nudged = YES;
+ } else if (y == height) {
+ points[offset + 1] = height - 1;
+ nudged = YES;
+ }
+ }
+ return YES;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXHybridBinarizer.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXHybridBinarizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..0d723a33f44a69df0922e7fbb5f9c82b5fb35186
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXHybridBinarizer.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXGlobalHistogramBinarizer.h"
+
+/**
+ * This class implements a local thresholding algorithm, which while slower than the
+ * ZXGlobalHistogramBinarizer, is fairly efficient for what it does. It is designed for
+ * high frequency images of barcodes with black data on white backgrounds. For this application,
+ * it does a much better job than a global blackpoint with severe shadows and gradients.
+ * However it tends to produce artifacts on lower frequency images and is therefore not
+ * a good general purpose binarizer for uses outside ZXing.
+ *
+ * This class extends ZXGlobalHistogramBinarizer, using the older histogram approach for 1D readers,
+ * and the newer local approach for 2D readers. 1D decoding using a per-row histogram is already
+ * inherently local, and only fails for horizontal gradients. We can revisit that problem later,
+ * but for now it was not a win to use local blocks for 1D.
+ *
+ * This Binarizer is the default for the unit tests and the recommended class for library users.
+ */
+
+@class ZXBinarizer, ZXBitMatrix, ZXLuminanceSource;
+
+@interface ZXHybridBinarizer : ZXGlobalHistogramBinarizer
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXHybridBinarizer.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXHybridBinarizer.m
new file mode 100644
index 0000000000000000000000000000000000000000..ce39a527fd97143f370e3d95cdc69e2fb71c5ee4
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXHybridBinarizer.m
@@ -0,0 +1,244 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXHybridBinarizer.h"
+
+// This class uses 5x5 blocks to compute local luminance, where each block is 8x8 pixels.
+// So this is the smallest dimension in each axis we can accept.
+const int BLOCK_SIZE_POWER = 3;
+const int BLOCK_SIZE = 1 << BLOCK_SIZE_POWER; // ...0100...00
+const int BLOCK_SIZE_MASK = BLOCK_SIZE - 1; // ...0011...11
+const int MINIMUM_DIMENSION = BLOCK_SIZE * 5;
+const int MIN_DYNAMIC_RANGE = 24;
+
+@interface ZXHybridBinarizer ()
+
+@property (nonatomic, retain) ZXBitMatrix *matrix;
+
+- (int **)calculateBlackPoints:(unsigned char *)luminances subWidth:(int)subWidth subHeight:(int)subHeight width:(int)width height:(int)height;
+- (void)calculateThresholdForBlock:(unsigned char *)luminances subWidth:(int)subWidth subHeight:(int)subHeight width:(int)width height:(int)height blackPoints:(int **)blackPoints matrix:(ZXBitMatrix *)matrix;
+- (int)cap:(int)value min:(int)min max:(int)max;
+- (void)thresholdBlock:(unsigned char *)luminances xoffset:(int)xoffset yoffset:(int)yoffset threshold:(int)threshold stride:(int)stride matrix:(ZXBitMatrix *)matrix;
+
+@end
+
+@implementation ZXHybridBinarizer
+
+@synthesize matrix;
+
+- (id)initWithSource:(ZXLuminanceSource *)aSource {
+ if (self = [super initWithSource:aSource]) {
+ self.matrix = nil;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [matrix release];
+
+ [super dealloc];
+}
+
+/**
+ * Calculates the final BitMatrix once for all requests. This could be called once from the
+ * constructor instead, but there are some advantages to doing it lazily, such as making
+ * profiling easier, and not doing heavy lifting when callers don't expect it.
+ */
+- (ZXBitMatrix *)blackMatrixWithError:(NSError **)error {
+ if (self.matrix != nil) {
+ return self.matrix;
+ }
+ ZXLuminanceSource *source = [self luminanceSource];
+ int width = source.width;
+ int height = source.height;
+ if (width >= MINIMUM_DIMENSION && height >= MINIMUM_DIMENSION) {
+ unsigned char *_luminances = source.matrix;
+ int subWidth = width >> BLOCK_SIZE_POWER;
+ if ((width & BLOCK_SIZE_MASK) != 0) {
+ subWidth++;
+ }
+ int subHeight = height >> BLOCK_SIZE_POWER;
+ if ((height & BLOCK_SIZE_MASK) != 0) {
+ subHeight++;
+ }
+ int **blackPoints = [self calculateBlackPoints:_luminances subWidth:subWidth subHeight:subHeight width:width height:height];
+
+ ZXBitMatrix *newMatrix = [[[ZXBitMatrix alloc] initWithWidth:width height:height] autorelease];
+ [self calculateThresholdForBlock:_luminances subWidth:subWidth subHeight:subHeight width:width height:height blackPoints:blackPoints matrix:newMatrix];
+ self.matrix = newMatrix;
+
+ free(_luminances);
+
+ for (int i = 0; i < subHeight; i++) {
+ free(blackPoints[i]);
+ }
+ free(blackPoints);
+ } else {
+ // If the image is too small, fall back to the global histogram approach.
+ self.matrix = [super blackMatrixWithError:error];
+ }
+ return self.matrix;
+}
+
+- (ZXBinarizer *)createBinarizer:(ZXLuminanceSource *)source {
+ return [[[ZXHybridBinarizer alloc] initWithSource:source] autorelease];
+}
+
+/**
+ * For each block in the image, calculate the average black point using a 5x5 grid
+ * of the blocks around it. Also handles the corner cases (fractional blocks are computed based
+ * on the last pixels in the row/column which are also used in the previous block).
+ */
+- (void)calculateThresholdForBlock:(unsigned char *)_luminances
+ subWidth:(int)subWidth
+ subHeight:(int)subHeight
+ width:(int)width
+ height:(int)height
+ blackPoints:(int **)blackPoints
+ matrix:(ZXBitMatrix *)_matrix {
+ for (int y = 0; y < subHeight; y++) {
+ int yoffset = y << BLOCK_SIZE_POWER;
+ int maxYOffset = height - BLOCK_SIZE;
+ if (yoffset > maxYOffset) {
+ yoffset = maxYOffset;
+ }
+ for (int x = 0; x < subWidth; x++) {
+ int xoffset = x << BLOCK_SIZE_POWER;
+ int maxXOffset = width - BLOCK_SIZE;
+ if (xoffset > maxXOffset) {
+ xoffset = maxXOffset;
+ }
+ int left = [self cap:x min:2 max:subWidth - 3];
+ int top = [self cap:y min:2 max:subHeight - 3];
+ int sum = 0;
+ for (int z = -2; z <= 2; z++) {
+ int *blackRow = blackPoints[top + z];
+ sum += blackRow[left - 2] + blackRow[left - 1] + blackRow[left] + blackRow[left + 1] + blackRow[left + 2];
+ }
+ int average = sum / 25;
+ [self thresholdBlock:_luminances xoffset:xoffset yoffset:yoffset threshold:average stride:width matrix:_matrix];
+ }
+ }
+}
+
+- (int)cap:(int)value min:(int)min max:(int)max {
+ return value < min ? min : value > max ? max : value;
+}
+
+/**
+ * Applies a single threshold to a block of pixels.
+ */
+- (void)thresholdBlock:(unsigned char *)_luminances
+ xoffset:(int)xoffset
+ yoffset:(int)yoffset
+ threshold:(int)threshold
+ stride:(int)stride
+ matrix:(ZXBitMatrix *)_matrix {
+ for (int y = 0, offset = yoffset * stride + xoffset; y < BLOCK_SIZE; y++, offset += stride) {
+ for (int x = 0; x < BLOCK_SIZE; x++) {
+ // Comparison needs to be <= so that black == 0 pixels are black even if the threshold is 0
+ if ((_luminances[offset + x] & 0xFF) <= threshold) {
+ [_matrix setX:xoffset + x y:yoffset + y];
+ }
+ }
+ }
+}
+
+/**
+ * Calculates a single black point for each block of pixels and saves it away.
+ * See the following thread for a discussion of this algorithm:
+ * http://groups.google.com/group/zxing/browse_thread/thread/d06efa2c35a7ddc0
+ */
+- (int **)calculateBlackPoints:(unsigned char *)_luminances
+ subWidth:(int)subWidth
+ subHeight:(int)subHeight
+ width:(int)width
+ height:(int)height {
+ int **blackPoints = (int **)malloc(subHeight * sizeof(int *));
+ for (int y = 0; y < subHeight; y++) {
+ blackPoints[y] = (int *)malloc(subWidth * sizeof(int));
+
+ int yoffset = y << BLOCK_SIZE_POWER;
+ int maxYOffset = height - BLOCK_SIZE;
+ if (yoffset > maxYOffset) {
+ yoffset = maxYOffset;
+ }
+ for (int x = 0; x < subWidth; x++) {
+ int xoffset = x << BLOCK_SIZE_POWER;
+ int maxXOffset = width - BLOCK_SIZE;
+ if (xoffset > maxXOffset) {
+ xoffset = maxXOffset;
+ }
+ int sum = 0;
+ int min = 0xFF;
+ int max = 0;
+ for (int yy = 0, offset = yoffset * width + xoffset; yy < BLOCK_SIZE; yy++, offset += width) {
+ for (int xx = 0; xx < BLOCK_SIZE; xx++) {
+ int pixel = _luminances[offset + xx] & 0xFF;
+ sum += pixel;
+ // still looking for good contrast
+ if (pixel < min) {
+ min = pixel;
+ }
+ if (pixel > max) {
+ max = pixel;
+ }
+ }
+ // short-circuit min/max tests once dynamic range is met
+ if (max - min > MIN_DYNAMIC_RANGE) {
+ // finish the rest of the rows quickly
+ for (yy++, offset += width; yy < BLOCK_SIZE; yy++, offset += width) {
+ for (int xx = 0; xx < BLOCK_SIZE; xx++) {
+ sum += _luminances[offset + xx] & 0xFF;
+ }
+ }
+ }
+ }
+
+ // The default estimate is the average of the values in the block.
+ int average = sum >> (BLOCK_SIZE_POWER * 2);
+ if (max - min <= MIN_DYNAMIC_RANGE) {
+ // If variation within the block is low, assume this is a block with only light or only
+ // dark pixels. In that case we do not want to use the average, as it would divide this
+ // low contrast area into black and white pixels, essentially creating data out of noise.
+ //
+ // The default assumption is that the block is light/background. Since no estimate for
+ // the level of dark pixels exists locally, use half the min for the block.
+ average = min >> 1;
+
+ if (y > 0 && x > 0) {
+ // Correct the "white background" assumption for blocks that have neighbors by comparing
+ // the pixels in this block to the previously calculated black points. This is based on
+ // the fact that dark barcode symbology is always surrounded by some amount of light
+ // background for which reasonable black point estimates were made. The bp estimated at
+ // the boundaries is used for the interior.
+
+ // The (min < bp) is arbitrary but works better than other heuristics that were tried.
+ int averageNeighborBlackPoint = (blackPoints[y - 1][x] + (2 * blackPoints[y][x - 1]) +
+ blackPoints[y - 1][x - 1]) >> 2;
+ if (min < averageNeighborBlackPoint) {
+ average = averageNeighborBlackPoint;
+ }
+ }
+ }
+ blackPoints[y][x] = average;
+ }
+ }
+ return blackPoints;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXPerspectiveTransform.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXPerspectiveTransform.h
new file mode 100644
index 0000000000000000000000000000000000000000..bcb444c35b367ac7615e1a85eb8d571760c05458
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXPerspectiveTransform.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This class implements a perspective transform in two dimensions. Given four source and four
+ * destination points, it will compute the transformation implied between them. The code is based
+ * directly upon section 3.4.2 of George Wolberg's "Digital Image Warping"; see pages 54-56.
+ */
+
+@interface ZXPerspectiveTransform : NSObject
+
++ (ZXPerspectiveTransform *) quadrilateralToQuadrilateral:(float)x0 y0:(float)y0 x1:(float)x1 y1:(float)y1 x2:(float)x2 y2:(float)y2 x3:(float)x3 y3:(float)y3 x0p:(float)x0p y0p:(float)y0p x1p:(float)x1p y1p:(float)y1p x2p:(float)x2p y2p:(float)y2p x3p:(float)x3p y3p:(float)y3p;
+- (void) transformPoints:(float *)points pointsLen:(int)pointsLen;
+- (void) transformPoints:(float *)xValues yValues:(float *)yValues pointsLen:(int)pointsLen;
++ (ZXPerspectiveTransform *) squareToQuadrilateral:(float)x0 y0:(float)y0 x1:(float)x1 y1:(float)y1 x2:(float)x2 y2:(float)y2 x3:(float)x3 y3:(float)y3;
++ (ZXPerspectiveTransform *) quadrilateralToSquare:(float)x0 y0:(float)y0 x1:(float)x1 y1:(float)y1 x2:(float)x2 y2:(float)y2 x3:(float)x3 y3:(float)y3;
+- (ZXPerspectiveTransform *) buildAdjoint;
+- (ZXPerspectiveTransform *) times:(ZXPerspectiveTransform *)other;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXPerspectiveTransform.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXPerspectiveTransform.m
new file mode 100644
index 0000000000000000000000000000000000000000..39a6ffed9ed2b7af7cdd5a21a2c9d04330117318
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXPerspectiveTransform.m
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXPerspectiveTransform.h"
+
+@interface ZXPerspectiveTransform ()
+
+@property (nonatomic, assign) float a11;
+@property (nonatomic, assign) float a12;
+@property (nonatomic, assign) float a13;
+@property (nonatomic, assign) float a21;
+@property (nonatomic, assign) float a22;
+@property (nonatomic, assign) float a23;
+@property (nonatomic, assign) float a31;
+@property (nonatomic, assign) float a32;
+@property (nonatomic, assign) float a33;
+
+@end
+
+@implementation ZXPerspectiveTransform
+
+@synthesize a11;
+@synthesize a12;
+@synthesize a13;
+@synthesize a21;
+@synthesize a22;
+@synthesize a23;
+@synthesize a31;
+@synthesize a32;
+@synthesize a33;
+
+- (id)initWithA11:(float)_a11 a21:(float)_a21 a31:(float)_a31 a12:(float)_a12 a22:(float)_a22 a32:(float)_a32 a13:(float)_a13 a23:(float)_a23 a33:(float)_a33 {
+ if (self = [super init]) {
+ self.a11 = _a11;
+ self.a12 = _a12;
+ self.a13 = _a13;
+ self.a21 = _a21;
+ self.a22 = _a22;
+ self.a23 = _a23;
+ self.a31 = _a31;
+ self.a32 = _a32;
+ self.a33 = _a33;
+ }
+
+ return self;
+}
+
++ (ZXPerspectiveTransform *)quadrilateralToQuadrilateral:(float)x0 y0:(float)y0 x1:(float)x1 y1:(float)y1 x2:(float)x2 y2:(float)y2 x3:(float)x3 y3:(float)y3 x0p:(float)x0p y0p:(float)y0p x1p:(float)x1p y1p:(float)y1p x2p:(float)x2p y2p:(float)y2p x3p:(float)x3p y3p:(float)y3p {
+ ZXPerspectiveTransform *qToS = [self quadrilateralToSquare:x0 y0:y0 x1:x1 y1:y1 x2:x2 y2:y2 x3:x3 y3:y3];
+ ZXPerspectiveTransform *sToQ = [self squareToQuadrilateral:x0p y0:y0p x1:x1p y1:y1p x2:x2p y2:y2p x3:x3p y3:y3p];
+ return [sToQ times:qToS];
+}
+
+- (void)transformPoints:(float *)points pointsLen:(int)pointsLen {
+ int max = pointsLen;
+ for (int i = 0; i < max; i += 2) {
+ float x = points[i];
+ float y = points[i + 1];
+ float denominator = self.a13 * x + self.a23 * y + self.a33;
+ points[i] = (self.a11 * x + self.a21 * y + self.a31) / denominator;
+ points[i + 1] = (self.a12 * x + self.a22 * y + self.a32) / denominator;
+ }
+}
+
+
+/**
+ * Convenience method, not optimized for performance.
+ */
+- (void)transformPoints:(float *)xValues yValues:(float *)yValues pointsLen:(int)pointsLen {
+ int n = pointsLen;
+ for (int i = 0; i < n; i ++) {
+ float x = xValues[i];
+ float y = yValues[i];
+ float denominator = self.a13 * x + self.a23 * y + self.a33;
+ xValues[i] = (self.a11 * x + self.a21 * y + self.a31) / denominator;
+ yValues[i] = (self.a12 * x + self.a22 * y + self.a32) / denominator;
+ }
+}
+
++ (ZXPerspectiveTransform *)squareToQuadrilateral:(float)x0 y0:(float)y0 x1:(float)x1 y1:(float)y1 x2:(float)x2 y2:(float)y2 x3:(float)x3 y3:(float)y3 {
+ float dx3 = x0 - x1 + x2 - x3;
+ float dy3 = y0 - y1 + y2 - y3;
+ if (dx3 == 0.0f && dy3 == 0.0f) {
+ // Affine
+ return [[[ZXPerspectiveTransform alloc] initWithA11:x1 - x0 a21:x2 - x1 a31:x0 a12:y1 - y0 a22:y2 - y1 a32:y0 a13:0.0f a23:0.0f a33:1.0f] autorelease];
+ } else {
+ float dx1 = x1 - x2;
+ float dx2 = x3 - x2;
+ float dy1 = y1 - y2;
+ float dy2 = y3 - y2;
+ float denominator = dx1 * dy2 - dx2 * dy1;
+ float a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
+ float a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
+ return [[[ZXPerspectiveTransform alloc] initWithA11:x1 - x0 + a13 * x1 a21:x3 - x0 + a23 * x3 a31:x0 a12:y1 - y0 + a13 * y1 a22:y3 - y0 + a23 * y3 a32:y0 a13:a13 a23:a23 a33:1.0f] autorelease];
+ }
+}
+
++ (ZXPerspectiveTransform *)quadrilateralToSquare:(float)x0 y0:(float)y0 x1:(float)x1 y1:(float)y1 x2:(float)x2 y2:(float)y2 x3:(float)x3 y3:(float)y3 {
+ return [[self squareToQuadrilateral:x0 y0:y0 x1:x1 y1:y1 x2:x2 y2:y2 x3:x3 y3:y3] buildAdjoint];
+}
+
+- (ZXPerspectiveTransform *)buildAdjoint {
+ return [[[ZXPerspectiveTransform alloc] initWithA11:a22 * a33 - a23 * a32
+ a21:a23 * a31 - a21 * a33
+ a31:a21 * a32 - a22 * a31
+ a12:a13 * a32 - a12 * a33
+ a22:a11 * a33 - a13 * a31
+ a32:a12 * a31 - a11 * a32
+ a13:a12 * a23 - a13 * a22
+ a23:a13 * a21 - a11 * a23
+ a33:a11 * a22 - a12 * a21] autorelease];
+}
+
+- (ZXPerspectiveTransform *)times:(ZXPerspectiveTransform *)other {
+ return [[[ZXPerspectiveTransform alloc] initWithA11:a11 * other->a11 + a21 * other->a12 + a31 * other->a13
+ a21:a11 * other->a21 + a21 * other->a22 + a31 * other->a23
+ a31:a11 * other->a31 + a21 * other->a32 + a31 * other->a33
+ a12:a12 * other->a11 + a22 * other->a12 + a32 * other->a13
+ a22:a12 * other->a21 + a22 * other->a22 + a32 * other->a23
+ a32:a12 * other->a31 + a22 * other->a32 + a32 * other->a33
+ a13:a13 * other->a11 + a23 * other->a12 + a33 * other->a13
+ a23:a13 * other->a21 + a23 * other->a22 + a33 * other->a23
+ a33:a13 * other->a31 + a23 * other->a32 + a33 * other->a33] autorelease];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXStringUtils.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXStringUtils.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf7dd4d20b11bb2108726c37e1b15c689cd26cdf
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXStringUtils.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Common string-related functions.
+ */
+
+@class ZXDecodeHints;
+
+@interface ZXStringUtils : NSObject
+
++ (NSStringEncoding)guessEncoding:(unsigned char *)bytes length:(unsigned int)length hints:(ZXDecodeHints *)hints;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXStringUtils.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXStringUtils.m
new file mode 100644
index 0000000000000000000000000000000000000000..082cd53e2615bd1d362bcc238c5f4c7744f26b80
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/ZXStringUtils.m
@@ -0,0 +1,185 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecodeHints.h"
+#import "ZXStringUtils.h"
+
+@implementation ZXStringUtils
+
++ (NSStringEncoding)guessEncoding:(unsigned char *)bytes length:(unsigned int)length hints:(ZXDecodeHints *)hints {
+ BOOL assumeShiftJIS = CFStringGetSystemEncoding() == NSShiftJISStringEncoding || CFStringGetSystemEncoding() == NSJapaneseEUCStringEncoding;
+
+ if (hints != nil) {
+ NSStringEncoding encoding = hints.encoding;
+ if (encoding > 0) {
+ return encoding;
+ }
+ }
+ // For now, merely tries to distinguish ISO-8859-1, UTF-8 and Shift_JIS,
+ // which should be by far the most common encodings.
+ BOOL canBeISO88591 = YES;
+ BOOL canBeShiftJIS = YES;
+ BOOL canBeUTF8 = YES;
+ int utf8BytesLeft = 0;
+ //int utf8LowChars = 0;
+ int utf2BytesChars = 0;
+ int utf3BytesChars = 0;
+ int utf4BytesChars = 0;
+ int sjisBytesLeft = 0;
+ //int sjisLowChars = 0;
+ int sjisKatakanaChars = 0;
+ //int sjisDoubleBytesChars = 0;
+ int sjisCurKatakanaWordLength = 0;
+ int sjisCurDoubleBytesWordLength = 0;
+ int sjisMaxKatakanaWordLength = 0;
+ int sjisMaxDoubleBytesWordLength = 0;
+ //int isoLowChars = 0;
+ //int isoHighChars = 0;
+ int isoHighOther = 0;
+
+ BOOL utf8bom = length > 3 &&
+ bytes[0] == (unsigned char) 0xEF &&
+ bytes[1] == (unsigned char) 0xBB &&
+ bytes[2] == (unsigned char) 0xBF;
+
+ for (int i = 0;
+ i < length && (canBeISO88591 || canBeShiftJIS || canBeUTF8);
+ i++) {
+
+ int value = bytes[i] & 0xFF;
+
+ // UTF-8 stuff
+ if (canBeUTF8) {
+ if (utf8BytesLeft > 0) {
+ if ((value & 0x80) == 0) {
+ canBeUTF8 = NO;
+ } else {
+ utf8BytesLeft--;
+ }
+ } else if ((value & 0x80) != 0) {
+ if ((value & 0x40) == 0) {
+ canBeUTF8 = NO;
+ } else {
+ utf8BytesLeft++;
+ if ((value & 0x20) == 0) {
+ utf2BytesChars++;
+ } else {
+ utf8BytesLeft++;
+ if ((value & 0x10) == 0) {
+ utf3BytesChars++;
+ } else {
+ utf8BytesLeft++;
+ if ((value & 0x08) == 0) {
+ utf4BytesChars++;
+ } else {
+ canBeUTF8 = NO;
+ }
+ }
+ }
+ }
+ } //else {
+ //utf8LowChars++;
+ //}
+ }
+
+ // ISO-8859-1 stuff
+ if (canBeISO88591) {
+ if (value > 0x7F && value < 0xA0) {
+ canBeISO88591 = NO;
+ } else if (value > 0x9F) {
+ if (value < 0xC0 || value == 0xD7 || value == 0xF7) {
+ isoHighOther++;
+ } //else {
+ //isoHighChars++;
+ //}
+ } //else {
+ //isoLowChars++;
+ //}
+ }
+
+ // Shift_JIS stuff
+ if (canBeShiftJIS) {
+ if (sjisBytesLeft > 0) {
+ if (value < 0x40 || value == 0x7F || value > 0xFC) {
+ canBeShiftJIS = NO;
+ } else {
+ sjisBytesLeft--;
+ }
+ } else if (value == 0x80 || value == 0xA0 || value > 0xEF) {
+ canBeShiftJIS = NO;
+ } else if (value > 0xA0 && value < 0xE0) {
+ sjisKatakanaChars++;
+ sjisCurDoubleBytesWordLength = 0;
+ sjisCurKatakanaWordLength++;
+ if (sjisCurKatakanaWordLength > sjisMaxKatakanaWordLength) {
+ sjisMaxKatakanaWordLength = sjisCurKatakanaWordLength;
+ }
+ } else if (value > 0x7F) {
+ sjisBytesLeft++;
+ //sjisDoubleBytesChars++;
+ sjisCurKatakanaWordLength = 0;
+ sjisCurDoubleBytesWordLength++;
+ if (sjisCurDoubleBytesWordLength > sjisMaxDoubleBytesWordLength) {
+ sjisMaxDoubleBytesWordLength = sjisCurDoubleBytesWordLength;
+ }
+ } else {
+ //sjisLowChars++;
+ sjisCurKatakanaWordLength = 0;
+ sjisCurDoubleBytesWordLength = 0;
+ }
+ }
+ }
+
+ if (canBeUTF8 && utf8BytesLeft > 0) {
+ canBeUTF8 = NO;
+ }
+ if (canBeShiftJIS && sjisBytesLeft > 0) {
+ canBeShiftJIS = NO;
+ }
+
+ // Easy -- if there is BOM or at least 1 valid not-single byte character (and no evidence it can't be UTF-8), done
+ if (canBeUTF8 && (utf8bom || utf2BytesChars + utf3BytesChars + utf4BytesChars > 0)) {
+ return NSUTF8StringEncoding;
+ }
+ // Easy -- if assuming Shift_JIS or at least 3 valid consecutive not-ascii characters (and no evidence it can't be), done
+ if (canBeShiftJIS && (assumeShiftJIS || sjisMaxKatakanaWordLength >= 3 || sjisMaxDoubleBytesWordLength >= 3)) {
+ return NSShiftJISStringEncoding;
+ }
+ // Distinguishing Shift_JIS and ISO-8859-1 can be a little tough for short words. The crude heuristic is:
+ // - If we saw
+ // - only two consecutive katakana chars in the whole text, or
+ // - at least 10% of bytes that could be "upper" not-alphanumeric Latin1,
+ // - then we conclude Shift_JIS, else ISO-8859-1
+ if (canBeISO88591 && canBeShiftJIS) {
+ return (sjisMaxKatakanaWordLength == 2 && sjisKatakanaChars == 2) || isoHighOther * 10 >= length
+ ? NSShiftJISStringEncoding : NSISOLatin1StringEncoding;
+ }
+
+ // Otherwise, try in order ISO-8859-1, Shift JIS, UTF-8 and fall back to default platform encoding
+ if (canBeISO88591) {
+ return NSISOLatin1StringEncoding;
+ }
+ if (canBeShiftJIS) {
+ return NSShiftJISStringEncoding;
+ }
+ if (canBeUTF8) {
+ return NSUTF8StringEncoding;
+ }
+ // Otherwise, we take a wild guess with platform encoding
+ return CFStringGetSystemEncoding();
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXMathUtils.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXMathUtils.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd38da4a2a3978b05c6245b5034e3713016956df
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXMathUtils.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@interface ZXMathUtils : NSObject
+
++ (int)round:(float)d;
++ (float)distance:(float)aX aY:(float)aY bX:(float)bX bY:(float)bY;
++ (float)distanceInt:(int)aX aY:(int)aY bX:(int)bX bY:(int)bY;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXMathUtils.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXMathUtils.m
new file mode 100644
index 0000000000000000000000000000000000000000..6cadbc7af8dfede661c508d58dd9c1575db1f875
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXMathUtils.m
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXMathUtils.h"
+
+@implementation ZXMathUtils
+
++ (int)round:(float)d {
+ return (int)(d + 0.5f);
+}
+
++ (float)distance:(float)aX aY:(float)aY bX:(float)bX bY:(float)bY {
+ float xDiff = aX - bX;
+ float yDiff = aY - bY;
+ return sqrtf(xDiff * xDiff + yDiff * yDiff);
+}
+
++ (float)distanceInt:(int)aX aY:(int)aY bX:(int)bX bY:(int)bY {
+ int xDiff = aX - bX;
+ int yDiff = aY - bY;
+ return sqrtf(xDiff * xDiff + yDiff * yDiff);
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXMonochromeRectangleDetector.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXMonochromeRectangleDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..700218a327c1b0e1f723f774db0b5882cbe2336d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXMonochromeRectangleDetector.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * A somewhat generic detector that looks for a barcode-like rectangular region within an image.
+ * It looks within a mostly white region of an image for a region of black and white, but mostly
+ * black. It returns the four corners of the region, as best it can determine.
+ */
+
+@class ZXBitMatrix;
+
+@interface ZXMonochromeRectangleDetector : NSObject
+
+- (id)initWithImage:(ZXBitMatrix *)image;
+- (NSArray *)detectWithError:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXMonochromeRectangleDetector.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXMonochromeRectangleDetector.m
new file mode 100644
index 0000000000000000000000000000000000000000..0606503196ffb94cf1b596fef87ce0dc2a24b683
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXMonochromeRectangleDetector.m
@@ -0,0 +1,231 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXErrors.h"
+#import "ZXMonochromeRectangleDetector.h"
+#import "ZXResultPoint.h"
+
+int const MONOCHROME_MAX_MODULES = 32;
+
+@interface ZXMonochromeRectangleDetector ()
+
+@property (nonatomic, retain) ZXBitMatrix *image;
+
+- (NSArray *)blackWhiteRange:(int)fixedDimension maxWhiteRun:(int)maxWhiteRun minDim:(int)minDim maxDim:(int)maxDim horizontal:(BOOL)horizontal;
+- (ZXResultPoint *)findCornerFromCenter:(int)centerX deltaX:(int)deltaX left:(int)left right:(int)right centerY:(int)centerY deltaY:(int)deltaY top:(int)top bottom:(int)bottom maxWhiteRun:(int)maxWhiteRun;
+
+@end
+
+
+@implementation ZXMonochromeRectangleDetector
+
+@synthesize image;
+
+- (id)initWithImage:(ZXBitMatrix *)anImage {
+ if (self = [super init]) {
+ self.image = anImage;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [image release];
+
+ [super dealloc];
+}
+
+
+/**
+ * Detects a rectangular region of black and white -- mostly black -- with a region of mostly
+ * white, in an image.
+ *
+ * Returns a ResultPoint NSArray describing the corners of the rectangular region. The first and
+ * last points are opposed on the diagonal, as are the second and third. The first point will be
+ * the topmost point and the last, the bottommost. The second point will be leftmost and the
+ * third, the rightmost
+ */
+- (NSArray *)detectWithError:(NSError **)error {
+ int height = [self.image height];
+ int width = [self.image width];
+ int halfHeight = height >> 1;
+ int halfWidth = width >> 1;
+ int deltaY = MAX(1, height / (MONOCHROME_MAX_MODULES << 3) > 1);
+ int deltaX = MAX(1, width / (MONOCHROME_MAX_MODULES << 3) > 1);
+
+ int top = 0;
+ int bottom = height;
+ int left = 0;
+ int right = width;
+ ZXResultPoint *pointA = [self findCornerFromCenter:halfWidth deltaX:0 left:left right:right
+ centerY:halfHeight deltaY:-deltaY top:top bottom:bottom maxWhiteRun:halfWidth >> 1];
+ if (!pointA) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ top = (int)[pointA y] - 1;
+ ZXResultPoint *pointB = [self findCornerFromCenter:halfWidth deltaX:-deltaX left:left right:right
+ centerY:halfHeight deltaY:0 top:top bottom:bottom maxWhiteRun:halfHeight >> 1];
+ if (!pointB) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ left = (int)[pointB x] - 1;
+ ZXResultPoint *pointC = [self findCornerFromCenter:halfWidth deltaX:deltaX left:left right:right
+ centerY:halfHeight deltaY:0 top:top bottom:bottom maxWhiteRun:halfHeight >> 1];
+ if (!pointC) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ right = (int)[pointC x] + 1;
+ ZXResultPoint *pointD = [self findCornerFromCenter:halfWidth deltaX:0 left:left right:right
+ centerY:halfHeight deltaY:deltaY top:top bottom:bottom maxWhiteRun:halfWidth >> 1];
+ if (!pointD) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ bottom = (int)[pointD y] + 1;
+
+ pointA = [self findCornerFromCenter:halfWidth deltaX:0 left:left right:right
+ centerY:halfHeight deltaY:-deltaY top:top bottom:bottom maxWhiteRun:halfWidth >> 2];
+ if (!pointA) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ return [NSArray arrayWithObjects:pointA, pointB, pointC, pointD, nil];
+}
+
+
+/**
+ * Attempts to locate a corner of the barcode by scanning up, down, left or right from a center
+ * point which should be within the barcode.
+ *
+ * Params:
+ * centerX center's x component (horizontal)
+ * deltaX same as deltaY but change in x per step instead
+ * left minimum value of x
+ * right maximum value of x
+ * centerY center's y component (vertical)
+ * deltaY change in y per step. If scanning up this is negative; down, positive;
+ * left or right, 0
+ * top minimum value of y to search through (meaningless when di == 0)
+ * bottom maximum value of y
+ * maxWhiteRun maximum run of white pixels that can still be considered to be within
+ * the barcode
+ */
+- (ZXResultPoint *)findCornerFromCenter:(int)centerX deltaX:(int)deltaX left:(int)left right:(int)right centerY:(int)centerY deltaY:(int)deltaY top:(int)top bottom:(int)bottom maxWhiteRun:(int)maxWhiteRun {
+ NSArray *lastRange = nil;
+ for (int y = centerY, x = centerX; y < bottom && y >= top && x < right && x >= left; y += deltaY, x += deltaX) {
+ NSArray *range;
+ if (deltaX == 0) {
+ range = [self blackWhiteRange:y maxWhiteRun:maxWhiteRun minDim:left maxDim:right horizontal:YES];
+ } else {
+ range = [self blackWhiteRange:x maxWhiteRun:maxWhiteRun minDim:top maxDim:bottom horizontal:NO];
+ }
+ if (range == nil) {
+ if (lastRange == nil) {
+ return nil;
+ }
+ if (deltaX == 0) {
+ int lastY = y - deltaY;
+ if ([[lastRange objectAtIndex:0] intValue] < centerX) {
+ if ([[lastRange objectAtIndex:0] intValue] > centerX) {
+ return [[[ZXResultPoint alloc] initWithX:deltaY > 0 ? [[lastRange objectAtIndex:0] intValue] : [[lastRange objectAtIndex:1] intValue] y:lastY] autorelease];
+ }
+ return [[[ZXResultPoint alloc] initWithX:[[lastRange objectAtIndex:0] intValue] y:lastY] autorelease];
+ } else {
+ return [[[ZXResultPoint alloc] initWithX:[[lastRange objectAtIndex:1] intValue] y:lastY] autorelease];
+ }
+ } else {
+ int lastX = x - deltaX;
+ if ([[lastRange objectAtIndex:0] intValue] < centerY) {
+ if ([[lastRange objectAtIndex:1] intValue] > centerY) {
+ return [[[ZXResultPoint alloc] initWithX:lastX y:deltaX < 0 ? [[lastRange objectAtIndex:0] intValue] : [[lastRange objectAtIndex:1] intValue]] autorelease];
+ }
+ return [[[ZXResultPoint alloc] initWithX:lastX y:[[lastRange objectAtIndex:0] intValue]] autorelease];
+ } else {
+ return [[[ZXResultPoint alloc] initWithX:lastX y:[[lastRange objectAtIndex:1] intValue]] autorelease];
+ }
+ }
+ }
+ lastRange = range;
+ }
+
+ return nil;
+}
+
+
+/**
+ * Computes the start and end of a region of pixels, either horizontally or vertically, that could
+ * be part of a Data Matrix barcode.
+ *
+ * Params:
+ * fixedDimension if scanning horizontally, this is the row (the fixed vertical location)
+ * where we are scanning. If scanning vertically it's the column, the fixed horizontal location
+ * maxWhiteRun largest run of white pixels that can still be considered part of the
+ * barcode region
+ * minDim minimum pixel location, horizontally or vertically, to consider
+ * maxDim maximum pixel location, horizontally or vertically, to consider
+ * horizontal if true, we're scanning left-right, instead of up-down
+ */
+- (NSArray *)blackWhiteRange:(int)fixedDimension maxWhiteRun:(int)maxWhiteRun minDim:(int)minDim maxDim:(int)maxDim horizontal:(BOOL)horizontal {
+ int center = (minDim + maxDim) >> 1;
+
+ int start = center;
+ while (start >= minDim) {
+ if (horizontal ? [self.image getX:start y:fixedDimension] : [self.image getX:fixedDimension y:start]) {
+ start--;
+ } else {
+ int whiteRunStart = start;
+
+ do {
+ start--;
+ } while (start >= minDim && !(horizontal ? [self.image getX:start y:fixedDimension] : [self.image getX:fixedDimension y:start]));
+ int whiteRunSize = whiteRunStart - start;
+ if (start < minDim || whiteRunSize > maxWhiteRun) {
+ start = whiteRunStart;
+ break;
+ }
+ }
+ }
+
+ start++;
+ int end = center;
+
+ while (end < maxDim) {
+ if (horizontal ? [self.image getX:end y:fixedDimension] : [self.image getX:fixedDimension y:end]) {
+ end++;
+ } else {
+ int whiteRunStart = end;
+
+ do {
+ end++;
+ } while (end < maxDim && !(horizontal ? [self.image getX:end y:fixedDimension] : [self.image getX:fixedDimension y:end]));
+ int whiteRunSize = end - whiteRunStart;
+ if (end >= maxDim || whiteRunSize > maxWhiteRun) {
+ end = whiteRunStart;
+ break;
+ }
+ }
+ }
+
+ end--;
+ return end > start ? [NSArray arrayWithObjects:[NSNumber numberWithInt:start], [NSNumber numberWithInt:end], nil] : nil;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXWhiteRectangleDetector.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXWhiteRectangleDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..08c5adffb968381cbbfd03f3c7d8777ed2cffbf0
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXWhiteRectangleDetector.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultPoint.h"
+#import "ZXBitMatrix.h"
+
+/**
+ * Detects a candidate barcode-like rectangular region within an image. It
+ * starts around the center of the image, increases the size of the candidate
+ * region until it finds a white rectangular region. By keeping track of the
+ * last black points it encountered, it determines the corners of the barcode.
+ */
+
+@interface ZXWhiteRectangleDetector : NSObject
+
+- (id)initWithImage:(ZXBitMatrix *)image error:(NSError **)error;
+- (id)initWithImage:(ZXBitMatrix *)image initSize:(int)initSize x:(int)x y:(int)y error:(NSError **)error;
+- (NSArray *)detectWithError:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXWhiteRectangleDetector.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXWhiteRectangleDetector.m
new file mode 100644
index 0000000000000000000000000000000000000000..779e517e149d38657b863df08ff3a781665c10d5
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/detector/ZXWhiteRectangleDetector.m
@@ -0,0 +1,330 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXErrors.h"
+#import "ZXMathUtils.h"
+#import "ZXWhiteRectangleDetector.h"
+
+@interface ZXWhiteRectangleDetector ()
+
+@property (nonatomic, retain) ZXBitMatrix *image;
+@property (nonatomic, assign) int height;
+@property (nonatomic, assign) int width;
+@property (nonatomic, assign) int leftInit;
+@property (nonatomic, assign) int rightInit;
+@property (nonatomic, assign) int downInit;
+@property (nonatomic, assign) int upInit;
+
+- (NSArray *)centerEdges:(ZXResultPoint *)y z:(ZXResultPoint *)z x:(ZXResultPoint *)x t:(ZXResultPoint *)t;
+- (BOOL)containsBlackPoint:(int)a b:(int)b fixed:(int)fixed horizontal:(BOOL)horizontal;
+- (ZXResultPoint *)blackPointOnSegment:(float)aX aY:(float)aY bX:(float)bX bY:(float)bY;
+
+@end
+
+int const INIT_SIZE = 30;
+int const CORR = 1;
+
+@implementation ZXWhiteRectangleDetector
+
+@synthesize image;
+@synthesize height;
+@synthesize width;
+@synthesize leftInit;
+@synthesize rightInit;
+@synthesize downInit;
+@synthesize upInit;
+
+- (id)initWithImage:(ZXBitMatrix *)anImage error:(NSError **)error {
+ if (self = [super init]) {
+ self.image = anImage;
+ self.height = anImage.height;
+ self.width = anImage.width;
+ self.leftInit = (self.width - INIT_SIZE) >> 1;
+ self.rightInit = (self.width + INIT_SIZE) >> 1;
+ self.upInit = (self.height - INIT_SIZE) >> 1;
+ self.downInit = (self.height + INIT_SIZE) >> 1;
+ if (self.upInit < 0 || self.leftInit < 0 || self.downInit >= self.height || self.rightInit >= self.width) {
+ [self release];
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ }
+
+ return self;
+}
+
+- (id)initWithImage:(ZXBitMatrix *)anImage initSize:(int)initSize x:(int)x y:(int)y error:(NSError **)error {
+ if (self = [super init]) {
+ self.image = anImage;
+ self.height = anImage.height;
+ self.width = anImage.width;
+ int halfsize = initSize >> 1;
+ self.leftInit = x - halfsize;
+ self.rightInit = x + halfsize;
+ self.upInit = y - halfsize;
+ self.downInit = y + halfsize;
+ if (self.upInit < 0 || self.leftInit < 0 || self.downInit >= self.height || self.rightInit >= self.width) {
+ [self release];
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [image release];
+
+ [super dealloc];
+}
+
+/**
+ * Detects a candidate barcode-like rectangular region within an image. It
+ * starts around the center of the image, increases the size of the candidate
+ * region until it finds a white rectangular region.
+ *
+ * Returns a ResultPoint NSArray describing the corners of the rectangular
+ * region. The first and last points are opposed on the diagonal, as
+ * are the second and third. The first point will be the topmost
+ * point and the last, the bottommost. The second point will be
+ * leftmost and the third, the rightmost
+ */
+- (NSArray *)detectWithError:(NSError **)error {
+ int left = self.leftInit;
+ int right = self.rightInit;
+ int up = self.upInit;
+ int down = self.downInit;
+ BOOL sizeExceeded = NO;
+ BOOL aBlackPointFoundOnBorder = YES;
+ BOOL atLeastOneBlackPointFoundOnBorder = NO;
+
+ while (aBlackPointFoundOnBorder) {
+ aBlackPointFoundOnBorder = NO;
+
+ // .....
+ // . |
+ // .....
+ BOOL rightBorderNotWhite = YES;
+ while (rightBorderNotWhite && right < self.width) {
+ rightBorderNotWhite = [self containsBlackPoint:up b:down fixed:right horizontal:NO];
+ if (rightBorderNotWhite) {
+ right++;
+ aBlackPointFoundOnBorder = YES;
+ }
+ }
+
+ if (right >= self.width) {
+ sizeExceeded = YES;
+ break;
+ }
+
+ // .....
+ // . .
+ // .___.
+ BOOL bottomBorderNotWhite = YES;
+ while (bottomBorderNotWhite && down < self.height) {
+ bottomBorderNotWhite = [self containsBlackPoint:left b:right fixed:down horizontal:YES];
+ if (bottomBorderNotWhite) {
+ down++;
+ aBlackPointFoundOnBorder = YES;
+ }
+ }
+
+ if (down >= self.height) {
+ sizeExceeded = YES;
+ break;
+ }
+
+ // .....
+ // | .
+ // .....
+ BOOL leftBorderNotWhite = YES;
+ while (leftBorderNotWhite && left >= 0) {
+ leftBorderNotWhite = [self containsBlackPoint:up b:down fixed:left horizontal:NO];
+ if (leftBorderNotWhite) {
+ left--;
+ aBlackPointFoundOnBorder = YES;
+ }
+ }
+
+ if (left < 0) {
+ sizeExceeded = YES;
+ break;
+ }
+
+ // .___.
+ // . .
+ // .....
+ BOOL topBorderNotWhite = YES;
+ while (topBorderNotWhite && up >= 0) {
+ topBorderNotWhite = [self containsBlackPoint:left b:right fixed:up horizontal:YES];
+ if (topBorderNotWhite) {
+ up--;
+ aBlackPointFoundOnBorder = YES;
+ }
+ }
+
+ if (up < 0) {
+ sizeExceeded = YES;
+ break;
+ }
+
+ if (aBlackPointFoundOnBorder) {
+ atLeastOneBlackPointFoundOnBorder = YES;
+ }
+ }
+
+ if (!sizeExceeded && atLeastOneBlackPointFoundOnBorder) {
+ int maxSize = right - left;
+
+ ZXResultPoint *z = nil;
+ for (int i = 1; i < maxSize; i++) {
+ z = [self blackPointOnSegment:left aY:down - i bX:left + i bY:down];
+ if (z != nil) {
+ break;
+ }
+ }
+
+ if (z == nil) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ ZXResultPoint *t = nil;
+ for (int i = 1; i < maxSize; i++) {
+ t = [self blackPointOnSegment:left aY:up + i bX:left + i bY:up];
+ if (t != nil) {
+ break;
+ }
+ }
+
+ if (t == nil) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ ZXResultPoint *x = nil;
+ for (int i = 1; i < maxSize; i++) {
+ x = [self blackPointOnSegment:right aY:up + i bX:right - i bY:up];
+ if (x != nil) {
+ break;
+ }
+ }
+
+ if (x == nil) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ ZXResultPoint *y = nil;
+ for (int i = 1; i < maxSize; i++) {
+ y = [self blackPointOnSegment:right aY:down - i bX:right - i bY:down];
+ if (y != nil) {
+ break;
+ }
+ }
+
+ if (y == nil) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ return [self centerEdges:y z:z x:x t:t];
+ } else {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+}
+
+
+- (ZXResultPoint *)blackPointOnSegment:(float)aX aY:(float)aY bX:(float)bX bY:(float)bY {
+ int dist = [ZXMathUtils round:[ZXMathUtils distance:aX aY:aY bX:bX bY:bY]];
+ float xStep = (bX - aX) / dist;
+ float yStep = (bY - aY) / dist;
+
+ for (int i = 0; i < dist; i++) {
+ int x = [ZXMathUtils round:aX + i * xStep];
+ int y = [ZXMathUtils round:aY + i * yStep];
+ if ([self.image getX:x y:y]) {
+ return [[[ZXResultPoint alloc] initWithX:x y:y] autorelease];
+ }
+ }
+
+ return nil;
+}
+
+/**
+ * recenters the points of a constant distance towards the center
+ *
+ * returns a ResultPoint NSArray describing the corners of the rectangular
+ * region. The first and last points are opposed on the diagonal, as
+ * are the second and third. The first point will be the topmost
+ * point and the last, the bottommost. The second point will be
+ * leftmost and the third, the rightmost
+ */
+- (NSArray *)centerEdges:(ZXResultPoint *)y z:(ZXResultPoint *)z x:(ZXResultPoint *)x t:(ZXResultPoint *)t {
+ //
+ // t t
+ // z x
+ // x OR z
+ // y y
+ //
+
+ float yi = y.x;
+ float yj = y.y;
+ float zi = z.x;
+ float zj = z.y;
+ float xi = x.x;
+ float xj = x.y;
+ float ti = t.x;
+ float tj = t.y;
+
+ if (yi < self.width / 2.0f) {
+ return [NSArray arrayWithObjects:[[[ZXResultPoint alloc] initWithX:ti - CORR y:tj + CORR] autorelease],
+ [[[ZXResultPoint alloc] initWithX:zi + CORR y:zj + CORR] autorelease],
+ [[[ZXResultPoint alloc] initWithX:xi - CORR y:xj - CORR] autorelease],
+ [[[ZXResultPoint alloc] initWithX:yi + CORR y:yj - CORR] autorelease], nil];
+ } else {
+ return [NSArray arrayWithObjects:[[[ZXResultPoint alloc] initWithX:ti + CORR y:tj + CORR] autorelease],
+ [[[ZXResultPoint alloc] initWithX:zi + CORR y:zj - CORR] autorelease],
+ [[[ZXResultPoint alloc] initWithX:xi - CORR y:xj + CORR] autorelease],
+ [[[ZXResultPoint alloc] initWithX:yi - CORR y:yj - CORR] autorelease], nil];
+ }
+}
+
+
+/**
+ * Determines whether a segment contains a black point
+ */
+- (BOOL)containsBlackPoint:(int)a b:(int)b fixed:(int)fixed horizontal:(BOOL)horizontal {
+ if (horizontal) {
+ for (int x = a; x <= b; x++) {
+ if ([self.image getX:x y:fixed]) {
+ return YES;
+ }
+ }
+ } else {
+ for (int y = a; y <= b; y++) {
+ if ([self.image getX:fixed y:y]) {
+ return YES;
+ }
+ }
+ }
+
+ return NO;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXGenericGF.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXGenericGF.h
new file mode 100644
index 0000000000000000000000000000000000000000..0187c9b1f8e0f4f1878dae563b3a097494bd4d1a
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXGenericGF.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This class contains utility methods for performing mathematical operations over
+ * the Galois Fields. Operations use a given primitive polynomial in calculations.
+ *
+ * Throughout this package, elements of the GF are represented as an int
+ * for convenience and speed (but at the cost of memory).
+ */
+
+@class ZXGenericGFPoly;
+
+@interface ZXGenericGF : NSObject
+
+@property (nonatomic, retain, readonly) ZXGenericGFPoly *zero;
+@property (nonatomic, retain, readonly) ZXGenericGFPoly *one;
+@property (nonatomic, assign, readonly) int size;
+@property (nonatomic, assign, readonly) int generatorBase;
+
++ (ZXGenericGF *)AztecData12;
++ (ZXGenericGF *)AztecData10;
++ (ZXGenericGF *)AztecData6;
++ (ZXGenericGF *)AztecParam;
++ (ZXGenericGF *)QrCodeField256;
++ (ZXGenericGF *)DataMatrixField256;
++ (ZXGenericGF *)AztecData8;
++ (ZXGenericGF *)MaxiCodeField64;
+
+- (id)initWithPrimitive:(int)primitive size:(int)size b:(int)b;
+- (ZXGenericGFPoly *)buildMonomial:(int)degree coefficient:(int)coefficient;
++ (int)addOrSubtract:(int)a b:(int)b;
+- (int)exp:(int)a;
+- (int)log:(int)a;
+- (int)inverse:(int)a;
+- (int)multiply:(int)a b:(int)b;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXGenericGF.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXGenericGF.m
new file mode 100644
index 0000000000000000000000000000000000000000..6c1f61c8e617c05aa9fbb0843aa46bbbac1ad40d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXGenericGF.m
@@ -0,0 +1,197 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXGenericGF.h"
+#import "ZXGenericGFPoly.h"
+
+@interface ZXGenericGF ()
+
+@property (nonatomic, retain) ZXGenericGFPoly *zero;
+@property (nonatomic, retain) ZXGenericGFPoly *one;
+@property (nonatomic, assign) int size;
+@property (nonatomic, assign) int *expTable;
+@property (nonatomic, assign) int *logTable;
+@property (nonatomic, assign) int primitive;
+@property (nonatomic, assign) int generatorBase;
+
+@end
+
+@implementation ZXGenericGF
+
+@synthesize zero;
+@synthesize one;
+@synthesize size;
+@synthesize expTable;
+@synthesize logTable;
+@synthesize primitive;
+@synthesize generatorBase;
+
+/**
+ * Create a representation of GF(size) using the given primitive polynomial.
+ */
+- (id)initWithPrimitive:(int)aPrimitive size:(int)aSize b:(int)b {
+ if (self = [super init]) {
+ self.primitive = aPrimitive;
+ self.size = aSize;
+ self.generatorBase = b;
+ self.expTable = (int *)malloc(size * sizeof(int));
+ self.logTable = (int *)malloc(size * sizeof(int));
+ int x = 1;
+ for (int i = 0; i < size; i++) {
+ expTable[i] = x;
+ x <<= 1; // x = x * 2; we're assuming the generator alpha is 2
+ if (x >= size) {
+ x ^= primitive;
+ x &= size - 1;
+ }
+ }
+
+ for (int i = 0; i < self.size-1; i++) {
+ logTable[expTable[i]] = i;
+ }
+ // logTable[0] == 0 but this should never be used
+ self.zero = [[[ZXGenericGFPoly alloc] initWithField:self coefficients:NULL coefficientsLen:0] autorelease];
+ int oneInt = 1;
+ self.one = [[[ZXGenericGFPoly alloc] initWithField:self coefficients:&oneInt coefficientsLen:1] autorelease];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ free(expTable);
+ free(logTable);
+ [zero release];
+ [one release];
+
+ [super dealloc];
+}
+
++ (ZXGenericGF *)AztecData12 {
+ static ZXGenericGF *AztecData12 = nil;
+ if (!AztecData12) {
+ AztecData12 = [[ZXGenericGF alloc] initWithPrimitive:0x1069 size:4096 b:1]; // x^12 + x^6 + x^5 + x^3 + 1
+ }
+ return AztecData12;
+}
+
++ (ZXGenericGF *)AztecData10 {
+ static ZXGenericGF *AztecData10 = nil;
+ if (!AztecData10) {
+ AztecData10 = [[ZXGenericGF alloc] initWithPrimitive:0x409 size:1024 b:1]; // x^10 + x^3 + 1
+ }
+ return AztecData10;
+}
+
++ (ZXGenericGF *)AztecData6 {
+ static ZXGenericGF *AztecData6 = nil;
+ if (!AztecData6) {
+ AztecData6 = [[ZXGenericGF alloc] initWithPrimitive:0x43 size:64 b:1]; // x^6 + x + 1
+ }
+ return AztecData6;
+}
+
++ (ZXGenericGF *)AztecParam {
+ static ZXGenericGF *AztecParam = nil;
+ if (!AztecParam) {
+ AztecParam = [[ZXGenericGF alloc] initWithPrimitive:0x13 size:16 b:1]; // x^4 + x + 1
+ }
+ return AztecParam;
+}
+
++ (ZXGenericGF *)QrCodeField256 {
+ static ZXGenericGF *QrCodeField256 = nil;
+ if (!QrCodeField256) {
+ QrCodeField256 = [[ZXGenericGF alloc] initWithPrimitive:0x011D size:256 b:0]; // x^8 + x^4 + x^3 + x^2 + 1
+ }
+ return QrCodeField256;
+}
+
++ (ZXGenericGF *)DataMatrixField256 {
+ static ZXGenericGF *DataMatrixField256 = nil;
+ if (!DataMatrixField256) {
+ DataMatrixField256 = [[ZXGenericGF alloc] initWithPrimitive:0x012D size:256 b:1]; // x^8 + x^5 + x^3 + x^2 + 1
+ }
+ return DataMatrixField256;
+}
+
++ (ZXGenericGF *)AztecData8 {
+ return [self DataMatrixField256];
+}
+
++ (ZXGenericGF *)MaxiCodeField64 {
+ return [self AztecData6];
+}
+
+- (ZXGenericGFPoly *)buildMonomial:(int)degree coefficient:(int)coefficient {
+ if (degree < 0) {
+ [NSException raise:NSInvalidArgumentException format:@"Degree must be greater than 0."];
+ }
+ if (coefficient == 0) {
+ return zero;
+ }
+
+ int coefficientsLen = degree + 1;
+ int coefficients[coefficientsLen];
+ coefficients[0] = coefficient;
+ for (int i = 1; i < coefficientsLen; i++) {
+ coefficients[i] = 0;
+ }
+ return [[[ZXGenericGFPoly alloc] initWithField:self coefficients:coefficients coefficientsLen:coefficientsLen] autorelease];
+}
+
+/**
+ * Implements both addition and subtraction -- they are the same in GF(size).
+ */
++ (int)addOrSubtract:(int)a b:(int)b {
+ return a ^ b;
+}
+
+- (int)exp:(int)a {
+ return expTable[a];
+}
+
+- (int)log:(int)a {
+ if (a == 0) {
+ [NSException raise:NSInvalidArgumentException format:@"Argument must be non-zero."];
+ }
+ return logTable[a];
+}
+
+- (int)inverse:(int)a {
+ if (a == 0) {
+ [NSException raise:NSInvalidArgumentException format:@"Argument must be non-zero."];
+ }
+ return self.expTable[self.size - self.logTable[a] - 1];
+}
+
+- (int)multiply:(int)a b:(int)b {
+ if (a == 0 || b == 0) {
+ return 0;
+ }
+
+ return expTable[(logTable[a] + logTable[b]) % (size - 1)];
+}
+
+- (BOOL)isEqual:(ZXGenericGF *)object {
+ return self.primitive == object->primitive && self.size == object->size;
+}
+
+- (NSString *)description {
+ return [NSString stringWithFormat:@"GF(0x%X,%d)", self.primitive, self.size];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXGenericGFPoly.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXGenericGFPoly.h
new file mode 100644
index 0000000000000000000000000000000000000000..faca70b8e09ae5e517ea92f1032b33a801a080b9
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXGenericGFPoly.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Represents a polynomial whose coefficients are elements of a GF.
+ * Instances of this class are immutable.
+ *
+ * Much credit is due to William Rucklidge since portions of this code are an indirect
+ * port of his C++ Reed-Solomon implementation.
+ */
+
+@class ZXGenericGF;
+
+@interface ZXGenericGFPoly : NSObject
+
+@property (nonatomic, assign, readonly) int *coefficients;
+@property (nonatomic, assign, readonly) int coefficientsLen;
+
+- (id)initWithField:(ZXGenericGF *)field coefficients:(int *)coefficients coefficientsLen:(int)coefficientsLen;
+- (int)degree;
+- (BOOL)zero;
+- (int)coefficient:(int)degree;
+- (int)evaluateAt:(int)a;
+- (ZXGenericGFPoly *)addOrSubtract:(ZXGenericGFPoly *)other;
+- (ZXGenericGFPoly *)multiply:(ZXGenericGFPoly *)other;
+- (ZXGenericGFPoly *)multiplyScalar:(int)scalar;
+- (ZXGenericGFPoly *)multiplyByMonomial:(int)degree coefficient:(int)coefficient;
+- (NSArray *)divide:(ZXGenericGFPoly *)other;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXGenericGFPoly.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXGenericGFPoly.m
new file mode 100644
index 0000000000000000000000000000000000000000..7162da9573b71fd6d2c0149c69e061e05f2767c8
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXGenericGFPoly.m
@@ -0,0 +1,266 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXGenericGF.h"
+#import "ZXGenericGFPoly.h"
+
+@interface ZXGenericGFPoly ()
+
+@property (nonatomic, assign) int *coefficients;
+@property (nonatomic, assign) int coefficientsLen;
+@property (nonatomic, retain) ZXGenericGF *field;
+
+@end
+
+
+@implementation ZXGenericGFPoly
+
+@synthesize coefficients;
+@synthesize coefficientsLen;
+@synthesize field;
+
+- (id)initWithField:(ZXGenericGF *)aField coefficients:(int *)aCoefficients coefficientsLen:(int)aCoefficientsLen {
+ if (self = [super init]) {
+ self.field = aField;
+ if (aCoefficientsLen > 1 && aCoefficients[0] == 0) {
+ int firstNonZero = 1;
+ while (firstNonZero < aCoefficientsLen && aCoefficients[firstNonZero] == 0) {
+ firstNonZero++;
+ }
+ if (firstNonZero == aCoefficientsLen) {
+ ZXGenericGFPoly *zero = [field zero];
+ self.coefficients = (int *)malloc(zero.coefficientsLen * sizeof(int));
+ memcpy(self.coefficients, zero.coefficients, zero.coefficientsLen * sizeof(int));
+ self.coefficientsLen = zero.coefficientsLen;
+ } else {
+ self.coefficientsLen = (aCoefficientsLen - firstNonZero);
+ self.coefficients = (int *)malloc(self.coefficientsLen * sizeof(int));
+ for (int i = 0; i < self.coefficientsLen; i++) {
+ self.coefficients[i] = aCoefficients[firstNonZero + i];
+ }
+ }
+ } else {
+ self.coefficients = (int *)malloc(aCoefficientsLen * sizeof(int));
+ memcpy(self.coefficients, aCoefficients, aCoefficientsLen * sizeof(int));
+ self.coefficientsLen = aCoefficientsLen;
+ }
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ if (self.coefficients != NULL) {
+ free(self.coefficients);
+ self.coefficients = NULL;
+ }
+ [field release];
+
+ [super dealloc];
+}
+
+
+- (int)degree {
+ return self.coefficientsLen - 1;
+}
+
+- (BOOL)zero {
+ return self.coefficients[0] == 0;
+}
+
+- (int)coefficient:(int)degree {
+ return self.coefficients[self.coefficientsLen - 1 - degree];
+}
+
+- (int)evaluateAt:(int)a {
+ if (a == 0) {
+ return [self coefficient:0];
+ }
+ int size = self.coefficientsLen;
+ if (a == 1) {
+ int result = 0;
+ for (int i = 0; i < size; i++) {
+ result = [ZXGenericGF addOrSubtract:result b:coefficients[i]];
+ }
+ return result;
+ }
+ int result = coefficients[0];
+ for (int i = 1; i < size; i++) {
+ result = [ZXGenericGF addOrSubtract:[field multiply:a b:result] b:coefficients[i]];
+ }
+ return result;
+}
+
+- (ZXGenericGFPoly *)addOrSubtract:(ZXGenericGFPoly *)other {
+ if (![self.field isEqual:other->field]) {
+ [NSException raise:NSInvalidArgumentException format:@"ZXGenericGFPolys do not have same ZXGenericGF field"];
+ }
+ if (self.zero) {
+ return other;
+ }
+ if (other.zero) {
+ return self;
+ }
+
+ int *smallerCoefficients = self.coefficients;
+ int smallerCoefficientsLen = self.coefficientsLen;
+ int *largerCoefficients = other.coefficients;
+ int largerCoefficientsLen = other.coefficientsLen;
+ if (smallerCoefficientsLen > largerCoefficientsLen) {
+ int *temp = smallerCoefficients;
+ int tempLen = smallerCoefficientsLen;
+ smallerCoefficients = largerCoefficients;
+ smallerCoefficientsLen = largerCoefficientsLen;
+ largerCoefficients = temp;
+ largerCoefficientsLen = tempLen;
+ }
+ int sumDiff[largerCoefficientsLen];
+ int lengthDiff = largerCoefficientsLen - smallerCoefficientsLen;
+ for (int i = 0; i < lengthDiff; i++) {
+ sumDiff[i] = largerCoefficients[i];
+ }
+ for (int i = lengthDiff; i < largerCoefficientsLen; i++) {
+ sumDiff[i] = [ZXGenericGF addOrSubtract:smallerCoefficients[i - lengthDiff] b:largerCoefficients[i]];
+ }
+
+ return [[[ZXGenericGFPoly alloc] initWithField:self.field coefficients:sumDiff coefficientsLen:largerCoefficientsLen] autorelease];
+}
+
+- (ZXGenericGFPoly *) multiply:(ZXGenericGFPoly *)other {
+ if (![self.field isEqual:other->field]) {
+ [NSException raise:NSInvalidArgumentException format:@"ZXGenericGFPolys do not have same GenericGF field"];
+ }
+ if (self.zero || other.zero) {
+ return self.field.zero;
+ }
+ int *aCoefficients = self.coefficients;
+ int aLength = self.coefficientsLen;
+ int *bCoefficients = other.coefficients;
+ int bLength = other.coefficientsLen;
+ int productLen = aLength + bLength - 1;
+ int product[productLen];
+ memset(product, 0, productLen * sizeof(int));
+
+ for (int i = 0; i < aLength; i++) {
+ int aCoeff = aCoefficients[i];
+ for (int j = 0; j < bLength; j++) {
+ product[i + j] = [ZXGenericGF addOrSubtract:product[i + j]
+ b:[field multiply:aCoeff b:bCoefficients[j]]];
+ }
+ }
+ return [[[ZXGenericGFPoly alloc] initWithField:field coefficients:product coefficientsLen:productLen] autorelease];
+}
+
+- (ZXGenericGFPoly *)multiplyScalar:(int)scalar {
+ if (scalar == 0) {
+ return self.field.zero;
+ }
+ if (scalar == 1) {
+ return self;
+ }
+ int size = self.coefficientsLen;
+ int product[size];
+ for (int i = 0; i < size; i++) {
+ product[i] = [self.field multiply:self.coefficients[i] b:scalar];
+ }
+ return [[[ZXGenericGFPoly alloc] initWithField:self.field coefficients:product coefficientsLen:size] autorelease];
+}
+
+- (ZXGenericGFPoly *)multiplyByMonomial:(int)degree coefficient:(int)coefficient {
+ if (degree < 0) {
+ [NSException raise:NSInvalidArgumentException format:@"Degree must be greater than 0."];
+ }
+ if (coefficient == 0) {
+ return self.field.zero;
+ }
+ int size = self.coefficientsLen;
+ int product[size + degree];
+ for (int i = 0; i < size + degree; i++) {
+ if (i < size) {
+ product[i] = [self.field multiply:self.coefficients[i] b:coefficient];
+ } else {
+ product[i] = 0;
+ }
+ }
+
+ return [[[ZXGenericGFPoly alloc] initWithField:self.field coefficients:product coefficientsLen:size + degree] autorelease];
+}
+
+- (NSArray *)divide:(ZXGenericGFPoly *)other {
+ if (![self.field isEqual:other->field]) {
+ [NSException raise:NSInvalidArgumentException format:@"ZXGenericGFPolys do not have same ZXGenericGF field"];
+ }
+ if (other.zero) {
+ [NSException raise:NSInvalidArgumentException format:@"Divide by 0"];
+ }
+
+ ZXGenericGFPoly *quotient = self.field.zero;
+ ZXGenericGFPoly *remainder = self;
+
+ int denominatorLeadingTerm = [other coefficient:other.degree];
+ int inverseDenominatorLeadingTerm = [self.field inverse:denominatorLeadingTerm];
+
+ while ([remainder degree] >= other.degree && !remainder.zero) {
+ int degreeDifference = remainder.degree - other.degree;
+ int scale = [self.field multiply:[remainder coefficient:remainder.degree] b:inverseDenominatorLeadingTerm];
+ ZXGenericGFPoly *term = [other multiplyByMonomial:degreeDifference coefficient:scale];
+ ZXGenericGFPoly *iterationQuotient = [field buildMonomial:degreeDifference coefficient:scale];
+ quotient = [quotient addOrSubtract:iterationQuotient];
+ remainder = [remainder addOrSubtract:term];
+ }
+
+ return [NSArray arrayWithObjects:quotient, remainder, nil];
+}
+
+- (NSString *) description {
+ NSMutableString *result = [NSMutableString stringWithCapacity:8 * [self degree]];
+ for (int degree = [self degree]; degree >= 0; degree--) {
+ int coefficient = [self coefficient:degree];
+ if (coefficient != 0) {
+ if (coefficient < 0) {
+ [result appendString:@" - "];
+ coefficient = -coefficient;
+ } else {
+ if ([result length] > 0) {
+ [result appendString:@" + "];
+ }
+ }
+ if (degree == 0 || coefficient != 1) {
+ int alphaPower = [field log:coefficient];
+ if (alphaPower == 0) {
+ [result appendString:@"1"];
+ } else if (alphaPower == 1) {
+ [result appendString:@"a"];
+ } else {
+ [result appendString:@"a^"];
+ [result appendFormat:@"%d", alphaPower];
+ }
+ }
+ if (degree != 0) {
+ if (degree == 1) {
+ [result appendString:@"x"];
+ } else {
+ [result appendString:@"x^"];
+ [result appendFormat:@"%d", degree];
+ }
+ }
+ }
+ }
+
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXReedSolomonDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXReedSolomonDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..d256a4b12278f804165daf1a69bc68927d8b0a6d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXReedSolomonDecoder.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Implements Reed-Solomon decoding, as the name implies.
+ *
+ * The algorithm will not be explained here, but the following references were helpful
+ * in creating this implementation:
+ *
+ * Bruce Maggs.
+ * http://www.cs.cmu.edu/afs/cs.cmu.edu/project/pscico-guyb/realworld/www/rs_decode.ps
+ * "Decoding Reed-Solomon Codes" (see discussion of Forney's Formula)
+ *
+ * J.I. Hall. www.mth.msu.edu/~jhall/classes/codenotes/GRS.pdf
+ * "Chapter 5. Generalized Reed-Solomon Codes"
+ * (see discussion of Euclidean algorithm)
+ *
+ * Much credit is due to William Rucklidge since portions of this code are an indirect
+ * port of his C++ Reed-Solomon implementation.
+ */
+
+@class ZXGenericGF;
+
+@interface ZXReedSolomonDecoder : NSObject
+
+- (id)initWithField:(ZXGenericGF *)field;
+- (BOOL)decode:(int *)received receivedLen:(int)receivedLen twoS:(int)twoS error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXReedSolomonDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXReedSolomonDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..36c6d2e0611d0a07de5a24ce40f6665c3ff38da5
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXReedSolomonDecoder.m
@@ -0,0 +1,201 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXErrors.h"
+#import "ZXGenericGF.h"
+#import "ZXGenericGFPoly.h"
+#import "ZXReedSolomonDecoder.h"
+
+@interface ZXReedSolomonDecoder ()
+
+@property (nonatomic, retain) ZXGenericGF *field;
+
+- (NSArray *)runEuclideanAlgorithm:(ZXGenericGFPoly *)a b:(ZXGenericGFPoly *)b R:(int)R error:(NSError **)error;
+- (NSArray *)findErrorLocations:(ZXGenericGFPoly *)errorLocator error:(NSError **)error;
+- (NSArray *)findErrorMagnitudes:(ZXGenericGFPoly *)errorEvaluator errorLocations:(NSArray *)errorLocations;
+
+@end
+
+
+@implementation ZXReedSolomonDecoder
+
+@synthesize field;
+
+- (id)initWithField:(ZXGenericGF *)aField {
+ if (self = [super init]) {
+ self.field = aField;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [field release];
+
+ [super dealloc];
+}
+
+
+/**
+ * Decodes given set of received codewords, which include both data and error-correction
+ * codewords. Really, this means it uses Reed-Solomon to detect and correct errors, in-place,
+ * in the input.
+ */
+- (BOOL)decode:(int *)received receivedLen:(int)receivedLen twoS:(int)twoS error:(NSError **)error {
+ ZXGenericGFPoly *poly = [[[ZXGenericGFPoly alloc] initWithField:field coefficients:received coefficientsLen:receivedLen] autorelease];
+ int syndromeCoefficientsLen = twoS;
+ int syndromeCoefficients[syndromeCoefficientsLen];
+ BOOL noError = YES;
+
+ for (int i = 0; i < twoS; i++) {
+ int eval = [poly evaluateAt:[field exp:i + field.generatorBase]];
+ syndromeCoefficients[syndromeCoefficientsLen - 1 - i] = eval;
+ if (eval != 0) {
+ noError = NO;
+ }
+ }
+ if (noError) {
+ return YES;
+ }
+ ZXGenericGFPoly *syndrome = [[[ZXGenericGFPoly alloc] initWithField:field coefficients:syndromeCoefficients coefficientsLen:syndromeCoefficientsLen] autorelease];
+ NSArray *sigmaOmega = [self runEuclideanAlgorithm:[field buildMonomial:twoS coefficient:1] b:syndrome R:twoS error:error];
+ if (!sigmaOmega) {
+ return NO;
+ }
+ ZXGenericGFPoly *sigma = [sigmaOmega objectAtIndex:0];
+ ZXGenericGFPoly *omega = [sigmaOmega objectAtIndex:1];
+ NSArray *errorLocations = [self findErrorLocations:sigma error:error];
+ if (!errorLocations) {
+ return NO;
+ }
+ NSArray *errorMagnitudes = [self findErrorMagnitudes:omega errorLocations:errorLocations];
+ for (int i = 0; i < [errorLocations count]; i++) {
+ int position = receivedLen - 1 - [field log:[[errorLocations objectAtIndex:i] intValue]];
+ if (position < 0) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"Bad error location"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXReedSolomonError userInfo:userInfo] autorelease];
+ return NO;
+ }
+ received[position] = [ZXGenericGF addOrSubtract:received[position] b:[[errorMagnitudes objectAtIndex:i] intValue]];
+ }
+ return YES;
+}
+
+- (NSArray *)runEuclideanAlgorithm:(ZXGenericGFPoly *)a b:(ZXGenericGFPoly *)b R:(int)R error:(NSError **)error {
+ if (a.degree < b.degree) {
+ ZXGenericGFPoly *temp = a;
+ a = b;
+ b = temp;
+ }
+
+ ZXGenericGFPoly *rLast = a;
+ ZXGenericGFPoly *r = b;
+ ZXGenericGFPoly *tLast = field.zero;
+ ZXGenericGFPoly *t = field.one;
+
+ while ([r degree] >= R / 2) {
+ ZXGenericGFPoly *rLastLast = rLast;
+ ZXGenericGFPoly *tLastLast = tLast;
+ rLast = r;
+ tLast = t;
+
+ if ([rLast zero]) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"r_{i-1} was zero"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXReedSolomonError userInfo:userInfo] autorelease];
+ return NO;
+ }
+ r = rLastLast;
+ ZXGenericGFPoly *q = [field zero];
+ int denominatorLeadingTerm = [rLast coefficient:[rLast degree]];
+ int dltInverse = [field inverse:denominatorLeadingTerm];
+
+ while ([r degree] >= [rLast degree] && ![r zero]) {
+ int degreeDiff = [r degree] - [rLast degree];
+ int scale = [field multiply:[r coefficient:[r degree]] b:dltInverse];
+ q = [q addOrSubtract:[field buildMonomial:degreeDiff coefficient:scale]];
+ r = [r addOrSubtract:[rLast multiplyByMonomial:degreeDiff coefficient:scale]];
+ }
+
+ t = [[q multiply:tLast] addOrSubtract:tLastLast];
+ }
+
+ int sigmaTildeAtZero = [t coefficient:0];
+ if (sigmaTildeAtZero == 0) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"sigmaTilde(0) was zero"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXReedSolomonError userInfo:userInfo] autorelease];
+ return NO;
+ }
+
+ int inverse = [field inverse:sigmaTildeAtZero];
+ ZXGenericGFPoly *sigma = [t multiplyScalar:inverse];
+ ZXGenericGFPoly *omega = [r multiplyScalar:inverse];
+ return [NSArray arrayWithObjects:sigma, omega, nil];
+}
+
+- (NSArray *)findErrorLocations:(ZXGenericGFPoly *)errorLocator error:(NSError **)error {
+ int numErrors = [errorLocator degree];
+ if (numErrors == 1) {
+ return [NSArray arrayWithObject:[NSNumber numberWithInt:[errorLocator coefficient:1]]];
+ }
+ NSMutableArray *result = [NSMutableArray arrayWithCapacity:numErrors];
+ int e = 0;
+ for (int i = 1; i < [field size] && e < numErrors; i++) {
+ if ([errorLocator evaluateAt:i] == 0) {
+ [result addObject:[NSNumber numberWithInt:[field inverse:i]]];
+ e++;
+ }
+ }
+
+ if (e != numErrors) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"Error locator degree does not match number of roots"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXReedSolomonError userInfo:userInfo] autorelease];
+ return nil;
+ }
+ return result;
+}
+
+- (NSArray *)findErrorMagnitudes:(ZXGenericGFPoly *)errorEvaluator errorLocations:(NSArray *)errorLocations {
+ int s = [errorLocations count];
+ NSMutableArray *result = [NSMutableArray array];
+ for (int i = 0; i < s; i++) {
+ int xiInverse = [self.field inverse:[[errorLocations objectAtIndex:i] intValue]];
+ int denominator = 1;
+ for (int j = 0; j < s; j++) {
+ if (i != j) {
+ int term = [self.field multiply:[[errorLocations objectAtIndex:j] intValue] b:xiInverse];
+ int termPlus1 = (term & 0x1) == 0 ? term | 1 : term & ~1;
+ denominator = [self.field multiply:denominator b:termPlus1];
+ }
+ }
+
+ [result addObject:[NSNumber numberWithInt:[self.field multiply:[errorEvaluator evaluateAt:xiInverse] b:[self.field inverse:denominator]]]];
+ if (self.field.generatorBase != 0) {
+ [result replaceObjectAtIndex:i withObject:[NSNumber numberWithInt:[self.field multiply:[[result objectAtIndex:i] intValue] b:xiInverse]]];
+ }
+ }
+
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXReedSolomonEncoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXReedSolomonEncoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..a073722f60bb83309601857ffb05223483d41cbc
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXReedSolomonEncoder.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Implements Reed-Solomon enbcoding, as the name implies.
+ */
+
+@class ZXGenericGF;
+
+@interface ZXReedSolomonEncoder : NSObject
+
+- (id)initWithField:(ZXGenericGF *)field;
+- (void)encode:(int *)toEncode toEncodeLen:(int)toEncodeLen ecBytes:(int)ecBytes;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXReedSolomonEncoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXReedSolomonEncoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..af8503bd9e0c81ab3d1addfed4f02adbafb61a60
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/common/reedsolomon/ZXReedSolomonEncoder.m
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXGenericGF.h"
+#import "ZXGenericGFPoly.h"
+#import "ZXReedSolomonEncoder.h"
+
+@interface ZXReedSolomonEncoder ()
+
+@property (nonatomic, retain) NSMutableArray *cachedGenerators;
+@property (nonatomic, retain) ZXGenericGF *field;
+
+@end
+
+
+@implementation ZXReedSolomonEncoder
+
+@synthesize cachedGenerators;
+@synthesize field;
+
+- (id)initWithField:(ZXGenericGF *)aField {
+ if (self = [super init]) {
+ self.field = aField;
+ int one = 1;
+ self.cachedGenerators = [NSMutableArray arrayWithObject:[[[ZXGenericGFPoly alloc] initWithField:aField coefficients:&one coefficientsLen:1] autorelease]];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [cachedGenerators release];
+ [field release];
+
+ [super dealloc];
+}
+
+- (ZXGenericGFPoly *)buildGenerator:(int)degree {
+ if (degree >= self.cachedGenerators.count) {
+ ZXGenericGFPoly *lastGenerator = [self.cachedGenerators objectAtIndex:[cachedGenerators count] - 1];
+ for (int d = [self.cachedGenerators count]; d <= degree; d++) {
+ int next[2] = { 1, [field exp:d - 1 + field.generatorBase] };
+ ZXGenericGFPoly *nextGenerator = [lastGenerator multiply:[[[ZXGenericGFPoly alloc] initWithField:field coefficients:next coefficientsLen:2] autorelease]];
+ [self.cachedGenerators addObject:nextGenerator];
+ lastGenerator = nextGenerator;
+ }
+ }
+
+ return (ZXGenericGFPoly *)[self.cachedGenerators objectAtIndex:degree];
+}
+
+- (void)encode:(int *)toEncode toEncodeLen:(int)toEncodeLen ecBytes:(int)ecBytes {
+ if (ecBytes == 0) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:@"No error correction bytes"
+ userInfo:nil];
+ }
+ int dataBytes = toEncodeLen - ecBytes;
+ if (dataBytes <= 0) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:@"No data bytes provided"
+ userInfo:nil];
+ }
+ ZXGenericGFPoly *generator = [self buildGenerator:ecBytes];
+ int infoCoefficients[dataBytes];
+ for (int i = 0; i < dataBytes; i++) {
+ infoCoefficients[i] = toEncode[i];
+ }
+ ZXGenericGFPoly *info = [[[ZXGenericGFPoly alloc] initWithField:field coefficients:infoCoefficients coefficientsLen:dataBytes] autorelease];
+ info = [info multiplyByMonomial:ecBytes coefficient:1];
+ ZXGenericGFPoly *remainder = [[info divide:generator] objectAtIndex:1];
+ int *coefficients = remainder.coefficients;
+ int coefficientsLen = remainder.coefficientsLen;
+ int numZeroCoefficients = ecBytes - coefficientsLen;
+ for (int i = 0; i < numZeroCoefficients; i++) {
+ toEncode[dataBytes + i] = 0;
+ }
+ for (int i = 0; i < coefficientsLen; i++) {
+ toEncode[dataBytes + numZeroCoefficients + i] = coefficients[i];
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/ZXDataMatrixReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/ZXDataMatrixReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..17d7359367fe5b7b54139dc972b33a38c2f48cd0
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/ZXDataMatrixReader.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXReader.h"
+
+/**
+ * This implementation can detect and decode Data Matrix codes in an image.
+ */
+
+@class ZXBinaryBitmap, ZXDecodeHints, ZXResult;
+
+@interface ZXDataMatrixReader : NSObject <ZXReader>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/ZXDataMatrixReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/ZXDataMatrixReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..54976767bc9fd9449f452084f4ca4ec16545753a
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/ZXDataMatrixReader.m
@@ -0,0 +1,183 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBinaryBitmap.h"
+#import "ZXBitMatrix.h"
+#import "ZXDataMatrixDecoder.h"
+#import "ZXDataMatrixReader.h"
+#import "ZXDataMatrixDetector.h"
+#import "ZXDecodeHints.h"
+#import "ZXDecoderResult.h"
+#import "ZXDetectorResult.h"
+#import "ZXErrors.h"
+#import "ZXResult.h"
+
+@interface ZXDataMatrixReader ()
+
+@property (nonatomic, retain) ZXDataMatrixDecoder *decoder;
+
+- (ZXBitMatrix *)extractPureBits:(ZXBitMatrix *)image;
+- (int)moduleSize:(NSArray *)leftTopBlack image:(ZXBitMatrix *)image;
+
+@end
+
+@implementation ZXDataMatrixReader
+
+@synthesize decoder;
+
+- (id)init {
+ if (self = [super init]) {
+ self.decoder = [[[ZXDataMatrixDecoder alloc] init] autorelease];
+ }
+
+ return self;
+}
+
+- (void) dealloc {
+ [decoder release];
+
+ [super dealloc];
+}
+
+
+/**
+ * Locates and decodes a Data Matrix code in an image.
+ */
+- (ZXResult *)decode:(ZXBinaryBitmap *)image error:(NSError **)error {
+ return [self decode:image hints:nil error:error];
+}
+
+- (ZXResult *)decode:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ ZXDecoderResult *decoderResult;
+ NSArray *points;
+ if (hints != nil && hints.pureBarcode) {
+ ZXBitMatrix *matrix = [image blackMatrixWithError:error];
+ if (!matrix) {
+ return nil;
+ }
+ ZXBitMatrix *bits = [self extractPureBits:matrix];
+ if (!bits) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ decoderResult = [decoder decodeMatrix:bits error:error];
+ if (!decoderResult) {
+ return nil;
+ }
+ points = [NSArray array];
+ } else {
+ ZXBitMatrix *matrix = [image blackMatrixWithError:error];
+ if (!matrix) {
+ return nil;
+ }
+ ZXDataMatrixDetector *detector = [[[ZXDataMatrixDetector alloc] initWithImage:matrix error:error] autorelease];
+ if (!detector) {
+ return nil;
+ }
+ ZXDetectorResult *detectorResult = [detector detectWithError:error];
+ if (!detectorResult) {
+ return nil;
+ }
+ decoderResult = [decoder decodeMatrix:detectorResult.bits error:error];
+ if (!decoderResult) {
+ return nil;
+ }
+ points = detectorResult.points;
+ }
+ ZXResult *result = [ZXResult resultWithText:decoderResult.text
+ rawBytes:decoderResult.rawBytes
+ length:decoderResult.length
+ resultPoints:points
+ format:kBarcodeFormatDataMatrix];
+ if (decoderResult.byteSegments != nil) {
+ [result putMetadata:kResultMetadataTypeByteSegments value:decoderResult.byteSegments];
+ }
+ if (decoderResult.ecLevel != nil) {
+ [result putMetadata:kResultMetadataTypeErrorCorrectionLevel value:decoderResult.ecLevel];
+ }
+ return result;
+}
+
+- (void) reset {
+ // do nothing
+}
+
+
+/**
+ * This method detects a code in a "pure" image -- that is, pure monochrome image
+ * which contains only an unrotated, unskewed, image of a code, with some white border
+ * around it. This is a specialized method that works exceptionally fast in this special
+ * case.
+ */
+- (ZXBitMatrix *)extractPureBits:(ZXBitMatrix *)image {
+ NSArray *leftTopBlack = image.topLeftOnBit;
+ NSArray *rightBottomBlack = image.bottomRightOnBit;
+ if (leftTopBlack == nil || rightBottomBlack == nil) {
+ return nil;
+ }
+
+ int moduleSize = [self moduleSize:leftTopBlack image:image];
+ if (moduleSize == -1) {
+ return nil;
+ }
+
+ int top = [[leftTopBlack objectAtIndex:1] intValue];
+ int bottom = [[rightBottomBlack objectAtIndex:1] intValue];
+ int left = [[leftTopBlack objectAtIndex:0] intValue];
+ int right = [[rightBottomBlack objectAtIndex:0] intValue];
+
+ int matrixWidth = (right - left + 1) / moduleSize;
+ int matrixHeight = (bottom - top + 1) / moduleSize;
+ if (matrixWidth <= 0 || matrixHeight <= 0) {
+ return nil;
+ }
+
+ int nudge = moduleSize >> 1;
+ top += nudge;
+ left += nudge;
+
+ ZXBitMatrix *bits = [[[ZXBitMatrix alloc] initWithWidth:matrixWidth height:matrixHeight] autorelease];
+ for (int y = 0; y < matrixHeight; y++) {
+ int iOffset = top + y * moduleSize;
+ for (int x = 0; x < matrixWidth; x++) {
+ if ([image getX:left + x * moduleSize y:iOffset]) {
+ [bits setX:x y:y];
+ }
+ }
+ }
+
+ return bits;
+}
+
+- (int)moduleSize:(NSArray *)leftTopBlack image:(ZXBitMatrix *)image {
+ int width = image.width;
+ int x = [[leftTopBlack objectAtIndex:0] intValue];
+ int y = [[leftTopBlack objectAtIndex:1] intValue];
+ while (x < width && [image getX:x y:y]) {
+ x++;
+ }
+ if (x == width) {
+ return -1;
+ }
+
+ int moduleSize = x - [[leftTopBlack objectAtIndex:0] intValue];
+ if (moduleSize == 0) {
+ return -1;
+ }
+ return moduleSize;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/ZXDataMatrixWriter.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/ZXDataMatrixWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..3762cd74f275ac116dbced8b6ffcdebb18ec60f0
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/ZXDataMatrixWriter.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXWriter.h"
+
+/**
+ * This object renders a Data Matrix code as a BitMatrix 2D array of greyscale values.
+ */
+
+@interface ZXDataMatrixWriter : NSObject <ZXWriter>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/ZXDataMatrixWriter.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/ZXDataMatrixWriter.m
new file mode 100644
index 0000000000000000000000000000000000000000..71bc89c33432930dc94e51113e29484e82b1eec6
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/ZXDataMatrixWriter.m
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXByteMatrix.h"
+#import "ZXDataMatrixErrorCorrection.h"
+#import "ZXDataMatrixWriter.h"
+#import "ZXDefaultPlacement.h"
+#import "ZXDimension.h"
+#import "ZXEncodeHints.h"
+#import "ZXHighLevelEncoder.h"
+#import "ZXSymbolInfo.h"
+#import "ZXSymbolShapeHint.h"
+
+@interface ZXDataMatrixWriter ()
+
+- (ZXBitMatrix *)encodeLowLevel:(ZXDefaultPlacement *)placement symbolInfo:(ZXSymbolInfo *)symbolInfo;
+- (ZXBitMatrix *)convertByteMatrixToBitMatrix:(ZXByteMatrix *)matrix;
+
+@end
+
+@implementation ZXDataMatrixWriter
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height error:(NSError **)error {
+ return [self encode:contents format:format width:width height:height hints:nil error:error];
+}
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height hints:(ZXEncodeHints *)hints error:(NSError **)error {
+ if (contents.length == 0) {
+ [NSException raise:NSInvalidArgumentException format:@"Found empty contents"];
+ }
+
+ if (format != kBarcodeFormatDataMatrix) {
+ [NSException raise:NSInvalidArgumentException format:@"Can only encode kBarcodeFormatDataMatrix"];
+ }
+
+ if (width < 0 || height < 0) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Requested dimensions are too small: %dx%d", width, height];
+ }
+
+ // Try to get force shape & min / max size
+ ZXSymbolShapeHint *shape = [ZXSymbolShapeHint forceNone];
+ ZXDimension *minSize = nil;
+ ZXDimension *maxSize = nil;
+ if (hints != nil) {
+ ZXSymbolShapeHint *requestedShape = hints.dataMatrixShape;
+ if (requestedShape != nil) {
+ shape = requestedShape;
+ }
+ ZXDimension *requestedMinSize = hints.minSize;
+ if (requestedMinSize != nil) {
+ minSize = requestedMinSize;
+ }
+ ZXDimension *requestedMaxSize = hints.maxSize;
+ if (requestedMaxSize != nil) {
+ maxSize = requestedMaxSize;
+ }
+ }
+
+ //1. step: Data encodation
+ NSString *encoded = [ZXHighLevelEncoder encodeHighLevel:contents shape:shape minSize:minSize maxSize:maxSize];
+
+ ZXSymbolInfo *symbolInfo = [ZXSymbolInfo lookup:encoded.length shape:shape minSize:minSize maxSize:maxSize fail:YES];
+
+ //2. step: ECC generation
+ NSString *codewords = [ZXDataMatrixErrorCorrection encodeECC200:encoded symbolInfo:symbolInfo];
+
+ //3. step: Module placement in Matrix
+ ZXDefaultPlacement *placement = [[[ZXDefaultPlacement alloc] initWithCodewords:codewords numcols:symbolInfo.symbolDataWidth numrows:symbolInfo.symbolDataHeight] autorelease];
+ [placement place];
+
+ //4. step: low-level encoding
+ return [self encodeLowLevel:placement symbolInfo:symbolInfo];
+}
+
+/**
+ * Encode the given symbol info to a bit matrix.
+ */
+- (ZXBitMatrix *)encodeLowLevel:(ZXDefaultPlacement *)placement symbolInfo:(ZXSymbolInfo *)symbolInfo {
+ int symbolWidth = symbolInfo.symbolDataWidth;
+ int symbolHeight = symbolInfo.symbolDataHeight;
+
+ ZXByteMatrix *matrix = [[[ZXByteMatrix alloc] initWithWidth:symbolInfo.symbolWidth height:symbolInfo.symbolHeight] autorelease];
+
+ int matrixY = 0;
+
+ for (int y = 0; y < symbolHeight; y++) {
+ // Fill the top edge with alternate 0 / 1
+ int matrixX;
+ if ((y % symbolInfo.matrixHeight) == 0) {
+ matrixX = 0;
+ for (int x = 0; x < symbolInfo.symbolWidth; x++) {
+ [matrix setX:matrixX y:matrixY boolValue:(x % 2) == 0];
+ matrixX++;
+ }
+ matrixY++;
+ }
+ matrixX = 0;
+ for (int x = 0; x < symbolWidth; x++) {
+ // Fill the right edge with full 1
+ if ((x % symbolInfo.matrixWidth) == 0) {
+ [matrix setX:matrixX y:matrixY boolValue:YES];
+ matrixX++;
+ }
+ [matrix setX:matrixX y:matrixY boolValue:[placement bitAtCol:x row:y]];
+ matrixX++;
+ // Fill the right edge with alternate 0 / 1
+ if ((x % symbolInfo.matrixWidth) == symbolInfo.matrixWidth - 1) {
+ [matrix setX:matrixX y:matrixY boolValue:(y % 2) == 0];
+ matrixX++;
+ }
+ }
+ matrixY++;
+ // Fill the bottom edge with full 1
+ if ((y % symbolInfo.matrixHeight) == symbolInfo.matrixHeight - 1) {
+ matrixX = 0;
+ for (int x = 0; x < symbolInfo.symbolWidth; x++) {
+ [matrix setX:matrixX y:matrixY boolValue:YES];
+ matrixX++;
+ }
+ matrixY++;
+ }
+ }
+
+ return [self convertByteMatrixToBitMatrix:matrix];
+}
+
+/**
+ * Convert the ByteMatrix to BitMatrix.
+ */
+- (ZXBitMatrix *)convertByteMatrixToBitMatrix:(ZXByteMatrix *)matrix {
+ int matrixWidgth = matrix.width;
+ int matrixHeight = matrix.height;
+
+ ZXBitMatrix *output = [[[ZXBitMatrix alloc] initWithWidth:matrixWidgth height:matrixHeight] autorelease];
+ [output clear];
+ for (int i = 0; i < matrixWidgth; i++) {
+ for (int j = 0; j < matrixHeight; j++) {
+ // Zero is white in the bytematrix
+ if ([matrix getX:i y:j] == 1) {
+ [output setX:i y:j];
+ }
+ }
+ }
+
+ return output;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixBitMatrixParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixBitMatrixParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..3073b0cbcad57348a2096e41f3a589787c6e670b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixBitMatrixParser.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXBitMatrix, ZXDataMatrixVersion;
+
+@interface ZXDataMatrixBitMatrixParser : NSObject
+
+@property (nonatomic, retain, readonly) ZXDataMatrixVersion *version;
+
+- (id)initWithBitMatrix:(ZXBitMatrix *)bitMatrix error:(NSError **)error;
+- (NSArray *)readCodewords;
+- (BOOL)readModule:(int)row column:(int)column numRows:(int)numRows numColumns:(int)numColumns;
+- (int)readUtah:(int)row column:(int)column numRows:(int)numRows numColumns:(int)numColumns;
+- (int)readCorner1:(int)numRows numColumns:(int)numColumns;
+- (int)readCorner2:(int)numRows numColumns:(int)numColumns;
+- (int)readCorner3:(int)numRows numColumns:(int)numColumns;
+- (int)readCorner4:(int)numRows numColumns:(int)numColumns;
+- (ZXBitMatrix *)extractDataRegion:(ZXBitMatrix *)bitMatrix;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixBitMatrixParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixBitMatrixParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..229f7b71539e9bd0aa0fa326b036fefc61b8b53b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixBitMatrixParser.m
@@ -0,0 +1,422 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXDataMatrixBitMatrixParser.h"
+#import "ZXDataMatrixVersion.h"
+#import "ZXErrors.h"
+
+@interface ZXDataMatrixBitMatrixParser ()
+
+@property (nonatomic, retain) ZXBitMatrix *mappingBitMatrix;
+@property (nonatomic, retain) ZXBitMatrix *readMappingMatrix;
+@property (nonatomic, retain) ZXDataMatrixVersion *version;
+
+- (ZXDataMatrixVersion *) readVersion:(ZXBitMatrix *)bitMatrix;
+
+@end
+
+@implementation ZXDataMatrixBitMatrixParser
+
+@synthesize mappingBitMatrix;
+@synthesize readMappingMatrix;
+@synthesize version;
+
+- (id)initWithBitMatrix:(ZXBitMatrix *)bitMatrix error:(NSError **)error {
+ if (self = [super init]) {
+ int dimension = bitMatrix.height;
+ if (dimension < 8 || dimension > 144 || (dimension & 0x01) != 0) {
+ if (error) *error = FormatErrorInstance();
+ [self release];
+ return nil;
+ }
+ self.version = [self readVersion:bitMatrix];
+ if (!self.version) {
+ if (error) *error = FormatErrorInstance();
+ [self release];
+ return nil;
+ }
+ self.mappingBitMatrix = [self extractDataRegion:bitMatrix];
+ self.readMappingMatrix = [[[ZXBitMatrix alloc] initWithWidth:mappingBitMatrix.width
+ height:mappingBitMatrix.height] autorelease];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [mappingBitMatrix release];
+ [readMappingMatrix release];
+ [version release];
+
+ [super dealloc];
+}
+
+
+/**
+ * Creates the version object based on the dimension of the original bit matrix from
+ * the datamatrix code.
+ *
+ * See ISO 16022:2006 Table 7 - ECC 200 symbol attributes
+ */
+- (ZXDataMatrixVersion *)readVersion:(ZXBitMatrix *)bitMatrix {
+ int numRows = bitMatrix.height;
+ int numColumns = bitMatrix.width;
+ return [ZXDataMatrixVersion versionForDimensions:numRows numColumns:numColumns];
+}
+
+
+/**
+ * Reads the bits in the {@link BitMatrix} representing the mapping matrix (No alignment patterns)
+ * in the correct order in order to reconstitute the codewords bytes contained within the
+ * Data Matrix Code.
+ */
+- (NSArray *)readCodewords {
+ NSMutableArray *result = [NSMutableArray arrayWithCapacity:version.totalCodewords];
+
+ int row = 4;
+ int column = 0;
+
+ int numRows = mappingBitMatrix.height;
+ int numColumns = mappingBitMatrix.width;
+
+ BOOL corner1Read = NO;
+ BOOL corner2Read = NO;
+ BOOL corner3Read = NO;
+ BOOL corner4Read = NO;
+
+ do {
+ if ((row == numRows) && (column == 0) && !corner1Read) {
+ [result addObject:[NSNumber numberWithInt:[self readCorner1:numRows numColumns:numColumns]]];
+ row -= 2;
+ column += 2;
+ corner1Read = YES;
+ } else if ((row == numRows - 2) && (column == 0) && ((numColumns & 0x03) != 0) && !corner2Read) {
+ [result addObject:[NSNumber numberWithInt:[self readCorner2:numRows numColumns:numColumns]]];
+ row -= 2;
+ column += 2;
+ corner2Read = YES;
+ } else if ((row == numRows + 4) && (column == 2) && ((numColumns & 0x07) == 0) && !corner3Read) {
+ [result addObject:[NSNumber numberWithInt:[self readCorner3:numRows numColumns:numColumns]]];
+ row -= 2;
+ column += 2;
+ corner3Read = YES;
+ } else if ((row == numRows - 2) && (column == 0) && ((numColumns & 0x07) == 4) && !corner4Read) {
+ [result addObject:[NSNumber numberWithInt:[self readCorner4:numRows numColumns:numColumns]]];
+ row -= 2;
+ column += 2;
+ corner4Read = YES;
+ } else {
+ do {
+ if ((row < numRows) && (column >= 0) && ![readMappingMatrix getX:column y:row]) {
+ [result addObject:[NSNumber numberWithInt:[self readUtah:row column:column numRows:numRows numColumns:numColumns]]];
+ }
+ row -= 2;
+ column += 2;
+ } while ((row >= 0) && (column < numColumns));
+ row += 1;
+ column += 3;
+
+ do {
+ if ((row >= 0) && (column < numColumns) && ![readMappingMatrix getX:column y:row]) {
+ [result addObject:[NSNumber numberWithInt:[self readUtah:row column:column numRows:numRows numColumns:numColumns]]];
+ }
+ row += 2;
+ column -= 2;
+ } while ((row < numRows) && (column >= 0));
+ row += 3;
+ column += 1;
+ }
+ } while ((row < numRows) || (column < numColumns));
+
+ if ([result count] != version.totalCodewords) {
+ return nil;
+ }
+ return result;
+}
+
+
+/**
+ * Reads a bit of the mapping matrix accounting for boundary wrapping.
+ */
+- (BOOL)readModule:(int)row column:(int)column numRows:(int)numRows numColumns:(int)numColumns {
+ if (row < 0) {
+ row += numRows;
+ column += 4 - ((numRows + 4) & 0x07);
+ }
+ if (column < 0) {
+ column += numColumns;
+ row += 4 - ((numColumns + 4) & 0x07);
+ }
+ [readMappingMatrix setX:column y:row];
+ return [mappingBitMatrix getX:column y:row];
+}
+
+
+/**
+ * Reads the 8 bits of the standard Utah-shaped pattern.
+ *
+ * See ISO 16022:2006, 5.8.1 Figure 6
+ */
+- (int)readUtah:(int)row column:(int)column numRows:(int)numRows numColumns:(int)numColumns {
+ int currentByte = 0;
+ if ([self readModule:row - 2 column:column - 2 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:row - 2 column:column - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:row - 1 column:column - 2 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:row - 1 column:column - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:row - 1 column:column numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:row column:column - 2 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:row column:column - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:row column:column numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ return currentByte;
+}
+
+
+/**
+ * Reads the 8 bits of the special corner condition 1.
+ *
+ * See ISO 16022:2006, Figure F.3
+ */
+- (int)readCorner1:(int)numRows numColumns:(int)numColumns {
+ int currentByte = 0;
+ if ([self readModule:numRows - 1 column:0 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:numRows - 1 column:1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:numRows - 1 column:2 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:0 column:numColumns - 2 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:0 column:numColumns - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:1 column:numColumns - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:2 column:numColumns - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:3 column:numColumns - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ return currentByte;
+}
+
+
+/**
+ * Reads the 8 bits of the special corner condition 2.
+ *
+ * See ISO 16022:2006, Figure F.4
+ */
+- (int)readCorner2:(int)numRows numColumns:(int)numColumns {
+ int currentByte = 0;
+ if ([self readModule:numRows - 3 column:0 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:numRows - 2 column:0 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:numRows - 1 column:0 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:0 column:numColumns - 4 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:0 column:numColumns - 3 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:0 column:numColumns - 2 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:0 column:numColumns - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:1 column:numColumns - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ return currentByte;
+}
+
+
+/**
+ * Reads the 8 bits of the special corner condition 3.
+ *
+ * See ISO 16022:2006, Figure F.5
+ */
+- (int)readCorner3:(int)numRows numColumns:(int)numColumns {
+ int currentByte = 0;
+ if ([self readModule:numRows - 1 column:0 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:numRows - 1 column:numColumns - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:0 column:numColumns - 3 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:0 column:numColumns - 2 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:0 column:numColumns - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:1 column:numColumns - 3 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:1 column:numColumns - 2 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:1 column:numColumns - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ return currentByte;
+}
+
+
+/**
+ * Reads the 8 bits of the special corner condition 4.
+ *
+ * See ISO 16022:2006, Figure F.6
+ */
+- (int)readCorner4:(int)numRows numColumns:(int)numColumns {
+ int currentByte = 0;
+ if ([self readModule:numRows - 3 column:0 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:numRows - 2 column:0 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:numRows - 1 column:0 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:0 column:numColumns - 2 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:0 column:numColumns - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:1 column:numColumns - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:2 column:numColumns - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ currentByte <<= 1;
+ if ([self readModule:3 column:numColumns - 1 numRows:numRows numColumns:numColumns]) {
+ currentByte |= 1;
+ }
+ return currentByte;
+}
+
+
+/**
+ * Extracts the data region from a {@link BitMatrix} that contains
+ * alignment patterns.
+ */
+- (ZXBitMatrix *)extractDataRegion:(ZXBitMatrix *)bitMatrix {
+ int symbolSizeRows = version.symbolSizeRows;
+ int symbolSizeColumns = version.symbolSizeColumns;
+
+ if (bitMatrix.height != symbolSizeRows) {
+ [NSException raise:NSInvalidArgumentException format:@"Dimension of bitMatrix must match the version size"];
+ }
+
+ int dataRegionSizeRows = version.dataRegionSizeRows;
+ int dataRegionSizeColumns = version.dataRegionSizeColumns;
+
+ int numDataRegionsRow = symbolSizeRows / dataRegionSizeRows;
+ int numDataRegionsColumn = symbolSizeColumns / dataRegionSizeColumns;
+
+ int sizeDataRegionRow = numDataRegionsRow * dataRegionSizeRows;
+ int sizeDataRegionColumn = numDataRegionsColumn * dataRegionSizeColumns;
+
+ ZXBitMatrix *bitMatrixWithoutAlignment = [[[ZXBitMatrix alloc] initWithWidth:sizeDataRegionColumn height:sizeDataRegionRow] autorelease];
+ for (int dataRegionRow = 0; dataRegionRow < numDataRegionsRow; ++dataRegionRow) {
+ int dataRegionRowOffset = dataRegionRow * dataRegionSizeRows;
+ for (int dataRegionColumn = 0; dataRegionColumn < numDataRegionsColumn; ++dataRegionColumn) {
+ int dataRegionColumnOffset = dataRegionColumn * dataRegionSizeColumns;
+ for (int i = 0; i < dataRegionSizeRows; ++i) {
+ int readRowOffset = dataRegionRow * (dataRegionSizeRows + 2) + 1 + i;
+ int writeRowOffset = dataRegionRowOffset + i;
+ for (int j = 0; j < dataRegionSizeColumns; ++j) {
+ int readColumnOffset = dataRegionColumn * (dataRegionSizeColumns + 2) + 1 + j;
+ if ([bitMatrix getX:readColumnOffset y:readRowOffset]) {
+ int writeColumnOffset = dataRegionColumnOffset + j;
+ [bitMatrixWithoutAlignment setX:writeColumnOffset y:writeRowOffset];
+ }
+ }
+ }
+ }
+ }
+
+ return bitMatrixWithoutAlignment;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDataBlock.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDataBlock.h
new file mode 100644
index 0000000000000000000000000000000000000000..2d6457adbfe2acd12fd63fe3d31f2bed19ecac60
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDataBlock.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates a block of data within a Data Matrix Code. Data Matrix Codes may split their data into
+ * multiple blocks, each of which is a unit of data and error-correction codewords. Each
+ * is represented by an instance of this class.
+ */
+
+@class ZXDataMatrixVersion;
+
+@interface ZXDataMatrixDataBlock : NSObject
+
+@property (nonatomic, assign, readonly) int numDataCodewords;
+@property (nonatomic, retain, readonly) NSMutableArray *codewords;
+
++ (NSArray *)dataBlocks:(NSArray *)rawCodewords version:(ZXDataMatrixVersion *)version;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDataBlock.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDataBlock.m
new file mode 100644
index 0000000000000000000000000000000000000000..c043ea524c796709f6b74127c51225047e876285
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDataBlock.m
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDataMatrixDataBlock.h"
+#import "ZXDataMatrixVersion.h"
+#import "ZXQRCodeVersion.h"
+
+@interface ZXDataMatrixDataBlock ()
+
+@property (nonatomic, assign) int numDataCodewords;
+@property (nonatomic, retain) NSMutableArray *codewords;
+
+@end
+
+@implementation ZXDataMatrixDataBlock
+
+@synthesize codewords;
+@synthesize numDataCodewords;
+
+- (id)initWithNumDataCodewords:(int)theNumDataCodewords codewords:(NSMutableArray *)theCodewords {
+ if (self = [super init]) {
+ self.numDataCodewords = theNumDataCodewords;
+ self.codewords = theCodewords;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [codewords release];
+
+ [super dealloc];
+}
+
+
+/**
+ * When Data Matrix Codes use multiple data blocks, they actually interleave the bytes of each of them.
+ * That is, the first byte of data block 1 to n is written, then the second bytes, and so on. This
+ * method will separate the data into original blocks.
+ */
++ (NSArray *)dataBlocks:(NSArray *)rawCodewords version:(ZXDataMatrixVersion *)version {
+ ZXDataMatrixECBlocks *ecBlocks = version.ecBlocks;
+
+ int totalBlocks = 0;
+ NSArray *ecBlockArray = ecBlocks.ecBlocks;
+ for (ZXDataMatrixECB *ecBlock in ecBlockArray) {
+ totalBlocks += ecBlock.count;
+ }
+
+ NSMutableArray *result = [NSMutableArray arrayWithCapacity:totalBlocks];
+ int numResultBlocks = 0;
+ for (ZXDataMatrixECB *ecBlock in ecBlockArray) {
+ for (int i = 0; i < ecBlock.count; i++) {
+ int numDataCodewords = ecBlock.dataCodewords;
+ int numBlockCodewords = ecBlocks.ecCodewords + numDataCodewords;
+ NSMutableArray *tempCodewords = [NSMutableArray arrayWithCapacity:numBlockCodewords];
+ for (int j = 0; j < numBlockCodewords; j++) {
+ [tempCodewords addObject:[NSNumber numberWithInt:0]];
+ }
+ [result addObject:[[[ZXDataMatrixDataBlock alloc] initWithNumDataCodewords:numDataCodewords codewords:tempCodewords] autorelease]];
+ numResultBlocks++;
+ }
+ }
+
+ int longerBlocksTotalCodewords = [[[result objectAtIndex:0] codewords] count];
+ int longerBlocksNumDataCodewords = longerBlocksTotalCodewords - ecBlocks.ecCodewords;
+ int shorterBlocksNumDataCodewords = longerBlocksNumDataCodewords - 1;
+ int rawCodewordsOffset = 0;
+ for (int i = 0; i < shorterBlocksNumDataCodewords; i++) {
+ for (int j = 0; j < numResultBlocks; j++) {
+ [[[result objectAtIndex:j] codewords] replaceObjectAtIndex:i
+ withObject:[rawCodewords objectAtIndex:rawCodewordsOffset++]];
+ }
+ }
+
+ BOOL specialVersion = version.versionNumber == 24;
+ int numLongerBlocks = specialVersion ? 8 : numResultBlocks;
+ for (int j = 0; j < numLongerBlocks; j++) {
+ [[[result objectAtIndex:j] codewords] replaceObjectAtIndex:longerBlocksNumDataCodewords - 1
+ withObject:[rawCodewords objectAtIndex:rawCodewordsOffset++]];
+ }
+
+ int max = [[[result objectAtIndex:0] codewords] count];
+ for (int i = longerBlocksNumDataCodewords; i < max; i++) {
+ for (int j = 0; j < numResultBlocks; j++) {
+ int iOffset = specialVersion && j > 7 ? i - 1 : i;
+ [[[result objectAtIndex:j] codewords] replaceObjectAtIndex:iOffset
+ withObject:[rawCodewords objectAtIndex:rawCodewordsOffset++]];
+ }
+ }
+
+ if (rawCodewordsOffset != [rawCodewords count]) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Codewords size mismatch"];
+ }
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDecodedBitStreamParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDecodedBitStreamParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..549c19a136d2180fb72dcf4e887d7188ae0493f8
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDecodedBitStreamParser.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Data Matrix Codes can encode text as bits in one of several modes, and can use multiple modes
+ * in one Data Matrix Code. This class decodes the bits back into text.
+ *
+ * See ISO 16022:2006, 5.2.1 - 5.2.9.2
+ */
+
+@class ZXDecoderResult;
+
+@interface ZXDataMatrixDecodedBitStreamParser : NSObject
+
++ (ZXDecoderResult *)decode:(unsigned char *)bytes length:(unsigned int)length error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDecodedBitStreamParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDecodedBitStreamParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..45c3934e4fc3506e4f291ab293faf1b934759385
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDecodedBitStreamParser.m
@@ -0,0 +1,511 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitSource.h"
+#import "ZXDataMatrixDecodedBitStreamParser.h"
+#import "ZXDecoderResult.h"
+#import "ZXErrors.h"
+
+/**
+ * See ISO 16022:2006, Annex C Table C.1
+ * The C40 Basic Character Set (*'s used for placeholders for the shift values)
+ */
+const char C40_BASIC_SET_CHARS[40] = {
+ '*', '*', '*', ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
+ 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
+};
+
+const char C40_SHIFT2_SET_CHARS[40] = {
+ '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.',
+ '/', ':', ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '_'
+};
+
+/**
+ * See ISO 16022:2006, Annex C Table C.2
+ * The Text Basic Character Set (*'s used for placeholders for the shift values)
+ */
+const char TEXT_BASIC_SET_CHARS[40] = {
+ '*', '*', '*', ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+ 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
+};
+
+const char TEXT_SHIFT3_SET_CHARS[32] = {
+ '\'', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
+ 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '{', '|', '}', '~', (char) 127
+};
+
+enum {
+ PAD_ENCODE = 0, // Not really a mode
+ ASCII_ENCODE,
+ C40_ENCODE,
+ TEXT_ENCODE,
+ ANSIX12_ENCODE,
+ EDIFACT_ENCODE,
+ BASE256_ENCODE
+};
+
+@interface ZXDataMatrixDecodedBitStreamParser ()
+
++ (BOOL)decodeAnsiX12Segment:(ZXBitSource *)bits result:(NSMutableString *)result;
++ (int)decodeAsciiSegment:(ZXBitSource *)bits result:(NSMutableString *)result resultTrailer:(NSMutableString *)resultTrailer;
++ (BOOL)decodeBase256Segment:(ZXBitSource *)bits result:(NSMutableString *)result byteSegments:(NSMutableArray *)byteSegments;
++ (BOOL)decodeC40Segment:(ZXBitSource *)bits result:(NSMutableString *)result;
++ (void)decodeEdifactSegment:(ZXBitSource *)bits result:(NSMutableString *)result;
++ (BOOL)decodeTextSegment:(ZXBitSource *)bits result:(NSMutableString *)result;
++ (void)parseTwoBytes:(int)firstByte secondByte:(int)secondByte result:(int[])result;
++ (int)unrandomize255State:(int)randomizedBase256Codeword base256CodewordPosition:(int)base256CodewordPosition;
+
+@end
+
+@implementation ZXDataMatrixDecodedBitStreamParser
+
++ (ZXDecoderResult *)decode:(unsigned char *)bytes length:(unsigned int)length error:(NSError **)error {
+ ZXBitSource *bits = [[[ZXBitSource alloc] initWithBytes:bytes length:length] autorelease];
+ NSMutableString *result = [NSMutableString stringWithCapacity:100];
+ NSMutableString *resultTrailer = [NSMutableString string];
+ NSMutableArray *byteSegments = [NSMutableArray arrayWithCapacity:1];
+ int mode = ASCII_ENCODE;
+ do {
+ if (mode == ASCII_ENCODE) {
+ mode = [self decodeAsciiSegment:bits result:result resultTrailer:resultTrailer];
+ if (mode == -1) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ } else {
+ switch (mode) {
+ case C40_ENCODE:
+ if (![self decodeC40Segment:bits result:result]) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ break;
+ case TEXT_ENCODE:
+ if (![self decodeTextSegment:bits result:result]) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ break;
+ case ANSIX12_ENCODE:
+ if (![self decodeAnsiX12Segment:bits result:result]) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ break;
+ case EDIFACT_ENCODE:
+ [self decodeEdifactSegment:bits result:result];
+ break;
+ case BASE256_ENCODE:
+ if (![self decodeBase256Segment:bits result:result byteSegments:byteSegments]) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ break;
+ default:
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ mode = ASCII_ENCODE;
+ }
+ } while (mode != PAD_ENCODE && bits.available > 0);
+ if ([resultTrailer length] > 0) {
+ [result appendString:resultTrailer];
+ }
+ return [[[ZXDecoderResult alloc] initWithRawBytes:bytes
+ length:length
+ text:result
+ byteSegments:[byteSegments count] == 0 ? nil : byteSegments
+ ecLevel:nil] autorelease];
+}
+
+
+/**
+ * See ISO 16022:2006, 5.2.3 and Annex C, Table C.2
+ */
++ (int)decodeAsciiSegment:(ZXBitSource *)bits result:(NSMutableString *)result resultTrailer:(NSMutableString *)resultTrailer {
+ BOOL upperShift = NO;
+ do {
+ int oneByte = [bits readBits:8];
+ if (oneByte == 0) {
+ return -1;
+ } else if (oneByte <= 128) { // ASCII data (ASCII value + 1)
+ if (upperShift) {
+ oneByte += 128;
+ //upperShift = NO;
+ }
+ [result appendFormat:@"%C", (unichar)(oneByte - 1)];
+ return ASCII_ENCODE;
+ } else if (oneByte == 129) { // Pad
+ return PAD_ENCODE;
+ } else if (oneByte <= 229) { // 2-digit data 00-99 (Numeric Value + 130)
+ int value = oneByte - 130;
+ if (value < 10) { // padd with '0' for single digit values
+ [result appendString:@"0"];
+ }
+ [result appendFormat:@"%d", value];
+ } else if (oneByte == 230) { // Latch to C40 encodation
+ return C40_ENCODE;
+ } else if (oneByte == 231) { // Latch to Base 256 encodation
+ return BASE256_ENCODE;
+ } else if (oneByte == 232) {
+ // FNC1
+ [result appendFormat:@"%C", (unichar)29]; // translate as ASCII 29
+ } else if (oneByte == 233 || oneByte == 234) {
+ // Structured Append, Reader Programming
+ // Ignore these symbols for now
+ //return -1;
+ } else if (oneByte == 235) { // Upper Shift (shift to Extended ASCII)
+ upperShift = YES;
+ } else if (oneByte == 236) { // 05 Macro
+ [result appendFormat:@"[)>%C%C", (unichar)0x001E05, (unichar)0x001D];
+ [resultTrailer insertString:[NSString stringWithFormat:@"%C%C", (unichar)0x001E, (unichar)0x0004] atIndex:0];
+ } else if (oneByte == 237) { // 06 Macro
+ [result appendFormat:@"[)>%C%C", (unichar)0x001E06, (unichar)0x001D];
+ [resultTrailer insertString:[NSString stringWithFormat:@"%C%C", (unichar)0x001E, (unichar)0x0004] atIndex:0];
+ } else if (oneByte == 238) { // Latch to ANSI X12 encodation
+ return ANSIX12_ENCODE;
+ } else if (oneByte == 239) { // Latch to Text encodation
+ return TEXT_ENCODE;
+ } else if (oneByte == 240) { // Latch to EDIFACT encodation
+ return EDIFACT_ENCODE;
+ } else if (oneByte == 241) { // ECI Character
+ // TODO(bbrown): I think we need to support ECI
+ // Ignore this symbol for now
+ } else if (oneByte >= 242) { // Not to be used in ASCII encodation
+ // ... but work around encoders that end with 254, latch back to ASCII
+ if (oneByte != 254 || bits.available != 0) {
+ return -1;
+ }
+ }
+ } while (bits.available > 0);
+ return ASCII_ENCODE;
+}
+
+
+/**
+ * See ISO 16022:2006, 5.2.5 and Annex C, Table C.1
+ */
++ (BOOL)decodeC40Segment:(ZXBitSource *)bits result:(NSMutableString *)result {
+ // Three C40 values are encoded in a 16-bit value as
+ // (1600 * C1) + (40 * C2) + C3 + 1
+ // TODO(bbrown): The Upper Shift with C40 doesn't work in the 4 value scenario all the time
+ BOOL upperShift = NO;
+
+ int cValues[3] = {0};
+ int shift = 0;
+
+ do {
+ // If there is only one byte left then it will be encoded as ASCII
+ if ([bits available] == 8) {
+ return YES;
+ }
+ int firstByte = [bits readBits:8];
+ if (firstByte == 254) { // Unlatch codeword
+ return YES;
+ }
+
+ [self parseTwoBytes:firstByte secondByte:[bits readBits:8] result:cValues];
+
+ for (int i = 0; i < 3; i++) {
+ int cValue = cValues[i];
+ switch (shift) {
+ case 0:
+ if (cValue < 3) {
+ shift = cValue + 1;
+ } else if (cValue < sizeof(C40_BASIC_SET_CHARS) / sizeof(char)) {
+ unichar c40char = C40_BASIC_SET_CHARS[cValue];
+ if (upperShift) {
+ [result appendFormat:@"%C", (unichar)(c40char + 128)];
+ upperShift = NO;
+ } else {
+ [result appendFormat:@"%C", c40char];
+ }
+ } else {
+ return NO;
+ }
+ break;
+ case 1:
+ if (upperShift) {
+ [result appendFormat:@"%C", (unichar)(cValue + 128)];
+ upperShift = NO;
+ } else {
+ [result appendFormat:@"%C", (unichar)cValue];
+ }
+ shift = 0;
+ break;
+ case 2:
+ if (cValue < sizeof(C40_SHIFT2_SET_CHARS) / sizeof(char)) {
+ unichar c40char = C40_SHIFT2_SET_CHARS[cValue];
+ if (upperShift) {
+ [result appendFormat:@"%C", (unichar)(c40char + 128)];
+ upperShift = NO;
+ } else {
+ [result appendFormat:@"%C", c40char];
+ }
+ } else if (cValue == 27) { // FNC1
+ [result appendFormat:@"%C", (unichar)29]; // translate as ASCII 29
+ } else if (cValue == 30) { // Upper Shift
+ upperShift = YES;
+ } else {
+ return NO;
+ }
+ shift = 0;
+ break;
+ case 3:
+ if (upperShift) {
+ [result appendFormat:@"%C", (unichar)(cValue + 224)];
+ upperShift = NO;
+ } else {
+ [result appendFormat:@"%C", (unichar)(cValue + 96)];
+ }
+ shift = 0;
+ break;
+ default:
+ return NO;
+ }
+ }
+ } while (bits.available > 0);
+
+ return YES;
+}
+
+
+/**
+ * See ISO 16022:2006, 5.2.6 and Annex C, Table C.2
+ */
++ (BOOL)decodeTextSegment:(ZXBitSource *)bits result:(NSMutableString *)result {
+ // Three Text values are encoded in a 16-bit value as
+ // (1600 * C1) + (40 * C2) + C3 + 1
+ // TODO(bbrown): The Upper Shift with Text doesn't work in the 4 value scenario all the time
+ BOOL upperShift = NO;
+
+ int cValues[3] = {0};
+
+ int shift = 0;
+ do {
+ // If there is only one byte left then it will be encoded as ASCII
+ if (bits.available == 8) {
+ return YES;
+ }
+ int firstByte = [bits readBits:8];
+ if (firstByte == 254) { // Unlatch codeword
+ return YES;
+ }
+
+ [self parseTwoBytes:firstByte secondByte:[bits readBits:8] result:cValues];
+
+ for (int i = 0; i < 3; i++) {
+ int cValue = cValues[i];
+ switch (shift) {
+ case 0:
+ if (cValue < 3) {
+ shift = cValue + 1;
+ } else if (cValue < sizeof(TEXT_BASIC_SET_CHARS) / sizeof(char)) {
+ unichar textChar = TEXT_BASIC_SET_CHARS[cValue];
+ if (upperShift) {
+ [result appendFormat:@"%C", (unichar)(textChar + 128)];
+ upperShift = NO;
+ } else {
+ [result appendFormat:@"%C", textChar];
+ }
+ } else {
+ return NO;
+ }
+ break;
+ case 1:
+ if (upperShift) {
+ [result appendFormat:@"%C", (unichar)(cValue + 128)];
+ upperShift = NO;
+ } else {
+ [result appendFormat:@"%C", (unichar)cValue];
+ }
+ shift = 0;
+ break;
+ case 2:
+ // Shift 2 for Text is the same encoding as C40
+ if (cValue < sizeof(C40_SHIFT2_SET_CHARS) / sizeof(char)) {
+ unichar c40char = C40_SHIFT2_SET_CHARS[cValue];
+ if (upperShift) {
+ [result appendFormat:@"%C", (unichar)(c40char + 128)];
+ upperShift = NO;
+ } else {
+ [result appendFormat:@"%C", c40char];
+ }
+ } else if (cValue == 27) {
+ [result appendFormat:@"%C", (unichar)29]; // translate as ASCII 29
+ } else if (cValue == 30) { // Upper Shift
+ upperShift = YES;
+ } else {
+ return NO;
+ }
+ shift = 0;
+ break;
+ case 3:
+ if (cValue < sizeof(TEXT_SHIFT3_SET_CHARS) / sizeof(char)) {
+ unichar textChar = TEXT_SHIFT3_SET_CHARS[cValue];
+ if (upperShift) {
+ [result appendFormat:@"%C", (unichar)(textChar + 128)];
+ upperShift = NO;
+ } else {
+ [result appendFormat:@"%C", textChar];
+ }
+ shift = 0;
+ } else {
+ return NO;
+ }
+ break;
+ default:
+ return NO;
+ }
+ }
+ } while (bits.available > 0);
+ return YES;
+}
+
+
+/**
+ * See ISO 16022:2006, 5.2.7
+ */
++ (BOOL)decodeAnsiX12Segment:(ZXBitSource *)bits result:(NSMutableString *)result {
+ // Three ANSI X12 values are encoded in a 16-bit value as
+ // (1600 * C1) + (40 * C2) + C3 + 1
+
+ int cValues[3] = {0};
+ do {
+ // If there is only one byte left then it will be encoded as ASCII
+ if (bits.available == 8) {
+ return YES;
+ }
+ int firstByte = [bits readBits:8];
+ if (firstByte == 254) { // Unlatch codeword
+ return YES;
+ }
+
+ [self parseTwoBytes:firstByte secondByte:[bits readBits:8] result:cValues];
+
+ for (int i = 0; i < 3; i++) {
+ int cValue = cValues[i];
+ if (cValue == 0) { // X12 segment terminator <CR>
+ [result appendString:@"\r"];
+ } else if (cValue == 1) { // X12 segment separator *
+ [result appendString:@"*"];
+ } else if (cValue == 2) { // X12 sub-element separator >
+ [result appendString:@">"];
+ } else if (cValue == 3) { // space
+ [result appendString:@" "];
+ } else if (cValue < 14) { // 0 - 9
+ [result appendFormat:@"%C", (unichar)(cValue + 44)];
+ } else if (cValue < 40) { // A - Z
+ [result appendFormat:@"%C", (unichar)(cValue + 51)];
+ } else {
+ return NO;
+ }
+ }
+ } while (bits.available > 0);
+ return YES;
+}
+
++ (void)parseTwoBytes:(int)firstByte secondByte:(int)secondByte result:(int[])result {
+ int fullBitValue = (firstByte << 8) + secondByte - 1;
+ int temp = fullBitValue / 1600;
+ result[0] = temp;
+ fullBitValue -= temp * 1600;
+ temp = fullBitValue / 40;
+ result[1] = temp;
+ result[2] = fullBitValue - temp * 40;
+}
+
+
+/**
+ * See ISO 16022:2006, 5.2.8 and Annex C Table C.3
+ */
++ (void)decodeEdifactSegment:(ZXBitSource *)bits result:(NSMutableString *)result {
+ do {
+ // If there is only two or less bytes left then it will be encoded as ASCII
+ if (bits.available <= 16) {
+ return;
+ }
+
+ for (int i = 0; i < 4; i++) {
+ int edifactValue = [bits readBits:6];
+
+ // Check for the unlatch character
+ if (edifactValue == 0x1F) { // 011111
+ // Read rest of byte, which should be 0, and stop
+ int bitsLeft = 8 - bits.bitOffset;
+ if (bitsLeft != 8) {
+ [bits readBits:bitsLeft];
+ }
+ return;
+ }
+
+ if ((edifactValue & 0x20) == 0) { // no 1 in the leading (6th) bit
+ edifactValue |= 0x40; // Add a leading 01 to the 6 bit binary value
+ }
+ [result appendFormat:@"%c", (char)edifactValue];
+ }
+ } while (bits.available > 0);
+}
+
+
+/**
+ * See ISO 16022:2006, 5.2.9 and Annex B, B.2
+ */
++ (BOOL)decodeBase256Segment:(ZXBitSource *)bits result:(NSMutableString *)result byteSegments:(NSMutableArray *)byteSegments {
+ int codewordPosition = 1 + bits.byteOffset; // position is 1-indexed
+ int d1 = [self unrandomize255State:[bits readBits:8] base256CodewordPosition:codewordPosition++];
+ int count;
+ if (d1 == 0) {
+ count = [bits available] / 8;
+ } else if (d1 < 250) {
+ count = d1;
+ } else {
+ count = 250 * (d1 - 249) + [self unrandomize255State:[bits readBits:8] base256CodewordPosition:codewordPosition++];
+ }
+
+ if (count < 0) {
+ return NO;
+ }
+
+ NSMutableArray *bytesArray = [NSMutableArray arrayWithCapacity:count];
+ unsigned char bytes[count];
+ for (int i = 0; i < count; i++) {
+ if ([bits available] < 8) {
+ return NO;
+ }
+ unsigned char byte = (unsigned char)[self unrandomize255State:[bits readBits:8] base256CodewordPosition:codewordPosition++];
+ bytes[i] = byte;
+ [bytesArray addObject:[NSNumber numberWithChar:byte]];
+ }
+ [byteSegments addObject:bytesArray];
+
+ [result appendString:[[[NSString alloc] initWithBytes:bytes length:count encoding:NSISOLatin1StringEncoding] autorelease]];
+ return YES;
+}
+
+
+/**
+ * See ISO 16022:2006, Annex B, B.2
+ */
++ (int)unrandomize255State:(int)randomizedBase256Codeword base256CodewordPosition:(int)base256CodewordPosition {
+ int pseudoRandomNumber = ((149 * base256CodewordPosition) % 255) + 1;
+ int tempVariable = randomizedBase256Codeword - pseudoRandomNumber;
+ return tempVariable >= 0 ? tempVariable : tempVariable + 256;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..03506ae2c24db44d9e4860e1be2defb0d9269f7f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDecoder.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The main class which implements Data Matrix Code decoding -- as opposed to locating and extracting
+ * the Data Matrix Code from an image.
+ */
+
+@class ZXBitMatrix, ZXDecoderResult, ZXReedSolomonDecoder;
+
+@interface ZXDataMatrixDecoder : NSObject
+
+- (ZXDecoderResult *)decode:(BOOL **)image length:(unsigned int)length error:(NSError **)error;
+- (ZXDecoderResult *)decodeMatrix:(ZXBitMatrix *)bits error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..c5c3ce673377a71d6b0c346ad5b858e7b2744840
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixDecoder.m
@@ -0,0 +1,146 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXDataMatrixBitMatrixParser.h"
+#import "ZXDataMatrixDataBlock.h"
+#import "ZXDataMatrixDecodedBitStreamParser.h"
+#import "ZXDataMatrixDecoder.h"
+#import "ZXDataMatrixVersion.h"
+#import "ZXDecoderResult.h"
+#import "ZXErrors.h"
+#import "ZXGenericGF.h"
+#import "ZXReedSolomonDecoder.h"
+
+@interface ZXDataMatrixDecoder ()
+
+@property (nonatomic, retain) ZXReedSolomonDecoder *rsDecoder;
+
+- (BOOL)correctErrors:(NSMutableArray *)codewordBytes numDataCodewords:(int)numDataCodewords error:(NSError **)error;
+
+@end
+
+@implementation ZXDataMatrixDecoder
+
+@synthesize rsDecoder;
+
+- (id) init {
+ if (self = [super init]) {
+ self.rsDecoder = [[[ZXReedSolomonDecoder alloc] initWithField:[ZXGenericGF DataMatrixField256]] autorelease];
+ }
+
+ return self;
+}
+
+- (void) dealloc {
+ [rsDecoder release];
+
+ [super dealloc];
+}
+
+
+/**
+ * Convenience method that can decode a Data Matrix Code represented as a 2D array of booleans.
+ * "true" is taken to mean a black module.
+ */
+- (ZXDecoderResult *)decode:(BOOL **)image length:(unsigned int)length error:(NSError **)error {
+ int dimension = length;
+ ZXBitMatrix *bits = [[[ZXBitMatrix alloc] initWithDimension:dimension] autorelease];
+ for (int i = 0; i < dimension; i++) {
+ for (int j = 0; j < dimension; j++) {
+ if (image[i][j]) {
+ [bits setX:j y:i];
+ }
+ }
+ }
+
+ return [self decodeMatrix:bits error:error];
+}
+
+
+/**
+ * Decodes a Data Matrix Code represented as a BitMatrix. A 1 or "true" is taken
+ * to mean a black module.
+ */
+- (ZXDecoderResult *)decodeMatrix:(ZXBitMatrix *)bits error:(NSError **)error {
+ ZXDataMatrixBitMatrixParser *parser = [[[ZXDataMatrixBitMatrixParser alloc] initWithBitMatrix:bits error:error] autorelease];
+ if (!parser) {
+ return nil;
+ }
+ ZXDataMatrixVersion *version = [parser version];
+
+ NSArray *codewords = [parser readCodewords];
+ NSArray *dataBlocks = [ZXDataMatrixDataBlock dataBlocks:codewords version:version];
+
+ int dataBlocksCount = [dataBlocks count];
+
+ int totalBytes = 0;
+ for (int i = 0; i < dataBlocksCount; i++) {
+ totalBytes += [[dataBlocks objectAtIndex:i] numDataCodewords];
+ }
+
+ if (totalBytes == 0) {
+ return nil;
+ }
+
+ unsigned char resultBytes[totalBytes];
+
+ for (int j = 0; j < dataBlocksCount; j++) {
+ ZXDataMatrixDataBlock *dataBlock = [dataBlocks objectAtIndex:j];
+ NSMutableArray *codewordBytes = dataBlock.codewords;
+ int numDataCodewords = [dataBlock numDataCodewords];
+ if (![self correctErrors:codewordBytes numDataCodewords:numDataCodewords error:error]) {
+ return nil;
+ }
+ for (int i = 0; i < numDataCodewords; i++) {
+ resultBytes[i * dataBlocksCount + j] = [[codewordBytes objectAtIndex:i] charValue];
+ }
+ }
+
+ return [ZXDataMatrixDecodedBitStreamParser decode:resultBytes length:totalBytes error:error];
+}
+
+
+/**
+ * Given data and error-correction codewords received, possibly corrupted by errors, attempts to
+ * correct the errors in-place using Reed-Solomon error correction.
+ */
+- (BOOL)correctErrors:(NSMutableArray *)codewordBytes numDataCodewords:(int)numDataCodewords error:(NSError **)error {
+ int numCodewords = [codewordBytes count];
+ int codewordsInts[numCodewords];
+ for (int i = 0; i < numCodewords; i++) {
+ codewordsInts[i] = [[codewordBytes objectAtIndex:i] charValue] & 0xFF;
+ }
+ int numECCodewords = [codewordBytes count] - numDataCodewords;
+
+ NSError *decodeError = nil;
+ if (![rsDecoder decode:codewordsInts receivedLen:numCodewords twoS:numECCodewords error:&decodeError]) {
+ if (decodeError.code == ZXReedSolomonError) {
+ if (error) *error = ChecksumErrorInstance();
+ return NO;
+ } else {
+ if (error) *error = decodeError;
+ return NO;
+ }
+ }
+
+ for (int i = 0; i < numDataCodewords; i++) {
+ [codewordBytes replaceObjectAtIndex:i withObject:[NSNumber numberWithChar:codewordsInts[i]]];
+ }
+ return YES;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixVersion.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixVersion.h
new file mode 100644
index 0000000000000000000000000000000000000000..e25f3401005c3779a147150517d6956cf28443cd
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixVersion.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates a set of error-correction blocks in one symbol version. Most versions will
+ * use blocks of differing sizes within one version, so, this encapsulates the parameters for
+ * each set of blocks. It also holds the number of error-correction codewords per block since it
+ * will be the same across all blocks within one version.
+ */
+
+@interface ZXDataMatrixECBlocks : NSObject
+
+@property (nonatomic, retain, readonly) NSArray *ecBlocks;
+@property (nonatomic, assign, readonly) int ecCodewords;
+
+@end
+
+/**
+ * Encapsualtes the parameters for one error-correction block in one symbol version.
+ * This includes the number of data codewords, and the number of times a block with these
+ * parameters is used consecutively in the Data Matrix code version's format.
+ */
+
+@interface ZXDataMatrixECB : NSObject
+
+@property (nonatomic, assign, readonly) int count;
+@property (nonatomic, assign, readonly) int dataCodewords;
+
+@end
+
+/**
+ * The Version object encapsulates attributes about a particular
+ * size Data Matrix Code.
+ */
+
+@interface ZXDataMatrixVersion : NSObject
+
+@property (nonatomic, retain, readonly) ZXDataMatrixECBlocks *ecBlocks;
+@property (nonatomic, assign, readonly) int dataRegionSizeColumns;
+@property (nonatomic, assign, readonly) int dataRegionSizeRows;
+@property (nonatomic, assign, readonly) int symbolSizeColumns;
+@property (nonatomic, assign, readonly) int symbolSizeRows;
+@property (nonatomic, assign, readonly) int totalCodewords;
+@property (nonatomic, assign, readonly) int versionNumber;
+
++ (ZXDataMatrixVersion *)versionForDimensions:(int)numRows numColumns:(int)numColumns;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixVersion.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixVersion.m
new file mode 100644
index 0000000000000000000000000000000000000000..10b7498633f613cf7e9045db558d79da475c426d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/decoder/ZXDataMatrixVersion.m
@@ -0,0 +1,464 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDataMatrixVersion.h"
+
+@interface ZXDataMatrixECBlocks ()
+
+@property (nonatomic, retain) NSArray *ecBlocks;
+@property (nonatomic, assign) int ecCodewords;
+
+@end
+
+@implementation ZXDataMatrixECBlocks
+
+@synthesize ecBlocks;
+@synthesize ecCodewords;
+
+- (id)initWithCodewords:(int)theEcCodewords ecBlocks:(ZXDataMatrixECB *)theEcBlocks {
+ if (self = [super init]) {
+ self.ecCodewords = theEcCodewords;
+ self.ecBlocks = [NSArray arrayWithObjects:theEcBlocks, nil];
+ }
+
+ return self;
+}
+
+- (id)initWithCodewords:(int)theEcCodewords ecBlocks1:(ZXDataMatrixECB *)ecBlocks1 ecBlocks2:(ZXDataMatrixECB *)ecBlocks2 {
+ if (self = [super init]) {
+ self.ecCodewords = theEcCodewords;
+ self.ecBlocks = [NSArray arrayWithObjects:ecBlocks1, ecBlocks2, nil];
+ }
+
+ return self;
+}
+
+- (void) dealloc {
+ [ecBlocks release];
+
+ [super dealloc];
+}
+
+@end
+
+@interface ZXDataMatrixECB ()
+
+@property (nonatomic, assign) int count;
+@property (nonatomic, assign) int dataCodewords;
+
+@end
+
+@implementation ZXDataMatrixECB
+
+@synthesize count;
+@synthesize dataCodewords;
+
+- (id)initWithCount:(int)aCount dataCodewords:(int)theDataCodewords {
+ if (self = [super init]) {
+ self.count = aCount;
+ self.dataCodewords = theDataCodewords;
+ }
+
+ return self;
+}
+
+@end
+
+static NSArray *VERSIONS = nil;
+
+@interface ZXDataMatrixVersion ()
+
+@property (nonatomic, retain) ZXDataMatrixECBlocks *ecBlocks;
+@property (nonatomic, assign) int dataRegionSizeRows;
+@property (nonatomic, assign) int dataRegionSizeColumns;
+@property (nonatomic, assign) int symbolSizeColumns;
+@property (nonatomic, assign) int symbolSizeRows;
+@property (nonatomic, assign) int totalCodewords;
+@property (nonatomic, assign) int versionNumber;
+
+@end
+
+@implementation ZXDataMatrixVersion
+
+@synthesize ecBlocks;
+@synthesize dataRegionSizeColumns;
+@synthesize dataRegionSizeRows;
+@synthesize symbolSizeColumns;
+@synthesize symbolSizeRows;
+@synthesize totalCodewords;
+@synthesize versionNumber;
+
+- (id)initWithVersionNumber:(int)aVersionNumber symbolSizeRows:(int)theSymbolSizeRows symbolSizeColumns:(int)theSymbolSizeColumns dataRegionSizeRows:(int)theDataRegionSizeRows dataRegionSizeColumns:(int)theDataRegionSizeColumns ecBlocks:(ZXDataMatrixECBlocks *)anEcBlocks {
+ if (self = [super init]) {
+ self.versionNumber = aVersionNumber;
+ self.symbolSizeRows = theSymbolSizeRows;
+ self.symbolSizeColumns = theSymbolSizeColumns;
+ self.dataRegionSizeRows = theDataRegionSizeRows;
+ self.dataRegionSizeColumns = theDataRegionSizeColumns;
+ self.ecBlocks = anEcBlocks;
+
+ int total = 0;
+ int ecCodewords = ecBlocks.ecCodewords;
+ NSArray *ecbArray = ecBlocks.ecBlocks;
+ for (ZXDataMatrixECB *ecBlock in ecbArray) {
+ total += ecBlock.count * (ecBlock.dataCodewords + ecCodewords);
+ }
+ self.totalCodewords = total;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [ecBlocks release];
+
+ [super dealloc];
+}
+
+
+/**
+ * Deduces version information from Data Matrix dimensions.
+ */
++ (ZXDataMatrixVersion *)versionForDimensions:(int)numRows numColumns:(int)numColumns {
+ if ((numRows & 0x01) != 0 || (numColumns & 0x01) != 0) {
+ return nil;
+ }
+
+ for (ZXDataMatrixVersion *version in VERSIONS) {
+ if (version.symbolSizeRows == numRows && version.symbolSizeColumns == numColumns) {
+ return version;
+ }
+ }
+
+ return nil;
+}
+
+- (NSString *)description {
+ return [[NSNumber numberWithInt:versionNumber] stringValue];
+}
+
+
+/**
+ * See ISO 16022:2006 5.5.1 Table 7
+ */
++ (void)initialize {
+ VERSIONS = [[NSArray alloc] initWithObjects:
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:1
+ symbolSizeRows:10
+ symbolSizeColumns:10
+ dataRegionSizeRows:8
+ dataRegionSizeColumns:8
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:5
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:3] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:2
+ symbolSizeRows:12
+ symbolSizeColumns:12
+ dataRegionSizeRows:10
+ dataRegionSizeColumns:10
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:7
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:5] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:3
+ symbolSizeRows:14
+ symbolSizeColumns:14
+ dataRegionSizeRows:12
+ dataRegionSizeColumns:12
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:10
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:8] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:4
+ symbolSizeRows:16
+ symbolSizeColumns:16
+ dataRegionSizeRows:14
+ dataRegionSizeColumns:14
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:12
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:12] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:5
+ symbolSizeRows:18
+ symbolSizeColumns:18
+ dataRegionSizeRows:16
+ dataRegionSizeColumns:16
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:14
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:18] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:6
+ symbolSizeRows:20
+ symbolSizeColumns:20
+ dataRegionSizeRows:18
+ dataRegionSizeColumns:18
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:18
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:22] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:7
+ symbolSizeRows:22
+ symbolSizeColumns:22
+ dataRegionSizeRows:20
+ dataRegionSizeColumns:20
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:20
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:30] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:8
+ symbolSizeRows:24
+ symbolSizeColumns:24
+ dataRegionSizeRows:22
+ dataRegionSizeColumns:22
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:24
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:36] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:9
+ symbolSizeRows:26
+ symbolSizeColumns:26
+ dataRegionSizeRows:24
+ dataRegionSizeColumns:24
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:28
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:44] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:10
+ symbolSizeRows:32
+ symbolSizeColumns:32
+ dataRegionSizeRows:14
+ dataRegionSizeColumns:14
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:36
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:62] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:11
+ symbolSizeRows:36
+ symbolSizeColumns:36
+ dataRegionSizeRows:16
+ dataRegionSizeColumns:16
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:42
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:86] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:12
+ symbolSizeRows:40
+ symbolSizeColumns:40
+ dataRegionSizeRows:18
+ dataRegionSizeColumns:18
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:48
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:114] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:13
+ symbolSizeRows:44
+ symbolSizeColumns:44
+ dataRegionSizeRows:20
+ dataRegionSizeColumns:20
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:56
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:144] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:14
+ symbolSizeRows:48
+ symbolSizeColumns:48
+ dataRegionSizeRows:22
+ dataRegionSizeColumns:22
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:68
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:174] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:15
+ symbolSizeRows:52
+ symbolSizeColumns:52
+ dataRegionSizeRows:24
+ dataRegionSizeColumns:24
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:42
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:2 dataCodewords:102] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:16
+ symbolSizeRows:64
+ symbolSizeColumns:64
+ dataRegionSizeRows:14
+ dataRegionSizeColumns:14
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:56
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:2 dataCodewords:140] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:17
+ symbolSizeRows:72
+ symbolSizeColumns:72
+ dataRegionSizeRows:16
+ dataRegionSizeColumns:16
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:36
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:4 dataCodewords:92] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:18
+ symbolSizeRows:80
+ symbolSizeColumns:80
+ dataRegionSizeRows:18
+ dataRegionSizeColumns:18
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:48
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:4 dataCodewords:114] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:19
+ symbolSizeRows:88
+ symbolSizeColumns:88
+ dataRegionSizeRows:20
+ dataRegionSizeColumns:20
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:56
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:4 dataCodewords:144] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:20
+ symbolSizeRows:96
+ symbolSizeColumns:96
+ dataRegionSizeRows:22
+ dataRegionSizeColumns:22
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:68
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:4 dataCodewords:174] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:21
+ symbolSizeRows:104
+ symbolSizeColumns:104
+ dataRegionSizeRows:24
+ dataRegionSizeColumns:24
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:56
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:6 dataCodewords:136] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:22
+ symbolSizeRows:120
+ symbolSizeColumns:120
+ dataRegionSizeRows:18
+ dataRegionSizeColumns:18
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:68
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:6 dataCodewords:175] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:23
+ symbolSizeRows:132
+ symbolSizeColumns:132
+ dataRegionSizeRows:20
+ dataRegionSizeColumns:20
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:62
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:8 dataCodewords:163] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:24
+ symbolSizeRows:144
+ symbolSizeColumns:144
+ dataRegionSizeRows:22
+ dataRegionSizeColumns:22
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:62
+ ecBlocks1:
+ [[[ZXDataMatrixECB alloc] initWithCount:8 dataCodewords:156] autorelease]
+ ecBlocks2:
+ [[[ZXDataMatrixECB alloc] initWithCount:2 dataCodewords:155] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:25
+ symbolSizeRows:8
+ symbolSizeColumns:18
+ dataRegionSizeRows:6
+ dataRegionSizeColumns:16
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:7
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:5] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:26
+ symbolSizeRows:8
+ symbolSizeColumns:32
+ dataRegionSizeRows:6
+ dataRegionSizeColumns:14
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:11
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:10] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:27
+ symbolSizeRows:12
+ symbolSizeColumns:26
+ dataRegionSizeRows:10
+ dataRegionSizeColumns:24
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:14
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:16] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:28
+ symbolSizeRows:12
+ symbolSizeColumns:36
+ dataRegionSizeRows:10
+ dataRegionSizeColumns:16
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:18
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:22] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:29
+ symbolSizeRows:16
+ symbolSizeColumns:36
+ dataRegionSizeRows:14
+ dataRegionSizeColumns:16
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:24
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:32] autorelease]] autorelease]] autorelease],
+
+ [[[ZXDataMatrixVersion alloc] initWithVersionNumber:30
+ symbolSizeRows:16
+ symbolSizeColumns:48
+ dataRegionSizeRows:14
+ dataRegionSizeColumns:22
+ ecBlocks:
+ [[[ZXDataMatrixECBlocks alloc] initWithCodewords:28
+ ecBlocks:
+ [[[ZXDataMatrixECB alloc] initWithCount:1 dataCodewords:49] autorelease]] autorelease]] autorelease],
+
+ nil];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/detector/ZXDataMatrixDetector.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/detector/ZXDataMatrixDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..de5f4a23f2e3ad1d6092a2ad9b2124a0071e6e9e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/detector/ZXDataMatrixDetector.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates logic that can detect a Data Matrix Code in an image, even if the Data Matrix Code
+ * is rotated or skewed, or partially obscured.
+ */
+
+@class ZXBitMatrix, ZXDetectorResult, ZXWhiteRectangleDetector;
+
+@interface ZXDataMatrixDetector : NSObject
+
+- (id)initWithImage:(ZXBitMatrix *)image error:(NSError **)error;
+- (ZXDetectorResult *)detectWithError:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/detector/ZXDataMatrixDetector.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/detector/ZXDataMatrixDetector.m
new file mode 100644
index 0000000000000000000000000000000000000000..aa4a089d76f104a1b1afa7079e42d436faafbb25
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/detector/ZXDataMatrixDetector.m
@@ -0,0 +1,406 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDataMatrixDetector.h"
+#import "ZXDetectorResult.h"
+#import "ZXErrors.h"
+#import "ZXGridSampler.h"
+#import "ZXMathUtils.h"
+#import "ZXResultPoint.h"
+#import "ZXWhiteRectangleDetector.h"
+
+/**
+ * Simply encapsulates two points and a number of transitions between them.
+ */
+
+@interface ResultPointsAndTransitions : NSObject
+
+@property(nonatomic, retain) ZXResultPoint *from;
+@property(nonatomic, retain) ZXResultPoint *to;
+@property(nonatomic, assign) int transitions;
+
+- (id)initWithFrom:(ZXResultPoint *)from to:(ZXResultPoint *)to transitions:(int)transitions;
+- (NSComparisonResult)compare:(ResultPointsAndTransitions *)otherObject;
+
+@end
+
+@implementation ResultPointsAndTransitions
+
+@synthesize from;
+@synthesize to;
+@synthesize transitions;
+
+- (id)initWithFrom:(ZXResultPoint *)aFrom to:(ZXResultPoint *)aTo transitions:(int)aTransitions {
+ if (self = [super init]) {
+ self.from = aFrom;
+ self.to = aTo;
+ self.transitions = aTransitions;
+ }
+
+ return self;
+}
+
+- (void) dealloc {
+ [from release];
+ [to release];
+
+ [super dealloc];
+}
+
+- (NSString *)description {
+ return [NSString stringWithFormat:@"%@/%@/%d", self.from, self.to, self.transitions];
+}
+
+- (NSComparisonResult)compare:(ResultPointsAndTransitions *)otherObject {
+ return [[NSNumber numberWithInt:transitions] compare:[NSNumber numberWithInt:otherObject.transitions]];
+}
+
+@end
+
+
+@interface ZXDataMatrixDetector ()
+
+@property (nonatomic, retain) ZXBitMatrix *image;
+@property (nonatomic, retain) ZXWhiteRectangleDetector *rectangleDetector;
+
+- (ZXResultPoint *)correctTopRight:(ZXResultPoint *)bottomLeft bottomRight:(ZXResultPoint *)bottomRight topLeft:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight dimension:(int)dimension;
+- (ZXResultPoint *)correctTopRightRectangular:(ZXResultPoint *)bottomLeft bottomRight:(ZXResultPoint *)bottomRight topLeft:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight dimensionTop:(int)dimensionTop dimensionRight:(int)dimensionRight;
+- (int)distance:(ZXResultPoint *)a b:(ZXResultPoint *)b;
+- (void)increment:(NSMutableDictionary *)table key:(ZXResultPoint *)key;
+- (BOOL)isValid:(ZXResultPoint *)p;
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)image
+ topLeft:(ZXResultPoint *)topLeft
+ bottomLeft:(ZXResultPoint *)bottomLeft
+ bottomRight:(ZXResultPoint *)bottomRight
+ topRight:(ZXResultPoint *)topRight
+ dimensionX:(int)dimensionX
+ dimensionY:(int)dimensionY
+ error:(NSError **)error;
+- (ResultPointsAndTransitions *)transitionsBetween:(ZXResultPoint *)from to:(ZXResultPoint *)to;
+
+@end
+
+@implementation ZXDataMatrixDetector
+
+@synthesize image;
+@synthesize rectangleDetector;
+
+- (id)initWithImage:(ZXBitMatrix *)anImage error:(NSError **)error {
+ if (self = [super init]) {
+ self.image = anImage;
+ self.rectangleDetector = [[[ZXWhiteRectangleDetector alloc] initWithImage:anImage error:error] autorelease];
+ if (!self.rectangleDetector) {
+ [self release];
+ return nil;
+ }
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [image release];
+ [rectangleDetector release];
+
+ [super dealloc];
+}
+
+
+/**
+ * Detects a Data Matrix Code in an image.
+ */
+- (ZXDetectorResult *)detectWithError:(NSError **)error {
+ NSArray *cornerPoints = [self.rectangleDetector detectWithError:error];
+ if (!cornerPoints) {
+ return nil;
+ }
+ ZXResultPoint *pointA = [cornerPoints objectAtIndex:0];
+ ZXResultPoint *pointB = [cornerPoints objectAtIndex:1];
+ ZXResultPoint *pointC = [cornerPoints objectAtIndex:2];
+ ZXResultPoint *pointD = [cornerPoints objectAtIndex:3];
+
+ NSMutableArray *transitions = [NSMutableArray arrayWithCapacity:4];
+ [transitions addObject:[self transitionsBetween:pointA to:pointB]];
+ [transitions addObject:[self transitionsBetween:pointA to:pointC]];
+ [transitions addObject:[self transitionsBetween:pointB to:pointD]];
+ [transitions addObject:[self transitionsBetween:pointC to:pointD]];
+ [transitions sortUsingSelector:@selector(compare:)];
+
+ ResultPointsAndTransitions *lSideOne = (ResultPointsAndTransitions *)[transitions objectAtIndex:0];
+ ResultPointsAndTransitions *lSideTwo = (ResultPointsAndTransitions *)[transitions objectAtIndex:1];
+
+ NSMutableDictionary *pointCount = [NSMutableDictionary dictionary];
+ [self increment:pointCount key:[lSideOne from]];
+ [self increment:pointCount key:[lSideOne to]];
+ [self increment:pointCount key:[lSideTwo from]];
+ [self increment:pointCount key:[lSideTwo to]];
+
+ ZXResultPoint *maybeTopLeft = nil;
+ ZXResultPoint *bottomLeft = nil;
+ ZXResultPoint *maybeBottomRight = nil;
+ for (ZXResultPoint *point in [pointCount allKeys]) {
+ NSNumber *value = [pointCount objectForKey:point];
+ if ([value intValue] == 2) {
+ bottomLeft = point;
+ } else {
+ if (maybeTopLeft == nil) {
+ maybeTopLeft = point;
+ } else {
+ maybeBottomRight = point;
+ }
+ }
+ }
+
+ if (maybeTopLeft == nil || bottomLeft == nil || maybeBottomRight == nil) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ NSMutableArray *corners = [NSMutableArray arrayWithObjects:maybeTopLeft, bottomLeft, maybeBottomRight, nil];
+ [ZXResultPoint orderBestPatterns:corners];
+
+ ZXResultPoint *bottomRight = [corners objectAtIndex:0];
+ bottomLeft = [corners objectAtIndex:1];
+ ZXResultPoint *topLeft = [corners objectAtIndex:2];
+
+ ZXResultPoint *topRight;
+ if (![pointCount objectForKey:pointA]) {
+ topRight = pointA;
+ } else if (![pointCount objectForKey:pointB]) {
+ topRight = pointB;
+ } else if (![pointCount objectForKey:pointC]) {
+ topRight = pointC;
+ } else {
+ topRight = pointD;
+ }
+
+ int dimensionTop = [[self transitionsBetween:topLeft to:topRight] transitions];
+ int dimensionRight = [[self transitionsBetween:bottomRight to:topRight] transitions];
+
+ if ((dimensionTop & 0x01) == 1) {
+ dimensionTop++;
+ }
+ dimensionTop += 2;
+
+ if ((dimensionRight & 0x01) == 1) {
+ dimensionRight++;
+ }
+ dimensionRight += 2;
+
+ ZXBitMatrix *bits;
+ ZXResultPoint *correctedTopRight;
+
+ if (4 * dimensionTop >= 7 * dimensionRight || 4 * dimensionRight >= 7 * dimensionTop) {
+ correctedTopRight = [self correctTopRightRectangular:bottomLeft bottomRight:bottomRight topLeft:topLeft topRight:topRight dimensionTop:dimensionTop dimensionRight:dimensionRight];
+ if (correctedTopRight == nil) {
+ correctedTopRight = topRight;
+ }
+
+ dimensionTop = [[self transitionsBetween:topLeft to:correctedTopRight] transitions];
+ dimensionRight = [[self transitionsBetween:bottomRight to:correctedTopRight] transitions];
+
+ if ((dimensionTop & 0x01) == 1) {
+ dimensionTop++;
+ }
+
+ if ((dimensionRight & 0x01) == 1) {
+ dimensionRight++;
+ }
+
+ bits = [self sampleGrid:image topLeft:topLeft bottomLeft:bottomLeft bottomRight:bottomRight topRight:correctedTopRight dimensionX:dimensionTop dimensionY:dimensionRight error:error];
+ if (!bits) {
+ return nil;
+ }
+ } else {
+ int dimension = MIN(dimensionRight, dimensionTop);
+ correctedTopRight = [self correctTopRight:bottomLeft bottomRight:bottomRight topLeft:topLeft topRight:topRight dimension:dimension];
+ if (correctedTopRight == nil) {
+ correctedTopRight = topRight;
+ }
+
+ int dimensionCorrected = MAX([[self transitionsBetween:topLeft to:correctedTopRight] transitions], [[self transitionsBetween:bottomRight to:correctedTopRight] transitions]);
+ dimensionCorrected++;
+ if ((dimensionCorrected & 0x01) == 1) {
+ dimensionCorrected++;
+ }
+
+ bits = [self sampleGrid:image topLeft:topLeft bottomLeft:bottomLeft bottomRight:bottomRight topRight:correctedTopRight dimensionX:dimensionCorrected dimensionY:dimensionCorrected error:error];
+ if (!bits) {
+ return nil;
+ }
+ }
+ return [[[ZXDetectorResult alloc] initWithBits:bits
+ points:[NSArray arrayWithObjects:topLeft, bottomLeft, bottomRight, correctedTopRight, nil]] autorelease];
+}
+
+
+/**
+ * Calculates the position of the white top right module using the output of the rectangle detector
+ * for a rectangular matrix
+ */
+- (ZXResultPoint *)correctTopRightRectangular:(ZXResultPoint *)bottomLeft bottomRight:(ZXResultPoint *)bottomRight topLeft:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight dimensionTop:(int)dimensionTop dimensionRight:(int)dimensionRight {
+ float corr = [self distance:bottomLeft b:bottomRight] / (float)dimensionTop;
+ int norm = [self distance:topLeft b:topRight];
+ float cos = ([topRight x] - [topLeft x]) / norm;
+ float sin = ([topRight y] - [topLeft y]) / norm;
+
+ ZXResultPoint *c1 = [[[ZXResultPoint alloc] initWithX:[topRight x] + corr * cos y:[topRight y] + corr * sin] autorelease];
+
+ corr = [self distance:bottomLeft b:topLeft] / (float)dimensionRight;
+ norm = [self distance:bottomRight b:topRight];
+ cos = ([topRight x] - [bottomRight x]) / norm;
+ sin = ([topRight y] - [bottomRight y]) / norm;
+
+ ZXResultPoint *c2 = [[[ZXResultPoint alloc] initWithX:[topRight x] + corr * cos y:[topRight y] + corr * sin] autorelease];
+
+ if (![self isValid:c1]) {
+ if ([self isValid:c2]) {
+ return c2;
+ }
+ return nil;
+ } else if (![self isValid:c2]) {
+ return c1;
+ }
+
+ int l1 = abs(dimensionTop - [[self transitionsBetween:topLeft to:c1] transitions]) + abs(dimensionRight - [[self transitionsBetween:bottomRight to:c1] transitions]);
+ int l2 = abs(dimensionTop - [[self transitionsBetween:topLeft to:c2] transitions]) + abs(dimensionRight - [[self transitionsBetween:bottomRight to:c2] transitions]);
+
+ if (l1 <= l2) {
+ return c1;
+ }
+
+ return c2;
+}
+
+
+/**
+ * Calculates the position of the white top right module using the output of the rectangle detector
+ * for a square matrix
+ */
+- (ZXResultPoint *)correctTopRight:(ZXResultPoint *)bottomLeft bottomRight:(ZXResultPoint *)bottomRight topLeft:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight dimension:(int)dimension {
+ float corr = [self distance:bottomLeft b:bottomRight] / (float)dimension;
+ int norm = [self distance:topLeft b:topRight];
+ float cos = ([topRight x] - [topLeft x]) / norm;
+ float sin = ([topRight y] - [topLeft y]) / norm;
+
+ ZXResultPoint *c1 = [[[ZXResultPoint alloc] initWithX:[topRight x] + corr * cos y:[topRight y] + corr * sin] autorelease];
+
+ corr = [self distance:bottomLeft b:topLeft] / (float)dimension;
+ norm = [self distance:bottomRight b:topRight];
+ cos = ([topRight x] - [bottomRight x]) / norm;
+ sin = ([topRight y] - [bottomRight y]) / norm;
+
+ ZXResultPoint *c2 = [[[ZXResultPoint alloc] initWithX:[topRight x] + corr * cos y:[topRight y] + corr * sin] autorelease];
+
+ if (![self isValid:c1]) {
+ if ([self isValid:c2]) {
+ return c2;
+ }
+ return nil;
+ } else if (![self isValid:c2]) {
+ return c1;
+ }
+
+ int l1 = abs([[self transitionsBetween:topLeft to:c1] transitions] - [[self transitionsBetween:bottomRight to:c1] transitions]);
+ int l2 = abs([[self transitionsBetween:topLeft to:c2] transitions] - [[self transitionsBetween:bottomRight to:c2] transitions]);
+
+ return l1 <= l2 ? c1 : c2;
+}
+
+- (BOOL) isValid:(ZXResultPoint *)p {
+ return [p x] >= 0 && [p x] < image.width && [p y] > 0 && [p y] < image.height;
+}
+
+- (int)distance:(ZXResultPoint *)a b:(ZXResultPoint *)b {
+ return [ZXMathUtils round:[ZXResultPoint distance:a pattern2:b]];
+}
+
+
+/**
+ * Increments the Integer associated with a key by one.
+ */
+- (void)increment:(NSMutableDictionary *)table key:(ZXResultPoint *)key {
+ NSNumber *value = [table objectForKey:key];
+ [table setObject:value == nil ? [NSNumber numberWithInt:1] : [NSNumber numberWithInt:[value intValue] + 1] forKey:key];
+}
+
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)anImage
+ topLeft:(ZXResultPoint *)topLeft
+ bottomLeft:(ZXResultPoint *)bottomLeft
+ bottomRight:(ZXResultPoint *)bottomRight
+ topRight:(ZXResultPoint *)topRight
+ dimensionX:(int)dimensionX
+ dimensionY:(int)dimensionY
+ error:(NSError **)error {
+ ZXGridSampler *sampler = [ZXGridSampler instance];
+ return [sampler sampleGrid:anImage
+ dimensionX:dimensionX dimensionY:dimensionY
+ p1ToX:0.5f p1ToY:0.5f
+ p2ToX:dimensionX - 0.5f p2ToY:0.5f
+ p3ToX:dimensionX - 0.5f p3ToY:dimensionY - 0.5f
+ p4ToX:0.5f p4ToY:dimensionY - 0.5f
+ p1FromX:[topLeft x] p1FromY:[topLeft y]
+ p2FromX:[topRight x] p2FromY:[topRight y]
+ p3FromX:[bottomRight x] p3FromY:[bottomRight y]
+ p4FromX:[bottomLeft x] p4FromY:[bottomLeft y]
+ error:error];
+}
+
+
+/**
+ * Counts the number of black/white transitions between two points, using something like Bresenham's algorithm.
+ */
+- (ResultPointsAndTransitions *)transitionsBetween:(ZXResultPoint *)from to:(ZXResultPoint *)to {
+ int fromX = (int)[from x];
+ int fromY = (int)[from y];
+ int toX = (int)[to x];
+ int toY = (int)[to y];
+ BOOL steep = abs(toY - fromY) > abs(toX - fromX);
+ if (steep) {
+ int temp = fromX;
+ fromX = fromY;
+ fromY = temp;
+ temp = toX;
+ toX = toY;
+ toY = temp;
+ }
+
+ int dx = abs(toX - fromX);
+ int dy = abs(toY - fromY);
+ int error = -dx >> 1;
+ int ystep = fromY < toY ? 1 : -1;
+ int xstep = fromX < toX ? 1 : -1;
+ int transitions = 0;
+ BOOL inBlack = [self.image getX:steep ? fromY : fromX y:steep ? fromX : fromY];
+ for (int x = fromX, y = fromY; x != toX; x += xstep) {
+ BOOL isBlack = [self.image getX:steep ? y : x y:steep ? x : y];
+ if (isBlack != inBlack) {
+ transitions++;
+ inBlack = isBlack;
+ }
+ error += dy;
+ if (error > 0) {
+ if (y == toY) {
+ break;
+ }
+ y += ystep;
+ error -= dx;
+ }
+ }
+ return [[[ResultPointsAndTransitions alloc] initWithFrom:from to:to transitions:transitions] autorelease];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXASCIIEncoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXASCIIEncoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..c8e2b12c512f68b41c4589c666f63835f343c502
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXASCIIEncoder.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDataMatrixEncoder.h"
+
+@interface ZXASCIIEncoder : NSObject <ZXDataMatrixEncoder>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXASCIIEncoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXASCIIEncoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..b3f5c84fbef0549a12117415e8c95f5eeb244042
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXASCIIEncoder.m
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXASCIIEncoder.h"
+#import "ZXEncoderContext.h"
+#import "ZXHighLevelEncoder.h"
+
+@interface ZXASCIIEncoder ()
+
+- (unichar)encodeASCIIDigits:(unichar)digit1 digit2:(unichar)digit2;
+
+@end
+
+@implementation ZXASCIIEncoder
+
+- (int)encodingMode {
+ return [ZXHighLevelEncoder asciiEncodation];
+}
+
+- (void)encode:(ZXEncoderContext *)context {
+ //step B
+ int n = [ZXHighLevelEncoder determineConsecutiveDigitCount:context.message startpos:context.pos];
+ if (n >= 2) {
+ [context writeCodeword:[self encodeASCIIDigits:[context.message characterAtIndex:context.pos]
+ digit2:[context.message characterAtIndex:context.pos + 1]]];
+ context.pos += 2;
+ } else {
+ unichar c = [context currentChar];
+ int newMode = [ZXHighLevelEncoder lookAheadTest:context.message startpos:context.pos currentMode:[self encodingMode]];
+ if (newMode != [self encodingMode]) {
+ if (newMode == [ZXHighLevelEncoder base256Encodation]) {
+ [context writeCodeword:[ZXHighLevelEncoder latchToBase256]];
+ [context signalEncoderChange:[ZXHighLevelEncoder base256Encodation]];
+ return;
+ } else if (newMode == [ZXHighLevelEncoder c40Encodation]) {
+ [context writeCodeword:[ZXHighLevelEncoder latchToC40]];
+ [context signalEncoderChange:[ZXHighLevelEncoder c40Encodation]];
+ return;
+ } else if (newMode == [ZXHighLevelEncoder x12Encodation]) {
+ [context writeCodeword:[ZXHighLevelEncoder latchToAnsiX12]];
+ [context signalEncoderChange:[ZXHighLevelEncoder x12Encodation]];
+ } else if (newMode == [ZXHighLevelEncoder textEncodation]) {
+ [context writeCodeword:[ZXHighLevelEncoder latchToText]];
+ [context signalEncoderChange:[ZXHighLevelEncoder textEncodation]];
+ } else if (newMode == [ZXHighLevelEncoder edifactEncodation]) {
+ [context writeCodeword:[ZXHighLevelEncoder latchToEdifact]];
+ [context signalEncoderChange:[ZXHighLevelEncoder edifactEncodation]];
+ } else {
+ @throw [NSException exceptionWithName:@"IllegalStateException" reason:@"Illegal mode" userInfo:nil];
+ }
+ } else if ([ZXHighLevelEncoder isExtendedASCII:c]) {
+ [context writeCodeword:[ZXHighLevelEncoder upperShift]];
+ [context writeCodeword:(unichar)(c - 128 + 1)];
+ context.pos++;
+ } else {
+ [context writeCodeword:(unichar)(c + 1)];
+ context.pos++;
+ }
+ }
+}
+
+- (unichar)encodeASCIIDigits:(unichar)digit1 digit2:(unichar)digit2 {
+ if ([ZXHighLevelEncoder isDigit:digit1] && [ZXHighLevelEncoder isDigit:digit2]) {
+ int num = (digit1 - 48) * 10 + (digit2 - 48);
+ return (unichar) (num + 130);
+ }
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:[NSString stringWithFormat:@"not digits: %C %C", digit1, digit2]
+ userInfo:nil];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXBase256Encoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXBase256Encoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..7142266c372b62ed6aebb8f92aed39a49542356e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXBase256Encoder.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDataMatrixEncoder.h"
+
+@interface ZXBase256Encoder : NSObject <ZXDataMatrixEncoder>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXBase256Encoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXBase256Encoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..01a6af53b3b520248eb8611c142027fe5a51ae69
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXBase256Encoder.m
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBase256Encoder.h"
+#import "ZXEncoderContext.h"
+#import "ZXHighLevelEncoder.h"
+#import "ZXSymbolInfo.h"
+
+@interface ZXBase256Encoder ()
+
+- (unichar)randomize255State:(unichar)ch codewordPosition:(int)codewordPosition;
+
+@end
+
+@implementation ZXBase256Encoder
+
+- (int)encodingMode {
+ return [ZXHighLevelEncoder base256Encodation];
+}
+
+- (void)encode:(ZXEncoderContext *)context {
+ NSMutableString *buffer = [NSMutableString string];
+ [buffer appendString:@"\0"]; //Initialize length field
+ while ([context hasMoreCharacters]) {
+ unichar c = [context currentChar];
+ [buffer appendFormat:@"%C", c];
+
+ context.pos++;
+
+ int newMode = [ZXHighLevelEncoder lookAheadTest:context.message startpos:context.pos currentMode:[self encodingMode]];
+ if (newMode != [self encodingMode]) {
+ [context signalEncoderChange:newMode];
+ break;
+ }
+ }
+ int dataCount = buffer.length - 1;
+ int lengthFieldSize = 1;
+ int currentSize = [context codewordCount] + dataCount + lengthFieldSize;
+ [context updateSymbolInfoWithLength:currentSize];
+ BOOL mustPad = (context.symbolInfo.dataCapacity - currentSize) > 0;
+ if ([context hasMoreCharacters] || mustPad) {
+ if (dataCount <= 249) {
+ [buffer replaceCharactersInRange:NSMakeRange(0, 1)
+ withString:[NSString stringWithFormat:@"%C", (unichar) dataCount]];
+ } else if (dataCount > 249 && dataCount <= 1555) {
+ [buffer replaceCharactersInRange:NSMakeRange(0, 1)
+ withString:[NSString stringWithFormat:@"%C", (unichar) ((dataCount / 250) + 249)]];
+ [buffer insertString:[NSString stringWithFormat:@"%C", (unichar) (dataCount % 250)]
+ atIndex:1];
+ } else {
+ @throw [NSException exceptionWithName:@"IllegalStateException"
+ reason:[NSString stringWithFormat:@"Message length not in valid ranges: %d", dataCount]
+ userInfo:nil];
+ }
+ }
+ for (int i = 0, c = buffer.length; i < c; i++) {
+ [context writeCodeword:[self randomize255State:[buffer characterAtIndex:i] codewordPosition:context.codewordCount + 1]];
+ }
+}
+
+- (unichar)randomize255State:(unichar)ch codewordPosition:(int)codewordPosition {
+ int pseudoRandom = ((149 * codewordPosition) % 255) + 1;
+ int tempVariable = ch + pseudoRandom;
+ if (tempVariable <= 255) {
+ return (unichar) tempVariable;
+ } else {
+ return (unichar) (tempVariable - 256);
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXC40Encoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXC40Encoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..40cca6050492b55c8e4bf67becfa8c0c958f2046
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXC40Encoder.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDataMatrixEncoder.h"
+
+@interface ZXC40Encoder : NSObject <ZXDataMatrixEncoder>
+
+- (int)encodeChar:(unichar)c buffer:(NSMutableString *)sb;
+- (void)writeNextTriplet:(ZXEncoderContext *)context buffer:(NSMutableString *)buffer;
+- (void)handleEOD:(ZXEncoderContext *)context buffer:(NSMutableString *)buffer;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXC40Encoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXC40Encoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..7a2bce21269c426fe4412fda254d62f0cbe756ee
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXC40Encoder.m
@@ -0,0 +1,188 @@
+/*
+ * Copyright 2013 9 authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXC40Encoder.h"
+#import "ZXEncoderContext.h"
+#import "ZXHighLevelEncoder.h"
+#import "ZXSymbolInfo.h"
+
+@interface ZXC40Encoder ()
+
+- (int)backtrackOneCharacter:(ZXEncoderContext *)context buffer:(NSMutableString *)buffer
+ removed:(NSMutableString *)removed lastCharSize:(int)lastCharSize;
+
+@end
+
+@implementation ZXC40Encoder
+
+- (int)encodingMode {
+ return [ZXHighLevelEncoder c40Encodation];
+}
+
+- (void)encode:(ZXEncoderContext *)context {
+ //step C
+ NSMutableString *buffer = [NSMutableString string];
+ while ([context hasMoreCharacters]) {
+ unichar c = [context currentChar];
+ context.pos++;
+
+ int lastCharSize = [self encodeChar:c buffer:buffer];
+
+ int unwritten = (buffer.length / 3) * 2;
+
+ int curCodewordCount = context.codewordCount + unwritten;
+ [context updateSymbolInfoWithLength:curCodewordCount];
+ int available = context.symbolInfo.dataCapacity - curCodewordCount;
+
+ if (![context hasMoreCharacters]) {
+ //Avoid having a single C40 value in the last triplet
+ NSMutableString *removed = [NSMutableString string];
+ if ((buffer.length % 3) == 2) {
+ if (available < 2 || available > 2) {
+ lastCharSize = [self backtrackOneCharacter:context buffer:buffer removed:removed lastCharSize:lastCharSize];
+ }
+ }
+ while ((buffer.length % 3) == 1
+ && ((lastCharSize <= 3 && available != 1) || lastCharSize > 3)) {
+ lastCharSize = [self backtrackOneCharacter:context buffer:buffer removed:removed lastCharSize:lastCharSize];
+ }
+ break;
+ }
+
+ int count = buffer.length;
+ if ((count % 3) == 0) {
+ int newMode = [ZXHighLevelEncoder lookAheadTest:context.message startpos:context.pos currentMode:[self encodingMode]];
+ if (newMode != [self encodingMode]) {
+ [context signalEncoderChange:newMode];
+ break;
+ }
+ }
+ }
+ [self handleEOD:context buffer:buffer];
+}
+
+- (int)backtrackOneCharacter:(ZXEncoderContext *)context buffer:(NSMutableString *)buffer
+ removed:(NSMutableString *)removed lastCharSize:(int)lastCharSize {
+ int count = buffer.length;
+ [buffer deleteCharactersInRange:NSMakeRange(count - lastCharSize, lastCharSize)];
+ context.pos--;
+ unichar c = context.currentChar;
+ lastCharSize = [self encodeChar:c buffer:removed];
+ [context resetSymbolInfo]; //Deal with possible reduction in symbol size
+ return lastCharSize;
+}
+
+- (void)writeNextTriplet:(ZXEncoderContext *)context buffer:(NSMutableString *)buffer {
+ [context writeCodewords:[self encodeToCodewords:buffer startpos:0]];
+ [buffer deleteCharactersInRange:NSMakeRange(0, 3)];
+}
+
+/**
+ * Handle "end of data" situations
+ */
+- (void)handleEOD:(ZXEncoderContext *)context buffer:(NSMutableString *)buffer {
+ int unwritten = (buffer.length / 3) * 2;
+ int rest = buffer.length % 3;
+
+ int curCodewordCount = context.codewordCount + unwritten;
+ [context updateSymbolInfoWithLength:curCodewordCount];
+ int available = context.symbolInfo.dataCapacity - curCodewordCount;
+
+ if (rest == 2) {
+ [buffer appendString:@"\0"]; //Shift 1
+ while (buffer.length >= 3) {
+ [self writeNextTriplet:context buffer:buffer];
+ }
+ if ([context hasMoreCharacters]) {
+ [context writeCodeword:[ZXHighLevelEncoder c40Unlatch]];
+ }
+ } else if (available == 1 && rest == 1) {
+ while (buffer.length >= 3) {
+ [self writeNextTriplet:context buffer:buffer];
+ }
+ if ([context hasMoreCharacters]) {
+ [context writeCodeword:[ZXHighLevelEncoder c40Unlatch]];
+ }
+ // else no latch
+ context.pos--;
+ } else if (rest == 0) {
+ while (buffer.length >= 3) {
+ [self writeNextTriplet:context buffer:buffer];
+ }
+ if (available > 0 || [context hasMoreCharacters]) {
+ [context writeCodeword:[ZXHighLevelEncoder c40Unlatch]];
+ }
+ } else {
+ @throw [NSException exceptionWithName:@"IllegalStateException"
+ reason:@"Unexpected case. Please report!"
+ userInfo:nil];
+ }
+ [context signalEncoderChange:[ZXHighLevelEncoder asciiEncodation]];
+}
+
+- (int)encodeChar:(unichar)c buffer:(NSMutableString *)sb {
+ if (c == ' ') {
+ [sb appendString:@"\3"];
+ return 1;
+ } else if (c >= '0' && c <= '9') {
+ [sb appendFormat:@"%C", (unichar) (c - 48 + 4)];
+ return 1;
+ } else if (c >= 'A' && c <= 'Z') {
+ [sb appendFormat:@"%C", (unichar) (c - 65 + 14)];
+ return 1;
+ } else if (c >= '\0' && c <= (unichar)0x001f) {
+ [sb appendString:@"\0"]; //Shift 1 Set
+ [sb appendFormat:@"%C", c];
+ return 2;
+ } else if (c >= '!' && c <= '/') {
+ [sb appendString:@"\1"]; //Shift 2 Set
+ [sb appendFormat:@"%C", (unichar) (c - 33)];
+ return 2;
+ } else if (c >= ':' && c <= '@') {
+ [sb appendString:@"\1"]; //Shift 2 Set
+ [sb appendFormat:@"%C", (unichar) (c - 58 + 15)];
+ return 2;
+ } else if (c >= '[' && c <= '_') {
+ [sb appendString:@"\1"]; //Shift 2 Set
+ [sb appendFormat:@"%C", (unichar) (c - 91 + 22)];
+ return 2;
+ } else if (c >= '\u0060' && c <= (char)0x007f) {
+ [sb appendString:@"\2"]; //Shift 3 Set
+ [sb appendFormat:@"%C", (unichar) (c - 96)];
+ return 2;
+ } else if (c >= (char)0x0080) {
+ [sb appendFormat:@"\1%C", (unichar)0x001e]; //Shift 2, Upper Shift
+ int len = 2;
+ len += [self encodeChar:(unichar) (c - 128) buffer:sb];
+ return len;
+ } else {
+ @throw [NSException exceptionWithName:@"IllegalStateException"
+ reason:[NSString stringWithFormat:@"Illegal character: %C", c]
+ userInfo:nil];
+ }
+}
+
+- (NSString *)encodeToCodewords:(NSString *)sb startpos:(int)startPos {
+ unichar c1 = [sb characterAtIndex:startPos];
+ unichar c2 = [sb characterAtIndex:startPos + 1];
+ unichar c3 = [sb characterAtIndex:startPos + 2];
+ int v = (1600 * c1) + (40 * c2) + c3 + 1;
+ unichar cw1 = (unichar) (v / 256);
+ unichar cw2 = (unichar) (v % 256);
+ return [NSString stringWithFormat:@"%C%C", cw1, cw2];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixEncoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixEncoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..bab9e59ff77c9f0d2131cd3c7212162965add723
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixEncoder.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXEncoderContext;
+
+@protocol ZXDataMatrixEncoder <NSObject>
+
+- (int)encodingMode;
+- (void)encode:(ZXEncoderContext *)context;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixErrorCorrection.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixErrorCorrection.h
new file mode 100644
index 0000000000000000000000000000000000000000..fe7c53063b50835b904acac92a0bca20684ebd59
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixErrorCorrection.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Error Correction Code for ECC200.
+ */
+
+@class ZXSymbolInfo;
+
+@interface ZXDataMatrixErrorCorrection : NSObject
+
++ (NSString *)encodeECC200:(NSString *)codewords symbolInfo:(ZXSymbolInfo *)symbolInfo;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixErrorCorrection.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixErrorCorrection.m
new file mode 100644
index 0000000000000000000000000000000000000000..9043817ff3b8cd090e578825f5aa1cefd0821043
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixErrorCorrection.m
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDataMatrixErrorCorrection.h"
+#import "ZXSymbolInfo.h"
+
+/**
+ * Lookup table which factors to use for which number of error correction codewords.
+ * See FACTORS.
+ */
+const int FACTOR_SETS_LEN = 16;
+const int FACTOR_SETS[FACTOR_SETS_LEN] = {5, 7, 10, 11, 12, 14, 18, 20, 24, 28, 36, 42, 48, 56, 62, 68};
+
+/**
+ * Precomputed polynomial factors for ECC 200.
+ */
+const int FACTORS[16][68] = {
+ {228, 48, 15, 111, 62},
+ {23, 68, 144, 134, 240, 92, 254},
+ {28, 24, 185, 166, 223, 248, 116, 255, 110, 61},
+ {175, 138, 205, 12, 194, 168, 39, 245, 60, 97, 120},
+ {41, 153, 158, 91, 61, 42, 142, 213, 97, 178, 100, 242},
+ {156, 97, 192, 252, 95, 9, 157, 119, 138, 45, 18, 186, 83, 185},
+ {83, 195, 100, 39, 188, 75, 66, 61, 241, 213, 109, 129, 94, 254, 225, 48, 90, 188},
+ {15, 195, 244, 9, 233, 71, 168, 2, 188, 160, 153, 145, 253, 79, 108, 82, 27, 174, 186, 172},
+ {52, 190, 88, 205, 109, 39, 176, 21, 155, 197, 251, 223, 155, 21, 5, 172,
+ 254, 124, 12, 181, 184, 96, 50, 193},
+ {211, 231, 43, 97, 71, 96, 103, 174, 37, 151, 170, 53, 75, 34, 249, 121,
+ 17, 138, 110, 213, 141, 136, 120, 151, 233, 168, 93, 255},
+ {245, 127, 242, 218, 130, 250, 162, 181, 102, 120, 84, 179, 220, 251, 80, 182,
+ 229, 18, 2, 4, 68, 33, 101, 137, 95, 119, 115, 44, 175, 184, 59, 25,
+ 225, 98, 81, 112},
+ {77, 193, 137, 31, 19, 38, 22, 153, 247, 105, 122, 2, 245, 133, 242, 8,
+ 175, 95, 100, 9, 167, 105, 214, 111, 57, 121, 21, 1, 253, 57, 54, 101,
+ 248, 202, 69, 50, 150, 177, 226, 5, 9, 5},
+ {245, 132, 172, 223, 96, 32, 117, 22, 238, 133, 238, 231, 205, 188, 237, 87,
+ 191, 106, 16, 147, 118, 23, 37, 90, 170, 205, 131, 88, 120, 100, 66, 138,
+ 186, 240, 82, 44, 176, 87, 187, 147, 160, 175, 69, 213, 92, 253, 225, 19},
+ {175, 9, 223, 238, 12, 17, 220, 208, 100, 29, 175, 170, 230, 192, 215, 235,
+ 150, 159, 36, 223, 38, 200, 132, 54, 228, 146, 218, 234, 117, 203, 29, 232,
+ 144, 238, 22, 150, 201, 117, 62, 207, 164, 13, 137, 245, 127, 67, 247, 28,
+ 155, 43, 203, 107, 233, 53, 143, 46},
+ {242, 93, 169, 50, 144, 210, 39, 118, 202, 188, 201, 189, 143, 108, 196, 37,
+ 185, 112, 134, 230, 245, 63, 197, 190, 250, 106, 185, 221, 175, 64, 114, 71,
+ 161, 44, 147, 6, 27, 218, 51, 63, 87, 10, 40, 130, 188, 17, 163, 31,
+ 176, 170, 4, 107, 232, 7, 94, 166, 224, 124, 86, 47, 11, 204},
+ {220, 228, 173, 89, 251, 149, 159, 56, 89, 33, 147, 244, 154, 36, 73, 127,
+ 213, 136, 248, 180, 234, 197, 158, 177, 68, 122, 93, 213, 15, 160, 227, 236,
+ 66, 139, 153, 185, 202, 167, 179, 25, 220, 232, 96, 210, 231, 136, 223, 239,
+ 181, 241, 59, 52, 172, 25, 49, 232, 211, 189, 64, 54, 108, 153, 132, 63,
+ 96, 103, 82, 186}};
+
+const int MODULO_VALUE = 0x12D;
+
+static int LOG[256], ALOG[256];
+
+@interface ZXDataMatrixErrorCorrection ()
+
++ (NSString *)createECCBlock:(NSString *)codewords numECWords:(int)numECWords;
++ (NSString *)createECCBlock:(NSString *)codewords start:(int)start len:(int)len numECWords:(int)numECWords;
+
+@end
+
+@implementation ZXDataMatrixErrorCorrection
+
++ (void)initialize {
+ //Create log and antilog table
+ int p = 1;
+ for (int i = 0; i < 255; i++) {
+ ALOG[i] = p;
+ LOG[p] = i;
+ p <<= 1;
+ if (p >= 256) {
+ p ^= MODULO_VALUE;
+ }
+ }
+}
+
++ (NSString *)encodeECC200:(NSString *)codewords symbolInfo:(ZXSymbolInfo *)symbolInfo {
+ if (codewords.length != symbolInfo.dataCapacity) {
+ [NSException raise:NSInvalidArgumentException format:@"The number of codewords does not match the selected symbol"];
+ }
+ NSUInteger capacity = symbolInfo.dataCapacity + symbolInfo.errorCodewords;
+ NSMutableString *sb = [NSMutableString stringWithCapacity:capacity];
+ [sb appendString:codewords];
+ int blockCount = symbolInfo.interleavedBlockCount;
+ if (blockCount == 1) {
+ NSString *ecc = [self createECCBlock:codewords numECWords:symbolInfo.errorCodewords];
+ [sb appendString:ecc];
+ } else {
+ if (sb.length > capacity) {
+ [sb deleteCharactersInRange:NSMakeRange(capacity, sb.length - capacity)];
+ }
+ int dataSizes[blockCount];
+ int errorSizes[blockCount];
+ int startPos[blockCount];
+ for (int i = 0; i < blockCount; i++) {
+ dataSizes[i] = [symbolInfo dataLengthForInterleavedBlock:i + 1];
+ errorSizes[i] = [symbolInfo errorLengthForInterleavedBlock:i + 1];
+ startPos[i] = 0;
+ if (i > 0) {
+ startPos[i] = startPos[i - 1] + dataSizes[i];
+ }
+ }
+ for (int block = 0; block < blockCount; block++) {
+ NSMutableString *temp = [NSMutableString stringWithCapacity:dataSizes[block]];
+ for (int d = block; d < symbolInfo.dataCapacity; d += blockCount) {
+ [temp appendFormat:@"%c", [codewords characterAtIndex:d]];
+ }
+ NSString *ecc = [self createECCBlock:temp numECWords:errorSizes[block]];
+ int pos = 0;
+ for (int e = block; e < errorSizes[block] * blockCount; e += blockCount) {
+ [sb replaceCharactersInRange:NSMakeRange(symbolInfo.dataCapacity + e, 1) withString:[ecc substringWithRange:NSMakeRange(pos++, 1)]];
+ }
+ }
+ }
+ return [NSString stringWithString:sb];
+}
+
++ (NSString *)createECCBlock:(NSString *)codewords numECWords:(int)numECWords {
+ return [self createECCBlock:codewords start:0 len:codewords.length numECWords:numECWords];
+}
+
++ (NSString *)createECCBlock:(NSString *)codewords start:(int)start len:(int)len numECWords:(int)numECWords {
+ int table = -1;
+ for (int i = 0; i < FACTOR_SETS_LEN; i++) {
+ if (FACTOR_SETS[i] == numECWords) {
+ table = i;
+ break;
+ }
+ }
+ if (table < 0) {
+ [NSException raise:NSInvalidArgumentException format:@"Illegal number of error correction codewords specified: %d", numECWords];
+ }
+ int *poly = (int *)FACTORS[table];
+ unichar ecc[numECWords];
+ for (int i = 0; i < numECWords; i++) {
+ ecc[i] = 0;
+ }
+ for (int i = start; i < start + len; i++) {
+ int m = (unsigned char)ecc[numECWords - 1] ^ (unsigned char)[codewords characterAtIndex:i];
+ for (int k = numECWords - 1; k > 0; k--) {
+ if (m != 0 && poly[k] != 0) {
+ ecc[k] = (unichar) (ecc[k - 1] ^ ALOG[(LOG[m] + LOG[poly[k]]) % 255]);
+ } else {
+ ecc[k] = ecc[k - 1];
+ }
+ }
+ if (m != 0 && poly[0] != 0) {
+ ecc[0] = (unichar) ALOG[(LOG[m] + LOG[poly[0]]) % 255];
+ } else {
+ ecc[0] = 0;
+ }
+ }
+ unichar eccReversed[numECWords];
+ for (int i = 0; i < numECWords; i++) {
+ eccReversed[i] = ecc[numECWords - i - 1];
+ }
+ return [NSString stringWithCharacters:eccReversed length:numECWords];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixSymbolInfo144.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixSymbolInfo144.h
new file mode 100644
index 0000000000000000000000000000000000000000..28e3a9f97e9e22790dd5786673befac8b2486586
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixSymbolInfo144.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXSymbolInfo.h"
+
+@interface ZXDataMatrixSymbolInfo144 : ZXSymbolInfo
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixSymbolInfo144.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixSymbolInfo144.m
new file mode 100644
index 0000000000000000000000000000000000000000..83a8dcc8d8572640bcafe241ad0a664e98c83c0f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDataMatrixSymbolInfo144.m
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDataMatrixSymbolInfo144.h"
+
+@implementation ZXDataMatrixSymbolInfo144
+
+- (id)init {
+ if (self = [super initWithRectangular:NO dataCapacity:1558 errorCodewords:620 matrixWidth:22 matrixHeight:22 dataRegions:36]) {
+ self.rsBlockData = -1; //special! see below
+ self.rsBlockError = 62;
+ }
+
+ return self;
+}
+
+- (int)interleavedBlockCount {
+ return 10;
+}
+
+- (int)dataLengthForInterleavedBlock:(int)index {
+ return (index <= 8) ? 156 : 155;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDefaultPlacement.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDefaultPlacement.h
new file mode 100644
index 0000000000000000000000000000000000000000..8784187f54256d1bf9d59008952bf06ce434cde6
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDefaultPlacement.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Symbol Character Placement Program. Adapted from Annex M.1 in ISO/IEC 16022:2000(E).
+ */
+
+@interface ZXDefaultPlacement : NSObject
+
+@property (nonatomic, copy, readonly) NSString *codewords;
+@property (nonatomic, assign, readonly) int numrows;
+@property (nonatomic, assign, readonly) int numcols;
+@property (nonatomic, assign, readonly) unsigned char *bits;
+@property (nonatomic, assign, readonly) int bitsLen;
+
+- (id)initWithCodewords:(NSString *)codewords numcols:(int)numcols numrows:(int)numrows;
+- (BOOL)bitAtCol:(int)col row:(int)row;
+- (void)setBitAtCol:(int)col row:(int)row bit:(BOOL)bit;
+- (BOOL)hasBitAtCol:(int)col row:(int)row;
+- (void)place;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDefaultPlacement.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDefaultPlacement.m
new file mode 100644
index 0000000000000000000000000000000000000000..f5fcf2f54b30aa2c38a635165fc249b5c93aecdb
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXDefaultPlacement.m
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDefaultPlacement.h"
+
+@interface ZXDefaultPlacement ()
+
+@property (nonatomic, copy) NSString *codewords;
+@property (nonatomic, assign) int numrows;
+@property (nonatomic, assign) int numcols;
+@property (nonatomic, assign) unsigned char *bits;
+@property (nonatomic, assign) int bitsLen;
+
+- (void)moduleAtRow:(int)row col:(int)col pos:(int)pos bit:(int)bit;
+- (void)utahAtRow:(int)row col:(int)col pos:(int)pos;
+- (void)corner1:(int)pos;
+- (void)corner2:(int)pos;
+- (void)corner3:(int)pos;
+- (void)corner4:(int)pos;
+
+@end
+
+@implementation ZXDefaultPlacement
+
+@synthesize codewords = _codewords;
+@synthesize numcols = _numcols;
+@synthesize numrows = _numrows;
+@synthesize bits = _bits;
+@synthesize bitsLen = _bitsLen;
+
+- (id)initWithCodewords:(NSString *)codewords numcols:(int)numcols numrows:(int)numrows {
+ if (self = [super init]) {
+ _codewords = [codewords copy];
+ _numcols = numcols;
+ _numrows = numrows;
+ _bitsLen = numcols * numrows;
+ _bits = (unsigned char *)malloc(_bitsLen * sizeof(unsigned char));
+ memset(_bits, -1, _bitsLen); //Initialize with "not set" value
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [_codewords release];
+
+ if (_bits != NULL) {
+ free(_bits);
+ _bits = NULL;
+ }
+
+ [super dealloc];
+}
+
+- (BOOL)bitAtCol:(int)col row:(int)row {
+ return self.bits[row * self.numcols + col] == 1;
+}
+
+- (void)setBitAtCol:(int)col row:(int)row bit:(BOOL)bit {
+ self.bits[row * self.numcols + col] = bit ? (unsigned char) 1 : (unsigned char) 0;
+}
+
+- (BOOL)hasBitAtCol:(int)col row:(int)row {
+ return self.bits[row * self.numcols + col] != 0xFF;
+}
+
+- (void)place {
+ int pos = 0;
+ int row = 4;
+ int col = 0;
+
+ do {
+ /* repeatedly first check for one of the special corner cases, then... */
+ if ((row == self.numrows) && (col == 0)) {
+ [self corner1:pos++];
+ }
+ if ((row == self.numrows - 2) && (col == 0) && ((self.numcols % 4) != 0)) {
+ [self corner2:pos++];
+ }
+ if ((row == self.numrows - 2) && (col == 0) && (self.numcols % 8 == 4)) {
+ [self corner3:pos++];
+ }
+ if ((row == self.numrows + 4) && (col == 2) && ((self.numcols % 8) == 0)) {
+ [self corner4:pos++];
+ }
+ /* sweep upward diagonally, inserting successive characters... */
+ do {
+ if ((row < self.numrows) && (col >= 0) && ![self hasBitAtCol:col row:row]) {
+ [self utahAtRow:row col:col pos:pos++];
+ }
+ row -= 2;
+ col += 2;
+ } while (row >= 0 && (col < self.numcols));
+ row++;
+ col += 3;
+
+ /* and then sweep downward diagonally, inserting successive characters, ... */
+ do {
+ if ((row >= 0) && (col < self.numcols) && ![self hasBitAtCol:col row:row]) {
+ [self utahAtRow:row col:col pos:pos++];
+ }
+ row += 2;
+ col -= 2;
+ } while ((row < self.numrows) && (col >= 0));
+ row += 3;
+ col++;
+
+ /* ...until the entire array is scanned */
+ } while ((row < self.numrows) || (col < self.numcols));
+
+ /* Lastly, if the lower righthand corner is untouched, fill in fixed pattern */
+ if (![self hasBitAtCol:self.numcols - 1 row:self.numrows - 1]) {
+ [self setBitAtCol:self.numcols - 1 row:self.numrows - 1 bit:YES];
+ [self setBitAtCol:self.numcols - 2 row:self.numrows - 2 bit:YES];
+ }
+}
+
+- (void)moduleAtRow:(int)row col:(int)col pos:(int)pos bit:(int)bit {
+ if (row < 0) {
+ row += self.numrows;
+ col += 4 - ((self.numrows + 4) % 8);
+ }
+ if (col < 0) {
+ col += self.numcols;
+ row += 4 - ((self.numcols + 4) % 8);
+ }
+ // Note the conversion:
+ int v = [self.codewords characterAtIndex:pos];
+ v &= 1 << (8 - bit);
+ [self setBitAtCol:col row:row bit:v != 0];
+}
+
+/**
+ * Places the 8 bits of a utah-shaped symbol character in ECC200.
+ */
+- (void)utahAtRow:(int)row col:(int)col pos:(int)pos {
+ [self moduleAtRow:row - 2 col:col - 2 pos:pos bit:1];
+ [self moduleAtRow:row - 2 col:col - 1 pos:pos bit:2];
+ [self moduleAtRow:row - 1 col:col - 2 pos:pos bit:3];
+ [self moduleAtRow:row - 1 col:col - 1 pos:pos bit:4];
+ [self moduleAtRow:row - 1 col:col pos:pos bit:5];
+ [self moduleAtRow:row col:col - 2 pos:pos bit:6];
+ [self moduleAtRow:row col:col - 1 pos:pos bit:7];
+ [self moduleAtRow:row col:col pos:pos bit:8];
+}
+
+- (void)corner1:(int)pos {
+ [self moduleAtRow:self.numrows - 1 col:0 pos:pos bit:1];
+ [self moduleAtRow:self.numrows - 1 col:1 pos:pos bit:2];
+ [self moduleAtRow:self.numrows - 1 col:2 pos:pos bit:3];
+ [self moduleAtRow:0 col:self.numcols - 2 pos:pos bit:4];
+ [self moduleAtRow:0 col:self.numcols - 1 pos:pos bit:5];
+ [self moduleAtRow:1 col:self.numcols - 1 pos:pos bit:6];
+ [self moduleAtRow:2 col:self.numcols - 1 pos:pos bit:7];
+ [self moduleAtRow:3 col:self.numcols - 1 pos:pos bit:8];
+}
+
+- (void)corner2:(int)pos {
+ [self moduleAtRow:self.numrows - 3 col:0 pos:pos bit:1];
+ [self moduleAtRow:self.numrows - 2 col:0 pos:pos bit:2];
+ [self moduleAtRow:self.numrows - 1 col:0 pos:pos bit:3];
+ [self moduleAtRow:0 col:self.numcols - 4 pos:pos bit:4];
+ [self moduleAtRow:0 col:self.numcols - 3 pos:pos bit:5];
+ [self moduleAtRow:0 col:self.numcols - 2 pos:pos bit:6];
+ [self moduleAtRow:0 col:self.numcols - 1 pos:pos bit:7];
+ [self moduleAtRow:1 col:self.numcols - 1 pos:pos bit:8];
+}
+
+- (void)corner3:(int)pos {
+ [self moduleAtRow:self.numrows - 3 col:0 pos:pos bit:1];
+ [self moduleAtRow:self.numrows - 2 col:0 pos:pos bit:2];
+ [self moduleAtRow:self.numrows - 1 col:0 pos:pos bit:3];
+ [self moduleAtRow:0 col:self.numcols - 2 pos:pos bit:4];
+ [self moduleAtRow:0 col:self.numcols - 1 pos:pos bit:5];
+ [self moduleAtRow:1 col:self.numcols - 1 pos:pos bit:6];
+ [self moduleAtRow:2 col:self.numcols - 1 pos:pos bit:7];
+ [self moduleAtRow:3 col:self.numcols - 1 pos:pos bit:8];
+}
+
+- (void)corner4:(int)pos {
+ [self moduleAtRow:self.numrows - 1 col:0 pos:pos bit:1];
+ [self moduleAtRow:self.numrows - 1 col:self.numcols - 1 pos:pos bit:2];
+ [self moduleAtRow:0 col:self.numcols - 3 pos:pos bit:3];
+ [self moduleAtRow:0 col:self.numcols - 2 pos:pos bit:4];
+ [self moduleAtRow:0 col:self.numcols - 1 pos:pos bit:5];
+ [self moduleAtRow:1 col:self.numcols - 3 pos:pos bit:6];
+ [self moduleAtRow:1 col:self.numcols - 2 pos:pos bit:7];
+ [self moduleAtRow:1 col:self.numcols - 1 pos:pos bit:8];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXEdifactEncoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXEdifactEncoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..de9ceb9d2af349b8e4e585c6ae0865e93f1ac9fd
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXEdifactEncoder.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDataMatrixEncoder.h"
+
+@interface ZXEdifactEncoder : NSObject <ZXDataMatrixEncoder>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXEdifactEncoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXEdifactEncoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..1f9ccfb1a85d09d0e98262aae025a7ad84958d45
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXEdifactEncoder.m
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXEdifactEncoder.h"
+#import "ZXEncoderContext.h"
+#import "ZXHighLevelEncoder.h"
+#import "ZXSymbolInfo.h"
+
+@interface ZXEdifactEncoder ()
+
+- (void)handleEOD:(ZXEncoderContext *)context buffer:(NSMutableString *)buffer;
+- (void)encodeChar:(unichar)c buffer:(NSMutableString *)sb;
+- (NSString *)encodeToCodewords:(NSMutableString *)sb startpos:(int)startPos;
+
+@end
+
+@implementation ZXEdifactEncoder
+
+- (int)encodingMode {
+ return [ZXHighLevelEncoder edifactEncodation];
+}
+
+- (void)encode:(ZXEncoderContext *)context {
+ //step F
+ NSMutableString *buffer = [NSMutableString string];
+ while ([context hasMoreCharacters]) {
+ unichar c = [context currentChar];
+ [self encodeChar:c buffer:buffer];
+ context.pos++;
+
+ int count = buffer.length;
+ if (count >= 4) {
+ [context writeCodewords:[self encodeToCodewords:buffer startpos:0]];
+ [buffer deleteCharactersInRange:NSMakeRange(0, 4)];
+
+ int newMode = [ZXHighLevelEncoder lookAheadTest:context.message startpos:context.pos currentMode:[self encodingMode]];
+ if (newMode != [self encodingMode]) {
+ [context signalEncoderChange:[ZXHighLevelEncoder asciiEncodation]];
+ break;
+ }
+ }
+ }
+ [buffer appendFormat:@"%C", (unichar) 31]; //Unlatch
+ [self handleEOD:context buffer:buffer];
+}
+
+/**
+ * Handle "end of data" situations
+ */
+- (void)handleEOD:(ZXEncoderContext *)context buffer:(NSMutableString *)buffer {
+ @try {
+ int count = buffer.length;
+ if (count == 0) {
+ return; //Already finished
+ }
+ if (count == 1) {
+ //Only an unlatch at the end
+ [context updateSymbolInfo];
+ int available = context.symbolInfo.dataCapacity - context.codewordCount;
+ int remaining = [context remainingCharacters];
+ if (remaining == 0 && available <= 2) {
+ return; //No unlatch
+ }
+ }
+
+ if (count > 4) {
+ @throw [NSException exceptionWithName:@"IllegalStateException"
+ reason:@"Count must not exceed 4"
+ userInfo:nil];
+ }
+ int restChars = count - 1;
+ NSString *encoded = [self encodeToCodewords:buffer startpos:0];
+ BOOL endOfSymbolReached = ![context hasMoreCharacters];
+ BOOL restInAscii = endOfSymbolReached && restChars <= 2;
+
+ if (restChars <= 2) {
+ [context updateSymbolInfoWithLength:context.codewordCount + restChars];
+ int available = context.symbolInfo.dataCapacity - context.codewordCount;
+ if (available >= 3) {
+ restInAscii = NO;
+ [context updateSymbolInfoWithLength:context.codewordCount + encoded.length];
+ //available = context.symbolInfo.dataCapacity - context.codewordCount;
+ }
+ }
+
+ if (restInAscii) {
+ [context resetSymbolInfo];
+ context.pos -= restChars;
+ } else {
+ [context writeCodewords:encoded];
+ }
+ } @finally {
+ [context signalEncoderChange:[ZXHighLevelEncoder asciiEncodation]];
+ }
+}
+
+- (void)encodeChar:(unichar)c buffer:(NSMutableString *)sb {
+ if (c >= ' ' && c <= '?') {
+ [sb appendFormat:@"%C", c];
+ } else if (c >= '@' && c <= '^') {
+ [sb appendFormat:@"%C", (unichar) (c - 64)];
+ } else {
+ [ZXHighLevelEncoder illegalCharacter:c];
+ }
+}
+
+- (NSString *)encodeToCodewords:(NSMutableString *)sb startpos:(int)startPos {
+ int len = sb.length - startPos;
+ if (len == 0) {
+ @throw [NSException exceptionWithName:@"IllegalStateException"
+ reason:@"Buffer must not be empty"
+ userInfo:nil];
+ }
+ unichar c1 = [sb characterAtIndex:startPos];
+ unichar c2 = len >= 2 ? [sb characterAtIndex:startPos + 1] : 0;
+ unichar c3 = len >= 3 ? [sb characterAtIndex:startPos + 2] : 0;
+ unichar c4 = len >= 4 ? [sb characterAtIndex:startPos + 3] : 0;
+
+ int v = (c1 << 18) + (c2 << 12) + (c3 << 6) + c4;
+ unichar cw1 = (unichar) ((v >> 16) & 255);
+ unichar cw2 = (unichar) ((v >> 8) & 255);
+ unichar cw3 = (unichar) (v & 255);
+ NSMutableString *res = [NSMutableString stringWithCapacity:3];
+ [res appendFormat:@"%C", cw1];
+ if (len >= 2) {
+ [res appendFormat:@"%C", cw2];
+ }
+ if (len >= 3) {
+ [res appendFormat:@"%C", cw3];
+ }
+ return [NSString stringWithString:res];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXEncoderContext.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXEncoderContext.h
new file mode 100644
index 0000000000000000000000000000000000000000..184bbcb868f80e6ec6916ea3621865feb2025d62
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXEncoderContext.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXDimension, ZXSymbolInfo, ZXSymbolShapeHint;
+
+@interface ZXEncoderContext : NSObject
+
+@property (nonatomic, copy) NSMutableString *codewords;
+@property (nonatomic, copy) NSString *message;
+@property (nonatomic, assign) int newEncoding;
+@property (nonatomic, assign) int pos;
+@property (nonatomic, assign) int skipAtEnd;
+@property (nonatomic, retain) ZXSymbolShapeHint *symbolShape;
+@property (nonatomic, retain) ZXSymbolInfo *symbolInfo;
+
+- (id)initWithMessage:(NSString *)msg;
+- (void)setSizeConstraints:(ZXDimension *)minSize maxSize:(ZXDimension *)maxSize;
+- (void)setSkipAtEnd:(int)count;
+- (unichar)currentChar;
+- (unichar)current;
+- (void)writeCodewords:(NSString *)codewords;
+- (void)writeCodeword:(unichar)codeword;
+- (int)codewordCount;
+- (void)signalEncoderChange:(int)encoding;
+- (void)resetEncoderSignal;
+- (BOOL)hasMoreCharacters;
+- (int)totalMessageCharCount;
+- (int)remainingCharacters;
+- (void)updateSymbolInfo;
+- (void)updateSymbolInfoWithLength:(int)len;
+- (void)resetSymbolInfo;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXEncoderContext.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXEncoderContext.m
new file mode 100644
index 0000000000000000000000000000000000000000..b2f68756a223f91514abe286d1c4eda1e40d2023
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXEncoderContext.m
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXEncoderContext.h"
+#import "ZXSymbolInfo.h"
+#import "ZXSymbolShapeHint.h"
+
+@interface ZXEncoderContext ()
+
+@property (nonatomic, retain) ZXDimension *maxSize;
+@property (nonatomic, retain) ZXDimension *minSize;
+
+@end
+
+@implementation ZXEncoderContext
+
+@synthesize codewords = _codewords;
+@synthesize message = _message;
+@synthesize symbolShape = _symbolShape;
+@synthesize newEncoding = _newEncoding;
+@synthesize maxSize = _maxSize;
+@synthesize minSize = _minSize;
+@synthesize skipAtEnd = _skipAtEnd;
+@synthesize pos = _pos;
+@synthesize symbolInfo = _symbolInfo;
+
+- (id)initWithMessage:(NSString *)msg {
+ if (self = [super init]) {
+ //From this point on Strings are not Unicode anymore!
+ NSData *msgData = [msg dataUsingEncoding:NSISOLatin1StringEncoding];
+ if (!msgData) {
+ [NSException raise:NSInvalidArgumentException format:@"Message contains characters outside ISO-8859-1 encoding."];
+ }
+ const char *msgBinary = [msgData bytes];
+ NSMutableString *sb = [NSMutableString string];
+ for (int i = 0, c = msg.length; i < c; i++) {
+ unichar ch = (unichar) (msgBinary[i] & 0xff);
+ [sb appendFormat:@"%C", ch];
+ }
+
+ _message = [[NSString alloc] initWithString:sb];
+ _symbolShape = [[ZXSymbolShapeHint forceNone] retain];
+ _codewords = [[NSMutableString alloc] initWithCapacity:msg.length];
+ _newEncoding = -1;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [_codewords release];
+ [_maxSize release];
+ [_message release];
+ [_minSize release];
+ [_symbolInfo release];
+ [_symbolShape release];
+
+ [super dealloc];
+}
+
+- (void)setSizeConstraints:(ZXDimension *)minSize maxSize:(ZXDimension *)maxSize {
+ self.minSize = minSize;
+ self.maxSize = maxSize;
+}
+
+- (unichar)currentChar {
+ return [self.message characterAtIndex:self.pos];
+}
+
+- (unichar)current {
+ return [self.message characterAtIndex:self.pos];
+}
+
+- (void)writeCodewords:(NSString *)codewords {
+ [self.codewords appendString:codewords];
+}
+
+- (void)writeCodeword:(unichar)codeword {
+ [self.codewords appendFormat:@"%C", codeword];
+}
+
+- (int)codewordCount {
+ return self.codewords.length;
+}
+
+- (void)signalEncoderChange:(int)encoding {
+ self.newEncoding = encoding;
+}
+
+- (void)resetEncoderSignal {
+ self.newEncoding = -1;
+}
+
+- (BOOL)hasMoreCharacters {
+ return self.pos < [self totalMessageCharCount];
+}
+
+- (int)totalMessageCharCount {
+ return self.message.length - self.skipAtEnd;
+}
+
+- (int)remainingCharacters {
+ return [self totalMessageCharCount] - self.pos;
+}
+
+- (void)updateSymbolInfo {
+ [self updateSymbolInfoWithLength:[self codewordCount]];
+}
+
+- (void)updateSymbolInfoWithLength:(int)len {
+ if (self.symbolInfo == nil || len > self.symbolInfo.dataCapacity) {
+ self.symbolInfo = [ZXSymbolInfo lookup:len shape:self.symbolShape minSize:self.minSize maxSize:self.maxSize fail:YES];
+ }
+}
+
+- (void)resetSymbolInfo {
+ self.symbolInfo = nil;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXHighLevelEncoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXHighLevelEncoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb253851ab7c05fb2bd60f2eb566c6229793c70f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXHighLevelEncoder.h
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * DataMatrix ECC 200 data encoder following the algorithm described in ISO/IEC 16022:200(E) in
+ * annex S.
+ */
+
+@class ZXDimension, ZXSymbolShapeHint;
+
+@interface ZXHighLevelEncoder : NSObject
+
+/**
+ * mode latch to C40 encodation mode
+ */
++ (unichar)latchToC40;
+
+/**
+ * mode latch to Base 256 encodation mode
+ */
++ (unichar)latchToBase256;
+
+/**
+ * Upper Shift
+ */
++ (unichar)upperShift;
+
+/**
+ * 05 Macro
+ */
++ (unichar)macro05;
+
+/**
+ * 06 Macro
+ */
++ (unichar)macro06;
+
+/**
+ * mode latch to ANSI X.12 encodation mode
+ */
++ (unichar)latchToAnsiX12;
+
+/**
+ * mode latch to Text encodation mode
+ */
+
++ (unichar)latchToText;
+
+/**
+ * mode latch to EDIFACT encodation mode
+ */
++ (unichar)latchToEdifact;
+
+/**
+ * Unlatch from C40 encodation
+ */
++ (unichar)c40Unlatch;
+
+/**
+ * Unlatch from X12 encodation
+ */
++ (unichar)x12Unlatch;
+
++ (int)asciiEncodation;
++ (int)c40Encodation;
++ (int)textEncodation;
++ (int)x12Encodation;
++ (int)edifactEncodation;
++ (int)base256Encodation;
+
+/**
+ * Converts the message to a byte array using the default encoding (cp437) as defined by the
+ * specification
+ */
++ (unsigned char *)bytesForMessage:(NSString *)msg;
+
+/**
+ * Performs message encoding of a DataMatrix message using the algorithm described in annex P
+ * of ISO/IEC 16022:2000(E).
+ */
++ (NSString *)encodeHighLevel:(NSString *)msg;
+
+/**
+ * Performs message encoding of a DataMatrix message using the algorithm described in annex P
+ * of ISO/IEC 16022:2000(E).
+ */
++ (NSString *)encodeHighLevel:(NSString *)msg shape:(ZXSymbolShapeHint *)shape
+ minSize:(ZXDimension *)minSize maxSize:(ZXDimension *)maxSize;
+
++ (int)lookAheadTest:(NSString *)msg startpos:(int)startpos currentMode:(int)currentMode;
+
+/**
+ * Determines the number of consecutive characters that are encodable using numeric compaction.
+ */
++ (int)determineConsecutiveDigitCount:(NSString *)msg startpos:(int)startpos;
+
++ (BOOL)isDigit:(unichar)ch;
++ (BOOL)isExtendedASCII:(unichar)ch;
+
++ (void)illegalCharacter:(unichar)c;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXHighLevelEncoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXHighLevelEncoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..6d3621ca2e90531490207aafdddc741e622a2765
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXHighLevelEncoder.m
@@ -0,0 +1,442 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXASCIIEncoder.h"
+#import "ZXBase256Encoder.h"
+#import "ZXC40Encoder.h"
+#import "ZXEdifactEncoder.h"
+#import "ZXEncoderContext.h"
+#import "ZXHighLevelEncoder.h"
+#import "ZXSymbolInfo.h"
+#import "ZXSymbolShapeHint.h"
+#import "ZXTextEncoder.h"
+#import "ZXX12Encoder.h"
+
+/**
+ * Padding character
+ */
+const unichar PAD_CHAR = 129;
+
+/**
+ * 05 Macro header
+ */
+static NSString *MACRO_05_HEADER = nil;
+
+/**
+ * 06 Macro header
+ */
+static NSString *MACRO_06_HEADER = nil;
+
+/**
+ * Macro trailer
+ */
+static NSString *MACRO_TRAILER = nil;
+
+@interface ZXHighLevelEncoder ()
+
++ (unichar)randomize253State:(unichar)ch codewordPosition:(int)codewordPosition;
++ (int)findMinimums:(float *)charCounts intCharCounts:(int *)intCharCounts min:(int)min mins:(unsigned char *)mins;
++ (int)minimumCount:(unsigned char *)mins;
++ (BOOL)isNativeC40:(unichar)ch;
++ (BOOL)isNativeText:(unichar)ch;
++ (BOOL)isNativeX12:(unichar)ch;
++ (BOOL)isX12TermSep:(unichar)ch;
++ (BOOL)isNativeEDIFACT:(unichar)ch;
++ (BOOL)isSpecialB256:(unichar)ch;
+
+@end
+
+@implementation ZXHighLevelEncoder
+
++ (void)initialize {
+ MACRO_05_HEADER = [[NSString alloc] initWithFormat:@"[)>%C05%C", (unichar)0x001E, (unichar)0x001D];
+ MACRO_06_HEADER = [[NSString alloc] initWithFormat:@"[)>%C06%C", (unichar)0x001E, (unichar)0x001D];
+ MACRO_TRAILER = [[NSString alloc] initWithFormat:@"%C%C", (unichar)0x001E, (unichar)0x0004];
+}
+
++ (unichar)latchToC40 {
+ return 230;
+}
+
++ (unichar)latchToBase256 {
+ return 231;
+}
+
++ (unichar)upperShift {
+ return 235;
+}
+
++ (unichar)macro05 {
+ return 236;
+}
+
++ (unichar)macro06 {
+ return 237;
+}
+
++ (unichar)latchToAnsiX12 {
+ return 238;
+}
+
++ (unichar)latchToText {
+ return 239;
+}
+
++ (unichar)latchToEdifact {
+ return 240;
+}
+
++ (unichar)c40Unlatch {
+ return 254;
+}
+
++ (unichar)x12Unlatch {
+ return 254;
+}
+
++ (int)asciiEncodation {
+ return 0;
+}
+
++ (int)c40Encodation {
+ return 1;
+}
+
++ (int)textEncodation {
+ return 2;
+}
+
++ (int)x12Encodation {
+ return 3;
+}
+
++ (int)edifactEncodation {
+ return 4;
+}
+
++ (int)base256Encodation {
+ return 5;
+}
+
++ (unsigned char *)bytesForMessage:(NSString *)msg {
+ return (unsigned char *)[[msg dataUsingEncoding:(NSStringEncoding) 0x80000400] bytes]; //See 4.4.3 and annex B of ISO/IEC 15438:2001(E)
+}
+
++ (unichar)randomize253State:(unichar)ch codewordPosition:(int)codewordPosition {
+ int pseudoRandom = ((149 * codewordPosition) % 253) + 1;
+ int tempVariable = ch + pseudoRandom;
+ return tempVariable <= 254 ? (unichar) tempVariable : (unichar) (tempVariable - 254);
+}
+
++ (NSString *)encodeHighLevel:(NSString *)msg {
+ return [self encodeHighLevel:msg shape:[ZXSymbolShapeHint forceNone] minSize:nil maxSize:nil];
+}
+
++ (NSString *)encodeHighLevel:(NSString *)msg shape:(ZXSymbolShapeHint *)shape
+ minSize:(ZXDimension *)minSize maxSize:(ZXDimension *)maxSize {
+ //the codewords 0..255 are encoded as Unicode characters
+ NSArray *encoders = [NSArray arrayWithObjects:[[[ZXASCIIEncoder alloc] init] autorelease],
+ [[[ZXC40Encoder alloc] init] autorelease],
+ [[[ZXTextEncoder alloc] init] autorelease],
+ [[[ZXX12Encoder alloc] init] autorelease],
+ [[[ZXEdifactEncoder alloc] init] autorelease],
+ [[[ZXBase256Encoder alloc] init] autorelease], nil];
+
+ ZXEncoderContext *context = [[[ZXEncoderContext alloc] initWithMessage:msg] autorelease];
+ context.symbolShape = shape;
+ [context setSizeConstraints:minSize maxSize:maxSize];
+
+ if ([msg hasPrefix:MACRO_05_HEADER] && [msg hasSuffix:MACRO_TRAILER]) {
+ [context writeCodeword:[self macro05]];
+ [context setSkipAtEnd:2];
+ context.pos += MACRO_05_HEADER.length;
+ } else if ([msg hasPrefix:MACRO_06_HEADER] && [msg hasSuffix:MACRO_TRAILER]) {
+ [context writeCodeword:[self macro06]];
+ [context setSkipAtEnd:2];
+ context.pos += MACRO_06_HEADER.length;
+ }
+
+ int encodingMode = [self asciiEncodation]; //Default mode
+ while ([context hasMoreCharacters]) {
+ [[encoders objectAtIndex:encodingMode] encode:context];
+ if (context.newEncoding >= 0) {
+ encodingMode = context.newEncoding;
+ [context resetEncoderSignal];
+ }
+ }
+ int len = context.codewords.length;
+ [context updateSymbolInfo];
+ int capacity = context.symbolInfo.dataCapacity;
+ if (len < capacity) {
+ if (encodingMode != [self asciiEncodation] && encodingMode != [self base256Encodation]) {
+ [context writeCodeword:(unichar)0x00fe]; //Unlatch (254)
+ }
+ }
+ //Padding
+ NSMutableString *codewords = context.codewords;
+ if (codewords.length < capacity) {
+ [codewords appendFormat:@"%C", PAD_CHAR];
+ }
+ while (codewords.length < capacity) {
+ [codewords appendFormat:@"%C", [self randomize253State:PAD_CHAR codewordPosition:codewords.length + 1]];
+ }
+
+ return [NSString stringWithString:context.codewords];
+}
+
++ (int)lookAheadTest:(NSString *)msg startpos:(int)startpos currentMode:(int)currentMode {
+ if (startpos >= msg.length) {
+ return currentMode;
+ }
+ float charCounts[6];
+ //step J
+ if (currentMode == [self asciiEncodation]) {
+ charCounts[0] = 0;
+ charCounts[1] = 1;
+ charCounts[2] = 1;
+ charCounts[3] = 1;
+ charCounts[4] = 1;
+ charCounts[5] = 1.25f;
+ } else {
+ charCounts[0] = 1;
+ charCounts[1] = 2;
+ charCounts[2] = 2;
+ charCounts[3] = 2;
+ charCounts[4] = 2;
+ charCounts[5] = 2.25f;
+ charCounts[currentMode] = 0;
+ }
+
+ int charsProcessed = 0;
+ while (YES) {
+ //step K
+ if ((startpos + charsProcessed) == msg.length) {
+ int min = NSIntegerMax;
+ unsigned char mins[6];
+ int intCharCounts[6];
+ min = [self findMinimums:charCounts intCharCounts:intCharCounts min:min mins:mins];
+ int minCount = [self minimumCount:mins];
+
+ if (intCharCounts[[self asciiEncodation]] == min) {
+ return [self asciiEncodation];
+ }
+ if (minCount == 1 && mins[[self base256Encodation]] > 0) {
+ return [self base256Encodation];
+ }
+ if (minCount == 1 && mins[[self edifactEncodation]] > 0) {
+ return [self edifactEncodation];
+ }
+ if (minCount == 1 && mins[[self textEncodation]] > 0) {
+ return [self textEncodation];
+ }
+ if (minCount == 1 && mins[[self x12Encodation]] > 0) {
+ return [self x12Encodation];
+ }
+ return [self c40Encodation];
+ }
+
+ unichar c = [msg characterAtIndex:startpos + charsProcessed];
+ charsProcessed++;
+
+ //step L
+ if ([self isDigit:c]) {
+ charCounts[[self asciiEncodation]] += 0.5;
+ } else if ([self isExtendedASCII:c]) {
+ charCounts[[self asciiEncodation]] = (int) ceil(charCounts[[self asciiEncodation]]);
+ charCounts[[self asciiEncodation]] += 2;
+ } else {
+ charCounts[[self asciiEncodation]] = (int) ceil(charCounts[[self asciiEncodation]]);
+ charCounts[[self asciiEncodation]]++;
+ }
+
+ //step M
+ if ([self isNativeC40:c]) {
+ charCounts[[self c40Encodation]] += 2.0f / 3.0f;
+ } else if ([self isExtendedASCII:c]) {
+ charCounts[[self c40Encodation]] += 8.0f / 3.0f;
+ } else {
+ charCounts[[self c40Encodation]] += 4.0f / 3.0f;
+ }
+
+ //step N
+ if ([self isNativeText:c]) {
+ charCounts[[self textEncodation]] += 2.0f / 3.0f;
+ } else if ([self isExtendedASCII:c]) {
+ charCounts[[self textEncodation]] += 8.0f / 3.0f;
+ } else {
+ charCounts[[self textEncodation]] += 4.0f / 3.0f;
+ }
+
+ //step O
+ if ([self isNativeX12:c]) {
+ charCounts[[self x12Encodation]] += 2.0f / 3.0f;
+ } else if ([self isExtendedASCII:c]) {
+ charCounts[[self x12Encodation]] += 13.0f / 3.0f;
+ } else {
+ charCounts[[self x12Encodation]] += 10.0f / 3.0f;
+ }
+
+ //step P
+ if ([self isNativeEDIFACT:c]) {
+ charCounts[[self edifactEncodation]] += 3.0f / 4.0f;
+ } else if ([self isExtendedASCII:c]) {
+ charCounts[[self edifactEncodation]] += 17.0f / 4.0f;
+ } else {
+ charCounts[[self edifactEncodation]] += 13.0f / 4.0f;
+ }
+
+ // step Q
+ if ([self isSpecialB256:c]) {
+ charCounts[[self base256Encodation]] += 4;
+ } else {
+ charCounts[[self base256Encodation]]++;
+ }
+
+ //step R
+ if (charsProcessed >= 4) {
+ int intCharCounts[6];
+ unsigned char mins[6];
+ [self findMinimums:charCounts intCharCounts:intCharCounts min:NSIntegerMax mins:mins];
+ int minCount = [self minimumCount:mins];
+
+ if (intCharCounts[[self asciiEncodation]] < intCharCounts[[self base256Encodation]]
+ && intCharCounts[[self asciiEncodation]] < intCharCounts[[self c40Encodation]]
+ && intCharCounts[[self asciiEncodation]] < intCharCounts[[self textEncodation]]
+ && intCharCounts[[self asciiEncodation]] < intCharCounts[[self x12Encodation]]
+ && intCharCounts[[self asciiEncodation]] < intCharCounts[[self edifactEncodation]]) {
+ return [self asciiEncodation];
+ }
+ if (intCharCounts[[self base256Encodation]] < intCharCounts[[self asciiEncodation]]
+ || (mins[[self c40Encodation]] + mins[[self textEncodation]] + mins[[self x12Encodation]] + mins[[self edifactEncodation]]) == 0) {
+ return [self base256Encodation];
+ }
+ if (minCount == 1 && mins[[self edifactEncodation]] > 0) {
+ return [self edifactEncodation];
+ }
+ if (minCount == 1 && mins[[self textEncodation]] > 0) {
+ return [self textEncodation];
+ }
+ if (minCount == 1 && mins[[self x12Encodation]] > 0) {
+ return [self x12Encodation];
+ }
+ if (intCharCounts[[self c40Encodation]] + 1 < intCharCounts[[self asciiEncodation]]
+ && intCharCounts[[self c40Encodation]] + 1 < intCharCounts[[self base256Encodation]]
+ && intCharCounts[[self c40Encodation]] + 1 < intCharCounts[[self edifactEncodation]]
+ && intCharCounts[[self c40Encodation]] + 1 < intCharCounts[[self textEncodation]]) {
+ if (intCharCounts[[self c40Encodation]] < intCharCounts[[self x12Encodation]]) {
+ return [self c40Encodation];
+ }
+ if (intCharCounts[[self c40Encodation]] == intCharCounts[[self x12Encodation]]) {
+ int p = startpos + charsProcessed + 1;
+ while (p < msg.length) {
+ char tc = [msg characterAtIndex:p];
+ if ([self isX12TermSep:tc]) {
+ return [self x12Encodation];
+ }
+ if (![self isNativeX12:tc]) {
+ break;
+ }
+ p++;
+ }
+ return [self c40Encodation];
+ }
+ }
+ }
+ }
+}
+
++ (int)findMinimums:(float *)charCounts intCharCounts:(int *)intCharCounts min:(int)min mins:(unsigned char *)mins {
+ memset(mins, 0, 6);
+ for (int i = 0; i < 6; i++) {
+ intCharCounts[i] = (int) ceil(charCounts[i]);
+ int current = intCharCounts[i];
+ if (min > current) {
+ min = current;
+ memset(mins, 0, 6);
+ }
+ if (min == current) {
+ mins[i]++;
+ }
+ }
+ return min;
+}
+
++ (int)minimumCount:(unsigned char *)mins {
+ int minCount = 0;
+ for (int i = 0; i < 6; i++) {
+ minCount += mins[i];
+ }
+ return minCount;
+}
+
++ (BOOL)isDigit:(unichar)ch {
+ return ch >= '0' && ch <= '9';
+}
+
++ (BOOL)isExtendedASCII:(unichar)ch {
+ return ch >= 128 && ch <= 255;
+}
+
++ (BOOL)isNativeC40:(unichar)ch {
+ return (ch == ' ') || (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z');
+}
+
++ (BOOL)isNativeText:(unichar)ch {
+ return (ch == ' ') || (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z');
+}
+
++ (BOOL)isNativeX12:(unichar)ch {
+ return [self isX12TermSep:ch] || (ch == ' ') || (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z');
+}
+
++ (BOOL)isX12TermSep:(unichar)ch {
+ return (ch == '\r') //CR
+ || (ch == '*')
+ || (ch == '>');
+}
+
++ (BOOL)isNativeEDIFACT:(unichar)ch {
+ return ch >= ' ' && ch <= '^';
+}
+
++ (BOOL)isSpecialB256:(unichar)ch {
+ return NO; //TODO NOT IMPLEMENTED YET!!!
+}
+
++ (int)determineConsecutiveDigitCount:(NSString *)msg startpos:(int)startpos {
+ int count = 0;
+ int len = msg.length;
+ int idx = startpos;
+ if (idx < len) {
+ unichar ch = [msg characterAtIndex:idx];
+ while ([self isDigit:ch] && idx < len) {
+ count++;
+ idx++;
+ if (idx < len) {
+ ch = [msg characterAtIndex:idx];
+ }
+ }
+ }
+ return count;
+}
+
++ (void)illegalCharacter:(unichar)c {
+ NSString *hex = [NSString stringWithFormat:@"%x", c];
+ hex = [[@"0000" substringWithRange:NSMakeRange(0, hex.length)] stringByAppendingString:hex];
+ [NSException raise:NSInvalidArgumentException format:@"Illegal character: %C (0x%@)", c, hex];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXSymbolInfo.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXSymbolInfo.h
new file mode 100644
index 0000000000000000000000000000000000000000..e77553f9c82f6c94704084c428008552728f2132
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXSymbolInfo.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Symbol info table for DataMatrix.
+ */
+
+@class ZXDimension, ZXSymbolShapeHint;
+
+@interface ZXSymbolInfo : NSObject
+
+@property (nonatomic, assign) BOOL rectangular;
+@property (nonatomic, assign) int errorCodewords;
+@property (nonatomic, assign) int dataCapacity;
+@property (nonatomic, assign) int dataRegions;
+@property (nonatomic, assign) int matrixWidth;
+@property (nonatomic, assign) int matrixHeight;
+@property (nonatomic, assign) int rsBlockData;
+@property (nonatomic, assign) int rsBlockError;
+
+/**
+ * Overrides the symbol info set used by this class. Used for testing purposes.
+ */
++ (void)overrideSymbolSet:(NSArray *)override;
++ (NSArray *)prodSymbols;
+- (id)initWithRectangular:(BOOL)rectangular dataCapacity:(int)dataCapacity errorCodewords:(int)errorCodewords
+ matrixWidth:(int)matrixWidth matrixHeight:(int)matrixHeight dataRegions:(int)dataRegions;
+- (id)initWithRectangular:(BOOL)rectangular dataCapacity:(int)dataCapacity errorCodewords:(int)errorCodewords
+ matrixWidth:(int)matrixWidth matrixHeight:(int)matrixHeight dataRegions:(int)dataRegions
+ rsBlockData:(int)rsBlockData rsBlockError:(int)rsBlockError;
++ (ZXSymbolInfo *)lookup:(int)dataCodewords;
++ (ZXSymbolInfo *)lookup:(int)dataCodewords shape:(ZXSymbolShapeHint *)shape;
++ (ZXSymbolInfo *)lookup:(int)dataCodewords allowRectangular:(BOOL)allowRectangular fail:(BOOL)fail;
++ (ZXSymbolInfo *)lookup:(int)dataCodewords shape:(ZXSymbolShapeHint *)shape fail:(BOOL)fail;
++ (ZXSymbolInfo *)lookup:(int)dataCodewords shape:(ZXSymbolShapeHint *)shape minSize:(ZXDimension *)minSize
+ maxSize:(ZXDimension *)maxSize fail:(BOOL)fail;
+- (int)horizontalDataRegions;
+- (int)verticalDataRegions;
+- (int)symbolDataWidth;
+- (int)symbolDataHeight;
+- (int)symbolWidth;
+- (int)symbolHeight;
+- (int)codewordCount;
+- (int)interleavedBlockCount;
+- (int)dataLengthForInterleavedBlock:(int)index;
+- (int)errorLengthForInterleavedBlock:(int)index;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXSymbolInfo.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXSymbolInfo.m
new file mode 100644
index 0000000000000000000000000000000000000000..b02c8ef67be6fdd64b19f98a3d7e9631c2d2dd63
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXSymbolInfo.m
@@ -0,0 +1,229 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDataMatrixSymbolInfo144.h"
+#import "ZXDimension.h"
+#import "ZXSymbolInfo.h"
+#import "ZXSymbolShapeHint.h"
+
+static NSArray *PROD_SYMBOLS = nil;
+static NSArray *symbols = nil;
+
+@implementation ZXSymbolInfo
+
+@synthesize rectangular = _rectangular;
+@synthesize errorCodewords = _errorCodewords;
+@synthesize dataCapacity = _dataCapacity;
+@synthesize dataRegions = _dataRegions;
+@synthesize matrixHeight = _matrixHeight;
+@synthesize matrixWidth = _matrixWidth;
+@synthesize rsBlockData = _rsBlockData;
+@synthesize rsBlockError = _rsBlockError;
+
++ (void)initialize {
+ PROD_SYMBOLS = [[NSArray alloc] initWithObjects:
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:3 errorCodewords:5 matrixWidth:8 matrixHeight:8 dataRegions:1] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:5 errorCodewords:7 matrixWidth:10 matrixHeight:10 dataRegions:1] autorelease],
+ /*rect*/[[[ZXSymbolInfo alloc] initWithRectangular:YES dataCapacity:5 errorCodewords:7 matrixWidth:16 matrixHeight:6 dataRegions:1] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:8 errorCodewords:10 matrixWidth:12 matrixHeight:12 dataRegions:1] autorelease],
+ /*rect*/[[[ZXSymbolInfo alloc] initWithRectangular:YES dataCapacity:10 errorCodewords:11 matrixWidth:14 matrixHeight:6 dataRegions:2] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:12 errorCodewords:12 matrixWidth:14 matrixHeight:14 dataRegions:1] autorelease],
+ /*rect*/[[[ZXSymbolInfo alloc] initWithRectangular:YES dataCapacity:16 errorCodewords:14 matrixWidth:24 matrixHeight:10 dataRegions:1] autorelease],
+
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:18 errorCodewords:14 matrixWidth:16 matrixHeight:16 dataRegions:1] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:22 errorCodewords:18 matrixWidth:18 matrixHeight:18 dataRegions:1] autorelease],
+ /*rect*/[[[ZXSymbolInfo alloc] initWithRectangular:YES dataCapacity:22 errorCodewords:18 matrixWidth:16 matrixHeight:10 dataRegions:2] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:30 errorCodewords:20 matrixWidth:20 matrixHeight:20 dataRegions:1] autorelease],
+ /*rect*/[[[ZXSymbolInfo alloc] initWithRectangular:YES dataCapacity:32 errorCodewords:24 matrixWidth:16 matrixHeight:14 dataRegions:2] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:36 errorCodewords:24 matrixWidth:22 matrixHeight:22 dataRegions:1] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:44 errorCodewords:28 matrixWidth:24 matrixHeight:24 dataRegions:1] autorelease],
+ /*rect*/[[[ZXSymbolInfo alloc] initWithRectangular:YES dataCapacity:49 errorCodewords:28 matrixWidth:22 matrixHeight:14 dataRegions:2] autorelease],
+
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:62 errorCodewords:36 matrixWidth:14 matrixHeight:14 dataRegions:4] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:86 errorCodewords:42 matrixWidth:16 matrixHeight:16 dataRegions:4] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:114 errorCodewords:48 matrixWidth:18 matrixHeight:18 dataRegions:4] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:144 errorCodewords:56 matrixWidth:20 matrixHeight:20 dataRegions:4] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:174 errorCodewords:68 matrixWidth:22 matrixHeight:22 dataRegions:4] autorelease],
+
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:204 errorCodewords:84 matrixWidth:24 matrixHeight:24 dataRegions:4 rsBlockData:102 rsBlockError:42] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:280 errorCodewords:112 matrixWidth:14 matrixHeight:14 dataRegions:16 rsBlockData:140 rsBlockError:56] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:368 errorCodewords:144 matrixWidth:16 matrixHeight:16 dataRegions:16 rsBlockData:92 rsBlockError:36] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:456 errorCodewords:192 matrixWidth:18 matrixHeight:18 dataRegions:16 rsBlockData:114 rsBlockError:48] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:576 errorCodewords:224 matrixWidth:20 matrixHeight:20 dataRegions:16 rsBlockData:144 rsBlockError:56] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:696 errorCodewords:272 matrixWidth:22 matrixHeight:22 dataRegions:16 rsBlockData:174 rsBlockError:68] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:816 errorCodewords:336 matrixWidth:24 matrixHeight:24 dataRegions:16 rsBlockData:136 rsBlockError:56] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:1050 errorCodewords:408 matrixWidth:18 matrixHeight:18 dataRegions:36 rsBlockData:175 rsBlockError:68] autorelease],
+ [[[ZXSymbolInfo alloc] initWithRectangular:NO dataCapacity:1304 errorCodewords:496 matrixWidth:20 matrixHeight:20 dataRegions:36 rsBlockData:163 rsBlockError:62] autorelease],
+ [[[ZXDataMatrixSymbolInfo144 alloc] init] autorelease], nil];
+ symbols = PROD_SYMBOLS;
+}
+
++ (NSArray *)prodSymbols {
+ return PROD_SYMBOLS;
+}
+
++ (void)overrideSymbolSet:(NSArray *)override {
+ symbols = override;
+}
+
+- (id)initWithRectangular:(BOOL)rectangular dataCapacity:(int)dataCapacity errorCodewords:(int)errorCodewords
+ matrixWidth:(int)matrixWidth matrixHeight:(int)matrixHeight dataRegions:(int)dataRegions {
+ return [self initWithRectangular:rectangular dataCapacity:dataCapacity errorCodewords:errorCodewords
+ matrixWidth:matrixWidth matrixHeight:matrixHeight dataRegions:dataRegions
+ rsBlockData:dataCapacity rsBlockError:errorCodewords];
+}
+
+- (id)initWithRectangular:(BOOL)rectangular dataCapacity:(int)dataCapacity errorCodewords:(int)errorCodewords
+ matrixWidth:(int)matrixWidth matrixHeight:(int)matrixHeight dataRegions:(int)dataRegions
+ rsBlockData:(int)rsBlockData rsBlockError:(int)rsBlockError {
+ if (self = [super init]) {
+ _rectangular = rectangular;
+ _dataCapacity = dataCapacity;
+ _errorCodewords = errorCodewords;
+ _matrixWidth = matrixWidth;
+ _matrixHeight = matrixHeight;
+ _dataRegions = dataRegions;
+ _rsBlockData = rsBlockData;
+ _rsBlockError = rsBlockError;
+ }
+
+ return self;
+}
+
++ (ZXSymbolInfo *)lookup:(int)dataCodewords {
+ return [self lookup:dataCodewords shape:[ZXSymbolShapeHint forceNone] fail:YES];
+}
+
++ (ZXSymbolInfo *)lookup:(int)dataCodewords shape:(ZXSymbolShapeHint *)shape {
+ return [self lookup:dataCodewords shape:shape fail:YES];
+}
+
++ (ZXSymbolInfo *)lookup:(int)dataCodewords allowRectangular:(BOOL)allowRectangular fail:(BOOL)fail {
+ ZXSymbolShapeHint *shape = allowRectangular
+ ? [ZXSymbolShapeHint forceNone] : [ZXSymbolShapeHint forceSquare];
+ return [self lookup:dataCodewords shape:shape fail:fail];
+}
+
++ (ZXSymbolInfo *)lookup:(int)dataCodewords shape:(ZXSymbolShapeHint *)shape fail:(BOOL)fail {
+ return [self lookup:dataCodewords shape:shape minSize:nil maxSize:nil fail:fail];
+}
+
++ (ZXSymbolInfo *)lookup:(int)dataCodewords shape:(ZXSymbolShapeHint *)shape minSize:(ZXDimension *)minSize
+ maxSize:(ZXDimension *)maxSize fail:(BOOL)fail {
+ for (ZXSymbolInfo *symbol in symbols) {
+ if (shape == [ZXSymbolShapeHint forceSquare] && symbol.rectangular) {
+ continue;
+ }
+ if (shape == [ZXSymbolShapeHint forceRectangle] && !symbol.rectangular) {
+ continue;
+ }
+ if (minSize != nil
+ && ([symbol symbolWidth] < minSize.width
+ || [symbol symbolHeight] < minSize.height)) {
+ continue;
+ }
+ if (maxSize != nil
+ && ([symbol symbolWidth] > maxSize.width
+ || [symbol symbolHeight] > maxSize.height)) {
+ continue;
+ }
+ if (dataCodewords <= symbol.dataCapacity) {
+ return symbol;
+ }
+ }
+ if (fail) {
+ [NSException raise:NSInvalidArgumentException format:@"Can't find a symbol arrangement that matches the message. Data codewords: %d", dataCodewords];
+ }
+ return nil;
+}
+
+- (int)horizontalDataRegions {
+ switch (_dataRegions) {
+ case 1:
+ return 1;
+ case 2:
+ return 2;
+ case 4:
+ return 2;
+ case 16:
+ return 4;
+ case 36:
+ return 6;
+ default:
+ @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"Cannot handle this number of data regions" userInfo:nil];
+ }
+}
+
+- (int)verticalDataRegions {
+ switch (_dataRegions) {
+ case 1:
+ return 1;
+ case 2:
+ return 1;
+ case 4:
+ return 2;
+ case 16:
+ return 4;
+ case 36:
+ return 6;
+ default:
+ @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"Cannot handle this number of data regions" userInfo:nil];
+ }
+}
+
+- (int)symbolDataWidth {
+ return [self horizontalDataRegions] * _matrixWidth;
+}
+
+- (int)symbolDataHeight {
+ return [self verticalDataRegions] * _matrixHeight;
+}
+
+- (int)symbolWidth {
+ return [self symbolDataWidth] + ([self horizontalDataRegions] * 2);
+}
+
+- (int)symbolHeight {
+ return [self symbolDataHeight] + ([self verticalDataRegions] * 2);
+}
+
+- (int)codewordCount {
+ return _dataCapacity + _errorCodewords;
+}
+
+- (int)interleavedBlockCount {
+ return _dataCapacity / _rsBlockData;
+}
+
+- (int)dataLengthForInterleavedBlock:(int)index {
+ return _rsBlockData;
+}
+
+- (int)errorLengthForInterleavedBlock:(int)index {
+ return _rsBlockError;
+}
+
+- (NSString *)description {
+ NSMutableString *sb = [NSMutableString string];
+ [sb appendString:_rectangular ? @"Rectangular Symbol:" : @"Square Symbol:"];
+ [sb appendFormat:@" data region %dx%d", _matrixWidth, _matrixHeight];
+ [sb appendFormat:@", symbol size %dx%d", [self symbolWidth], [self symbolHeight]];
+ [sb appendFormat:@", symbol data size %dx%d", [self symbolDataWidth], [self symbolDataHeight]];
+ [sb appendFormat:@", codewords %d+%d", _dataCapacity, _errorCodewords];
+ return [NSString stringWithString:sb];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXSymbolShapeHint.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXSymbolShapeHint.h
new file mode 100644
index 0000000000000000000000000000000000000000..45cf67e4c911c2cdcce897e033ef05166f63c1e3
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXSymbolShapeHint.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Enumeration for DataMatrix symbol shape hint. It can be used to force square or rectangular
+ * symbols.
+ */
+
+@interface ZXSymbolShapeHint : NSObject
+
++ (ZXSymbolShapeHint *)forceNone;
++ (ZXSymbolShapeHint *)forceSquare;
++ (ZXSymbolShapeHint *)forceRectangle;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXSymbolShapeHint.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXSymbolShapeHint.m
new file mode 100644
index 0000000000000000000000000000000000000000..f9649d21fec6338a12b9e0d83efa120249361511
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXSymbolShapeHint.m
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXSymbolShapeHint.h"
+
+@implementation ZXSymbolShapeHint
+
++ (ZXSymbolShapeHint *)forceNone {
+ static ZXSymbolShapeHint *_forceNone = nil;
+
+ if (!_forceNone) {
+ _forceNone = [[ZXSymbolShapeHint alloc] init];
+ }
+
+ return _forceNone;
+}
+
++ (ZXSymbolShapeHint *)forceSquare {
+ static ZXSymbolShapeHint *_forceSquare = nil;
+
+ if (!_forceSquare) {
+ _forceSquare = [[ZXSymbolShapeHint alloc] init];
+ }
+
+ return _forceSquare;
+}
+
++ (ZXSymbolShapeHint *)forceRectangle {
+ static ZXSymbolShapeHint *_forceRectangle = nil;
+
+ if (!_forceRectangle) {
+ _forceRectangle = [[ZXSymbolShapeHint alloc] init];
+ }
+
+ return _forceRectangle;
+}
+
+@end
\ No newline at end of file
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXTextEncoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXTextEncoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..f2159340573e12d0c3c4080956791472ee82c640
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXTextEncoder.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXC40Encoder.h"
+
+@interface ZXTextEncoder : ZXC40Encoder
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXTextEncoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXTextEncoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..3612c7d886431f5a742b33e368e33213e4a16a64
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXTextEncoder.m
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXHighLevelEncoder.h"
+#import "ZXTextEncoder.h"
+
+@implementation ZXTextEncoder
+
+- (int)encodingMode {
+ return [ZXHighLevelEncoder textEncodation];
+}
+
+- (int)encodeChar:(unichar)c buffer:(NSMutableString *)sb {
+ if (c == ' ') {
+ [sb appendString:@"\3"];
+ return 1;
+ }
+ if (c >= '0' && c <= '9') {
+ [sb appendFormat:@"%C", (unichar) (c - 48 + 4)];
+ return 1;
+ }
+ if (c >= 'a' && c <= 'z') {
+ [sb appendFormat:@"%C", (unichar) (c - 97 + 14)];
+ return 1;
+ }
+ if (c >= '\0' && c <= (char)0x001f) {
+ [sb appendString:@"\0"]; //Shift 1 Set
+ [sb appendFormat:@"%C", c];
+ return 2;
+ }
+ if (c >= '!' && c <= '/') {
+ [sb appendString:@"\1"]; //Shift 2 Set
+ [sb appendFormat:@"%C", (unichar) (c - 33)];
+ return 2;
+ }
+ if (c >= ':' && c <= '@') {
+ [sb appendString:@"\1"]; //Shift 2 Set
+ [sb appendFormat:@"%C", (unichar) (c - 58 + 15)];
+ return 2;
+ }
+ if (c >= '[' && c <= '_') {
+ [sb appendString:@"\1"]; //Shift 2 Set
+ [sb appendFormat:@"%C", (unichar) (c - 91 + 22)];
+ return 2;
+ }
+ if (c == '\u0060') {
+ [sb appendString:@"\2"]; //Shift 3 Set
+ [sb appendFormat:@"%C", (unichar) (c - 96)];
+ return 2;
+ }
+ if (c >= 'A' && c <= 'Z') {
+ [sb appendString:@"\2"]; //Shift 3 Set
+ [sb appendFormat:@"%C", (unichar) (c - 65 + 1)];
+ return 2;
+ }
+ if (c >= '{' && c <= (char)0x007f) {
+ [sb appendString:@"\2"]; //Shift 3 Set
+ [sb appendFormat:@"%C", (unichar) (c - 123 + 27)];
+ return 2;
+ }
+ if (c >= (unichar)0x0080) {
+ [sb appendFormat:@"\1%C", (unichar)0x001e]; //Shift 2, Upper Shift
+ int len = 2;
+ len += [self encodeChar:(unichar) (c - 128) buffer:sb];
+ return len;
+ }
+ [ZXHighLevelEncoder illegalCharacter:c];
+ return -1;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXX12Encoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXX12Encoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..1564a82efc5227741378d89f01fb8ab616948712
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXX12Encoder.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXC40Encoder.h"
+
+@interface ZXX12Encoder : ZXC40Encoder
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXX12Encoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXX12Encoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..efc1b4673b82ff1ae4ddc0812b8761259691ee6c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/datamatrix/encoder/ZXX12Encoder.m
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXEncoderContext.h"
+#import "ZXHighLevelEncoder.h"
+#import "ZXSymbolInfo.h"
+#import "ZXX12Encoder.h"
+
+@implementation ZXX12Encoder
+
+- (int)encodingMode {
+ return [ZXHighLevelEncoder x12Encodation];
+}
+
+- (void)encode:(ZXEncoderContext *)context {
+ //step C
+ NSMutableString *buffer = [NSMutableString string];
+ while ([context hasMoreCharacters]) {
+ unichar c = [context currentChar];
+ context.pos++;
+
+ [self encodeChar:c buffer:buffer];
+
+ int count = buffer.length;
+ if ((count % 3) == 0) {
+ [self writeNextTriplet:context buffer:buffer];
+
+ int newMode = [ZXHighLevelEncoder lookAheadTest:context.message startpos:context.pos currentMode:[self encodingMode]];
+ if (newMode != [self encodingMode]) {
+ [context signalEncoderChange:newMode];
+ break;
+ }
+ }
+ }
+ [self handleEOD:context buffer:buffer];
+}
+
+- (int)encodeChar:(unichar)c buffer:(NSMutableString *)sb {
+ if (c == '\r') {
+ [sb appendString:@"\0"];
+ } else if (c == '*') {
+ [sb appendString:@"\1"];
+ } else if (c == '>') {
+ [sb appendString:@"\2"];
+ } else if (c == ' ') {
+ [sb appendString:@"\3"];
+ } else if (c >= '0' && c <= '9') {
+ [sb appendFormat:@"%C", (unichar) (c - 48 + 4)];
+ } else if (c >= 'A' && c <= 'Z') {
+ [sb appendFormat:@"%C", (unichar) (c - 65 + 14)];
+ } else {
+ [ZXHighLevelEncoder illegalCharacter:c];
+ }
+ return 1;
+}
+
+- (void)handleEOD:(ZXEncoderContext *)context buffer:(NSMutableString *)buffer {
+ [context updateSymbolInfo];
+ int available = context.symbolInfo.dataCapacity - [context codewordCount];
+ int count = buffer.length;
+ if (count == 2) {
+ [context writeCodeword:[ZXHighLevelEncoder x12Unlatch]];
+ context.pos -= 2;
+ [context signalEncoderChange:[ZXHighLevelEncoder asciiEncodation]];
+ } else if (count == 1) {
+ context.pos--;
+ if (available > 1) {
+ [context writeCodeword:[ZXHighLevelEncoder x12Unlatch]];
+ }
+ //NOP - No unlatch necessary
+ [context signalEncoderChange:[ZXHighLevelEncoder asciiEncodation]];
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/ZXMaxiCodeReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/ZXMaxiCodeReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..27f42b022703ea6f6fc4ccf92b5e41a7a0010275
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/ZXMaxiCodeReader.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXReader.h"
+
+@class ZXBinaryBitmap, ZXDecodeHints, ZXResult;
+
+/**
+ * This implementation can detect and decode a MaxiCode in an image.
+ */
+@interface ZXMaxiCodeReader : NSObject <ZXReader>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/ZXMaxiCodeReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/ZXMaxiCodeReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..941fb430e0f4b9420a9af195f7a832b87cfcd835
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/ZXMaxiCodeReader.m
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBinaryBitmap.h"
+#import "ZXBitMatrix.h"
+#import "ZXDecodeHints.h"
+#import "ZXDecoderResult.h"
+#import "ZXErrors.h"
+#import "ZXMaxiCodeDecoder.h"
+#import "ZXMaxiCodeReader.h"
+#import "ZXResult.h"
+
+const int MATRIX_WIDTH = 30;
+const int MATRIX_HEIGHT = 33;
+
+@interface ZXMaxiCodeReader ()
+
+@property (nonatomic, retain) ZXMaxiCodeDecoder *decoder;
+
+- (ZXBitMatrix *)extractPureBits:(ZXBitMatrix *)image;
+
+@end
+
+@implementation ZXMaxiCodeReader
+
+@synthesize decoder;
+
+- (id)init {
+ if (self = [super init]) {
+ self.decoder = [[[ZXMaxiCodeDecoder alloc] init] autorelease];
+ }
+
+ return self;
+}
+
+- (void) dealloc {
+ [decoder release];
+
+ [super dealloc];
+}
+
+
+/**
+ * Locates and decodes a MaxiCode code in an image.
+ */
+- (ZXResult *)decode:(ZXBinaryBitmap *)image error:(NSError **)error {
+ return [self decode:image hints:nil error:error];
+}
+
+- (ZXResult *)decode:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ ZXDecoderResult *decoderResult;
+ if (hints != nil && hints.pureBarcode) {
+ ZXBitMatrix *matrix = [image blackMatrixWithError:error];
+ if (!matrix) {
+ return nil;
+ }
+ ZXBitMatrix *bits = [self extractPureBits:matrix];
+ if (!bits) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ decoderResult = [self.decoder decode:bits hints:hints error:error];
+ if (!decoderResult) {
+ return nil;
+ }
+ } else {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ NSArray *points = [NSArray array];
+ ZXResult *result = [ZXResult resultWithText:decoderResult.text
+ rawBytes:decoderResult.rawBytes
+ length:decoderResult.length
+ resultPoints:points
+ format:kBarcodeFormatMaxiCode];
+
+ NSString *ecLevel = decoderResult.ecLevel;
+ if (ecLevel != nil) {
+ [result putMetadata:kResultMetadataTypeErrorCorrectionLevel value:ecLevel];
+ }
+ return result;
+}
+
+- (void) reset {
+ // do nothing
+}
+
+
+/**
+ * This method detects a code in a "pure" image -- that is, pure monochrome image
+ * which contains only an unrotated, unskewed, image of a code, with some white border
+ * around it. This is a specialized method that works exceptionally fast in this special
+ * case.
+ */
+- (ZXBitMatrix *)extractPureBits:(ZXBitMatrix *)image {
+ NSArray *enclosingRectangle = image.enclosingRectangle;
+ if (enclosingRectangle == nil) {
+ return nil;
+ }
+
+ int left = [[enclosingRectangle objectAtIndex:0] intValue];
+ int top = [[enclosingRectangle objectAtIndex:1] intValue];
+ int width = [[enclosingRectangle objectAtIndex:2] intValue];
+ int height = [[enclosingRectangle objectAtIndex:3] intValue];
+
+ // Now just read off the bits
+ ZXBitMatrix *bits = [[[ZXBitMatrix alloc] initWithWidth:MATRIX_WIDTH height:MATRIX_HEIGHT] autorelease];
+ for (int y = 0; y < MATRIX_HEIGHT; y++) {
+ int iy = top + (y * height + height / 2) / MATRIX_HEIGHT;
+ for (int x = 0; x < MATRIX_WIDTH; x++) {
+ int ix = left + (x * width + width / 2 + (y & 0x01) * width / 2) / MATRIX_WIDTH;
+ if ([image getX:ix y:iy]) {
+ [bits setX:x y:y];
+ }
+ }
+ }
+
+ return bits;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeBitMatrixParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeBitMatrixParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..c818a949ad431e671f7f73c8454abcec0bf239ba
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeBitMatrixParser.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXBitMatrix;
+
+@interface ZXMaxiCodeBitMatrixParser : NSObject
+
+- (id)initWithBitMatrix:(ZXBitMatrix *)bitMatrix error:(NSError **)error;
+- (NSArray *)readCodewords;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeBitMatrixParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeBitMatrixParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..983aa10e74f3f2bb1b0ddceaad63717cfb44c5f4
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeBitMatrixParser.m
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXErrors.h"
+#import "ZXMaxiCodeBitMatrixParser.h"
+
+const int BITNR[33][30] = {
+ {121,120,127,126,133,132,139,138,145,144,151,150,157,156,163,162,169,168,175,174,181,180,187,186,193,192,199,198, -2, -2},
+ {123,122,129,128,135,134,141,140,147,146,153,152,159,158,165,164,171,170,177,176,183,182,189,188,195,194,201,200,816, -3},
+ {125,124,131,130,137,136,143,142,149,148,155,154,161,160,167,166,173,172,179,178,185,184,191,190,197,196,203,202,818,817},
+ {283,282,277,276,271,270,265,264,259,258,253,252,247,246,241,240,235,234,229,228,223,222,217,216,211,210,205,204,819, -3},
+ {285,284,279,278,273,272,267,266,261,260,255,254,249,248,243,242,237,236,231,230,225,224,219,218,213,212,207,206,821,820},
+ {287,286,281,280,275,274,269,268,263,262,257,256,251,250,245,244,239,238,233,232,227,226,221,220,215,214,209,208,822, -3},
+ {289,288,295,294,301,300,307,306,313,312,319,318,325,324,331,330,337,336,343,342,349,348,355,354,361,360,367,366,824,823},
+ {291,290,297,296,303,302,309,308,315,314,321,320,327,326,333,332,339,338,345,344,351,350,357,356,363,362,369,368,825, -3},
+ {293,292,299,298,305,304,311,310,317,316,323,322,329,328,335,334,341,340,347,346,353,352,359,358,365,364,371,370,827,826},
+ {409,408,403,402,397,396,391,390, 79, 78, -2, -2, 13, 12, 37, 36, 2, -1, 44, 43,109,108,385,384,379,378,373,372,828, -3},
+ {411,410,405,404,399,398,393,392, 81, 80, 40, -2, 15, 14, 39, 38, 3, -1, -1, 45,111,110,387,386,381,380,375,374,830,829},
+ {413,412,407,406,401,400,395,394, 83, 82, 41, -3, -3, -3, -3, -3, 5, 4, 47, 46,113,112,389,388,383,382,377,376,831, -3},
+ {415,414,421,420,427,426,103,102, 55, 54, 16, -3, -3, -3, -3, -3, -3, -3, 20, 19, 85, 84,433,432,439,438,445,444,833,832},
+ {417,416,423,422,429,428,105,104, 57, 56, -3, -3, -3, -3, -3, -3, -3, -3, 22, 21, 87, 86,435,434,441,440,447,446,834, -3},
+ {419,418,425,424,431,430,107,106, 59, 58, -3, -3, -3, -3, -3, -3, -3, -3, -3, 23, 89, 88,437,436,443,442,449,448,836,835},
+ {481,480,475,474,469,468, 48, -2, 30, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, 0, 53, 52,463,462,457,456,451,450,837, -3},
+ {483,482,477,476,471,470, 49, -1, -2, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -1,465,464,459,458,453,452,839,838},
+ {485,484,479,478,473,472, 51, 50, 31, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, 1, -2, 42,467,466,461,460,455,454,840, -3},
+ {487,486,493,492,499,498, 97, 96, 61, 60, -3, -3, -3, -3, -3, -3, -3, -3, -3, 26, 91, 90,505,504,511,510,517,516,842,841},
+ {489,488,495,494,501,500, 99, 98, 63, 62, -3, -3, -3, -3, -3, -3, -3, -3, 28, 27, 93, 92,507,506,513,512,519,518,843, -3},
+ {491,490,497,496,503,502,101,100, 65, 64, 17, -3, -3, -3, -3, -3, -3, -3, 18, 29, 95, 94,509,508,515,514,521,520,845,844},
+ {559,558,553,552,547,546,541,540, 73, 72, 32, -3, -3, -3, -3, -3, -3, 10, 67, 66,115,114,535,534,529,528,523,522,846, -3},
+ {561,560,555,554,549,548,543,542, 75, 74, -2, -1, 7, 6, 35, 34, 11, -2, 69, 68,117,116,537,536,531,530,525,524,848,847},
+ {563,562,557,556,551,550,545,544, 77, 76, -2, 33, 9, 8, 25, 24, -1, -2, 71, 70,119,118,539,538,533,532,527,526,849, -3},
+ {565,564,571,570,577,576,583,582,589,588,595,594,601,600,607,606,613,612,619,618,625,624,631,630,637,636,643,642,851,850},
+ {567,566,573,572,579,578,585,584,591,590,597,596,603,602,609,608,615,614,621,620,627,626,633,632,639,638,645,644,852, -3},
+ {569,568,575,574,581,580,587,586,593,592,599,598,605,604,611,610,617,616,623,622,629,628,635,634,641,640,647,646,854,853},
+ {727,726,721,720,715,714,709,708,703,702,697,696,691,690,685,684,679,678,673,672,667,666,661,660,655,654,649,648,855, -3},
+ {729,728,723,722,717,716,711,710,705,704,699,698,693,692,687,686,681,680,675,674,669,668,663,662,657,656,651,650,857,856},
+ {731,730,725,724,719,718,713,712,707,706,701,700,695,694,689,688,683,682,677,676,671,670,665,664,659,658,653,652,858, -3},
+ {733,732,739,738,745,744,751,750,757,756,763,762,769,768,775,774,781,780,787,786,793,792,799,798,805,804,811,810,860,859},
+ {735,734,741,740,747,746,753,752,759,758,765,764,771,770,777,776,783,782,789,788,795,794,801,800,807,806,813,812,861, -3},
+ {737,736,743,742,749,748,755,754,761,760,767,766,773,772,779,778,785,784,791,790,797,796,803,802,809,808,815,814,863,862}
+};
+
+@interface ZXMaxiCodeBitMatrixParser ()
+
+@property (nonatomic, retain) ZXBitMatrix *bitMatrix;
+
+@end
+
+@implementation ZXMaxiCodeBitMatrixParser
+
+@synthesize bitMatrix;
+
+- (id)initWithBitMatrix:(ZXBitMatrix *)aBitMatrix error:(NSError **)error {
+ if (self = [super init]) {
+ self.bitMatrix = aBitMatrix;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [bitMatrix release];
+
+ [super dealloc];
+}
+
+- (NSArray *)readCodewords {
+ const int resultLength = 144;
+ unsigned char result[resultLength];
+ memset(result, 0, resultLength * sizeof(unsigned char));
+
+ int height = self.bitMatrix.height;
+ int width = self.bitMatrix.width;
+ for (int y = 0; y < height; y++) {
+ int *bitnrRow = (int *)BITNR[y];
+ for (int x = 0; x < width; x++) {
+ int bit = bitnrRow[x];
+ if (bit >= 0 && [bitMatrix getX:x y:y]) {
+ result[bit / 6] |= (unsigned char) (1 << (5 - (bit % 6)));
+ }
+ }
+ }
+
+ NSMutableArray *resultArray = [NSMutableArray arrayWithCapacity:resultLength];
+ for (int i = 0; i < resultLength; i++) {
+ [resultArray addObject:[NSNumber numberWithChar:result[i]]];
+ }
+
+ return resultArray;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeDecodedBitStreamParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeDecodedBitStreamParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..f1840a998fd46d8fb3aad218ab807d5f01b6fffc
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeDecodedBitStreamParser.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * MaxiCodes can encode text or structured information as bits in one of several modes,
+ * with multiple character sets in one code. This class decodes the bits back into text.
+ */
+
+@class ZXDecoderResult;
+
+@interface ZXMaxiCodeDecodedBitStreamParser : NSObject
+
++ (ZXDecoderResult *)decode:(unsigned char *)bytes length:(unsigned int)length mode:(int)mode;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeDecodedBitStreamParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeDecodedBitStreamParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..bfdc22039835c092e976e7a20ca6833898ab0b57
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeDecodedBitStreamParser.m
@@ -0,0 +1,233 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecoderResult.h"
+#import "ZXErrors.h"
+#import "ZXMaxiCodeDecodedBitStreamParser.h"
+
+const unichar SHIFTA = 0xFFF0;
+const unichar SHIFTB = 0xFFF1;
+const unichar SHIFTC = 0xFFF2;
+const unichar SHIFTD = 0xFFF3;
+const unichar SHIFTE = 0xFFF4;
+const unichar TWOSHIFTA = 0xFFF5;
+const unichar THREESHIFTA = 0xFFF6;
+const unichar LATCHA = 0xFFF7;
+const unichar LATCHB = 0xFFF8;
+const unichar LOCK = 0xFFF9;
+const unichar ECI = 0xFFFA;
+const unichar NS = 0xFFFB;
+const unichar PAD = 0xFFFC;
+const unichar FS = 0x001C;
+const unichar GS = 0x001D;
+const unichar RS = 0x001E;
+
+const unichar SETS[1][383] = {
+ '\n', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
+ 'X', 'Y', 'Z', ECI, FS, GS, RS, NS, ' ', PAD, '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', '0',
+ '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', SHIFTB, SHIFTC, SHIFTD, SHIFTE, LATCHB,
+ '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p' , 'q', 'r', 's', 't', 'u', 'v', 'w',
+ 'x', 'y', 'z', ECI, FS, GS, RS, NS, '{', PAD, '}', '~', 0x007F, ';', '<', '=', '>', '?', '[', '\\', ']', '^', '_', ' ',
+ ',', '.', '/', ':', '@', '!', '|', PAD, TWOSHIFTA, THREESHIFTA, PAD, SHIFTA, SHIFTC, SHIFTD, SHIFTE, LATCHA,
+ 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE,
+ 0x00CF, 0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7, 0x00D8, 0x00D9, 0x00DA, ECI, FS, GS, RS, 0x00DB,
+ 0x00DC, 0x00DD, 0x00DE, 0x00DF, 0x00AA, 0x00AC, 0x00B1, 0x00B2, 0x00B3, 0x00B5, 0x00B9, 0x00BA, 0x00BC, 0x00BD, 0x00BE,
+ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, LATCHA, ' ', LOCK, SHIFTD, SHIFTE, LATCHB,
+ 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE,
+ 0x00EF, 0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8, 0x00F9, 0x00FA, ECI, FS, GS, RS, NS,
+ 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF, 0x00A1, 0x00A8, 0x00AB, 0x00AF, 0x00B0, 0x00B4, 0x00B7, 0x00B8, 0x00BB, 0x00BF,
+ 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F, 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, LATCHA, ' ', SHIFTC, LOCK, SHIFTE,
+ LATCHB, 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, '\n', 0x000B, 0x000C, '\r',
+ 0x000E, 0x000F, 0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, ECI, PAD, PAD,
+ 0x001B, NS, FS, GS, RS, 0x001F, 0x009F, 0x00A0, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A9, 0x00AD, 0x00AE,
+ 0x00B6, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, LATCHA, ' ', SHIFTC, SHIFTD, LOCK,
+ LATCHB, 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, '\n', 0x000B, 0x000C, '\r',
+ 0x000E, 0x000F, 0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001B, 0x001C,
+ 0x001D, 0x001E, 0x001F, 0x0020, 0x0021, '"', 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B,
+ 0x002C, 0x002D, 0x002E, 0x002F, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003A,
+ 0x003B, 0x003C, 0x003D, 0x003E, 0x003F
+};
+
+@interface ZXMaxiCodeDecodedBitStreamParser ()
+
++ (int)bit:(int)bit bytes:(unsigned char *)bytes length:(unsigned int)length;
++ (int)integer:(unsigned char *)bytes length:(unsigned int)length x:(unsigned char *)x xLength:(unsigned int)xLength;
++ (int)country:(unsigned char *)bytes length:(unsigned int)length;
++ (int)serviceClass:(unsigned char *)bytes length:(unsigned int)length;
++ (int)postCode2Length:(unsigned char *)bytes length:(unsigned int)length;
++ (int)postCode2:(unsigned char *)bytes length:(unsigned int)length;
++ (NSString *)postCode3:(unsigned char *)bytes length:(unsigned int)length;
++ (NSString *)message:(unsigned char *)bytes length:(unsigned int)length start:(int)start len:(int)len;
+
+@end
+
+@implementation ZXMaxiCodeDecodedBitStreamParser
+
++ (ZXDecoderResult *)decode:(unsigned char *)bytes length:(unsigned int)length mode:(int)mode {
+ NSMutableString *result = [NSMutableString stringWithCapacity:144];
+ switch (mode) {
+ case 2:
+ case 3: {
+ NSString *postcode;
+ if (mode == 2) {
+ int pc = [self postCode2:bytes length:length];
+ postcode = [NSString stringWithFormat:@"%9d", pc];
+ } else {
+ postcode = [self postCode3:bytes length:length];
+ }
+ NSString *country = [NSString stringWithFormat:@"%3d", [self country:bytes length:length]];
+ NSString *service = [NSString stringWithFormat:@"%3d", [self serviceClass:bytes length:length]];
+ [result appendString:[self message:bytes length:length start:10 len:84]];
+ if ([result hasPrefix:[NSString stringWithFormat:@"[)>%C01%C", RS, GS]]) {
+ [result insertString:[NSString stringWithFormat:@"%@%C%@%C%@%C", postcode, GS, country, GS, service, GS] atIndex:9];
+ } else {
+ [result insertString:[NSString stringWithFormat:@"%@%C%@%C%@%C", postcode, GS, country, GS, service, GS] atIndex:0];
+ }
+ break;
+ }
+ case 4:
+ [result appendString:[self message:bytes length:length start:1 len:93]];
+ break;
+ case 5:
+ [result appendString:[self message:bytes length:length start:1 len:77]];
+ break;
+ }
+ return [[[ZXDecoderResult alloc] initWithRawBytes:bytes
+ length:length
+ text:result
+ byteSegments:nil
+ ecLevel:[NSString stringWithFormat:@"%d", mode]] autorelease];
+}
+
++ (int)bit:(int)bit bytes:(unsigned char *)bytes length:(unsigned int)length {
+ bit--;
+ return (bytes[bit / 6] & (1 << (5 - (bit % 6)))) == 0 ? 0 : 1;
+}
+
++ (int)integer:(unsigned char *)bytes length:(unsigned int)length x:(unsigned char *)x xLength:(unsigned int)xLength {
+ int val = 0;
+ for (int i = 0; i < xLength; i++) {
+ val += [self bit:x[i] bytes:bytes length:length] << (xLength - i - 1);
+ }
+ return val;
+}
+
+#define COUNTRY_ARRAY_LEN 10
++ (int)country:(unsigned char *)bytes length:(unsigned int)length {
+ unsigned char array[COUNTRY_ARRAY_LEN] = {53, 54, 43, 44, 45, 46, 47, 48, 37, 38};
+
+ return [self integer:bytes length:length x:array xLength:COUNTRY_ARRAY_LEN];
+}
+
+#define SERVICE_ARRAY_LEN 10
++ (int)serviceClass:(unsigned char *)bytes length:(unsigned int)length {
+ unsigned char array[SERVICE_ARRAY_LEN] = {55, 56, 57, 58, 59, 60, 49, 50, 51, 52};
+
+ return [self integer:bytes length:length x:array xLength:SERVICE_ARRAY_LEN];
+}
+
+#define POST_CODE2_LENGTH_LEN 10
++ (int)postCode2Length:(unsigned char *)bytes length:(unsigned int)length {
+ unsigned char array[POST_CODE2_LENGTH_LEN] = {39, 40, 41, 42, 31, 32};
+
+ return [self integer:bytes length:length x:array xLength:POST_CODE2_LENGTH_LEN];
+}
+
+#define POST_CODE2_LEN 30
++ (int)postCode2:(unsigned char *)bytes length:(unsigned int)length {
+ unsigned char array[POST_CODE2_LEN] = {33, 34, 35, 36, 25, 26, 27, 28, 29, 30, 19,
+ 20, 21, 22, 23, 24, 13, 14, 15, 16, 17, 18, 7, 8, 9, 10, 11, 12, 1, 2};
+
+ return [self integer:bytes length:length x:array xLength:POST_CODE2_LEN];
+}
+
+#define POST_CODE3_LEN 6
++ (NSString *)postCode3:(unsigned char *)bytes length:(unsigned int)length {
+ unsigned char array[POST_CODE3_LEN][POST_CODE3_LEN] = {
+ {39, 40, 41, 42, 31, 32},
+ {33, 34, 35, 36, 25, 26},
+ {27, 28, 29, 30, 19, 20},
+ {21, 22, 23, 24, 13, 14},
+ {15, 16, 17, 18, 7, 8},
+ { 9, 10, 11, 12, 1, 2}
+ };
+
+ return [NSString stringWithFormat:@"%C%C%C%C%C%C",
+ SETS[0][[self integer:bytes length:length x:array[0] xLength:POST_CODE3_LEN]],
+ SETS[0][[self integer:bytes length:length x:array[1] xLength:POST_CODE3_LEN]],
+ SETS[0][[self integer:bytes length:length x:array[2] xLength:POST_CODE3_LEN]],
+ SETS[0][[self integer:bytes length:length x:array[3] xLength:POST_CODE3_LEN]],
+ SETS[0][[self integer:bytes length:length x:array[4] xLength:POST_CODE3_LEN]],
+ SETS[0][[self integer:bytes length:length x:array[5] xLength:POST_CODE3_LEN]]];
+}
+
++ (NSString *)message:(unsigned char *)bytes length:(unsigned int)length start:(int)start len:(int)len {
+ NSMutableString *sb = [NSMutableString string];
+ int shift = -1;
+ int set = 0;
+ int lastset = 0;
+ for (int i = start; i < start + len; i++) {
+ unichar c = SETS[set][bytes[i]];
+ switch (c) {
+ case LATCHA:
+ set = 0;
+ shift = -1;
+ break;
+ case LATCHB:
+ set = 1;
+ shift = -1;
+ break;
+ case SHIFTA:
+ case SHIFTB:
+ case SHIFTC:
+ case SHIFTD:
+ case SHIFTE:
+ lastset = set;
+ set = c - SHIFTA;
+ shift = 1;
+ break;
+ case TWOSHIFTA:
+ lastset = set;
+ set = 0;
+ shift = 2;
+ break;
+ case THREESHIFTA:
+ lastset = set;
+ set = 0;
+ shift = 3;
+ break;
+ case NS: {
+ int nsval = (bytes[++i] << 24) + (bytes[++i] << 18) + (bytes[++i] << 12) + (bytes[++i] << 6) + bytes[++i];
+ [sb appendFormat:@"%9d", nsval];
+ break;
+ }
+ case LOCK:
+ shift = -1;
+ break;
+ default:
+ [sb appendFormat:@"%C", c];
+ }
+ if (shift-- == 0) {
+ set = lastset;
+ }
+ }
+ while (sb.length > 0 && [sb characterAtIndex:sb.length - 1] == PAD) {
+ [sb deleteCharactersInRange:NSMakeRange(sb.length - 1, 1)];
+ }
+ return sb;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..e0cb928ab199e53a8bd6adc770daa34a3f236e73
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeDecoder.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The main class which implements MaxiCode decoding -- as opposed to locating and extracting
+ * the MaxiCode from an image.
+ */
+
+@class ZXBitMatrix, ZXDecodeHints, ZXDecoderResult;
+
+@interface ZXMaxiCodeDecoder : NSObject
+
+- (ZXDecoderResult *)decode:(ZXBitMatrix *)bits error:(NSError **)error;
+- (ZXDecoderResult *)decode:(ZXBitMatrix *)bits hints:(ZXDecodeHints *)hints error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..9c285333f298b02af83f82ae1d9bafb26101a3ed
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/maxicode/decoder/ZXMaxiCodeDecoder.m
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXDecodeHints.h"
+#import "ZXDecoderResult.h"
+#import "ZXErrors.h"
+#import "ZXGenericGF.h"
+#import "ZXMaxiCodeBitMatrixParser.h"
+#import "ZXMaxiCodeDecodedBitStreamParser.h"
+#import "ZXMaxiCodeDecoder.h"
+#import "ZXReedSolomonDecoder.h"
+
+const int ALL = 0;
+const int EVEN = 1;
+const int ODD = 2;
+
+@interface ZXMaxiCodeDecoder ()
+
+@property (nonatomic, retain) ZXReedSolomonDecoder *rsDecoder;
+
+- (BOOL)correctErrors:(NSMutableArray *)codewordBytes start:(int)start dataCodewords:(int)dataCodewords
+ ecCodewords:(int)ecCodewords mode:(int)mode error:(NSError **)error;
+
+@end
+
+@implementation ZXMaxiCodeDecoder
+
+@synthesize rsDecoder;
+
+- (id)init {
+ if (self = [super init]) {
+ self.rsDecoder = [[[ZXReedSolomonDecoder alloc] initWithField:[ZXGenericGF MaxiCodeField64]] autorelease];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [rsDecoder release];
+
+ [super dealloc];
+}
+
+- (ZXDecoderResult *)decode:(ZXBitMatrix *)bits error:(NSError **)error {
+ return [self decode:bits hints:nil error:error];
+}
+
+- (ZXDecoderResult *)decode:(ZXBitMatrix *)bits hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ ZXMaxiCodeBitMatrixParser *parser = [[[ZXMaxiCodeBitMatrixParser alloc] initWithBitMatrix:bits error:error] autorelease];
+ if (!parser) {
+ return nil;
+ }
+ NSMutableArray *codewords = [[[parser readCodewords] mutableCopy] autorelease];
+
+ if (![self correctErrors:codewords start:0 dataCodewords:10 ecCodewords:10 mode:ALL error:error]) {
+ return nil;
+ }
+ int mode = [[codewords objectAtIndex:0] charValue] & 0x0F;
+ int datawordsLen;
+ switch (mode) {
+ case 2:
+ case 3:
+ case 4:
+ if (![self correctErrors:codewords start:20 dataCodewords:84 ecCodewords:40 mode:EVEN error:error]) {
+ return nil;
+ }
+ if (![self correctErrors:codewords start:20 dataCodewords:84 ecCodewords:40 mode:ODD error:error]) {
+ return nil;
+ }
+ datawordsLen = 94;
+ break;
+ case 5:
+ if (![self correctErrors:codewords start:20 dataCodewords:68 ecCodewords:56 mode:EVEN error:error]) {
+ return nil;
+ }
+ if (![self correctErrors:codewords start:20 dataCodewords:68 ecCodewords:56 mode:ODD error:error]) {
+ return nil;
+ }
+ datawordsLen = 78;
+ break;
+ default:
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ unsigned char *datawords = (unsigned char *)malloc(datawordsLen * sizeof(unsigned char));
+ for (int i = 0; i < 10; i++) {
+ datawords[i] = [[codewords objectAtIndex:i] charValue];
+ }
+ for (int i = 20; i < datawordsLen + 10; i++) {
+ datawords[i - 10] = [[codewords objectAtIndex:i] charValue];
+ }
+
+ ZXDecoderResult *result = [ZXMaxiCodeDecodedBitStreamParser decode:datawords length:datawordsLen mode:mode];
+ free(datawords);
+ return result;
+}
+
+- (BOOL)correctErrors:(NSMutableArray *)codewordBytes start:(int)start dataCodewords:(int)dataCodewords
+ ecCodewords:(int)ecCodewords mode:(int)mode error:(NSError **)error {
+ int codewords = dataCodewords + ecCodewords;
+
+ // in EVEN or ODD mode only half the codewords
+ int divisor = mode == ALL ? 1 : 2;
+
+ // First read into an array of ints
+ int codewordsIntsLen = codewords / divisor;
+ int *codewordsInts = (int *)malloc(codewordsIntsLen * sizeof(int));
+ memset(codewordsInts, 0, codewordsIntsLen * sizeof(int));
+ for (int i = 0; i < codewords; i++) {
+ if ((mode == ALL) || (i % 2 == (mode - 1))) {
+ codewordsInts[i / divisor] = [[codewordBytes objectAtIndex:i + start] charValue] & 0xFF;
+ }
+ }
+
+ NSError *decodeError = nil;
+ if (![self.rsDecoder decode:codewordsInts receivedLen:codewordsIntsLen twoS:ecCodewords / divisor error:&decodeError]) {
+ if (decodeError.code == ZXReedSolomonError && error) {
+ *error = ChecksumErrorInstance();
+ }
+ return NO;
+ }
+ // Copy back into array of bytes -- only need to worry about the bytes that were data
+ // We don't care about errors in the error-correction codewords
+ for (int i = 0; i < dataCodewords; i++) {
+ if ((mode == ALL) || (i % 2 == (mode - 1))) {
+ [codewordBytes replaceObjectAtIndex:i + start withObject:[NSNumber numberWithChar:codewordsInts[i / divisor]]];
+ }
+ }
+
+ return YES;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXByQuadrantReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXByQuadrantReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..14aab08d0d8c233b145f074c053d270dae171c12
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXByQuadrantReader.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXReader.h"
+
+/**
+ * This class attempts to decode a barcode from an image, not by scanning the whole image,
+ * but by scanning subsets of the image. This is important when there may be multiple barcodes in
+ * an image, and detecting a barcode may find parts of multiple barcode and fail to decode
+ * (e.g. QR Codes). Instead this scans the four quadrants of the image -- and also the center
+ * 'quadrant' to cover the case where a barcode is found in the center.
+ */
+
+@interface ZXByQuadrantReader : NSObject <ZXReader>
+
+- (id)initWithDelegate:(id<ZXReader>)delegate;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXByQuadrantReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXByQuadrantReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..3a9fa8bc89222a5425860136d6acd7c2b91266b7
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXByQuadrantReader.m
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBinaryBitmap.h"
+#import "ZXByQuadrantReader.h"
+#import "ZXDecodeHints.h"
+#import "ZXErrors.h"
+#import "ZXResult.h"
+
+@interface ZXByQuadrantReader ()
+
+@property (nonatomic, assign) id<ZXReader> delegate;
+
+@end
+
+@implementation ZXByQuadrantReader
+
+@synthesize delegate;
+
+- (id)initWithDelegate:(id<ZXReader>)aDelegate {
+ if (self = [super init]) {
+ self.delegate = aDelegate;
+ }
+ return self;
+}
+
+- (ZXResult *)decode:(ZXBinaryBitmap *)image error:(NSError **)error {
+ return [self decode:image hints:nil error:error];
+}
+
+- (ZXResult *)decode:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ int width = image.width;
+ int height = image.height;
+ int halfWidth = width / 2;
+ int halfHeight = height / 2;
+
+ ZXBinaryBitmap *topLeft = [image crop:0 top:0 width:halfWidth height:halfHeight];
+ NSError *decodeError = nil;
+ ZXResult *result = [self.delegate decode:topLeft hints:hints error:&decodeError];
+ if (result) {
+ return result;
+ } else if (decodeError.code != ZXNotFoundError) {
+ if (error) *error = decodeError;
+ return nil;
+ }
+
+ ZXBinaryBitmap *topRight = [image crop:halfWidth top:0 width:halfWidth height:halfHeight];
+ decodeError = nil;
+ result = [self.delegate decode:topRight hints:hints error:&decodeError];
+ if (result) {
+ return result;
+ } else if (decodeError.code != ZXNotFoundError) {
+ if (error) *error = decodeError;
+ return nil;
+ }
+
+ ZXBinaryBitmap *bottomLeft = [image crop:0 top:halfHeight width:halfWidth height:halfHeight];
+ decodeError = nil;
+ result = [self.delegate decode:bottomLeft hints:hints error:&decodeError];
+ if (result) {
+ return result;
+ } else if (decodeError.code != ZXNotFoundError) {
+ if (error) *error = decodeError;
+ return nil;
+ }
+
+ ZXBinaryBitmap *bottomRight = [image crop:halfWidth top:halfHeight width:halfWidth height:halfHeight];
+ decodeError = nil;
+ result = [self.delegate decode:bottomRight hints:hints error:&decodeError];
+ if (result) {
+ return result;
+ } else if (decodeError.code != ZXNotFoundError) {
+ if (error) *error = decodeError;
+ return nil;
+ }
+
+ int quarterWidth = halfWidth / 2;
+ int quarterHeight = halfHeight / 2;
+ ZXBinaryBitmap *center = [image crop:quarterWidth top:quarterHeight width:halfWidth height:halfHeight];
+ return [self.delegate decode:center hints:hints error:error];
+}
+
+- (void)reset {
+ [self.delegate reset];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXGenericMultipleBarcodeReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXGenericMultipleBarcodeReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..0df8a1500d37e536f1f6c9d2e6617378699ded31
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXGenericMultipleBarcodeReader.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXMultipleBarcodeReader.h"
+
+/**
+ * Attempts to locate multiple barcodes in an image by repeatedly decoding portion of the image.
+ * After one barcode is found, the areas left, above, right and below the barcode's
+ * ZXResultPoints are scanned, recursively.
+ *
+ * A caller may want to also employ ZXByQuadrantReader when attempting to find multiple
+ * 2D barcodes, like QR Codes, in an image, where the presence of multiple barcodes might prevent
+ * detecting any one of them.
+ *
+ * That is, instead of passing an ZXReader a caller might pass
+ * [[ZXByQuadrantReader alloc] initWithDelegate:reader]</code>.
+ */
+
+@protocol ZXReader;
+
+@interface ZXGenericMultipleBarcodeReader : NSObject <ZXMultipleBarcodeReader>
+
+- (id)initWithDelegate:(id<ZXReader>)delegate;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXGenericMultipleBarcodeReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXGenericMultipleBarcodeReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..0cf229cc51b0fb024eb368b1363a5d46b37df70c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXGenericMultipleBarcodeReader.m
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXErrors.h"
+#import "ZXGenericMultipleBarcodeReader.h"
+#import "ZXReader.h"
+#import "ZXResultPoint.h"
+
+int const MIN_DIMENSION_TO_RECUR = 100;
+int const MAX_DEPTH = 4;
+
+@interface ZXGenericMultipleBarcodeReader ()
+
+@property (nonatomic, assign) id<ZXReader> delegate;
+
+- (BOOL)doDecodeMultiple:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints results:(NSMutableArray *)results
+ xOffset:(int)xOffset yOffset:(int)yOffset currentDepth:(int)currentDepth error:(NSError **)error;
+- (ZXResult *)translateResultPoints:(ZXResult *)result xOffset:(int)xOffset yOffset:(int)yOffset;
+
+@end
+
+@implementation ZXGenericMultipleBarcodeReader
+
+@synthesize delegate;
+
+- (id)initWithDelegate:(id <ZXReader>)aDelegate {
+ if (self = [super init]) {
+ self.delegate = aDelegate;
+ }
+
+ return self;
+}
+
+- (NSArray *)decodeMultiple:(ZXBinaryBitmap *)image error:(NSError **)error {
+ return [self decodeMultiple:image hints:nil error:error];
+}
+
+- (NSArray *)decodeMultiple:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ NSMutableArray *results = [NSMutableArray array];
+ if (![self doDecodeMultiple:image hints:hints results:results xOffset:0 yOffset:0 currentDepth:0 error:error]) {
+ return nil;
+ } else if (results.count == 0) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ return results;
+}
+
+- (BOOL)doDecodeMultiple:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints results:(NSMutableArray *)results
+ xOffset:(int)xOffset yOffset:(int)yOffset currentDepth:(int)currentDepth error:(NSError **)error {
+ if (currentDepth > MAX_DEPTH) {
+ return YES;
+ }
+
+ ZXResult *result = [self.delegate decode:image hints:hints error:error];
+ if (!result) {
+ return NO;
+ }
+
+ BOOL alreadyFound = NO;
+ for (ZXResult *existingResult in results) {
+ if ([[existingResult text] isEqualToString:[result text]]) {
+ alreadyFound = YES;
+ break;
+ }
+ }
+ if (!alreadyFound) {
+ [results addObject:[self translateResultPoints:result xOffset:xOffset yOffset:yOffset]];
+ }
+ NSMutableArray *resultPoints = [result resultPoints];
+ if (resultPoints == nil || [resultPoints count] == 0) {
+ return YES;
+ }
+ int width = [image width];
+ int height = [image height];
+ float minX = width;
+ float minY = height;
+ float maxX = 0.0f;
+ float maxY = 0.0f;
+ for (ZXResultPoint *point in resultPoints) {
+ float x = [point x];
+ float y = [point y];
+ if (x < minX) {
+ minX = x;
+ }
+ if (y < minY) {
+ minY = y;
+ }
+ if (x > maxX) {
+ maxX = x;
+ }
+ if (y > maxY) {
+ maxY = y;
+ }
+ }
+
+ if (minX > MIN_DIMENSION_TO_RECUR) {
+ return [self doDecodeMultiple:[image crop:0 top:0 width:(int)minX height:height] hints:hints results:results xOffset:xOffset yOffset:yOffset currentDepth:currentDepth + 1 error:error];
+ }
+ if (minY > MIN_DIMENSION_TO_RECUR) {
+ return [self doDecodeMultiple:[image crop:0 top:0 width:width height:(int)minY] hints:hints results:results xOffset:xOffset yOffset:yOffset currentDepth:currentDepth + 1 error:error];
+ }
+ if (maxX < width - MIN_DIMENSION_TO_RECUR) {
+ return [self doDecodeMultiple:[image crop:(int)maxX top:0 width:width - (int)maxX height:height] hints:hints results:results xOffset:xOffset + (int)maxX yOffset:yOffset currentDepth:currentDepth + 1 error:error];
+ }
+ if (maxY < height - MIN_DIMENSION_TO_RECUR) {
+ return [self doDecodeMultiple:[image crop:0 top:(int)maxY width:width height:height - (int)maxY] hints:hints results:results xOffset:xOffset yOffset:yOffset + (int)maxY currentDepth:currentDepth + 1 error:error];
+ }
+
+ return YES;
+}
+
+- (ZXResult *)translateResultPoints:(ZXResult *)result xOffset:(int)xOffset yOffset:(int)yOffset {
+ NSArray *oldResultPoints = [result resultPoints];
+ if (oldResultPoints == nil) {
+ return result;
+ }
+ NSMutableArray *newResultPoints = [NSMutableArray arrayWithCapacity:[oldResultPoints count]];
+ for (ZXResultPoint *oldPoint in oldResultPoints) {
+ [newResultPoints addObject:[[[ZXResultPoint alloc] initWithX:[oldPoint x] + xOffset y:[oldPoint y] + yOffset] autorelease]];
+ }
+
+ return [ZXResult resultWithText:result.text rawBytes:result.rawBytes length:result.length resultPoints:newResultPoints format:result.barcodeFormat];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXMultipleBarcodeReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXMultipleBarcodeReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..e2fd647eaa18ebdc638985ebb75cc01f0a26370e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/ZXMultipleBarcodeReader.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBinaryBitmap.h"
+#import "ZXResult.h"
+
+/**
+ * Implementation of this interface attempt to read several barcodes from one image.
+ */
+
+@class ZXDecodeHints;
+
+@protocol ZXMultipleBarcodeReader <NSObject>
+
+- (NSArray *)decodeMultiple:(ZXBinaryBitmap *)image error:(NSError **)error;
+- (NSArray *)decodeMultiple:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/ZXQRCodeMultiReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/ZXQRCodeMultiReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..f6d80b60da4f0eac8be0a5c48db221bff1cbfef2
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/ZXQRCodeMultiReader.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXMultipleBarcodeReader.h"
+#import "ZXQRCodeReader.h"
+
+/**
+ * This implementation can detect and decode multiple QR Codes in an image.
+ */
+
+@interface ZXQRCodeMultiReader : ZXQRCodeReader <ZXMultipleBarcodeReader>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/ZXQRCodeMultiReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/ZXQRCodeMultiReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..e195c2fbbb93a1f293a7a4fc919b293bd3465770
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/ZXQRCodeMultiReader.m
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecoderResult.h"
+#import "ZXDetectorResult.h"
+#import "ZXMultiDetector.h"
+#import "ZXQRCodeDecoder.h"
+#import "ZXQRCodeMultiReader.h"
+#import "ZXResult.h"
+
+@implementation ZXQRCodeMultiReader
+
+- (NSArray *)decodeMultiple:(ZXBinaryBitmap *)image error:(NSError **)error {
+ return [self decodeMultiple:image hints:nil error:error];
+}
+
+- (NSArray *)decodeMultiple:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ ZXBitMatrix *matrix = [image blackMatrixWithError:error];
+ if (!matrix) {
+ return nil;
+ }
+ NSMutableArray *results = [NSMutableArray array];
+ NSArray *detectorResult = [[[[ZXMultiDetector alloc] initWithImage:matrix] autorelease] detectMulti:hints error:error];
+ if (!detectorResult) {
+ return nil;
+ }
+ for (int i = 0; i < [detectorResult count]; i++) {
+ ZXDecoderResult *decoderResult = [[self decoder] decodeMatrix:[(ZXDetectorResult *)[detectorResult objectAtIndex:i] bits] hints:hints error:nil];
+ if (decoderResult) {
+ NSArray *points = [(ZXDetectorResult *)[detectorResult objectAtIndex:i] points];
+ ZXResult *result = [ZXResult resultWithText:decoderResult.text
+ rawBytes:decoderResult.rawBytes
+ length:decoderResult.length
+ resultPoints:points
+ format:kBarcodeFormatQRCode];
+ NSMutableArray *byteSegments = decoderResult.byteSegments;
+ if (byteSegments != nil) {
+ [result putMetadata:kResultMetadataTypeByteSegments value:byteSegments];
+ }
+ NSString *ecLevel = decoderResult.ecLevel;
+ if (ecLevel != nil) {
+ [result putMetadata:kResultMetadataTypeErrorCorrectionLevel value:ecLevel];
+ }
+ [results addObject:result];
+ }
+ }
+
+ return results;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/detector/ZXMultiDetector.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/detector/ZXMultiDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..348b768c41cd3450c656a1b5b08f3138eb14120b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/detector/ZXMultiDetector.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXQRCodeDetector.h"
+
+/**
+ * Encapsulates logic that can detect one or more QR Codes in an image, even if the QR Code
+ * is rotated or skewed, or partially obscured.
+ */
+
+@class ZXDecodeHints;
+
+@interface ZXMultiDetector : ZXQRCodeDetector
+
+- (NSArray *)detectMulti:(ZXDecodeHints *)hints error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/detector/ZXMultiDetector.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/detector/ZXMultiDetector.m
new file mode 100644
index 0000000000000000000000000000000000000000..b9926fdf1b85462bb387390c3ee5652a9212ee58
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/detector/ZXMultiDetector.m
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecodeHints.h"
+#import "ZXErrors.h"
+#import "ZXMultiDetector.h"
+#import "ZXMultiFinderPatternFinder.h"
+#import "ZXResultPointCallback.h"
+
+@implementation ZXMultiDetector
+
+- (NSArray *)detectMulti:(ZXDecodeHints *)hints error:(NSError **)error {
+ id<ZXResultPointCallback> resultPointCallback = hints == nil ? nil : hints.resultPointCallback;
+ ZXMultiFinderPatternFinder *finder = [[[ZXMultiFinderPatternFinder alloc] initWithImage:self.image resultPointCallback:resultPointCallback] autorelease];
+ NSArray *info = [finder findMulti:hints error:error];
+ if ([info count] == 0) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ NSMutableArray *result = [NSMutableArray array];
+ for (int i = 0; i < [info count]; i++) {
+ ZXDetectorResult *patternInfo = [self processFinderPatternInfo:[info objectAtIndex:i] error:nil];
+ if (patternInfo) {
+ [result addObject:patternInfo];
+ }
+ }
+
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/detector/ZXMultiFinderPatternFinder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/detector/ZXMultiFinderPatternFinder.h
new file mode 100644
index 0000000000000000000000000000000000000000..6faf80d74902a2e0599a4f8921feec6da0df995e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/detector/ZXMultiFinderPatternFinder.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXFinderPatternFinder.h"
+
+/**
+ * This class attempts to find finder patterns in a QR Code. Finder patterns are the square
+ * markers at three corners of a QR Code.
+ *
+ * This class is thread-safe but not reentrant. Each thread must allocate its own object.
+ *
+ * In contrast to ZXFinderPatternFinder, this class will return an array of all possible
+ * QR code locations in the image.
+ *
+ * Use the tryHarder hint to ask for a more thorough detection.
+ */
+
+@class ZXDecodeHints;
+
+@interface ZXMultiFinderPatternFinder : ZXFinderPatternFinder
+
+- (NSArray *)findMulti:(ZXDecodeHints *)hints error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/detector/ZXMultiFinderPatternFinder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/detector/ZXMultiFinderPatternFinder.m
new file mode 100644
index 0000000000000000000000000000000000000000..af292bb960ce260833523f34a73f382b4453a546
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/multi/qrcode/detector/ZXMultiFinderPatternFinder.m
@@ -0,0 +1,251 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXDecodeHints.h"
+#import "ZXErrors.h"
+#import "ZXFinderPatternInfo.h"
+#import "ZXMultiFinderPatternFinder.h"
+#import "ZXQRCodeFinderPattern.h"
+
+// TODO MIN_MODULE_COUNT and MAX_MODULE_COUNT would be great hints to ask the user for
+// since it limits the number of regions to decode
+
+// max. legal count of modules per QR code edge (177)
+float const MAX_MODULE_COUNT_PER_EDGE = 180;
+// min. legal count per modules per QR code edge (11)
+float const MIN_MODULE_COUNT_PER_EDGE = 9;
+
+/**
+ * More or less arbitrary cutoff point for determining if two finder patterns might belong
+ * to the same code if they differ less than DIFF_MODSIZE_CUTOFF_PERCENT percent in their
+ * estimated modules sizes.
+ */
+float const DIFF_MODSIZE_CUTOFF_PERCENT = 0.05f;
+
+/**
+ * More or less arbitrary cutoff point for determining if two finder patterns might belong
+ * to the same code if they differ less than DIFF_MODSIZE_CUTOFF pixels/module in their
+ * estimated modules sizes.
+ */
+float const DIFF_MODSIZE_CUTOFF = 0.5f;
+
+
+@interface ZXMultiFinderPatternFinder ()
+
+NSInteger moduleSizeCompare(id center1, id center2, void *context);
+
+- (NSArray *)selectBestPatternsWithError:(NSError **)error;
+
+@end
+
+
+@implementation ZXMultiFinderPatternFinder
+
+/**
+ * Returns the 3 best {@link FinderPattern}s from our list of candidates. The "best" are
+ * those that have been detected at least {@link #CENTER_QUORUM} times, and whose module
+ * size differs from the average among those patterns the least
+ */
+- (NSArray *)selectBestPatternsWithError:(NSError **)error {
+ NSMutableArray *_possibleCenters = [NSMutableArray arrayWithArray:[self possibleCenters]];
+ int size = [_possibleCenters count];
+
+ if (size < 3) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ /*
+ * Begin HE modifications to safely detect multiple codes of equal size
+ */
+ if (size == 3) {
+ return [NSArray arrayWithObjects:[NSArray arrayWithObjects:[_possibleCenters objectAtIndex:0],
+ [_possibleCenters objectAtIndex:1],
+ [_possibleCenters objectAtIndex:2], nil], nil];
+ }
+
+ [_possibleCenters sortUsingFunction:moduleSizeCompare context:nil];
+
+ /*
+ * Now lets start: build a list of tuples of three finder locations that
+ * - feature similar module sizes
+ * - are placed in a distance so the estimated module count is within the QR specification
+ * - have similar distance between upper left/right and left top/bottom finder patterns
+ * - form a triangle with 90° angle (checked by comparing top right/bottom left distance
+ * with pythagoras)
+ *
+ * Note: we allow each point to be used for more than one code region: this might seem
+ * counterintuitive at first, but the performance penalty is not that big. At this point,
+ * we cannot make a good quality decision whether the three finders actually represent
+ * a QR code, or are just by chance layouted so it looks like there might be a QR code there.
+ * So, if the layout seems right, lets have the decoder try to decode.
+ */
+
+ NSMutableArray *results = [NSMutableArray array];
+
+ for (int i1 = 0; i1 < (size - 2); i1++) {
+ ZXQRCodeFinderPattern *p1 = [self.possibleCenters objectAtIndex:i1];
+ if (p1 == nil) {
+ continue;
+ }
+
+ for (int i2 = i1 + 1; i2 < (size - 1); i2++) {
+ ZXQRCodeFinderPattern *p2 = [self.possibleCenters objectAtIndex:i2];
+ if (p2 == nil) {
+ continue;
+ }
+
+ float vModSize12 = ([p1 estimatedModuleSize] - [p2 estimatedModuleSize]) / MIN([p1 estimatedModuleSize], [p2 estimatedModuleSize]);
+ float vModSize12A = fabsf([p1 estimatedModuleSize] - [p2 estimatedModuleSize]);
+ if (vModSize12A > DIFF_MODSIZE_CUTOFF && vModSize12 >= DIFF_MODSIZE_CUTOFF_PERCENT) {
+ break;
+ }
+
+ for (int i3 = i2 + 1; i3 < size; i3++) {
+ ZXQRCodeFinderPattern *p3 = [self.possibleCenters objectAtIndex:i3];
+ if (p3 == nil) {
+ continue;
+ }
+
+ float vModSize23 = ([p2 estimatedModuleSize] - [p3 estimatedModuleSize]) / MIN([p2 estimatedModuleSize], [p3 estimatedModuleSize]);
+ float vModSize23A = fabsf([p2 estimatedModuleSize] - [p3 estimatedModuleSize]);
+ if (vModSize23A > DIFF_MODSIZE_CUTOFF && vModSize23 >= DIFF_MODSIZE_CUTOFF_PERCENT) {
+ break;
+ }
+
+ NSMutableArray *test = [NSMutableArray arrayWithObjects:p1, p2, p3, nil];
+ [ZXResultPoint orderBestPatterns:test];
+
+ ZXFinderPatternInfo *info = [[[ZXFinderPatternInfo alloc] initWithPatternCenters:test] autorelease];
+ float dA = [ZXResultPoint distance:[info topLeft] pattern2:[info bottomLeft]];
+ float dC = [ZXResultPoint distance:[info topRight] pattern2:[info bottomLeft]];
+ float dB = [ZXResultPoint distance:[info topLeft] pattern2:[info topRight]];
+
+ float estimatedModuleCount = (dA + dB) / ([p1 estimatedModuleSize] * 2.0f);
+ if (estimatedModuleCount > MAX_MODULE_COUNT_PER_EDGE || estimatedModuleCount < MIN_MODULE_COUNT_PER_EDGE) {
+ continue;
+ }
+
+ float vABBC = fabsf((dA - dB) / MIN(dA, dB));
+ if (vABBC >= 0.1f) {
+ continue;
+ }
+
+ float dCpy = (float)sqrt(dA * dA + dB * dB);
+ float vPyC = fabsf((dC - dCpy) / MIN(dC, dCpy));
+
+ if (vPyC >= 0.1f) {
+ continue;
+ }
+
+ [results addObject:test];
+ }
+ }
+ }
+
+ if ([results count] > 0) {
+ return results;
+ }
+
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+}
+
+- (NSArray *)findMulti:(ZXDecodeHints *)hints error:(NSError **)error {
+ BOOL tryHarder = hints != nil && hints.tryHarder;
+ int maxI = self.image.height;
+ int maxJ = self.image.width;
+ // We are looking for black/white/black/white/black modules in
+ // 1:1:3:1:1 ratio; this tracks the number of such modules seen so far
+
+ // Let's assume that the maximum version QR Code we support takes up 1/4 the height of the
+ // image, and then account for the center being 3 modules in size. This gives the smallest
+ // number of pixels the center could be, so skip this often. When trying harder, look for all
+ // QR versions regardless of how dense they are.
+ int iSkip = (int)(maxI / (FINDER_PATTERN_MAX_MODULES * 4.0f) * 3);
+ if (iSkip < FINDER_PATTERN_MIN_SKIP || tryHarder) {
+ iSkip = FINDER_PATTERN_MIN_SKIP;
+ }
+
+ int stateCount[5];
+ for (int i = iSkip - 1; i < maxI; i += iSkip) {
+ stateCount[0] = 0;
+ stateCount[1] = 0;
+ stateCount[2] = 0;
+ stateCount[3] = 0;
+ stateCount[4] = 0;
+ int currentState = 0;
+
+ for (int j = 0; j < maxJ; j++) {
+ if ([self.image getX:j y:i]) {
+ if ((currentState & 1) == 1) {
+ currentState++;
+ }
+ stateCount[currentState]++;
+ } else {
+ if ((currentState & 1) == 0) {
+ if (currentState == 4) {
+ if ([ZXFinderPatternFinder foundPatternCross:stateCount] && [self handlePossibleCenter:stateCount i:i j:j]) {
+ currentState = 0;
+ stateCount[0] = 0;
+ stateCount[1] = 0;
+ stateCount[2] = 0;
+ stateCount[3] = 0;
+ stateCount[4] = 0;
+ } else {
+ stateCount[0] = stateCount[2];
+ stateCount[1] = stateCount[3];
+ stateCount[2] = stateCount[4];
+ stateCount[3] = 1;
+ stateCount[4] = 0;
+ currentState = 3;
+ }
+ } else {
+ stateCount[++currentState]++;
+ }
+ } else {
+ stateCount[currentState]++;
+ }
+ }
+ }
+
+ if ([ZXFinderPatternFinder foundPatternCross:stateCount]) {
+ [self handlePossibleCenter:stateCount i:i j:maxJ];
+ }
+ }
+ NSArray *patternInfo = [self selectBestPatternsWithError:error];
+ if (!patternInfo) {
+ return nil;
+ }
+ NSMutableArray *result = [NSMutableArray array];
+ for (NSMutableArray *pattern in patternInfo) {
+ [ZXResultPoint orderBestPatterns:pattern];
+ [result addObject:[[[ZXFinderPatternInfo alloc] initWithPatternCenters:pattern] autorelease]];
+ }
+
+ return result;
+}
+
+/**
+ * A comparator that orders FinderPatterns by their estimated module size.
+ */
+NSInteger moduleSizeCompare(id center1, id center2, void *context) {
+ float value = [((ZXQRCodeFinderPattern *)center2) estimatedModuleSize] - [((ZXQRCodeFinderPattern *)center1) estimatedModuleSize];
+ return value < 0.0 ? -1 : value > 0.0 ? 1 : 0;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCodaBarReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCodaBarReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..b850d664745e11e9acd64b84e8917728d439e73d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCodaBarReader.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXOneDReader.h"
+
+extern const int CODA_ALPHABET_LEN;
+extern const char CODA_ALPHABET[];
+extern const int CODA_CHARACTER_ENCODINGS[];
+
+@class ZXBitArray, ZXDecodeHints, ZXResult;
+
+/**
+ * Decodes Codabar barcodes.
+ */
+@interface ZXCodaBarReader : ZXOneDReader
+
++ (BOOL)arrayContains:(char *)array length:(unsigned int)length key:(unichar)key;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCodaBarReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCodaBarReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..4c75d920ffeeb6113de7ea3860604694b5f5f509
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCodaBarReader.m
@@ -0,0 +1,385 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXCodaBarReader.h"
+#import "ZXErrors.h"
+#import "ZXResult.h"
+#import "ZXResultPoint.h"
+
+// These values are critical for determining how permissive the decoding
+// will be. All stripe sizes must be within the window these define, as
+// compared to the average stripe size.
+static int MAX_ACCEPTABLE;
+static int PADDING;
+
+const int CODA_ALPHABET_LEN = 22;
+const char CODA_ALPHABET[CODA_ALPHABET_LEN] = "0123456789-$:/.+ABCDTN";
+
+/**
+ * These represent the encodings of characters, as patterns of wide and narrow bars. The 7 least-significant bits of
+ * each int correspond to the pattern of wide and narrow, with 1s representing "wide" and 0s representing narrow.
+ */
+const int CODA_CHARACTER_ENCODINGS_LEN = 20;
+const int CODA_CHARACTER_ENCODINGS[CODA_CHARACTER_ENCODINGS_LEN] = {
+ 0x003, 0x006, 0x009, 0x060, 0x012, 0x042, 0x021, 0x024, 0x030, 0x048, // 0-9
+ 0x00c, 0x018, 0x045, 0x051, 0x054, 0x015, 0x01A, 0x029, 0x00B, 0x00E, // -$:/.+ABCD
+};
+
+// minimal number of characters that should be present (inclusing start and stop characters)
+// under normal circumstances this should be set to 3, but can be set higher
+// as a last-ditch attempt to reduce false positives.
+const int MIN_CHARACTER_LENGTH = 3;
+
+// official start and end patterns
+const int STARTEND_ENCODING_LEN = 4;
+const char STARTEND_ENCODING[STARTEND_ENCODING_LEN] = {'A', 'B', 'C', 'D'};
+
+// some codabar generator allow the codabar string to be closed by every
+// character. This will cause lots of false positives!
+
+// some industries use a checksum standard but this is not part of the original codabar standard
+// for more information see : http://www.mecsw.com/specs/codabar.html
+
+@interface ZXCodaBarReader ()
+
+@property (nonatomic, retain) NSMutableString *decodeRowResult;
+@property (nonatomic, assign) int *counters;
+@property (nonatomic, assign) int countersLen;
+@property (nonatomic, assign) int counterLength;
+
+- (BOOL)validatePattern:(int)start;
+- (BOOL)setCountersWithRow:(ZXBitArray *)row;
+- (void)counterAppend:(int)e;
+- (int)findStartPattern;
+- (int)toNarrowWidePattern:(int)position;
+
+@end
+
+@implementation ZXCodaBarReader
+
+@synthesize decodeRowResult;
+@synthesize counters;
+@synthesize countersLen;
+@synthesize counterLength;
+
++ (void)initialize {
+ MAX_ACCEPTABLE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 2.0f);
+ PADDING = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 1.5f);
+}
+
+- (id)init {
+ if (self = [super init]) {
+ self.decodeRowResult = [NSMutableString stringWithCapacity:20];
+ self.countersLen = 80;
+ self.counters = (int *)malloc(self.countersLen * sizeof(int));
+ memset(self.counters, 0, self.countersLen * sizeof(int));
+ self.counterLength = 0;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ if (self.counters != NULL) {
+ free(self.counters);
+ self.counters = NULL;
+ }
+
+ [super dealloc];
+}
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ if (![self setCountersWithRow:row]) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ int startOffset = [self findStartPattern];
+ if (startOffset == -1) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ int nextStart = startOffset;
+
+ self.decodeRowResult = [NSMutableString string];
+ do {
+ int charOffset = [self toNarrowWidePattern:nextStart];
+ if (charOffset == -1) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ // Hack: We store the position in the alphabet table into a
+ // NSMutableString, so that we can access the decoded patterns in
+ // validatePattern. We'll translate to the actual characters later.
+ [self.decodeRowResult appendFormat:@"%C", (unichar)charOffset];
+ nextStart += 8;
+ // Stop as soon as we see the end character.
+ if (decodeRowResult.length > 1 &&
+ [ZXCodaBarReader arrayContains:(char *)STARTEND_ENCODING length:STARTEND_ENCODING_LEN key:CODA_ALPHABET[charOffset]]) {
+ break;
+ }
+ } while (nextStart < self.counterLength); // no fixed end pattern so keep on reading while data is available
+
+ // Look for whitespace after pattern:
+ int trailingWhitespace = self.counters[nextStart - 1];
+ int lastPatternSize = 0;
+ for (int i = -8; i < -1; i++) {
+ lastPatternSize += self.counters[nextStart + i];
+ }
+
+ // We need to see whitespace equal to 50% of the last pattern size,
+ // otherwise this is probably a false positive. The exception is if we are
+ // at the end of the row. (I.e. the barcode barely fits.)
+ if (nextStart < self.counterLength && trailingWhitespace < lastPatternSize / 2) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ if (![self validatePattern:startOffset]) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ // Translate character table offsets to actual characters.
+ for (int i = 0; i < self.decodeRowResult.length; i++) {
+ [self.decodeRowResult replaceCharactersInRange:NSMakeRange(i, 1) withString:[NSString stringWithFormat:@"%c", CODA_ALPHABET[[decodeRowResult characterAtIndex:i]]]];
+ }
+ // Ensure a valid start and end character
+ unichar startchar = [self.decodeRowResult characterAtIndex:0];
+ if (![ZXCodaBarReader arrayContains:(char *)STARTEND_ENCODING length:STARTEND_ENCODING_LEN key:startchar]) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ unichar endchar = [self.decodeRowResult characterAtIndex:self.decodeRowResult.length - 1];
+ if (![ZXCodaBarReader arrayContains:(char *)STARTEND_ENCODING length:STARTEND_ENCODING_LEN key:endchar]) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ // remove stop/start characters character and check if a long enough string is contained
+ if (decodeRowResult.length <= MIN_CHARACTER_LENGTH) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ [self.decodeRowResult deleteCharactersInRange:NSMakeRange(decodeRowResult.length - 1, 1)];
+ [self.decodeRowResult deleteCharactersInRange:NSMakeRange(0, 1)];
+
+ int runningCount = 0;
+ for (int i = 0; i < startOffset; i++) {
+ runningCount += counters[i];
+ }
+ float left = (float) runningCount;
+ for (int i = startOffset; i < nextStart - 1; i++) {
+ runningCount += counters[i];
+ }
+ float right = (float) runningCount;
+ return [ZXResult resultWithText:self.decodeRowResult
+ rawBytes:nil
+ length:0
+ resultPoints:[NSArray arrayWithObjects:
+ [[[ZXResultPoint alloc] initWithX:left y:(float)rowNumber] autorelease],
+ [[[ZXResultPoint alloc] initWithX:right y:(float)rowNumber] autorelease], nil]
+ format:kBarcodeFormatCodabar];
+}
+
+- (BOOL)validatePattern:(int)start {
+ // First, sum up the total size of our four categories of stripe sizes;
+ int sizes[4] = {0, 0, 0, 0};
+ int counts[4] = {0, 0, 0, 0};
+ int end = self.decodeRowResult.length - 1;
+
+ // We break out of this loop in the middle, in order to handle
+ // inter-character spaces properly.
+ int pos = start;
+ for (int i = 0; true; i++) {
+ int pattern = CODA_CHARACTER_ENCODINGS[[decodeRowResult characterAtIndex:i]];
+ for (int j = 6; j >= 0; j--) {
+ // Even j = bars, while odd j = spaces. Categories 2 and 3 are for
+ // long stripes, while 0 and 1 are for short stripes.
+ int category = (j & 1) + (pattern & 1) * 2;
+ sizes[category] += self.counters[pos + j];
+ counts[category]++;
+ pattern >>= 1;
+ }
+ if (i >= end) {
+ break;
+ }
+ // We ignore the inter-character space - it could be of any size.
+ pos += 8;
+ }
+
+ // Calculate our allowable size thresholds using fixed-point math.
+ int maxes[4] = {0};
+ int mins[4] = {0};
+ // Define the threshold of acceptability to be the midpoint between the
+ // average small stripe and the average large stripe. No stripe lengths
+ // should be on the "wrong" side of that line.
+ for (int i = 0; i < 2; i++) {
+ mins[i] = 0; // Accept arbitrarily small "short" stripes.
+ mins[i + 2] = ((sizes[i] << INTEGER_MATH_SHIFT) / counts[i] +
+ (sizes[i + 2] << INTEGER_MATH_SHIFT) / counts[i + 2]) >> 1;
+ maxes[i] = mins[i + 2];
+ maxes[i + 2] = (sizes[i + 2] * MAX_ACCEPTABLE + PADDING) / counts[i + 2];
+ }
+
+ // Now verify that all of the stripes are within the thresholds.
+ pos = start;
+ for (int i = 0; true; i++) {
+ int pattern = CODA_CHARACTER_ENCODINGS[[decodeRowResult characterAtIndex:i]];
+ for (int j = 6; j >= 0; j--) {
+ // Even j = bars, while odd j = spaces. Categories 2 and 3 are for
+ // long stripes, while 0 and 1 are for short stripes.
+ int category = (j & 1) + (pattern & 1) * 2;
+ int size = counters[pos + j] << INTEGER_MATH_SHIFT;
+ if (size < mins[category] || size > maxes[category]) {
+ return NO;
+ }
+ pattern >>= 1;
+ }
+ if (i >= end) {
+ break;
+ }
+ pos += 8;
+ }
+
+ return YES;
+}
+
+/**
+ * Records the size of all runs of white and black pixels, starting with white.
+ * This is just like recordPattern, except it records all the counters, and
+ * uses our builtin "counters" member for storage.
+ */
+- (BOOL)setCountersWithRow:(ZXBitArray *)row {
+ self.counterLength = 0;
+ // Start from the first white bit.
+ int i = [row nextUnset:0];
+ int end = row.size;
+ if (i >= end) {
+ return NO;
+ }
+ BOOL isWhite = YES;
+ int count = 0;
+ for (; i < end; i++) {
+ if ([row get:i] ^ isWhite) { // that is, exactly one is true
+ count++;
+ } else {
+ [self counterAppend:count];
+ count = 1;
+ isWhite = !isWhite;
+ }
+ }
+ [self counterAppend:count];
+ return YES;
+}
+
+- (void)counterAppend:(int)e {
+ self.counters[self.counterLength] = e;
+ self.counterLength++;
+ if (self.counterLength >= self.countersLen) {
+ int *temp = (int *)malloc(2 * self.counterLength * sizeof(int));
+ memcpy(temp, self.counters, self.countersLen * sizeof(int));
+ self.counters = temp;
+ memset(self.counters, 0, 2 * self.counterLength * sizeof(int));
+ self.countersLen = 2 * self.counterLength;
+ }
+}
+
+- (int)findStartPattern {
+ for (int i = 1; i < self.counterLength; i += 2) {
+ int charOffset = [self toNarrowWidePattern:i];
+ if (charOffset != -1 && [[self class] arrayContains:(char *)STARTEND_ENCODING length:STARTEND_ENCODING_LEN key:CODA_ALPHABET[charOffset]]) {
+ // Look for whitespace before start pattern, >= 50% of width of start pattern
+ // We make an exception if the whitespace is the first element.
+ int patternSize = 0;
+ for (int j = i; j < i + 7; j++) {
+ patternSize += self.counters[j];
+ }
+ if (i == 1 || self.counters[i-1] >= patternSize / 2) {
+ return i;
+ }
+ }
+ }
+
+ return -1;
+}
+
++ (BOOL)arrayContains:(char *)array length:(unsigned int)length key:(unichar)key {
+ if (array != nil) {
+ for (int i = 0; i < length; i++) {
+ if (array[i] == key) {
+ return YES;
+ }
+ }
+ }
+ return NO;
+}
+
+// Assumes that counters[position] is a bar.
+- (int)toNarrowWidePattern:(int)position {
+ int end = position + 7;
+ if (end >= self.counterLength) {
+ return -1;
+ }
+
+ int maxBar = 0;
+ int minBar = NSIntegerMax;
+ for (int j = position; j < end; j += 2) {
+ int currentCounter = counters[j];
+ if (currentCounter < minBar) {
+ minBar = currentCounter;
+ }
+ if (currentCounter > maxBar) {
+ maxBar = currentCounter;
+ }
+ }
+ int thresholdBar = (minBar + maxBar) / 2;
+
+ int maxSpace = 0;
+ int minSpace = NSIntegerMax;
+ for (int j = position + 1; j < end; j += 2) {
+ int currentCounter = counters[j];
+ if (currentCounter < minSpace) {
+ minSpace = currentCounter;
+ }
+ if (currentCounter > maxSpace) {
+ maxSpace = currentCounter;
+ }
+ }
+ int thresholdSpace = (minSpace + maxSpace) / 2;
+
+ int bitmask = 1 << 7;
+ int pattern = 0;
+ for (int i = 0; i < 7; i++) {
+ int threshold = (i & 1) == 0 ? thresholdBar : thresholdSpace;
+ bitmask >>= 1;
+ if (counters[position + i] > threshold) {
+ pattern |= bitmask;
+ }
+ }
+
+ for (int i = 0; i < CODA_CHARACTER_ENCODINGS_LEN; i++) {
+ if (CODA_CHARACTER_ENCODINGS[i] == pattern) {
+ return i;
+ }
+ }
+ return -1;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCodaBarWriter.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCodaBarWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..a07648a27cab57edb5e8cde120606a91b7feadff
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCodaBarWriter.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXOneDimensionalCodeWriter.h"
+
+@interface ZXCodaBarWriter : ZXOneDimensionalCodeWriter
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCodaBarWriter.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCodaBarWriter.m
new file mode 100644
index 0000000000000000000000000000000000000000..fcfc139481b3a299752cf2da4c729abd12c2e225
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCodaBarWriter.m
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXCodaBarReader.h"
+#import "ZXCodaBarWriter.h"
+
+const int START_CHARS_LEN = 4;
+const char START_CHARS[START_CHARS_LEN] = "ABCD";
+
+const int END_CHARS_LEN = 4;
+const char END_CHARS[END_CHARS_LEN] = "TN*E";
+
+@implementation ZXCodaBarWriter
+
+- (BOOL *)encode:(NSString *)contents length:(int *)pLength {
+
+ // Verify input and calculate decoded length.
+ if (![ZXCodaBarReader arrayContains:(char *)START_CHARS length:START_CHARS_LEN key:[[contents uppercaseString] characterAtIndex:0]]) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:[NSString stringWithFormat:@"Codabar should start with one of the following: %@", [NSString stringWithCString:START_CHARS encoding:NSUTF8StringEncoding]]
+ userInfo:nil];
+ }
+ if (![ZXCodaBarReader arrayContains:(char *)END_CHARS length:END_CHARS_LEN key:[[contents uppercaseString] characterAtIndex:contents.length - 1]]) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:[NSString stringWithFormat:@"Codabar should end with one of the following: %@", [NSString stringWithCString:START_CHARS encoding:NSUTF8StringEncoding]]
+ userInfo:nil];
+ }
+ // The start character and the end character are decoded to 10 length each.
+ int resultLength = 20;
+ char charsWhichAreTenLengthEachAfterDecoded[4] = {'/', ':', '+', '.'};
+ for (int i = 1; i < contents.length - 1; i++) {
+ if (([contents characterAtIndex:i] >= '0' && [contents characterAtIndex:i] <= '9') ||
+ [contents characterAtIndex:i] == '-' || [contents characterAtIndex:i] == '$') {
+ resultLength += 9;
+ } else if ([ZXCodaBarReader arrayContains:charsWhichAreTenLengthEachAfterDecoded length:4 key:[contents characterAtIndex:i]]) {
+ resultLength += 10;
+ } else {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:[NSString stringWithFormat:@"Cannot encode : '%C'", [contents characterAtIndex:i]]
+ userInfo:nil];
+ }
+ }
+ // A blank is placed between each character.
+ resultLength += contents.length - 1;
+
+ if (pLength) *pLength = resultLength;
+ BOOL *result = (BOOL *)malloc(resultLength * sizeof(BOOL));
+ int position = 0;
+ for (int index = 0; index < contents.length; index++) {
+ unichar c = [[contents uppercaseString] characterAtIndex:index];
+ if (index == contents.length - 1) {
+ // The end chars are not in the CodaBarReader.ALPHABET.
+ switch (c) {
+ case 'T':
+ c = 'A';
+ break;
+ case 'N':
+ c = 'B';
+ break;
+ case '*':
+ c = 'C';
+ break;
+ case 'E':
+ c = 'D';
+ break;
+ }
+ }
+ int code = 0;
+ for (int i = 0; i < CODA_ALPHABET_LEN; i++) {
+ // Found any, because I checked above.
+ if (c == CODA_ALPHABET[i]) {
+ code = CODA_CHARACTER_ENCODINGS[i];
+ break;
+ }
+ }
+ BOOL color = YES;
+ int counter = 0;
+ int bit = 0;
+ while (bit < 7) { // A character consists of 7 digit.
+ result[position] = color;
+ position++;
+ if (((code >> (6 - bit)) & 1) == 0 || counter == 1) {
+ color = !color; // Flip the color.
+ bit++;
+ counter = 0;
+ } else {
+ counter++;
+ }
+ }
+ if (index < contents.length - 1) {
+ result[position] = NO;
+ position++;
+ }
+ }
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode128Reader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode128Reader.h
new file mode 100644
index 0000000000000000000000000000000000000000..093ac407f48559760f22b6147aa4f29b61c6eb39
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode128Reader.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXOneDReader.h"
+
+/**
+ * Decodes Code 128 barcodes.
+ */
+
+extern const int CODE_PATTERNS[][7];
+
+extern const int CODE_START_B;
+extern const int CODE_START_C;
+extern const int CODE_CODE_B;
+extern const int CODE_CODE_C;
+extern const int CODE_STOP;
+
+extern int const CODE_FNC_1;
+extern int const CODE_FNC_2;
+extern int const CODE_FNC_3;
+extern int const CODE_FNC_4_A;
+extern int const CODE_FNC_4_B;
+
+@class ZXDecodeHints, ZXResult;
+
+@interface ZXCode128Reader : ZXOneDReader
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode128Reader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode128Reader.m
new file mode 100644
index 0000000000000000000000000000000000000000..683d90467bc43db1de19ee23a9e43f9240b76d5c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode128Reader.m
@@ -0,0 +1,483 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXCode128Reader.h"
+#import "ZXErrors.h"
+#import "ZXOneDReader.h"
+#import "ZXResult.h"
+#import "ZXResultPoint.h"
+
+#define CODE_PATTERNS_LENGTH 107
+#define countersLength 7
+
+const int CODE_PATTERNS[CODE_PATTERNS_LENGTH][countersLength] = {
+ {2, 1, 2, 2, 2, 2}, // 0
+ {2, 2, 2, 1, 2, 2},
+ {2, 2, 2, 2, 2, 1},
+ {1, 2, 1, 2, 2, 3},
+ {1, 2, 1, 3, 2, 2},
+ {1, 3, 1, 2, 2, 2}, // 5
+ {1, 2, 2, 2, 1, 3},
+ {1, 2, 2, 3, 1, 2},
+ {1, 3, 2, 2, 1, 2},
+ {2, 2, 1, 2, 1, 3},
+ {2, 2, 1, 3, 1, 2}, // 10
+ {2, 3, 1, 2, 1, 2},
+ {1, 1, 2, 2, 3, 2},
+ {1, 2, 2, 1, 3, 2},
+ {1, 2, 2, 2, 3, 1},
+ {1, 1, 3, 2, 2, 2}, // 15
+ {1, 2, 3, 1, 2, 2},
+ {1, 2, 3, 2, 2, 1},
+ {2, 2, 3, 2, 1, 1},
+ {2, 2, 1, 1, 3, 2},
+ {2, 2, 1, 2, 3, 1}, // 20
+ {2, 1, 3, 2, 1, 2},
+ {2, 2, 3, 1, 1, 2},
+ {3, 1, 2, 1, 3, 1},
+ {3, 1, 1, 2, 2, 2},
+ {3, 2, 1, 1, 2, 2}, // 25
+ {3, 2, 1, 2, 2, 1},
+ {3, 1, 2, 2, 1, 2},
+ {3, 2, 2, 1, 1, 2},
+ {3, 2, 2, 2, 1, 1},
+ {2, 1, 2, 1, 2, 3}, // 30
+ {2, 1, 2, 3, 2, 1},
+ {2, 3, 2, 1, 2, 1},
+ {1, 1, 1, 3, 2, 3},
+ {1, 3, 1, 1, 2, 3},
+ {1, 3, 1, 3, 2, 1}, // 35
+ {1, 1, 2, 3, 1, 3},
+ {1, 3, 2, 1, 1, 3},
+ {1, 3, 2, 3, 1, 1},
+ {2, 1, 1, 3, 1, 3},
+ {2, 3, 1, 1, 1, 3}, // 40
+ {2, 3, 1, 3, 1, 1},
+ {1, 1, 2, 1, 3, 3},
+ {1, 1, 2, 3, 3, 1},
+ {1, 3, 2, 1, 3, 1},
+ {1, 1, 3, 1, 2, 3}, // 45
+ {1, 1, 3, 3, 2, 1},
+ {1, 3, 3, 1, 2, 1},
+ {3, 1, 3, 1, 2, 1},
+ {2, 1, 1, 3, 3, 1},
+ {2, 3, 1, 1, 3, 1}, // 50
+ {2, 1, 3, 1, 1, 3},
+ {2, 1, 3, 3, 1, 1},
+ {2, 1, 3, 1, 3, 1},
+ {3, 1, 1, 1, 2, 3},
+ {3, 1, 1, 3, 2, 1}, // 55
+ {3, 3, 1, 1, 2, 1},
+ {3, 1, 2, 1, 1, 3},
+ {3, 1, 2, 3, 1, 1},
+ {3, 3, 2, 1, 1, 1},
+ {3, 1, 4, 1, 1, 1}, // 60
+ {2, 2, 1, 4, 1, 1},
+ {4, 3, 1, 1, 1, 1},
+ {1, 1, 1, 2, 2, 4},
+ {1, 1, 1, 4, 2, 2},
+ {1, 2, 1, 1, 2, 4}, // 65
+ {1, 2, 1, 4, 2, 1},
+ {1, 4, 1, 1, 2, 2},
+ {1, 4, 1, 2, 2, 1},
+ {1, 1, 2, 2, 1, 4},
+ {1, 1, 2, 4, 1, 2}, // 70
+ {1, 2, 2, 1, 1, 4},
+ {1, 2, 2, 4, 1, 1},
+ {1, 4, 2, 1, 1, 2},
+ {1, 4, 2, 2, 1, 1},
+ {2, 4, 1, 2, 1, 1}, // 75
+ {2, 2, 1, 1, 1, 4},
+ {4, 1, 3, 1, 1, 1},
+ {2, 4, 1, 1, 1, 2},
+ {1, 3, 4, 1, 1, 1},
+ {1, 1, 1, 2, 4, 2}, // 80
+ {1, 2, 1, 1, 4, 2},
+ {1, 2, 1, 2, 4, 1},
+ {1, 1, 4, 2, 1, 2},
+ {1, 2, 4, 1, 1, 2},
+ {1, 2, 4, 2, 1, 1}, // 85
+ {4, 1, 1, 2, 1, 2},
+ {4, 2, 1, 1, 1, 2},
+ {4, 2, 1, 2, 1, 1},
+ {2, 1, 2, 1, 4, 1},
+ {2, 1, 4, 1, 2, 1}, // 90
+ {4, 1, 2, 1, 2, 1},
+ {1, 1, 1, 1, 4, 3},
+ {1, 1, 1, 3, 4, 1},
+ {1, 3, 1, 1, 4, 1},
+ {1, 1, 4, 1, 1, 3}, // 95
+ {1, 1, 4, 3, 1, 1},
+ {4, 1, 1, 1, 1, 3},
+ {4, 1, 1, 3, 1, 1},
+ {1, 1, 3, 1, 4, 1},
+ {1, 1, 4, 1, 3, 1}, // 100
+ {3, 1, 1, 1, 4, 1},
+ {4, 1, 1, 1, 3, 1},
+ {2, 1, 1, 4, 1, 2},
+ {2, 1, 1, 2, 1, 4},
+ {2, 1, 1, 2, 3, 2}, // 105
+ {2, 3, 3, 1, 1, 1, 2}
+};
+
+static int MAX_AVG_VARIANCE = -1;
+static int MAX_INDIVIDUAL_VARIANCE = -1;
+
+int const CODE_SHIFT = 98;
+int const CODE_CODE_C = 99;
+int const CODE_CODE_B = 100;
+int const CODE_CODE_A = 101;
+int const CODE_FNC_1 = 102;
+int const CODE_FNC_2 = 97;
+int const CODE_FNC_3 = 96;
+int const CODE_FNC_4_A = 101;
+int const CODE_FNC_4_B = 100;
+int const CODE_START_A = 103;
+int const CODE_START_B = 104;
+int const CODE_START_C = 105;
+int const CODE_STOP = 106;
+
+@interface ZXCode128Reader ()
+
+- (int)decodeCode:(ZXBitArray *)row counters:(int[])counters countersCount:(int)countersCount rowOffset:(int)rowOffset;
+- (NSArray *)findStartPattern:(ZXBitArray *)row;
+
+@end
+
+@implementation ZXCode128Reader
+
++ (void)initialize {
+ if (MAX_AVG_VARIANCE == -1) {
+ MAX_AVG_VARIANCE = (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.25f);
+ }
+
+ if (MAX_INDIVIDUAL_VARIANCE == -1) {
+ MAX_INDIVIDUAL_VARIANCE = (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.7f);
+ }
+}
+
+- (NSArray *)findStartPattern:(ZXBitArray *)row {
+ int width = row.size;
+ int rowOffset = [row nextSet:0];
+
+ int counterPosition = 0;
+
+ const int patternLength = 6;
+ int counters[patternLength];
+ memset(counters, 0, patternLength * sizeof(int));
+
+ int patternStart = rowOffset;
+ BOOL isWhite = NO;
+
+ for (int i = rowOffset; i < width; i++) {
+ if ([row get:i] ^ isWhite) {
+ counters[counterPosition]++;
+ } else {
+ if (counterPosition == patternLength - 1) {
+ int bestVariance = MAX_AVG_VARIANCE;
+ int bestMatch = -1;
+ for (int startCode = CODE_START_A; startCode <= CODE_START_C; startCode++) {
+ int variance = [ZXOneDReader patternMatchVariance:counters countersSize:patternLength pattern:(int *)CODE_PATTERNS[startCode] maxIndividualVariance:MAX_INDIVIDUAL_VARIANCE];
+ if (variance < bestVariance) {
+ bestVariance = variance;
+ bestMatch = startCode;
+ }
+ }
+ // Look for whitespace before start pattern, >= 50% of width of start pattern
+ if (bestMatch >= 0 &&
+ [row isRange:MAX(0, patternStart - (i - patternStart) / 2) end:patternStart value:NO]) {
+ return [NSArray arrayWithObjects:[NSNumber numberWithInt:patternStart], [NSNumber numberWithInt:i], [NSNumber numberWithInt:bestMatch], nil];
+ }
+ patternStart += counters[0] + counters[1];
+ for (int y = 2; y < patternLength; y++) {
+ counters[y - 2] = counters[y];
+ }
+ counters[patternLength - 2] = 0;
+ counters[patternLength - 1] = 0;
+ counterPosition--;
+ } else {
+ counterPosition++;
+ }
+ counters[counterPosition] = 1;
+ isWhite = !isWhite;
+ }
+ }
+
+ return nil;
+}
+
+- (int)decodeCode:(ZXBitArray *)row counters:(int[])counters countersCount:(int)countersCount rowOffset:(int)rowOffset {
+ if (![ZXOneDReader recordPattern:row start:rowOffset counters:counters countersSize:countersCount]) {
+ return -1;
+ }
+ int bestVariance = MAX_AVG_VARIANCE;
+ int bestMatch = -1;
+
+ for (int d = 0; d < CODE_PATTERNS_LENGTH; d++) {
+ int *pattern = (int *)CODE_PATTERNS[d];
+ int variance = [ZXOneDReader patternMatchVariance:counters countersSize:countersCount pattern:pattern maxIndividualVariance:MAX_INDIVIDUAL_VARIANCE];
+ if (variance < bestVariance) {
+ bestVariance = variance;
+ bestMatch = d;
+ }
+ }
+
+ if (bestMatch >= 0) {
+ return bestMatch;
+ } else {
+ return -1;
+ }
+}
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ NSArray *startPatternInfo = [self findStartPattern:row];
+ if (!startPatternInfo) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ int startCode = [[startPatternInfo objectAtIndex:2] intValue];
+ int codeSet;
+
+ switch (startCode) {
+ case CODE_START_A:
+ codeSet = CODE_CODE_A;
+ break;
+ case CODE_START_B:
+ codeSet = CODE_CODE_B;
+ break;
+ case CODE_START_C:
+ codeSet = CODE_CODE_C;
+ break;
+ default:
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+
+ BOOL done = NO;
+ BOOL isNextShifted = NO;
+
+ NSMutableString *result = [NSMutableString stringWithCapacity:20];
+ NSMutableArray *rawCodes = [NSMutableArray arrayWithCapacity:20];
+
+ int lastStart = [[startPatternInfo objectAtIndex:0] intValue];
+ int nextStart = [[startPatternInfo objectAtIndex:1] intValue];
+
+ const int countersLen = 6;
+ int counters[countersLen];
+ memset(counters, 0, countersLen * sizeof(int));
+
+ int lastCode = 0;
+ int code = 0;
+ int checksumTotal = startCode;
+ int multiplier = 0;
+ BOOL lastCharacterWasPrintable = YES;
+
+ while (!done) {
+ BOOL unshift = isNextShifted;
+ isNextShifted = NO;
+
+ // Save off last code
+ lastCode = code;
+
+ // Decode another code from image
+ code = [self decodeCode:row counters:counters countersCount:countersLen rowOffset:nextStart];
+ if (code == -1) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ [rawCodes addObject:[NSNumber numberWithChar:(unsigned char)code]];
+
+ // Remember whether the last code was printable or not (excluding CODE_STOP)
+ if (code != CODE_STOP) {
+ lastCharacterWasPrintable = YES;
+ }
+
+ // Add to checksum computation (if not CODE_STOP of course)
+ if (code != CODE_STOP) {
+ multiplier++;
+ checksumTotal += multiplier * code;
+ }
+
+ // Advance to where the next code will to start
+ lastStart = nextStart;
+ for (int i = 0; i < countersLen; i++) {
+ nextStart += counters[i];
+ }
+
+ // Take care of illegal start codes
+ switch (code) {
+ case CODE_START_A:
+ case CODE_START_B:
+ case CODE_START_C:
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+
+ switch (codeSet) {
+ case CODE_CODE_A:
+ if (code < 64) {
+ [result appendFormat:@"%C", (unichar)(' ' + code)];
+ } else if (code < 96) {
+ [result appendFormat:@"%C", (unichar)(code - 64)];
+ } else {
+ // Don't let CODE_STOP, which always appears, affect whether whether we think the last
+ // code was printable or not.
+ if (code != CODE_STOP) {
+ lastCharacterWasPrintable = NO;
+ }
+
+ switch (code) {
+ case CODE_FNC_1:
+ case CODE_FNC_2:
+ case CODE_FNC_3:
+ case CODE_FNC_4_A:
+ break;
+ case CODE_SHIFT:
+ isNextShifted = YES;
+ codeSet = CODE_CODE_B;
+ break;
+ case CODE_CODE_B:
+ codeSet = CODE_CODE_B;
+ break;
+ case CODE_CODE_C:
+ codeSet = CODE_CODE_C;
+ break;
+ case CODE_STOP:
+ done = YES;
+ break;
+ }
+ }
+ break;
+ case CODE_CODE_B:
+ if (code < 96) {
+ [result appendFormat:@"%C", (unichar)(' ' + code)];
+ } else {
+ if (code != CODE_STOP) {
+ lastCharacterWasPrintable = NO;
+ }
+
+ switch (code) {
+ case CODE_FNC_1:
+ case CODE_FNC_2:
+ case CODE_FNC_3:
+ case CODE_FNC_4_B:
+ break;
+ case CODE_SHIFT:
+ isNextShifted = YES;
+ codeSet = CODE_CODE_A;
+ break;
+ case CODE_CODE_A:
+ codeSet = CODE_CODE_A;
+ break;
+ case CODE_CODE_C:
+ codeSet = CODE_CODE_C;
+ break;
+ case CODE_STOP:
+ done = YES;
+ break;
+ }
+ }
+ break;
+ case CODE_CODE_C:
+ if (code < 100) {
+ if (code < 10) {
+ [result appendString:@"0"];
+ }
+ [result appendFormat:@"%d", code];
+ } else {
+ if (code != CODE_STOP) {
+ lastCharacterWasPrintable = NO;
+ }
+
+ switch (code) {
+ case CODE_FNC_1:
+ break;
+ case CODE_CODE_A:
+ codeSet = CODE_CODE_A;
+ break;
+ case CODE_CODE_B:
+ codeSet = CODE_CODE_B;
+ break;
+ case CODE_STOP:
+ done = YES;
+ break;
+ }
+ }
+ break;
+ }
+
+ // Unshift back to another code set if we were shifted
+ if (unshift) {
+ codeSet = codeSet == CODE_CODE_A ? CODE_CODE_B : CODE_CODE_A;
+ }
+ }
+
+ // Check for ample whitespace following pattern, but, to do this we first need to remember that
+ // we fudged decoding CODE_STOP since it actually has 7 bars, not 6. There is a black bar left
+ // to read off. Would be slightly better to properly read. Here we just skip it:
+ nextStart = [row nextUnset:nextStart];
+ if (![row isRange:nextStart end:MIN(row.size, nextStart + (nextStart - lastStart) / 2) value:NO]) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ // Pull out from sum the value of the penultimate check code
+ checksumTotal -= multiplier * lastCode;
+ // lastCode is the checksum then:
+ if (checksumTotal % 103 != lastCode) {
+ if (error) *error = ChecksumErrorInstance();
+ return nil;
+ }
+
+ // Need to pull out the check digits from string
+ int resultLength = [result length];
+ if (resultLength == 0) {
+ // false positive
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ // Only bother if the result had at least one character, and if the checksum digit happened to
+ // be a printable character. If it was just interpreted as a control code, nothing to remove.
+ if (resultLength > 0 && lastCharacterWasPrintable) {
+ if (codeSet == CODE_CODE_C) {
+ [result deleteCharactersInRange:NSMakeRange(resultLength - 2, 2)];
+ } else {
+ [result deleteCharactersInRange:NSMakeRange(resultLength - 1, 1)];
+ }
+ }
+
+ float left = (float)([[startPatternInfo objectAtIndex:1] intValue] + [[startPatternInfo objectAtIndex:0] intValue]) / 2.0f;
+ float right = (float)(nextStart + lastStart) / 2.0f;
+
+ int rawCodesSize = [rawCodes count];
+ unsigned char rawBytes[rawCodesSize];
+ for (int i = 0; i < rawCodesSize; i++) {
+ rawBytes[i] = [[rawCodes objectAtIndex:i] charValue];
+ }
+
+ return [ZXResult resultWithText:result
+ rawBytes:rawBytes
+ length:rawCodesSize
+ resultPoints:[NSArray arrayWithObjects:[[[ZXResultPoint alloc] initWithX:left y:(float)rowNumber] autorelease],
+ [[[ZXResultPoint alloc] initWithX:right y:(float)rowNumber] autorelease], nil]
+ format:kBarcodeFormatCode128];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode128Writer.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode128Writer.h
new file mode 100644
index 0000000000000000000000000000000000000000..99fe0480f79b1cfcae785e2775990f5cc8f1d245
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode128Writer.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXOneDimensionalCodeWriter.h"
+
+/**
+ * This object renders a CODE128 code as a ZXBitMatrix.
+ */
+
+@interface ZXCode128Writer : ZXOneDimensionalCodeWriter
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode128Writer.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode128Writer.m
new file mode 100644
index 0000000000000000000000000000000000000000..42b9a2719f269fb048b54156fd36c26fe61d2909
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode128Writer.m
@@ -0,0 +1,197 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXCode128Reader.h"
+#import "ZXCode128Writer.h"
+
+// Dummy characters used to specify control characters in input
+const unichar ESCAPE_FNC_1 = L'\u00f1';
+const unichar ESCAPE_FNC_2 = L'\u00f2';
+const unichar ESCAPE_FNC_3 = L'\u00f3';
+const unichar ESCAPE_FNC_4 = L'\u00f4';
+
+@interface ZXCode128Writer ()
+
+- (BOOL)isDigits:(NSString *)value start:(int)start length:(unsigned int)length;
+
+@end
+
+@implementation ZXCode128Writer
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height hints:(ZXEncodeHints *)hints error:(NSError **)error {
+ if (format != kBarcodeFormatCode128) {
+ [NSException raise:NSInvalidArgumentException format:@"Can only encode CODE_128"];
+ }
+ return [super encode:contents format:format width:width height:height hints:hints error:error];
+}
+
+- (BOOL *)encode:(NSString *)contents length:(int *)pLength {
+ int length = (int)[contents length];
+ // Check length
+ if (length < 1 || length > 80) {
+ [NSException raise:NSInvalidArgumentException format:@"Contents length should be between 1 and 80 characters, but got %d", length];
+ }
+ // Check content
+ for (int i = 0; i < length; i++) {
+ unichar c = [contents characterAtIndex:i];
+ if (c < ' ' || c > '~') {
+ switch (c) {
+ case ESCAPE_FNC_1:
+ case ESCAPE_FNC_2:
+ case ESCAPE_FNC_3:
+ case ESCAPE_FNC_4:
+ break;
+ default:
+ [NSException raise:NSInvalidArgumentException format:@"Bad character in input: %C", c];
+ }
+ }
+ }
+
+ NSMutableArray *patterns = [NSMutableArray array]; // temporary storage for patterns
+ int checkSum = 0;
+ int checkWeight = 1;
+ int codeSet = 0; // selected code (CODE_CODE_B or CODE_CODE_C)
+ int position = 0; // position in contents
+
+ while (position < length) {
+ //Select code to use
+ int requiredDigitCount = codeSet == CODE_CODE_C ? 2 : 4;
+ int newCodeSet;
+ if ([self isDigits:contents start:position length:requiredDigitCount]) {
+ newCodeSet = CODE_CODE_C;
+ } else {
+ newCodeSet = CODE_CODE_B;
+ }
+
+ //Get the pattern index
+ int patternIndex;
+ if (newCodeSet == codeSet) {
+ // Encode the current character
+ if (codeSet == CODE_CODE_B) {
+ patternIndex = [contents characterAtIndex:position] - ' ';
+ position += 1;
+ } else { // CODE_CODE_C
+ switch ([contents characterAtIndex:position]) {
+ case ESCAPE_FNC_1:
+ patternIndex = CODE_FNC_1;
+ position++;
+ break;
+ case ESCAPE_FNC_2:
+ patternIndex = CODE_FNC_2;
+ position++;
+ break;
+ case ESCAPE_FNC_3:
+ patternIndex = CODE_FNC_3;
+ position++;
+ break;
+ case ESCAPE_FNC_4:
+ patternIndex = CODE_FNC_4_B; // FIXME if this ever outputs Code A
+ position++;
+ break;
+ default:
+ patternIndex = [[contents substringWithRange:NSMakeRange(position, 2)] intValue];
+ position += 2;
+ break;
+ }
+ }
+ } else {
+ // Should we change the current code?
+ // Do we have a code set?
+ if (codeSet == 0) {
+ // No, we don't have a code set
+ if (newCodeSet == CODE_CODE_B) {
+ patternIndex = CODE_START_B;
+ } else {
+ // CODE_CODE_C
+ patternIndex = CODE_START_C;
+ }
+ } else {
+ // Yes, we have a code set
+ patternIndex = newCodeSet;
+ }
+ codeSet = newCodeSet;
+ }
+
+ // Get the pattern
+ NSMutableArray *pattern = [NSMutableArray array];
+ for (int i = 0; i < sizeof(CODE_PATTERNS[patternIndex]) / sizeof(int); i++) {
+ [pattern addObject:[NSNumber numberWithInt:CODE_PATTERNS[patternIndex][i]]];
+ }
+ [patterns addObject:pattern];
+
+ // Compute checksum
+ checkSum += patternIndex * checkWeight;
+ if (position != 0) {
+ checkWeight++;
+ }
+ }
+
+ // Compute and append checksum
+ checkSum %= 103;
+ NSMutableArray *pattern = [NSMutableArray array];
+ for (int i = 0; i < sizeof(CODE_PATTERNS[checkSum]) / sizeof(int); i++) {
+ [pattern addObject:[NSNumber numberWithInt:CODE_PATTERNS[checkSum][i]]];
+ }
+ [patterns addObject:pattern];
+
+ // Append stop code
+ pattern = [NSMutableArray array];
+ for (int i = 0; i < sizeof(CODE_PATTERNS[CODE_STOP]) / sizeof(int); i++) {
+ [pattern addObject:[NSNumber numberWithInt:CODE_PATTERNS[CODE_STOP][i]]];
+ }
+ [patterns addObject:pattern];
+
+ // Compute code width
+ int codeWidth = 0;
+ for (pattern in patterns) {
+ for (int i = 0; i < pattern.count; i++) {
+ codeWidth += [[pattern objectAtIndex:i] intValue];
+ }
+ }
+
+ // Compute result
+ if (pLength) *pLength = codeWidth;
+ BOOL *result = (BOOL *)malloc(codeWidth * sizeof(BOOL));
+ int pos = 0;
+ for (NSArray *patternArray in patterns) {
+ int patternLen = (int)[patternArray count];
+ int pattern[patternLen];
+ for(int i = 0; i < patternLen; i++) {
+ pattern[i] = [[patternArray objectAtIndex:i] intValue];
+ }
+
+ pos += [super appendPattern:result pos:pos pattern:pattern patternLen:patternLen startColor:TRUE];
+ }
+
+ return result;
+}
+
+- (BOOL)isDigits:(NSString *)value start:(int)start length:(unsigned int)length {
+ int end = start + length;
+ int last = (int)[value length];
+ for (int i = start; i < end && i < last; i++) {
+ unichar c = [value characterAtIndex:i];
+ if (c < '0' || c > '9') {
+ if (c != ESCAPE_FNC_1) {
+ return NO;
+ }
+ end++; // ignore FNC_1
+ }
+ }
+ return end <= last; // end > last if we've run out of string
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode39Reader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode39Reader.h
new file mode 100644
index 0000000000000000000000000000000000000000..7d5cfdf5c5472a7f9dc99f6289370c04b01049ea
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode39Reader.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXOneDReader.h"
+
+/**
+ * Decodes Code 39 barcodes. This does not support "Full ASCII Code 39" yet.
+ */
+
+extern char CODE39_ALPHABET[];
+extern NSString *CODE39_ALPHABET_STRING;
+extern int CODE39_CHARACTER_ENCODINGS[];
+
+@class ZXDecodeHints, ZXResult;
+
+@interface ZXCode39Reader : ZXOneDReader
+
+- (id)initUsingCheckDigit:(BOOL)usingCheckDigit;
+- (id)initUsingCheckDigit:(BOOL)usingCheckDigit extendedMode:(BOOL)extendedMode;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode39Reader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode39Reader.m
new file mode 100644
index 0000000000000000000000000000000000000000..74a8471acb1d6ee8ce80e7a96bc708fea79f4e71
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode39Reader.m
@@ -0,0 +1,324 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXCode39Reader.h"
+#import "ZXErrors.h"
+#import "ZXResult.h"
+#import "ZXResultPoint.h"
+
+char CODE39_ALPHABET[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%";
+NSString *CODE39_ALPHABET_STRING = @"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%";
+
+/**
+ * These represent the encodings of characters, as patterns of wide and narrow bars.
+ * The 9 least-significant bits of each int correspond to the pattern of wide and narrow,
+ * with 1s representing "wide" and 0s representing narrow.
+ */
+int CODE39_CHARACTER_ENCODINGS[44] = {
+ 0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, // 0-9
+ 0x109, 0x049, 0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C, 0x04C, 0x01C, // A-J
+ 0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106, 0x046, 0x016, // K-T
+ 0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x094, // U-*
+ 0x0A8, 0x0A2, 0x08A, 0x02A // $-%
+};
+
+int const CODE39_ASTERISK_ENCODING = 0x094;
+
+@interface ZXCode39Reader ()
+
+@property (nonatomic, assign) BOOL extendedMode;
+@property (nonatomic, assign) BOOL usingCheckDigit;
+
+- (NSString *)decodeExtended:(NSMutableString *)encoded;
+- (BOOL)findAsteriskPattern:(ZXBitArray *)row a:(int *)a b:(int *)b counters:(int *)counters countersLen:(int)countersLen;
+- (unichar)patternToChar:(int)pattern;
+- (int)toNarrowWidePattern:(int *)counters countersLen:(unsigned int)countersLen;
+
+@end
+
+@implementation ZXCode39Reader
+
+@synthesize extendedMode;
+@synthesize usingCheckDigit;
+
+
+/**
+ * Creates a reader that assumes all encoded data is data, and does not treat the final
+ * character as a check digit. It will not decoded "extended Code 39" sequences.
+ */
+- (id)init {
+ return [self initUsingCheckDigit:NO extendedMode:NO];
+}
+
+
+/**
+ * Creates a reader that can be configured to check the last character as a check digit.
+ * It will not decoded "extended Code 39" sequences.
+ */
+- (id)initUsingCheckDigit:(BOOL)isUsingCheckDigit {
+ return [self initUsingCheckDigit:isUsingCheckDigit extendedMode:NO];
+}
+
+
+/**
+ * Creates a reader that can be configured to check the last character as a check digit,
+ * or optionally attempt to decode "extended Code 39" sequences that are used to encode
+ * the full ASCII character set.
+ */
+- (id)initUsingCheckDigit:(BOOL)isUsingCheckDigit extendedMode:(BOOL)isExtendedMode {
+ if (self = [super init]) {
+ self.usingCheckDigit = isUsingCheckDigit;
+ self.extendedMode = isExtendedMode;
+ }
+
+ return self;
+}
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ const int countersLen = 9;
+ int counters[countersLen];
+ memset(counters, 0, countersLen * sizeof(int));
+
+ int start[2] = {0};
+ if (![self findAsteriskPattern:row a:&start[0] b:&start[1] counters:counters countersLen:countersLen]) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ // Read off white space
+ int nextStart = [row nextSet:start[1]];
+ int end = [row size];
+
+ NSMutableString *result = [NSMutableString stringWithCapacity:20];
+ unichar decodedChar;
+ int lastStart;
+ do {
+ if (![ZXOneDReader recordPattern:row start:nextStart counters:counters countersSize:countersLen]) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ int pattern = [self toNarrowWidePattern:(int *)counters countersLen:countersLen];
+ if (pattern < 0) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ decodedChar = [self patternToChar:pattern];
+ if (decodedChar == -1) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ [result appendFormat:@"%C", decodedChar];
+ lastStart = nextStart;
+ for (int i = 0; i < sizeof(counters) / sizeof(int); i++) {
+ nextStart += counters[i];
+ }
+ // Read off white space
+ nextStart = [row nextSet:nextStart];
+ } while (decodedChar != '*');
+ [result deleteCharactersInRange:NSMakeRange([result length] - 1, 1)];
+
+ int lastPatternSize = 0;
+ for (int i = 0; i < sizeof(counters) / sizeof(int); i++) {
+ lastPatternSize += counters[i];
+ }
+ int whiteSpaceAfterEnd = nextStart - lastStart - lastPatternSize;
+ if (nextStart != end && (whiteSpaceAfterEnd >> 1) < lastPatternSize) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ if (usingCheckDigit) {
+ int max = [result length] - 1;
+ int total = 0;
+ for (int i = 0; i < max; i++) {
+ total += [CODE39_ALPHABET_STRING rangeOfString:[result substringWithRange:NSMakeRange(i, 1)]].location;
+ }
+ if ([result characterAtIndex:max] != CODE39_ALPHABET[total % 43]) {
+ if (error) *error = ChecksumErrorInstance();
+ return nil;
+ }
+ [result deleteCharactersInRange:NSMakeRange(max, 1)];
+ }
+
+ if ([result length] == 0) {
+ // false positive
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ NSString *resultString;
+ if (self.extendedMode) {
+ resultString = [self decodeExtended:result];
+ if (!resultString) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ } else {
+ resultString = result;
+ }
+
+ float left = (float) (start[1] + start[0]) / 2.0f;
+ float right = (float)(nextStart + lastStart) / 2.0f;
+
+ return [ZXResult resultWithText:resultString
+ rawBytes:nil
+ length:0
+ resultPoints:[NSArray arrayWithObjects:[[[ZXResultPoint alloc] initWithX:left y:(float)rowNumber] autorelease],
+ [[[ZXResultPoint alloc] initWithX:right y:(float)rowNumber] autorelease], nil]
+ format:kBarcodeFormatCode39];
+}
+
+- (BOOL)findAsteriskPattern:(ZXBitArray *)row a:(int *)a b:(int *)b counters:(int *)counters countersLen:(int)countersLen {
+ int width = row.size;
+ int rowOffset = [row nextSet:0];
+
+ int counterPosition = 0;
+ int patternStart = rowOffset;
+ BOOL isWhite = NO;
+
+ for (int i = rowOffset; i < width; i++) {
+ if ([row get:i] ^ isWhite) {
+ counters[counterPosition]++;
+ } else {
+ if (counterPosition == countersLen - 1) {
+ if ([self toNarrowWidePattern:counters countersLen:countersLen] == CODE39_ASTERISK_ENCODING &&
+ [row isRange:MAX(0, patternStart - ((i - patternStart) >> 1)) end:patternStart value:NO]) {
+ if (a) *a = patternStart;
+ if (b) *b = i;
+ return YES;
+ }
+ patternStart += counters[0] + counters[1];
+ for (int y = 2; y < countersLen; y++) {
+ counters[y - 2] = counters[y];
+ }
+ counters[countersLen - 2] = 0;
+ counters[countersLen - 1] = 0;
+ counterPosition--;
+ } else {
+ counterPosition++;
+ }
+ counters[counterPosition] = 1;
+ isWhite = !isWhite;
+ }
+ }
+
+ return NO;
+}
+
+- (int)toNarrowWidePattern:(int *)counters countersLen:(unsigned int)countersLen {
+ int numCounters = countersLen;
+ int maxNarrowCounter = 0;
+ int wideCounters;
+ do {
+ int minCounter = NSIntegerMax;
+ for (int i = 0; i < numCounters; i++) {
+ int counter = counters[i];
+ if (counter < minCounter && counter > maxNarrowCounter) {
+ minCounter = counter;
+ }
+ }
+ maxNarrowCounter = minCounter;
+ wideCounters = 0;
+ int totalWideCountersWidth = 0;
+ int pattern = 0;
+ for (int i = 0; i < numCounters; i++) {
+ int counter = counters[i];
+ if (counters[i] > maxNarrowCounter) {
+ pattern |= 1 << (numCounters - 1 - i);
+ wideCounters++;
+ totalWideCountersWidth += counter;
+ }
+ }
+ if (wideCounters == 3) {
+ for (int i = 0; i < numCounters && wideCounters > 0; i++) {
+ int counter = counters[i];
+ if (counters[i] > maxNarrowCounter) {
+ wideCounters--;
+ if ((counter << 1) >= totalWideCountersWidth) {
+ return -1;
+ }
+ }
+ }
+ return pattern;
+ }
+ } while (wideCounters > 3);
+ return -1;
+}
+
+- (unichar)patternToChar:(int)pattern {
+ for (int i = 0; i < sizeof(CODE39_CHARACTER_ENCODINGS) / sizeof(int); i++) {
+ if (CODE39_CHARACTER_ENCODINGS[i] == pattern) {
+ return CODE39_ALPHABET[i];
+ }
+ }
+ return -1;
+}
+
+- (NSString *)decodeExtended:(NSMutableString *)encoded {
+ int length = [encoded length];
+ NSMutableString *decoded = [NSMutableString stringWithCapacity:length];
+
+ for (int i = 0; i < length; i++) {
+ unichar c = [encoded characterAtIndex:i];
+ if (c == '+' || c == '$' || c == '%' || c == '/') {
+ unichar next = [encoded characterAtIndex:i + 1];
+ unichar decodedChar = '\0';
+
+ switch (c) {
+ case '+':
+ if (next >= 'A' && next <= 'Z') {
+ decodedChar = (unichar)(next + 32);
+ } else {
+ return nil;
+ }
+ break;
+ case '$':
+ if (next >= 'A' && next <= 'Z') {
+ decodedChar = (unichar)(next - 64);
+ } else {
+ return nil;
+ }
+ break;
+ case '%':
+ if (next >= 'A' && next <= 'E') {
+ decodedChar = (unichar)(next - 38);
+ } else if (next >= 'F' && next <= 'W') {
+ decodedChar = (unichar)(next - 11);
+ } else {
+ return nil;
+ }
+ break;
+ case '/':
+ if (next >= 'A' && next <= 'O') {
+ decodedChar = (unichar)(next - 32);
+ } else if (next == 'Z') {
+ decodedChar = ':';
+ } else {
+ return nil;
+ }
+ break;
+ }
+ [decoded appendFormat:@"%C", decodedChar];
+ i++;
+ } else {
+ [decoded appendFormat:@"%C", c];
+ }
+ }
+
+ return decoded;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode39Writer.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode39Writer.h
new file mode 100644
index 0000000000000000000000000000000000000000..3265ba41a9e6bdf5eadbc805b43639afa377adb5
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode39Writer.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXOneDimensionalCodeWriter.h"
+
+/**
+ * This object renders a CODE39 code as a {@link BitMatrix}.
+ */
+
+@interface ZXCode39Writer : ZXOneDimensionalCodeWriter
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode39Writer.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode39Writer.m
new file mode 100644
index 0000000000000000000000000000000000000000..4af22b9131973894f484b59dc7ca8cfdf7004c1c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode39Writer.m
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXCode39Reader.h"
+#import "ZXCode39Writer.h"
+
+#define ZX_CODE39_WHITELEN 1
+
+@interface ZXCode39Writer ()
+
+- (void)toIntArray:(int)a toReturn:(int[])toReturn;
+
+@end
+
+@implementation ZXCode39Writer
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height hints:(ZXEncodeHints *)hints error:(NSError **)error {
+ if (format != kBarcodeFormatCode39) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Can only encode CODE_39."];
+ }
+ return [super encode:contents format:format width:width height:height hints:hints error:error];
+}
+
+- (BOOL *)encode:(NSString *)contents length:(int *)pLength {
+ int length = [contents length];
+ if (length > 80) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Requested contents should be less than 80 digits long, but got %d", length];
+ }
+
+ const int widthsLengh = 9;
+ int widths[widthsLengh];
+ memset(widths, 0, widthsLengh * sizeof(int));
+
+ int codeWidth = 24 + 1 + length;
+ for (int i = 0; i < length; i++) {
+ int indexInString = [CODE39_ALPHABET_STRING rangeOfString:[contents substringWithRange:NSMakeRange(i, 1)]].location;
+ [self toIntArray:CODE39_CHARACTER_ENCODINGS[indexInString] toReturn:widths];
+ for (int j = 0; j < widthsLengh; j++) {
+ codeWidth += widths[j];
+ }
+ }
+
+ if (pLength) *pLength = codeWidth;
+ BOOL *result = (BOOL *)malloc(codeWidth * sizeof(BOOL));
+ [self toIntArray:CODE39_CHARACTER_ENCODINGS[39] toReturn:widths];
+ int pos = [super appendPattern:result pos:0 pattern:widths patternLen:widthsLengh startColor:TRUE];
+
+ const int narrowWhiteLen = ZX_CODE39_WHITELEN;
+ int narrowWhite[ZX_CODE39_WHITELEN] = {1};
+
+ pos += [super appendPattern:result pos:pos pattern:narrowWhite patternLen:narrowWhiteLen startColor:FALSE];
+
+ for (int i = length - 1; i >= 0; i--) {
+ int indexInString = [CODE39_ALPHABET_STRING rangeOfString:[contents substringWithRange:NSMakeRange(i, 1)]].location;
+ [self toIntArray:CODE39_CHARACTER_ENCODINGS[indexInString] toReturn:widths];
+ pos += [super appendPattern:result pos:pos pattern:widths patternLen:widthsLengh startColor:TRUE];
+ pos += [super appendPattern:result pos:pos pattern:narrowWhite patternLen:narrowWhiteLen startColor:FALSE];
+ }
+
+ [self toIntArray:CODE39_CHARACTER_ENCODINGS[39] toReturn:widths];
+ pos += [super appendPattern:result pos:pos pattern:widths patternLen:widthsLengh startColor:TRUE];
+ return result;
+}
+
+- (void)toIntArray:(int)a toReturn:(int[])toReturn {
+ for (int i = 0; i < 9; i++) {
+ int temp = a & (1 << i);
+ toReturn[i] = temp == 0 ? 1 : 2;
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode93Reader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode93Reader.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b31cd78054a5df1096f54eddea15a8434955614
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode93Reader.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXOneDReader.h"
+
+/**
+ * Decodes Code 93 barcodes.
+ */
+
+@interface ZXCode93Reader : ZXOneDReader
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode93Reader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode93Reader.m
new file mode 100644
index 0000000000000000000000000000000000000000..e994dc1195035743afed02d6e37d4c899df76f69
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXCode93Reader.m
@@ -0,0 +1,307 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXCode93Reader.h"
+#import "ZXErrors.h"
+#import "ZXResult.h"
+#import "ZXResultPoint.h"
+
+const NSString *CODE93_ALPHABET_STRING = @"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%abcd*";
+const char CODE93_ALPHABET[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%abcd*";
+
+/**
+ * These represent the encodings of characters, as patterns of wide and narrow bars.
+ * The 9 least-significant bits of each int correspond to the pattern of wide and narrow.
+ */
+const int CODE93_CHARACTER_ENCODINGS[48] = {
+ 0x114, 0x148, 0x144, 0x142, 0x128, 0x124, 0x122, 0x150, 0x112, 0x10A, // 0-9
+ 0x1A8, 0x1A4, 0x1A2, 0x194, 0x192, 0x18A, 0x168, 0x164, 0x162, 0x134, // A-J
+ 0x11A, 0x158, 0x14C, 0x146, 0x12C, 0x116, 0x1B4, 0x1B2, 0x1AC, 0x1A6, // K-T
+ 0x196, 0x19A, 0x16C, 0x166, 0x136, 0x13A, // U-Z
+ 0x12E, 0x1D4, 0x1D2, 0x1CA, 0x16E, 0x176, 0x1AE, // - - %
+ 0x126, 0x1DA, 0x1D6, 0x132, 0x15E, // Control chars? $-*
+};
+
+const int CODE93_ASTERISK_ENCODING = 0x15E;
+
+@interface ZXCode93Reader ()
+
+@property (nonatomic, retain) NSMutableString *decodeRowResult;
+
+- (BOOL)checkChecksums:(NSMutableString *)result error:(NSError **)error ;
+- (BOOL)checkOneChecksum:(NSMutableString *)result checkPosition:(int)checkPosition weightMax:(int)weightMax error:(NSError **)error ;
+- (NSString *)decodeExtended:(NSMutableString *)encoded;
+- (BOOL)findAsteriskPattern:(ZXBitArray *)row a:(int *)a b:(int *)b;
+- (unichar)patternToChar:(int)pattern;
+- (int)toPattern:(int *)counters countersLen:(unsigned int)countersLen;
+
+@end
+
+@implementation ZXCode93Reader
+
+@synthesize decodeRowResult;
+
+- (id)init {
+ if (self = [super init]) {
+ self.decodeRowResult = [NSMutableString stringWithCapacity:20];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [decodeRowResult release];
+
+ [super dealloc];
+}
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ const int countersLen = 6;
+ int counters[countersLen];
+ memset(counters, 0, countersLen * sizeof(int));
+
+ [self.decodeRowResult setString:@""];
+
+ int start[2] = {0};
+ if (![self findAsteriskPattern:row a:&start[0] b:&start[1]]) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ // Read off white space
+ int nextStart = [row nextSet:start[1]];
+ int end = row.size;
+
+ unichar decodedChar;
+ int lastStart;
+ do {
+ if (![ZXOneDReader recordPattern:row start:nextStart counters:counters countersSize:countersLen]) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ int pattern = [self toPattern:counters countersLen:countersLen];
+ if (pattern < 0) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ decodedChar = [self patternToChar:pattern];
+ if (decodedChar == -1) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ [self.decodeRowResult appendFormat:@"%C", decodedChar];
+ lastStart = nextStart;
+ for (int i = 0; i < countersLen; i++) {
+ nextStart += counters[i];
+ }
+ // Read off white space
+ nextStart = [row nextSet:nextStart];
+ } while (decodedChar != '*');
+ [self.decodeRowResult deleteCharactersInRange:NSMakeRange([self.decodeRowResult length] - 1, 1)];
+
+ if (nextStart == end || ![row get:nextStart]) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ if ([self.decodeRowResult length] < 2) {
+ // false positive -- need at least 2 checksum digits
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ if (![self checkChecksums:self.decodeRowResult error:error]) {
+ return nil;
+ }
+ [self.decodeRowResult deleteCharactersInRange:NSMakeRange([self.decodeRowResult length] - 2, 2)];
+
+ NSString *resultString = [self decodeExtended:self.decodeRowResult];
+ if (!resultString) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+
+ float left = (float) (start[1] + start[0]) / 2.0f;
+ float right = (float) (nextStart + lastStart) / 2.0f;
+ return [ZXResult resultWithText:resultString
+ rawBytes:nil
+ length:0
+ resultPoints:[NSArray arrayWithObjects:
+ [[[ZXResultPoint alloc] initWithX:left y:(float)rowNumber] autorelease],
+ [[[ZXResultPoint alloc] initWithX:right y:(float)rowNumber] autorelease], nil]
+ format:kBarcodeFormatCode93];
+}
+
+- (BOOL)findAsteriskPattern:(ZXBitArray *)row a:(int *)a b:(int *)b {
+ int width = row.size;
+ int rowOffset = [row nextSet:0];
+
+ int counterPosition = 0;
+
+ const int patternLength = 6;
+ int counters[patternLength];
+ memset(counters, 0, patternLength * sizeof(int));
+
+ int patternStart = rowOffset;
+ BOOL isWhite = NO;
+
+ for (int i = rowOffset; i < width; i++) {
+ if ([row get:i] ^ isWhite) {
+ counters[counterPosition]++;
+ } else {
+ if (counterPosition == patternLength - 1) {
+ if ([self toPattern:counters countersLen:patternLength] == CODE93_ASTERISK_ENCODING) {
+ if (a) *a = patternStart;
+ if (b) *b = i;
+ return YES;
+ }
+ patternStart += counters[0] + counters[1];
+ for (int y = 2; y < patternLength; y++) {
+ counters[y - 2] = counters[y];
+ }
+ counters[patternLength - 2] = 0;
+ counters[patternLength - 1] = 0;
+ counterPosition--;
+ } else {
+ counterPosition++;
+ }
+ counters[counterPosition] = 1;
+ isWhite = !isWhite;
+ }
+ }
+
+ return NO;
+}
+
+- (int)toPattern:(int *)counters countersLen:(unsigned int)countersLen {
+ int max = countersLen;
+ int sum = 0;
+ for (int i = 0; i < max; i++) {
+ sum += counters[i];
+ }
+ int pattern = 0;
+ for (int i = 0; i < max; i++) {
+ int scaledShifted = (counters[i] << INTEGER_MATH_SHIFT) * 9 / sum;
+ int scaledUnshifted = scaledShifted >> INTEGER_MATH_SHIFT;
+ if ((scaledShifted & 0xFF) > 0x7F) {
+ scaledUnshifted++;
+ }
+ if (scaledUnshifted < 1 || scaledUnshifted > 4) {
+ return -1;
+ }
+ if ((i & 0x01) == 0) {
+ for (int j = 0; j < scaledUnshifted; j++) {
+ pattern = (pattern << 1) | 0x01;
+ }
+ } else {
+ pattern <<= scaledUnshifted;
+ }
+ }
+ return pattern;
+}
+
+- (unichar)patternToChar:(int)pattern {
+ for (int i = 0; i < sizeof(CODE93_CHARACTER_ENCODINGS) / sizeof(int); i++) {
+ if (CODE93_CHARACTER_ENCODINGS[i] == pattern) {
+ return CODE93_ALPHABET[i];
+ }
+ }
+
+ return -1;
+}
+
+- (NSString *)decodeExtended:(NSMutableString *)encoded {
+ int length = [encoded length];
+ NSMutableString *decoded = [NSMutableString stringWithCapacity:length];
+ for (int i = 0; i < length; i++) {
+ unichar c = [encoded characterAtIndex:i];
+ if (c >= 'a' && c <= 'd') {
+ if (i >= length - 1) {
+ return nil;
+ }
+ unichar next = [encoded characterAtIndex:i + 1];
+ unichar decodedChar = '\0';
+ switch (c) {
+ case 'd':
+ if (next >= 'A' && next <= 'Z') {
+ decodedChar = (unichar)(next + 32);
+ } else {
+ return nil;
+ }
+ break;
+ case 'a':
+ if (next >= 'A' && next <= 'Z') {
+ decodedChar = (unichar)(next - 64);
+ } else {
+ return nil;
+ }
+ break;
+ case 'b':
+ if (next >= 'A' && next <= 'E') {
+ decodedChar = (unichar)(next - 38);
+ } else if (next >= 'F' && next <= 'W') {
+ decodedChar = (unichar)(next - 11);
+ } else {
+ return nil;
+ }
+ break;
+ case 'c':
+ if (next >= 'A' && next <= 'O') {
+ decodedChar = (unichar)(next - 32);
+ } else if (next == 'Z') {
+ decodedChar = ':';
+ } else {
+ return nil;
+ }
+ break;
+ }
+ [decoded appendFormat:@"%C", decodedChar];
+ i++;
+ } else {
+ [decoded appendFormat:@"%C", c];
+ }
+ }
+
+ return decoded;
+}
+
+- (BOOL)checkChecksums:(NSMutableString *)result error:(NSError **)error {
+ int length = [result length];
+ if (![self checkOneChecksum:result checkPosition:length - 2 weightMax:20 error:error]) {
+ return NO;
+ }
+ return [self checkOneChecksum:result checkPosition:length - 1 weightMax:15 error:error];
+}
+
+- (BOOL)checkOneChecksum:(NSMutableString *)result checkPosition:(int)checkPosition weightMax:(int)weightMax error:(NSError **)error {
+ int weight = 1;
+ int total = 0;
+
+ for (int i = checkPosition - 1; i >= 0; i--) {
+ total += weight * [CODE93_ALPHABET_STRING rangeOfString:[NSString stringWithFormat:@"%C", [result characterAtIndex:i]]].location;
+ if (++weight > weightMax) {
+ weight = 1;
+ }
+ }
+
+ if ([result characterAtIndex:checkPosition] != CODE93_ALPHABET[total % 47]) {
+ if (error) *error = ChecksumErrorInstance();
+ return NO;
+ }
+ return YES;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN13Reader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN13Reader.h
new file mode 100644
index 0000000000000000000000000000000000000000..34c64d2008c3aa7440334d68323f16957ffb174e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN13Reader.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXUPCEANReader.h"
+
+/**
+ * Implements decoding of the EAN-13 format.
+ */
+
+extern int FIRST_DIGIT_ENCODINGS[10];
+
+@interface ZXEAN13Reader : ZXUPCEANReader
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN13Reader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN13Reader.m
new file mode 100644
index 0000000000000000000000000000000000000000..e5ea543b7a9b65418e58013648fdac15574c9abb
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN13Reader.m
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXEAN13Reader.h"
+#import "ZXErrors.h"
+
+// For an EAN-13 barcode, the first digit is represented by the parities used
+// to encode the next six digits, according to the table below. For example,
+// if the barcode is 5 123456 789012 then the value of the first digit is
+// signified by using odd for '1', even for '2', even for '3', odd for '4',
+// odd for '5', and even for '6'. See http://en.wikipedia.org/wiki/EAN-13
+//
+// Parity of next 6 digits
+// Digit 0 1 2 3 4 5
+// 0 Odd Odd Odd Odd Odd Odd
+// 1 Odd Odd Even Odd Even Even
+// 2 Odd Odd Even Even Odd Even
+// 3 Odd Odd Even Even Even Odd
+// 4 Odd Even Odd Odd Even Even
+// 5 Odd Even Even Odd Odd Even
+// 6 Odd Even Even Even Odd Odd
+// 7 Odd Even Odd Even Odd Even
+// 8 Odd Even Odd Even Even Odd
+// 9 Odd Even Even Odd Even Odd
+//
+// Note that the encoding for '0' uses the same parity as a UPC barcode. Hence
+// a UPC barcode can be converted to an EAN-13 barcode by prepending a 0.
+//
+// The encoding is represented by the following array, which is a bit pattern
+// using Odd = 0 and Even = 1. For example, 5 is represented by:
+//
+// Odd Even Even Odd Odd Even
+// in binary:
+// 0 1 1 0 0 1 == 0x19
+//
+int FIRST_DIGIT_ENCODINGS[10] = {
+ 0x00, 0x0B, 0x0D, 0xE, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A
+};
+
+@interface ZXEAN13Reader ()
+
+@property (nonatomic, assign) int *decodeMiddleCounters;
+
+- (BOOL)determineFirstDigit:(NSMutableString *)resultString lgPatternFound:(int)lgPatternFound;
+
+@end
+
+@implementation ZXEAN13Reader
+
+@synthesize decodeMiddleCounters;
+
+- (id)init {
+ if (self = [super init]) {
+ self.decodeMiddleCounters = (int *)malloc(sizeof(4) * sizeof(int));
+ self.decodeMiddleCounters[0] = 0;
+ self.decodeMiddleCounters[1] = 0;
+ self.decodeMiddleCounters[2] = 0;
+ self.decodeMiddleCounters[3] = 0;
+ }
+ return self;
+}
+
+- (void)dealloc {
+ if (self.decodeMiddleCounters != NULL) {
+ free(self.decodeMiddleCounters);
+ self.decodeMiddleCounters = NULL;
+ }
+
+ [super dealloc];
+}
+
+- (int)decodeMiddle:(ZXBitArray *)row startRange:(NSRange)startRange result:(NSMutableString *)result error:(NSError **)error {
+ int *counters = self.decodeMiddleCounters;
+ counters[0] = 0;
+ counters[1] = 0;
+ counters[2] = 0;
+ counters[3] = 0;
+ const int countersLen = 4;
+ int end = row.size;
+ int rowOffset = NSMaxRange(startRange);
+
+ int lgPatternFound = 0;
+
+ for (int x = 0; x < 6 && rowOffset < end; x++) {
+ int bestMatch = [ZXUPCEANReader decodeDigit:row counters:counters countersLen:countersLen rowOffset:rowOffset patternType:UPC_EAN_PATTERNS_L_AND_G_PATTERNS error:error];
+ if (bestMatch == -1) {
+ return -1;
+ }
+ [result appendFormat:@"%C", (unichar)('0' + bestMatch % 10)];
+ for (int i = 0; i < countersLen; i++) {
+ rowOffset += counters[i];
+ }
+ if (bestMatch >= 10) {
+ lgPatternFound |= 1 << (5 - x);
+ }
+ }
+
+ if (![self determineFirstDigit:result lgPatternFound:lgPatternFound]) {
+ if (error) *error = NotFoundErrorInstance();
+ return -1;
+ }
+
+ NSRange middleRange = [[self class] findGuardPattern:row rowOffset:rowOffset whiteFirst:YES pattern:(int *)MIDDLE_PATTERN patternLen:MIDDLE_PATTERN_LEN error:error];
+ if (middleRange.location == NSNotFound) {
+ return -1;
+ }
+ rowOffset = NSMaxRange(middleRange);
+
+ for (int x = 0; x < 6 && rowOffset < end; x++) {
+ int bestMatch = [ZXUPCEANReader decodeDigit:row counters:counters countersLen:countersLen rowOffset:rowOffset patternType:UPC_EAN_PATTERNS_L_PATTERNS error:error];
+ if (bestMatch == -1) {
+ return -1;
+ }
+ [result appendFormat:@"%C", (unichar)('0' + bestMatch)];
+ for (int i = 0; i < countersLen; i++) {
+ rowOffset += counters[i];
+ }
+ }
+
+ return rowOffset;
+}
+
+- (ZXBarcodeFormat)barcodeFormat {
+ return kBarcodeFormatEan13;
+}
+
+
+/**
+ * Based on pattern of odd-even ('L' and 'G') patterns used to encoded the explicitly-encoded
+ * digits in a barcode, determines the implicitly encoded first digit and adds it to the
+ * result string.
+ */
+- (BOOL)determineFirstDigit:(NSMutableString *)resultString lgPatternFound:(int)lgPatternFound {
+ for (int d = 0; d < 10; d++) {
+ if (lgPatternFound == FIRST_DIGIT_ENCODINGS[d]) {
+ [resultString insertString:[NSString stringWithFormat:@"%C", (unichar)('0' + d)] atIndex:0];
+ return YES;
+ }
+ }
+ return NO;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN13Writer.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN13Writer.h
new file mode 100644
index 0000000000000000000000000000000000000000..1f8310202bfa98caa401b4a2b65525b5d02068ec
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN13Writer.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXUPCEANWriter.h"
+
+/**
+ * This object renders an EAN13 code as a {@link BitMatrix}.
+ */
+
+@interface ZXEAN13Writer : ZXUPCEANWriter
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN13Writer.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN13Writer.m
new file mode 100644
index 0000000000000000000000000000000000000000..d2b1dc684d2e590bf4e092c58fde69bab570f383
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN13Writer.m
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeFormat.h"
+#import "ZXEAN13Reader.h"
+#import "ZXEAN13Writer.h"
+#import "ZXUPCEANReader.h"
+
+const int EAN13_CODE_WIDTH = 3 + // start guard
+ (7 * 6) + // left bars
+ 5 + // middle guard
+ (7 * 6) + // right bars
+ 3; // end guard
+
+@implementation ZXEAN13Writer
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height hints:(ZXEncodeHints *)hints error:(NSError **)error {
+ if (format != kBarcodeFormatEan13) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:[NSString stringWithFormat:@"Can only encode EAN_13, but got %d", format]
+ userInfo:nil];
+ }
+
+ return [super encode:contents format:format width:width height:height hints:hints error:error];
+}
+
+- (BOOL *)encode:(NSString *)contents length:(int *)pLength {
+ if ([contents length] != 13) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Requested contents should be 13 digits long, but got %d", [contents length]];
+ }
+
+ if (![ZXUPCEANReader checkStandardUPCEANChecksum:contents]) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Contents do not pass checksum"];
+ }
+
+ int firstDigit = [[contents substringToIndex:1] intValue];
+ int parities = FIRST_DIGIT_ENCODINGS[firstDigit];
+ if (pLength) *pLength = EAN13_CODE_WIDTH;
+ BOOL *result = (BOOL *)malloc(EAN13_CODE_WIDTH * sizeof(BOOL));
+ memset(result, 0, EAN13_CODE_WIDTH * sizeof(unsigned char));
+ int pos = 0;
+
+ pos += [super appendPattern:result pos:pos pattern:(int *)START_END_PATTERN patternLen:START_END_PATTERN_LEN startColor:TRUE];
+
+ for (int i = 1; i <= 6; i++) {
+ int digit = [[contents substringWithRange:NSMakeRange(i, 1)] intValue];
+ if ((parities >> (6 - i) & 1) == 1) {
+ digit += 10;
+ }
+ pos += [super appendPattern:result pos:pos pattern:(int *)L_AND_G_PATTERNS[digit] patternLen:L_PATTERNS_SUB_LEN startColor:FALSE];
+ }
+
+ pos += [super appendPattern:result pos:pos pattern:(int *)MIDDLE_PATTERN patternLen:MIDDLE_PATTERN_LEN startColor:FALSE];
+
+ for (int i = 7; i <= 12; i++) {
+ int digit = [[contents substringWithRange:NSMakeRange(i, 1)] intValue];
+ pos += [super appendPattern:result pos:pos pattern:(int *)L_PATTERNS[digit] patternLen:L_PATTERNS_SUB_LEN startColor:TRUE];
+ }
+ pos += [super appendPattern:result pos:pos pattern:(int *)START_END_PATTERN patternLen:START_END_PATTERN_LEN startColor:TRUE];
+
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN8Reader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN8Reader.h
new file mode 100644
index 0000000000000000000000000000000000000000..718acbac3e7ea85cd7f2ce3fd2516421c8ef1c4e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN8Reader.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXUPCEANReader.h"
+
+/**
+ * Implements decoding of the EAN-8 format.
+ */
+
+@interface ZXEAN8Reader : ZXUPCEANReader
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN8Reader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN8Reader.m
new file mode 100644
index 0000000000000000000000000000000000000000..661878350a0c922ee12ecafbd9709c75f88dcc1b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN8Reader.m
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXEAN8Reader.h"
+
+@interface ZXEAN8Reader ()
+
+@property (nonatomic, assign) int *decodeMiddleCounters;
+
+@end
+
+@implementation ZXEAN8Reader
+
+@synthesize decodeMiddleCounters;
+
+- (id)init {
+ if (self = [super init]) {
+ self.decodeMiddleCounters = (int *)malloc(sizeof(4) * sizeof(int));
+ self.decodeMiddleCounters[0] = 0;
+ self.decodeMiddleCounters[1] = 0;
+ self.decodeMiddleCounters[2] = 0;
+ self.decodeMiddleCounters[3] = 0;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ if (self.decodeMiddleCounters != NULL) {
+ free(self.decodeMiddleCounters);
+ self.decodeMiddleCounters = NULL;
+ }
+
+ [super dealloc];
+}
+
+- (int)decodeMiddle:(ZXBitArray *)row startRange:(NSRange)startRange result:(NSMutableString *)result error:(NSError **)error {
+ const int countersLen = 4;
+ int counters[countersLen];
+ memset(counters, 0, countersLen * sizeof(int));
+
+ int end = row.size;
+ int rowOffset = NSMaxRange(startRange);
+
+ for (int x = 0; x < 4 && rowOffset < end; x++) {
+ int bestMatch = [ZXUPCEANReader decodeDigit:row counters:counters countersLen:countersLen rowOffset:rowOffset patternType:UPC_EAN_PATTERNS_L_PATTERNS error:error];
+ if (bestMatch == -1) {
+ return -1;
+ }
+ [result appendFormat:@"%C", (unichar)('0' + bestMatch)];
+ for (int i = 0; i < countersLen; i++) {
+ rowOffset += counters[i];
+ }
+ }
+
+ NSRange middleRange = [[self class] findGuardPattern:row rowOffset:rowOffset whiteFirst:YES pattern:(int *)MIDDLE_PATTERN patternLen:MIDDLE_PATTERN_LEN error:error];
+ if (middleRange.location == NSNotFound) {
+ return -1;
+ }
+ rowOffset = NSMaxRange(middleRange);
+
+ for (int x = 0; x < 4 && rowOffset < end; x++) {
+ int bestMatch = [ZXUPCEANReader decodeDigit:row counters:counters countersLen:countersLen rowOffset:rowOffset patternType:UPC_EAN_PATTERNS_L_PATTERNS error:error];
+ if (bestMatch == -1) {
+ return -1;
+ }
+ [result appendFormat:@"%C", (unichar)('0' + bestMatch)];
+ for (int i = 0; i < countersLen; i++) {
+ rowOffset += counters[i];
+ }
+ }
+
+ return rowOffset;
+}
+
+- (ZXBarcodeFormat)barcodeFormat {
+ return kBarcodeFormatEan8;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN8Writer.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN8Writer.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d236608ffe5f3621cc2fcdd3a4f122ff70fa430
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN8Writer.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXUPCEANWriter.h"
+
+/**
+ * This object renders an EAN8 code as a ZXBitMatrix.
+ */
+
+@interface ZXEAN8Writer : ZXUPCEANWriter
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN8Writer.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN8Writer.m
new file mode 100644
index 0000000000000000000000000000000000000000..beca9b6105bf6ae4c3bf225f8ffb1ee0cb5d812a
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEAN8Writer.m
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeFormat.h"
+#import "ZXEAN8Writer.h"
+#import "ZXUPCEANReader.h"
+
+int const EAN8codeWidth = 3 + (7 * 4) + 5 + (7 * 4) + 3;
+
+@implementation ZXEAN8Writer
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height hints:(ZXEncodeHints *)hints error:(NSError **)error {
+ if (format != kBarcodeFormatEan8) {
+ [NSException raise:NSInvalidArgumentException format:@"Can only encode EAN_8"];
+ }
+ return [super encode:contents format:format width:width height:height hints:hints error:error];
+}
+
+/**
+ * Returns a byte array of horizontal pixels (FALSE = white, TRUE = black)
+ */
+- (BOOL *)encode:(NSString *)contents length:(int *)pLength {
+ if ([contents length] != 8) {
+ [NSException raise:NSInvalidArgumentException format:@"Requested contents should be 8 digits long, but got %d", [contents length]];
+ }
+
+ if (pLength) *pLength = EAN8codeWidth;
+ BOOL *result = (BOOL *)malloc(EAN8codeWidth * sizeof(BOOL));
+ memset(result, 0, EAN8codeWidth * sizeof(unsigned char));
+ int pos = 0;
+
+ pos += [super appendPattern:result pos:pos pattern:(int *)START_END_PATTERN patternLen:START_END_PATTERN_LEN startColor:TRUE];
+
+ for (int i = 0; i <= 3; i++) {
+ int digit = [[contents substringWithRange:NSMakeRange(i, 1)] intValue];
+ pos += [super appendPattern:result pos:pos pattern:(int *)L_PATTERNS[digit] patternLen:L_PATTERNS_SUB_LEN startColor:FALSE];
+ }
+
+ pos += [super appendPattern:result pos:pos pattern:(int *)MIDDLE_PATTERN patternLen:MIDDLE_PATTERN_LEN startColor:FALSE];
+
+ for (int i = 4; i <= 7; i++) {
+ int digit = [[contents substringWithRange:NSMakeRange(i, 1)] intValue];
+ pos += [super appendPattern:result pos:pos pattern:(int *)L_PATTERNS[digit] patternLen:L_PATTERNS_SUB_LEN startColor:TRUE];
+ }
+
+ pos += [super appendPattern:result pos:pos pattern:(int *)START_END_PATTERN patternLen:START_END_PATTERN_LEN startColor:TRUE];
+
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEANManufacturerOrgSupport.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEANManufacturerOrgSupport.h
new file mode 100644
index 0000000000000000000000000000000000000000..ae70dfa4435c921f097f474e1a82cd0fbf2805b9
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEANManufacturerOrgSupport.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Records EAN prefix to GS1 Member Organization, where the member organization
+ * correlates strongly with a country. This is an imperfect means of identifying
+ * a country of origin by EAN-13 barcode value. See
+ * http://en.wikipedia.org/wiki/List_of_GS1_country_codes
+ */
+
+@interface ZXEANManufacturerOrgSupport : NSObject
+
+- (NSString *)lookupCountryIdentifier:(NSString *)productCode;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEANManufacturerOrgSupport.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEANManufacturerOrgSupport.m
new file mode 100644
index 0000000000000000000000000000000000000000..20f28ad246794b761461f03c2c46691712a5ef02
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXEANManufacturerOrgSupport.m
@@ -0,0 +1,191 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXEANManufacturerOrgSupport.h"
+
+@interface ZXEANManufacturerOrgSupport ()
+
+@property (nonatomic, retain) NSMutableArray *countryIdentifiers;
+@property (nonatomic, retain) NSMutableArray *ranges;
+
+- (void)add:(NSArray *)range identifier:(NSString *)identifier;
+- (void)initIfNeeded;
+
+@end
+
+@implementation ZXEANManufacturerOrgSupport
+
+@synthesize countryIdentifiers;
+@synthesize ranges;
+
+- (id)init {
+ if (self = [super init]) {
+ self.ranges = [NSMutableArray array];
+ self.countryIdentifiers = [NSMutableArray array];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [countryIdentifiers release];
+ [ranges release];
+
+ [super dealloc];
+}
+
+- (NSString *)lookupCountryIdentifier:(NSString *)productCode {
+ [self initIfNeeded];
+
+ int prefix = [[productCode substringToIndex:3] intValue];
+ int max = self.ranges.count;
+
+ for (int i = 0; i < max; i++) {
+ NSArray *range = (NSArray *)[self.ranges objectAtIndex:i];
+ int start = [[range objectAtIndex:0] intValue];
+ if (prefix < start) {
+ return nil;
+ }
+ int end = [range count] == 1 ? start : [[range objectAtIndex:1] intValue];
+ if (prefix <= end) {
+ return [self.countryIdentifiers objectAtIndex:i];
+ }
+ }
+
+ return nil;
+}
+
+- (void)add:(NSArray *)range identifier:(NSString *)identifier {
+ [self.ranges addObject:range];
+ [self.countryIdentifiers addObject:identifier];
+}
+
+- (void)initIfNeeded {
+ @synchronized(self.ranges) {
+ if ([self.ranges count] > 0) {
+ return;
+ }
+
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:0], [NSNumber numberWithInt:19], nil] identifier:@"US/CA"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:30], [NSNumber numberWithInt:39], nil] identifier:@"US"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:60], [NSNumber numberWithInt:139], nil] identifier:@"US/CA"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:300], [NSNumber numberWithInt:379], nil] identifier:@"FR"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:380], nil] identifier:@"BG"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:383], nil] identifier:@"SI"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:385], nil] identifier:@"HR"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:387], nil] identifier:@"BA"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:400], [NSNumber numberWithInt:440], nil] identifier:@"DE"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:450], [NSNumber numberWithInt:459], nil] identifier:@"JP"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:460], [NSNumber numberWithInt:469], nil] identifier:@"RU"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:471], nil] identifier:@"TW"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:474], nil] identifier:@"EE"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:475], nil] identifier:@"LV"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:476], nil] identifier:@"AZ"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:477], nil] identifier:@"LT"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:478], nil] identifier:@"UZ"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:479], nil] identifier:@"LK"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:480], nil] identifier:@"PH"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:481], nil] identifier:@"BY"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:482], nil] identifier:@"UA"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:484], nil] identifier:@"MD"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:485], nil] identifier:@"AM"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:486], nil] identifier:@"GE"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:487], nil] identifier:@"KZ"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:489], nil] identifier:@"HK"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:490], [NSNumber numberWithInt:499], nil] identifier:@"JP"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:500], [NSNumber numberWithInt:509], nil] identifier:@"GB"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:520], nil] identifier:@"GR"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:528], nil] identifier:@"LB"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:529], nil] identifier:@"CY"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:531], nil] identifier:@"MK"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:535], nil] identifier:@"MT"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:539], nil] identifier:@"IE"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:540], [NSNumber numberWithInt:549], nil] identifier:@"BE/LU"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:560], nil] identifier:@"PT"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:569], nil] identifier:@"IS"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:570], [NSNumber numberWithInt:579], nil] identifier:@"DK"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:590], nil] identifier:@"PL"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:594], nil] identifier:@"RO"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:599], nil] identifier:@"HU"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:600], [NSNumber numberWithInt:601], nil] identifier:@"ZA"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:603], nil] identifier:@"GH"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:608], nil] identifier:@"BH"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:609], nil] identifier:@"MU"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:611], nil] identifier:@"MA"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:613], nil] identifier:@"DZ"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:616], nil] identifier:@"KE"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:618], nil] identifier:@"CI"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:619], nil] identifier:@"TN"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:621], nil] identifier:@"SY"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:622], nil] identifier:@"EG"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:624], nil] identifier:@"LY"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:625], nil] identifier:@"JO"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:626], nil] identifier:@"IR"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:627], nil] identifier:@"KW"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:628], nil] identifier:@"SA"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:629], nil] identifier:@"AE"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:640], [NSNumber numberWithInt:649], nil] identifier:@"FI"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:690], [NSNumber numberWithInt:695], nil] identifier:@"CN"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:700], [NSNumber numberWithInt:709], nil] identifier:@"NO"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:729], nil] identifier:@"IL"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:730], [NSNumber numberWithInt:739], nil] identifier:@"SE"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:740], nil] identifier:@"GT"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:741], nil] identifier:@"SV"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:742], nil] identifier:@"HN"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:743], nil] identifier:@"NI"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:744], nil] identifier:@"CR"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:745], nil] identifier:@"PA"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:746], nil] identifier:@"DO"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:750], nil] identifier:@"MX"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:754], [NSNumber numberWithInt:755], nil] identifier:@"CA"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:759], nil] identifier:@"VE"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:760], [NSNumber numberWithInt:769], nil] identifier:@"CH"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:770], nil] identifier:@"CO"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:773], nil] identifier:@"UY"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:775], nil] identifier:@"PE"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:777], nil] identifier:@"BO"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:779], nil] identifier:@"AR"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:780], nil] identifier:@"CL"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:784], nil] identifier:@"PY"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:785], nil] identifier:@"PE"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:786], nil] identifier:@"EC"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:789], [NSNumber numberWithInt:790], nil] identifier:@"BR"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:800], [NSNumber numberWithInt:839], nil] identifier:@"IT"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:840], [NSNumber numberWithInt:849], nil] identifier:@"ES"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:850], nil] identifier:@"CU"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:858], nil] identifier:@"SK"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:859], nil] identifier:@"CZ"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:860], nil] identifier:@"YU"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:865], nil] identifier:@"MN"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:867], nil] identifier:@"KP"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:868], [NSNumber numberWithInt:869], nil] identifier:@"TR"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:870], [NSNumber numberWithInt:879], nil] identifier:@"NL"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:880], nil] identifier:@"KR"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:885], nil] identifier:@"TH"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:888], nil] identifier:@"SG"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:890], nil] identifier:@"IN"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:893], nil] identifier:@"VN"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:896], nil] identifier:@"PK"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:899], nil] identifier:@"ID"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:900], [NSNumber numberWithInt:919], nil] identifier:@"AT"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:930], [NSNumber numberWithInt:939], nil] identifier:@"AU"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:940], [NSNumber numberWithInt:949], nil] identifier:@"AZ"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:955], nil] identifier:@"MY"];
+ [self add:[NSArray arrayWithObjects:[NSNumber numberWithInt:958], nil] identifier:@"MO"];
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXITFReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXITFReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..9fa90cc7309c6898c5a93bab7c3ba372ddbdc698
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXITFReader.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXOneDReader.h"
+
+/**
+ * Implements decoding of the ITF format, or Interleaved Two of Five.
+ *
+ * This Reader will scan ITF barcodes of certain lengths only.
+ * At the moment it reads length 6, 8, 10, 12, 14, 16, 18, 20, 24, and 44 as these have appeared "in the wild". Not all
+ * lengths are scanned, especially shorter ones, to avoid false positives. This in turn is due to a lack of
+ * required checksum function.
+ *
+ * The checksum is optional and is not applied by this Reader. The consumer of the decoded
+ * value will have to apply a checksum if required.
+ *
+ * http://en.wikipedia.org/wiki/Interleaved_2_of_5 is a great reference for Interleaved 2 of 5 information.
+ */
+
+extern const int PATTERNS_LEN;
+extern const int PATTERNS[][5];
+
+@class ZXResult;
+
+@interface ZXITFReader : ZXOneDReader
+
+- (NSArray *)decodeStart:(ZXBitArray *)row;
+- (NSArray *)decodeEnd:(ZXBitArray *)row;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXITFReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXITFReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..724d4d1b1181befe027a906fd324ba08632a4e5b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXITFReader.m
@@ -0,0 +1,328 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXDecodeHints.h"
+#import "ZXErrors.h"
+#import "ZXITFReader.h"
+#import "ZXResult.h"
+#import "ZXResultPoint.h"
+
+static int MAX_AVG_VARIANCE;
+static int MAX_INDIVIDUAL_VARIANCE;
+
+static const int W = 3; // Pixel width of a wide line
+static const int N = 1; // Pixel width of a narrow line
+
+int const DEFAULT_ALLOWED_LENGTHS[10] = { 44, 24, 20, 18, 16, 14, 12, 10, 8, 6 };
+
+/**
+ * Start/end guard pattern.
+ *
+ * Note: The end pattern is reversed because the row is reversed before
+ * searching for the END_PATTERN
+ */
+int const ITF_START_PATTERN[4] = {N, N, N, N};
+int const END_PATTERN_REVERSED[3] = {N, N, W};
+
+/**
+ * Patterns of Wide / Narrow lines to indicate each digit
+ */
+const int PATTERNS_LEN = 10;
+const int PATTERNS[PATTERNS_LEN][5] = {
+ {N, N, W, W, N}, // 0
+ {W, N, N, N, W}, // 1
+ {N, W, N, N, W}, // 2
+ {W, W, N, N, N}, // 3
+ {N, N, W, N, W}, // 4
+ {W, N, W, N, N}, // 5
+ {N, W, W, N, N}, // 6
+ {N, N, N, W, W}, // 7
+ {W, N, N, W, N}, // 8
+ {N, W, N, W, N} // 9
+};
+
+@interface ZXITFReader ()
+
+@property (nonatomic, assign) int narrowLineWidth;
+
+- (int)decodeDigit:(int[])counters countersSize:(int)countersSize;
+- (BOOL)decodeMiddle:(ZXBitArray *)row payloadStart:(int)payloadStart payloadEnd:(int)payloadEnd resultString:(NSMutableString *)resultString;
+- (NSArray *)findGuardPattern:(ZXBitArray *)row rowOffset:(int)rowOffset pattern:(int[])pattern patternLen:(int)patternLen;
+- (int)skipWhiteSpace:(ZXBitArray *)row;
+- (BOOL)validateQuietZone:(ZXBitArray *)row startPattern:(int)startPattern;
+
+@end
+
+@implementation ZXITFReader
+
+@synthesize narrowLineWidth;
+
++ (void)initialize {
+ MAX_AVG_VARIANCE = (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.42f);
+ MAX_INDIVIDUAL_VARIANCE = (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.8f);
+}
+
+- (id)init {
+ if (self = [super init]) {
+ self.narrowLineWidth = -1;
+ }
+
+ return self;
+}
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ NSArray *startRange = [self decodeStart:row];
+ NSArray *endRange = [self decodeEnd:row];
+ if (!startRange || !endRange) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ NSMutableString *resultString = [NSMutableString stringWithCapacity:20];
+ if (![self decodeMiddle:row payloadStart:[[startRange objectAtIndex:1] intValue] payloadEnd:[[endRange objectAtIndex:0] intValue] resultString:resultString]) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ NSArray *allowedLengths = nil;
+ if (hints != nil) {
+ allowedLengths = hints.allowedLengths;
+ }
+ if (allowedLengths == nil) {
+ NSMutableArray *temp = [NSMutableArray array];
+ for (int i = 0; i < sizeof(DEFAULT_ALLOWED_LENGTHS) / sizeof(int); i++) {
+ [temp addObject:[NSNumber numberWithInt:DEFAULT_ALLOWED_LENGTHS[i]]];
+ }
+ allowedLengths = [NSArray arrayWithArray:temp];
+ }
+
+ int length = [resultString length];
+ BOOL lengthOK = NO;
+ for (NSNumber *i in allowedLengths) {
+ if (length == [i intValue]) {
+ lengthOK = YES;
+ break;
+ }
+ }
+ if (!lengthOK) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+
+ return [ZXResult resultWithText:resultString
+ rawBytes:nil
+ length:0
+ resultPoints:[NSArray arrayWithObjects:
+ [[[ZXResultPoint alloc] initWithX:[[startRange objectAtIndex:1] floatValue] y:(float)rowNumber] autorelease],
+ [[[ZXResultPoint alloc] initWithX:[[endRange objectAtIndex:0] floatValue] y:(float)rowNumber] autorelease], nil]
+ format:kBarcodeFormatITF];
+}
+
+
+- (BOOL)decodeMiddle:(ZXBitArray *)row payloadStart:(int)payloadStart payloadEnd:(int)payloadEnd resultString:(NSMutableString *)resultString {
+ const int counterDigitPairLen = 10;
+ int counterDigitPair[counterDigitPairLen];
+ memset(counterDigitPair, 0, counterDigitPairLen * sizeof(int));
+
+ const int counterBlackLen = 5;
+ int counterBlack[counterBlackLen];
+ memset(counterBlack, 0, counterBlackLen * sizeof(int));
+
+ const int counterWhiteLen = 5;
+ int counterWhite[counterWhiteLen];
+ memset(counterWhite, 0, counterWhiteLen * sizeof(int));
+
+ while (payloadStart < payloadEnd) {
+ if (![ZXOneDReader recordPattern:row start:payloadStart counters:counterDigitPair countersSize:counterDigitPairLen]) {
+ return NO;
+ }
+
+ for (int k = 0; k < 5; k++) {
+ int twoK = k << 1;
+ counterBlack[k] = counterDigitPair[twoK];
+ counterWhite[k] = counterDigitPair[twoK + 1];
+ }
+
+ int bestMatch = [self decodeDigit:counterBlack countersSize:counterBlackLen];
+ if (bestMatch == -1) {
+ return NO;
+ }
+ [resultString appendFormat:@"%C", (unichar)('0' + bestMatch)];
+ bestMatch = [self decodeDigit:counterWhite countersSize:counterWhiteLen];
+ if (bestMatch == -1) {
+ return NO;
+ }
+ [resultString appendFormat:@"%C", (unichar)('0' + bestMatch)];
+
+ for (int i = 0; i < counterDigitPairLen; i++) {
+ payloadStart += counterDigitPair[i];
+ }
+ }
+ return YES;
+}
+
+
+/**
+ * Identify where the start of the middle / payload section starts.
+ */
+- (NSArray *)decodeStart:(ZXBitArray *)row {
+ int endStart = [self skipWhiteSpace:row];
+ if (endStart == -1) {
+ return nil;
+ }
+ NSArray *startPattern = [self findGuardPattern:row rowOffset:endStart pattern:(int *)ITF_START_PATTERN patternLen:sizeof(ITF_START_PATTERN)/sizeof(int)];
+ if (!startPattern) {
+ return nil;
+ }
+
+ self.narrowLineWidth = ([[startPattern objectAtIndex:1] intValue] - [[startPattern objectAtIndex:0] intValue]) >> 2;
+
+ if (![self validateQuietZone:row startPattern:[[startPattern objectAtIndex:0] intValue]]) {
+ return nil;
+ }
+
+ return startPattern;
+}
+
+
+/**
+ * The start & end patterns must be pre/post fixed by a quiet zone. This
+ * zone must be at least 10 times the width of a narrow line. Scan back until
+ * we either get to the start of the barcode or match the necessary number of
+ * quiet zone pixels.
+ *
+ * Note: Its assumed the row is reversed when using this method to find
+ * quiet zone after the end pattern.
+ *
+ * ref: http://www.barcode-1.net/i25code.html
+ */
+- (BOOL)validateQuietZone:(ZXBitArray *)row startPattern:(int)startPattern {
+ int quietCount = self.narrowLineWidth * 10;
+
+ for (int i = startPattern - 1; quietCount > 0 && i >= 0; i--) {
+ if ([row get:i]) {
+ break;
+ }
+ quietCount--;
+ }
+ if (quietCount != 0) {
+ return NO;
+ }
+ return YES;
+}
+
+
+/**
+ * Skip all whitespace until we get to the first black line.
+ */
+- (int)skipWhiteSpace:(ZXBitArray *)row {
+ int width = [row size];
+ int endStart = [row nextSet:0];
+ if (endStart == width) {
+ return -1;
+ }
+ return endStart;
+}
+
+
+/**
+ * Identify where the end of the middle / payload section ends.
+ */
+- (NSArray *)decodeEnd:(ZXBitArray *)row {
+ [row reverse];
+
+ int endStart = [self skipWhiteSpace:row];
+ if (endStart == -1) {
+ [row reverse];
+ return nil;
+ }
+ NSMutableArray *endPattern = [[[self findGuardPattern:row rowOffset:endStart pattern:(int *)END_PATTERN_REVERSED patternLen:sizeof(END_PATTERN_REVERSED)/sizeof(int)] mutableCopy] autorelease];
+ if (!endPattern) {
+ [row reverse];
+ return nil;
+ }
+ [self validateQuietZone:row startPattern:[[endPattern objectAtIndex:0] intValue]];
+ int temp = [[endPattern objectAtIndex:0] intValue];
+ [endPattern replaceObjectAtIndex:0 withObject:[NSNumber numberWithInt:[row size] - [[endPattern objectAtIndex:1] intValue]]];
+ [endPattern replaceObjectAtIndex:1 withObject:[NSNumber numberWithInt:[row size] - temp]];
+ [row reverse];
+ return endPattern;
+}
+
+- (NSArray *)findGuardPattern:(ZXBitArray *)row rowOffset:(int)rowOffset pattern:(int[])pattern patternLen:(int)patternLen {
+ int patternLength = patternLen;
+ int counters[patternLength];
+ memset(counters, 0, patternLength * sizeof(int));
+ int width = row.size;
+ BOOL isWhite = NO;
+
+ int counterPosition = 0;
+ int patternStart = rowOffset;
+ for (int x = rowOffset; x < width; x++) {
+ if ([row get:x] ^ isWhite) {
+ counters[counterPosition]++;
+ } else {
+ if (counterPosition == patternLength - 1) {
+ if ([ZXOneDReader patternMatchVariance:counters countersSize:patternLength pattern:pattern maxIndividualVariance:MAX_INDIVIDUAL_VARIANCE] < MAX_AVG_VARIANCE) {
+ return [NSArray arrayWithObjects:[NSNumber numberWithInt:patternStart], [NSNumber numberWithInt:x], nil];
+ }
+ patternStart += counters[0] + counters[1];
+ for (int y = 2; y < patternLength; y++) {
+ counters[y - 2] = counters[y];
+ }
+ counters[patternLength - 2] = 0;
+ counters[patternLength - 1] = 0;
+ counterPosition--;
+ } else {
+ counterPosition++;
+ }
+ counters[counterPosition] = 1;
+ isWhite = !isWhite;
+ }
+ }
+
+ return nil;
+}
+
+
+/**
+ * Attempts to decode a sequence of ITF black/white lines into single
+ * digit.
+ */
+- (int)decodeDigit:(int[])counters countersSize:(int)countersSize {
+ int bestVariance = MAX_AVG_VARIANCE;
+ int bestMatch = -1;
+ int max = PATTERNS_LEN;
+ for (int i = 0; i < max; i++) {
+ int pattern[countersSize];
+ for(int ind = 0; ind<countersSize; ind++){
+ pattern[ind] = PATTERNS[i][ind];
+ }
+ int variance = [ZXOneDReader patternMatchVariance:counters countersSize:countersSize pattern:pattern maxIndividualVariance:MAX_INDIVIDUAL_VARIANCE];
+ if (variance < bestVariance) {
+ bestVariance = variance;
+ bestMatch = i;
+ }
+ }
+ if (bestMatch >= 0) {
+ return bestMatch;
+ } else {
+ return -1;
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXITFWriter.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXITFWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..1ddb330313dcb5694bcec8e4e45db0bc93b81d43
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXITFWriter.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXOneDimensionalCodeWriter.h"
+
+/**
+ * This object renders a ITF code as a {@link BitMatrix}.
+ */
+
+@interface ZXITFWriter : ZXOneDimensionalCodeWriter
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXITFWriter.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXITFWriter.m
new file mode 100644
index 0000000000000000000000000000000000000000..f07597050bba73511eb6af70bbe653dfa63b2dcc
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXITFWriter.m
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXITFReader.h"
+#import "ZXITFWriter.h"
+
+const int ITF_WRITER_START_PATTERN_LEN = 4;
+const int ITF_WRITER_START_PATTERN[ITF_WRITER_START_PATTERN_LEN] = {1, 1, 1, 1};
+
+const int ITF_WRITER_END_PATTERN_LEN = 3;
+const int ITF_WRITER_END_PATTERN[ITF_WRITER_END_PATTERN_LEN] = {3, 1, 1};
+
+@implementation ZXITFWriter
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height hints:(ZXEncodeHints *)hints error:(NSError **)error {
+ if (format != kBarcodeFormatITF) {
+ [NSException raise:NSInvalidArgumentException format:@"Can only encode ITF"];
+ }
+
+ return [super encode:contents format:format width:width height:height hints:hints error:error];
+}
+
+- (BOOL *)encode:(NSString *)contents length:(int *)pLength {
+ int length = [contents length];
+ if (length % 2 != 0) {
+ [NSException raise:NSInvalidArgumentException format:@"The length of the input should be even"];
+ }
+ if (length > 80) {
+ [NSException raise:NSInvalidArgumentException format:@"Requested contents should be less than 80 digits long, but got %d", length];
+ }
+
+ int resultLen = 9 + 9 * length;
+ if (pLength) *pLength = resultLen;
+ BOOL *result = (BOOL *)malloc(resultLen * sizeof(BOOL));
+ int pos = [super appendPattern:result pos:0 pattern:(int *)ITF_WRITER_START_PATTERN patternLen:ITF_WRITER_START_PATTERN_LEN startColor:TRUE];
+ for (int i = 0; i < length; i += 2) {
+ int one = [[contents substringWithRange:NSMakeRange(i, 1)] intValue];
+ int two = [[contents substringWithRange:NSMakeRange(i + 1, 1)] intValue];
+ const int encodingLen = 18;
+ int encoding[encodingLen];
+ memset(encoding, 0, encodingLen * sizeof(int));
+ for (int j = 0; j < 5; j++) {
+ encoding[j << 1] = PATTERNS[one][j];
+ encoding[(j << 1) + 1] = PATTERNS[two][j];
+ }
+ pos += [super appendPattern:result pos:pos pattern:encoding patternLen:encodingLen startColor:TRUE];
+ }
+ [super appendPattern:result pos:pos pattern:(int *)ITF_WRITER_END_PATTERN patternLen:ITF_WRITER_END_PATTERN_LEN startColor:TRUE];
+
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXMultiFormatOneDReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXMultiFormatOneDReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..71a4eb249016ec163022259b7e59d43d74545dbd
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXMultiFormatOneDReader.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXOneDReader.h"
+
+@class ZXDecodeHints;
+
+@interface ZXMultiFormatOneDReader : ZXOneDReader
+
+- (id)initWithHints:(ZXDecodeHints *)hints;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXMultiFormatOneDReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXMultiFormatOneDReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..39372ee7545c1df168f286b27e04908e44819332
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXMultiFormatOneDReader.m
@@ -0,0 +1,119 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXCodaBarReader.h"
+#import "ZXCode128Reader.h"
+#import "ZXCode39Reader.h"
+#import "ZXCode93Reader.h"
+#import "ZXDecodeHints.h"
+#import "ZXErrors.h"
+#import "ZXITFReader.h"
+#import "ZXMultiFormatOneDReader.h"
+#import "ZXMultiFormatUPCEANReader.h"
+#import "ZXRSS14Reader.h"
+#import "ZXRSSExpandedReader.h"
+
+@interface ZXMultiFormatOneDReader ()
+
+@property (nonatomic, retain) NSMutableArray *readers;
+
+@end
+
+@implementation ZXMultiFormatOneDReader
+
+@synthesize readers;
+
+- (id)initWithHints:(ZXDecodeHints *)hints {
+ if (self = [super init]) {
+ BOOL useCode39CheckDigit = hints != nil && hints.assumeCode39CheckDigit;
+ self.readers = [NSMutableArray array];
+ if (hints != nil) {
+ if ([hints containsFormat:kBarcodeFormatEan13] ||
+ [hints containsFormat:kBarcodeFormatUPCA] ||
+ [hints containsFormat:kBarcodeFormatEan8] ||
+ [hints containsFormat:kBarcodeFormatUPCE]) {
+ [self.readers addObject:[[[ZXMultiFormatUPCEANReader alloc] initWithHints:hints] autorelease]];
+ }
+
+ if ([hints containsFormat:kBarcodeFormatCode39]) {
+ [self.readers addObject:[[[ZXCode39Reader alloc] initUsingCheckDigit:useCode39CheckDigit] autorelease]];
+ }
+
+ if ([hints containsFormat:kBarcodeFormatCode93]) {
+ [self.readers addObject:[[[ZXCode93Reader alloc] init] autorelease]];
+ }
+
+ if ([hints containsFormat:kBarcodeFormatCode128]) {
+ [self.readers addObject:[[[ZXCode128Reader alloc] init] autorelease]];
+ }
+
+ if ([hints containsFormat:kBarcodeFormatITF]) {
+ [self.readers addObject:[[[ZXITFReader alloc] init] autorelease]];
+ }
+
+ if ([hints containsFormat:kBarcodeFormatCodabar]) {
+ [self.readers addObject:[[[ZXCodaBarReader alloc] init] autorelease]];
+ }
+
+ if ([hints containsFormat:kBarcodeFormatRSS14]) {
+ [self.readers addObject:[[[ZXRSS14Reader alloc] init] autorelease]];
+ }
+
+ if ([hints containsFormat:kBarcodeFormatRSSExpanded]) {
+ [self.readers addObject:[[[ZXRSSExpandedReader alloc] init] autorelease]];
+ }
+ }
+
+ if ([self.readers count] == 0) {
+ [self.readers addObject:[[[ZXMultiFormatUPCEANReader alloc] initWithHints:hints] autorelease]];
+ [self.readers addObject:[[[ZXCode39Reader alloc] init] autorelease]];
+ [self.readers addObject:[[[ZXCodaBarReader alloc] init] autorelease]];
+ [self.readers addObject:[[[ZXCode93Reader alloc] init] autorelease]];
+ [self.readers addObject:[[[ZXCode128Reader alloc] init] autorelease]];
+ [self.readers addObject:[[[ZXITFReader alloc] init] autorelease]];
+ [self.readers addObject:[[[ZXRSS14Reader alloc] init] autorelease]];
+ [self.readers addObject:[[[ZXRSSExpandedReader alloc] init] autorelease]];
+ }
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [readers release];
+
+ [super dealloc];
+}
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ for (ZXOneDReader *reader in self.readers) {
+ ZXResult *result = [reader decodeRow:rowNumber row:row hints:hints error:error];
+ if (result) {
+ return result;
+ }
+ }
+
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+}
+
+- (void)reset {
+ for (id<ZXReader> reader in self.readers) {
+ [reader reset];
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXMultiFormatUPCEANReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXMultiFormatUPCEANReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..32385e6c80eb4526834804ab32d7a41387b7f3e2
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXMultiFormatUPCEANReader.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXOneDReader.h"
+
+/**
+ * A reader that can read all available UPC/EAN formats. If a caller wants to try to
+ * read all such formats, it is most efficient to use this implementation rather than invoke
+ * individual readers.
+ */
+
+@class ZXDecodeHints;
+
+@interface ZXMultiFormatUPCEANReader : ZXOneDReader
+
+- (id)initWithHints:(ZXDecodeHints *)hints;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXMultiFormatUPCEANReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXMultiFormatUPCEANReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..2b04924fb56af8266cd42fc463f2aa8c2e1ebd0e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXMultiFormatUPCEANReader.m
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecodeHints.h"
+#import "ZXEAN8Reader.h"
+#import "ZXEAN13Reader.h"
+#import "ZXErrors.h"
+#import "ZXMultiFormatUPCEANReader.h"
+#import "ZXReader.h"
+#import "ZXResult.h"
+#import "ZXUPCAReader.h"
+#import "ZXUPCEReader.h"
+
+@interface ZXMultiFormatUPCEANReader ()
+
+@property (nonatomic, retain) NSMutableArray *readers;
+
+@end
+
+@implementation ZXMultiFormatUPCEANReader
+
+@synthesize readers;
+
+- (id)initWithHints:(ZXDecodeHints *)hints {
+ if (self = [super init]) {
+ self.readers = [NSMutableArray array];
+
+ if (hints != nil) {
+ if ([hints containsFormat:kBarcodeFormatEan13]) {
+ [self.readers addObject:[[[ZXEAN13Reader alloc] init] autorelease]];
+ } else if ([hints containsFormat:kBarcodeFormatUPCA]) {
+ [self.readers addObject:[[[ZXUPCAReader alloc] init] autorelease]];
+ }
+
+ if ([hints containsFormat:kBarcodeFormatEan8]) {
+ [self.readers addObject:[[[ZXEAN8Reader alloc] init] autorelease]];
+ }
+
+ if ([hints containsFormat:kBarcodeFormatUPCE]) {
+ [self.readers addObject:[[[ZXUPCEReader alloc] init] autorelease]];
+ }
+ }
+
+ if ([self.readers count] == 0) {
+ [self.readers addObject:[[[ZXEAN13Reader alloc] init] autorelease]];
+ [self.readers addObject:[[[ZXEAN8Reader alloc] init] autorelease]];
+ [self.readers addObject:[[[ZXUPCEReader alloc] init] autorelease]];
+ }
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [readers release];
+
+ [super dealloc];
+}
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ NSRange startGuardPattern = [ZXUPCEANReader findStartGuardPattern:row error:error];
+ if (startGuardPattern.location == NSNotFound) {
+ return nil;
+ }
+ for (ZXUPCEANReader *reader in self.readers) {
+ ZXResult *result = [reader decodeRow:rowNumber row:row startGuardRange:startGuardPattern hints:hints error:error];
+ if (!result) {
+ continue;
+ }
+
+ // Special case: a 12-digit code encoded in UPC-A is identical to a "0"
+ // followed by those 12 digits encoded as EAN-13. Each will recognize such a code,
+ // UPC-A as a 12-digit string and EAN-13 as a 13-digit string starting with "0".
+ // Individually these are correct and their readers will both read such a code
+ // and correctly call it EAN-13, or UPC-A, respectively.
+ //
+ // In this case, if we've been looking for both types, we'd like to call it
+ // a UPC-A code. But for efficiency we only run the EAN-13 decoder to also read
+ // UPC-A. So we special case it here, and convert an EAN-13 result to a UPC-A
+ // result if appropriate.
+ //
+ // But, don't return UPC-A if UPC-A was not a requested format!
+ BOOL ean13MayBeUPCA = kBarcodeFormatEan13 == result.barcodeFormat && [result.text characterAtIndex:0] == '0';
+ BOOL canReturnUPCA = hints == nil || [hints numberOfPossibleFormats] == 0 || [hints containsFormat:kBarcodeFormatUPCA];
+ if (ean13MayBeUPCA && canReturnUPCA) {
+ // Transfer the metdata across
+ ZXResult *resultUPCA = [ZXResult resultWithText:[result.text substringFromIndex:1]
+ rawBytes:result.rawBytes
+ length:result.length
+ resultPoints:result.resultPoints
+ format:kBarcodeFormatUPCA];
+ [resultUPCA putAllMetadata:result.resultMetadata];
+ return resultUPCA;
+ }
+ return result;
+ }
+
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+}
+
+- (void)reset {
+ for (id<ZXReader> reader in self.readers) {
+ [reader reset];
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXOneDReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXOneDReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..3752eed49fcc53a3c26b664e95a8e44c62a09d5f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXOneDReader.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXReader.h"
+
+/**
+ * Encapsulates functionality and implementation that is common to all families
+ * of one-dimensional barcodes.
+ */
+
+extern int const INTEGER_MATH_SHIFT;
+extern int const PATTERN_MATCH_RESULT_SCALE_FACTOR;
+
+@class ZXBitArray, ZXDecodeHints, ZXResult;
+
+@interface ZXOneDReader : NSObject <ZXReader>
+
++ (BOOL)recordPattern:(ZXBitArray *)row start:(int)start counters:(int[])counters countersSize:(int)countersSize;
++ (BOOL)recordPatternInReverse:(ZXBitArray *)row start:(int)start counters:(int[])counters countersSize:(int)countersSize;
++ (int)patternMatchVariance:(int[])counters countersSize:(int)countersSize pattern:(int[])pattern maxIndividualVariance:(int)maxIndividualVariance;
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row hints:(ZXDecodeHints *)hints error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXOneDReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXOneDReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..51aa8c49a37bc1cea299f62b507623a1b4df6540
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXOneDReader.m
@@ -0,0 +1,271 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBinaryBitmap.h"
+#import "ZXBitArray.h"
+#import "ZXDecodeHints.h"
+#import "ZXErrors.h"
+#import "ZXOneDReader.h"
+#import "ZXResult.h"
+#import "ZXResultPoint.h"
+
+int const INTEGER_MATH_SHIFT = 8;
+int const PATTERN_MATCH_RESULT_SCALE_FACTOR = 1 << INTEGER_MATH_SHIFT;
+
+@interface ZXOneDReader ()
+
+- (ZXResult *)doDecode:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error;
+
+@end
+
+@implementation ZXOneDReader
+
+- (ZXResult *)decode:(ZXBinaryBitmap *)image error:(NSError **)error {
+ return [self decode:image hints:nil error:error];
+}
+
+// Note that we don't try rotation without the try harder flag, even if rotation was supported.
+- (ZXResult *)decode:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ NSError *decodeError = nil;
+ ZXResult *result = [self doDecode:image hints:hints error:&decodeError];
+ if (result) {
+ return result;
+ } else if (decodeError.code == ZXNotFoundError) {
+ BOOL tryHarder = hints != nil && hints.tryHarder;
+ if (tryHarder && [image rotateSupported]) {
+ ZXBinaryBitmap *rotatedImage = [image rotateCounterClockwise];
+ ZXResult *result = [self doDecode:rotatedImage hints:hints error:error];
+ if (!result) {
+ return nil;
+ }
+ // Record that we found it rotated 90 degrees CCW / 270 degrees CW
+ NSMutableDictionary *metadata = [result resultMetadata];
+ int orientation = 270;
+ if (metadata != nil && [metadata objectForKey:[NSNumber numberWithInt:kResultMetadataTypeOrientation]]) {
+ // But if we found it reversed in doDecode(), add in that result here:
+ orientation = (orientation + [((NSNumber *)[metadata objectForKey:[NSNumber numberWithInt:kResultMetadataTypeOrientation]]) intValue]) % 360;
+ }
+ [result putMetadata:kResultMetadataTypeOrientation value:[NSNumber numberWithInt:orientation]];
+ // Update result points
+ NSMutableArray *points = [result resultPoints];
+ if (points != nil) {
+ int height = [rotatedImage height];
+ for (int i = 0; i < [points count]; i++) {
+ [points replaceObjectAtIndex:i
+ withObject:[[[ZXResultPoint alloc] initWithX:height - [(ZXResultPoint *)[points objectAtIndex:i] y]
+ y:[(ZXResultPoint *)[points objectAtIndex:i] x]]
+ autorelease]];
+ }
+ }
+ return result;
+ }
+ }
+
+ if (error) *error = decodeError;
+ return nil;
+}
+
+- (void)reset {
+
+}
+
+
+/**
+ * We're going to examine rows from the middle outward, searching alternately above and below the
+ * middle, and farther out each time. rowStep is the number of rows between each successive
+ * attempt above and below the middle. So we'd scan row middle, then middle - rowStep, then
+ * middle + rowStep, then middle - (2 * rowStep), etc.
+ * rowStep is bigger as the image is taller, but is always at least 1. We've somewhat arbitrarily
+ * decided that moving up and down by about 1/16 of the image is pretty good; we try more of the
+ * image if "trying harder".
+ */
+- (ZXResult *)doDecode:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ int width = image.width;
+ int height = image.height;
+ ZXBitArray *row = [[[ZXBitArray alloc] initWithSize:width] autorelease];
+ int middle = height >> 1;
+ BOOL tryHarder = hints != nil && hints.tryHarder;
+ int rowStep = MAX(1, height >> (tryHarder ? 8 : 5));
+ int maxLines;
+ if (tryHarder) {
+ maxLines = height;
+ } else {
+ maxLines = 15;
+ }
+
+ for (int x = 0; x < maxLines; x++) {
+ int rowStepsAboveOrBelow = (x + 1) >> 1;
+ BOOL isAbove = (x & 0x01) == 0;
+ int rowNumber = middle + rowStep * (isAbove ? rowStepsAboveOrBelow : -rowStepsAboveOrBelow);
+ if (rowNumber < 0 || rowNumber >= height) {
+ break;
+ }
+
+ NSError *rowError = nil;
+ row = [image blackRow:rowNumber row:row error:&rowError];
+ if (!row && rowError.code == ZXNotFoundError) {
+ continue;
+ } else if (!row) {
+ if (error) *error = rowError;
+ return nil;
+ }
+
+ for (int attempt = 0; attempt < 2; attempt++) {
+ if (attempt == 1) {
+ [row reverse];
+ if (hints != nil && hints.resultPointCallback) {
+ hints = [[hints copy] autorelease];
+ hints.resultPointCallback = nil;
+ }
+ }
+
+ ZXResult *result = [self decodeRow:rowNumber row:row hints:hints error:nil];
+ if (result) {
+ if (attempt == 1) {
+ [result putMetadata:kResultMetadataTypeOrientation value:[NSNumber numberWithInt:180]];
+ NSMutableArray *points = [result resultPoints];
+ if (points != nil) {
+ [points replaceObjectAtIndex:0
+ withObject:[[[ZXResultPoint alloc] initWithX:width - [(ZXResultPoint *)[points objectAtIndex:0] x]
+ y:[(ZXResultPoint *)[points objectAtIndex:0] y]]
+ autorelease]];
+ [points replaceObjectAtIndex:1
+ withObject:[[[ZXResultPoint alloc] initWithX:width - [(ZXResultPoint *)[points objectAtIndex:1] x]
+ y:[(ZXResultPoint *)[points objectAtIndex:1] y]]
+ autorelease]];
+ }
+ }
+ return result;
+ }
+ }
+ }
+
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+}
+
+
+/**
+ * Records the size of successive runs of white and black pixels in a row, starting at a given point.
+ * The values are recorded in the given array, and the number of runs recorded is equal to the size
+ * of the array. If the row starts on a white pixel at the given start point, then the first count
+ * recorded is the run of white pixels starting from that point; likewise it is the count of a run
+ * of black pixels if the row begin on a black pixels at that point.
+ */
++ (BOOL)recordPattern:(ZXBitArray *)row start:(int)start counters:(int[])counters countersSize:(int)countersSize {
+ int numCounters = countersSize;
+
+ memset(counters, 0, numCounters * sizeof(int));
+
+ int end = row.size;
+ if (start >= end) {
+ return NO;
+ }
+ BOOL isWhite = ![row get:start];
+ int counterPosition = 0;
+ int i = start;
+
+ while (i < end) {
+ if ([row get:i] ^ isWhite) {
+ counters[counterPosition]++;
+ } else {
+ counterPosition++;
+ if (counterPosition == numCounters) {
+ break;
+ } else {
+ counters[counterPosition] = 1;
+ isWhite = !isWhite;
+ }
+ }
+ i++;
+ }
+
+ if (!(counterPosition == numCounters || (counterPosition == numCounters - 1 && i == end))) {
+ return NO;
+ }
+ return YES;
+}
+
++ (BOOL)recordPatternInReverse:(ZXBitArray *)row start:(int)start counters:(int[])counters countersSize:(int)countersSize {
+ int numTransitionsLeft = countersSize;
+ BOOL last = [row get:start];
+
+ while (start > 0 && numTransitionsLeft >= 0) {
+ if ([row get:--start] != last) {
+ numTransitionsLeft--;
+ last = !last;
+ }
+ }
+
+ if (numTransitionsLeft >= 0 || ![self recordPattern:row start:start + 1 counters:counters countersSize:countersSize]) {
+ return NO;
+ }
+ return YES;
+}
+
+
+/**
+ * Determines how closely a set of observed counts of runs of black/white values matches a given
+ * target pattern. This is reported as the ratio of the total variance from the expected pattern
+ * proportions across all pattern elements, to the length of the pattern.
+ *
+ * Returns ratio of total variance between counters and pattern compared to total pattern size,
+ * where the ratio has been multiplied by 256. So, 0 means no variance (perfect match); 256 means
+ * the total variance between counters and patterns equals the pattern length, higher values mean
+ * even more variance
+ */
++ (int)patternMatchVariance:(int[])counters countersSize:(int)countersSize pattern:(int[])pattern maxIndividualVariance:(int)maxIndividualVariance {
+ int numCounters = countersSize;
+ int total = 0;
+ int patternLength = 0;
+
+ for (int i = 0; i < numCounters; i++) {
+ total += counters[i];
+ patternLength += pattern[i];
+ }
+
+ if (total < patternLength) {
+ return NSIntegerMax;
+ }
+ int unitBarWidth = (total << INTEGER_MATH_SHIFT) / patternLength;
+ maxIndividualVariance = (maxIndividualVariance * unitBarWidth) >> INTEGER_MATH_SHIFT;
+ int totalVariance = 0;
+
+ for (int x = 0; x < numCounters; x++) {
+ int counter = counters[x] << INTEGER_MATH_SHIFT;
+ int scaledPattern = pattern[x] * unitBarWidth;
+ int variance = counter > scaledPattern ? counter - scaledPattern : scaledPattern - counter;
+ if (variance > maxIndividualVariance) {
+ return NSIntegerMax;
+ }
+ totalVariance += variance;
+ }
+
+ return totalVariance / total;
+}
+
+
+/**
+ * Attempts to decode a one-dimensional barcode format given a single row of
+ * an image.
+ */
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXOneDimensionalCodeWriter.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXOneDimensionalCodeWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7734ae671845434d54d9930cdc7456446ca4742
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXOneDimensionalCodeWriter.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXWriter.h"
+
+/**
+ * Encapsulates functionality and implementation that is common to one-dimensional barcodes.
+ */
+@interface ZXOneDimensionalCodeWriter : NSObject <ZXWriter>
+
+- (BOOL *)encode:(NSString *)contents length:(int *)pLength;
+- (int)appendPattern:(BOOL *)target pos:(int)pos pattern:(int *)pattern patternLen:(int)patternLen startColor:(BOOL)startColor;
+- (int)defaultMargin;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXOneDimensionalCodeWriter.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXOneDimensionalCodeWriter.m
new file mode 100644
index 0000000000000000000000000000000000000000..df7e6ff50eb606d4e108a7509e34574256cf4a89
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXOneDimensionalCodeWriter.m
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXEncodeHints.h"
+#import "ZXOneDimensionalCodeWriter.h"
+
+@interface ZXOneDimensionalCodeWriter ()
+
+- (ZXBitMatrix *)renderResult:(BOOL *)code length:(int)length width:(int)width height:(int)height sidesMargin:(int)sidesMargin;
+
+@end
+
+@implementation ZXOneDimensionalCodeWriter
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height error:(NSError **)error {
+ return [self encode:contents format:format width:width height:height hints:nil error:error];
+}
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height
+ hints:(ZXEncodeHints *)hints error:(NSError **)error {
+ if (contents.length == 0) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"Found empty contents" userInfo:nil];
+ }
+
+ if (width < 0 || height < 0) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:[NSString stringWithFormat:@"Negative size is not allowed. Input: %dx%d", width, height]
+ userInfo:nil];
+ }
+
+ int sidesMargin = [self defaultMargin];
+ if (hints && hints.margin) {
+ sidesMargin = hints.margin.intValue;
+ }
+
+ int length;
+ BOOL *code = [self encode:contents length:&length];
+ ZXBitMatrix *result = [self renderResult:code length:length width:width height:height sidesMargin:sidesMargin];
+ free(code);
+ return result;
+}
+
+- (ZXBitMatrix *)renderResult:(BOOL *)code length:(int)length width:(int)width height:(int)height sidesMargin:(int)sidesMargin {
+ int inputWidth = length;
+ // Add quiet zone on both sides.
+ int fullWidth = inputWidth + sidesMargin;
+ int outputWidth = MAX(width, fullWidth);
+ int outputHeight = MAX(1, height);
+
+ int multiple = outputWidth / fullWidth;
+ int leftPadding = (outputWidth - (inputWidth * multiple)) / 2;
+
+ ZXBitMatrix *output = [ZXBitMatrix bitMatrixWithWidth:outputWidth height:outputHeight];
+ for (int inputX = 0, outputX = leftPadding; inputX < inputWidth; inputX++, outputX += multiple) {
+ if (code[inputX]) {
+ [output setRegionAtLeft:outputX top:0 width:multiple height:outputHeight];
+ }
+ }
+ return output;
+}
+
+/**
+ * Appends the given pattern to the target array starting at pos.
+ */
+- (int)appendPattern:(BOOL *)target pos:(int)pos pattern:(int *)pattern patternLen:(int)patternLen startColor:(BOOL)startColor {
+ BOOL color = startColor;
+ int numAdded = 0;
+ for (int i = 0; i < patternLen; i++) {
+ for (int j = 0; j < pattern[i]; j++) {
+ target[pos++] = color;
+ }
+ numAdded += pattern[i];
+ color = !color; // flip color after each segment
+ }
+ return numAdded;
+}
+
+- (int)defaultMargin {
+ // CodaBar spec requires a side margin to be more than ten times wider than narrow space.
+ // This seems like a decent idea for a default for all formats.
+ return 10;
+}
+
+/**
+ * Encode the contents to boolean array expression of one-dimensional barcode.
+ * Start code and end code should be included in result, and side margins should not be included.
+ */
+- (BOOL *)encode:(NSString *)contents length:(int *)pLength {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCAReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCAReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..b343228e364f667cf9c0df9b6ab38b89cc48d69d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCAReader.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXUPCEANReader.h"
+
+/**
+ * Implements decoding of the UPC-A format.
+ */
+
+@interface ZXUPCAReader : ZXUPCEANReader
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCAReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCAReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..2153d1812e71eefd3a248c601fa2770171b12146
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCAReader.m
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXEAN13Reader.h"
+#import "ZXErrors.h"
+#import "ZXResult.h"
+#import "ZXUPCAReader.h"
+
+@interface ZXUPCAReader ()
+
+@property (nonatomic, retain) ZXUPCEANReader *ean13Reader;
+
+- (ZXResult *)maybeReturnResult:(ZXResult *)result;
+
+@end
+
+@implementation ZXUPCAReader
+
+@synthesize ean13Reader;
+
+- (id)init {
+ if (self = [super init]) {
+ self.ean13Reader = [[[ZXEAN13Reader alloc] init] autorelease];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [ean13Reader release];
+
+ [super dealloc];
+}
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row startGuardRange:(NSRange)startGuardRange hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ ZXResult *result = [self.ean13Reader decodeRow:rowNumber row:row startGuardRange:startGuardRange hints:hints error:error];
+ if (result) {
+ result = [self maybeReturnResult:result];
+ if (!result) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ return result;
+ } else {
+ return nil;
+ }
+}
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ ZXResult *result = [self.ean13Reader decodeRow:rowNumber row:row hints:hints error:error];
+ if (result) {
+ result = [self maybeReturnResult:result];
+ if (!result) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ return result;
+ } else {
+ return nil;
+ }
+}
+
+- (ZXResult *)decode:(ZXBinaryBitmap *)image error:(NSError **)error {
+ ZXResult *result = [self.ean13Reader decode:image error:error];
+ if (result) {
+ result = [self maybeReturnResult:result];
+ if (!result) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ return result;
+ } else {
+ return nil;
+ }
+}
+
+- (ZXResult *)decode:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ ZXResult *result = [self.ean13Reader decode:image hints:hints error:error];
+ if (result) {
+ result = [self maybeReturnResult:result];
+ if (!result) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ return result;
+ } else {
+ return nil;
+ }
+}
+
+- (ZXBarcodeFormat)barcodeFormat {
+ return kBarcodeFormatUPCA;
+}
+
+- (int)decodeMiddle:(ZXBitArray *)row startRange:(NSRange)startRange result:(NSMutableString *)result error:(NSError **)error {
+ return [self.ean13Reader decodeMiddle:row startRange:startRange result:result error:error];
+}
+
+- (ZXResult *)maybeReturnResult:(ZXResult *)result {
+ NSString *text = result.text;
+ if ([text characterAtIndex:0] == '0') {
+ return [ZXResult resultWithText:[text substringFromIndex:1]
+ rawBytes:NULL
+ length:0
+ resultPoints:result.resultPoints
+ format:kBarcodeFormatUPCA];
+ } else {
+ return nil;
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCAWriter.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCAWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..9bff2cbcfb3895580e638d68877934c112065c27
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCAWriter.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXWriter.h"
+
+/**
+ * This object renders a UPC-A code as a ZXBitMatrix.
+ */
+
+@interface ZXUPCAWriter : NSObject <ZXWriter>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCAWriter.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCAWriter.m
new file mode 100644
index 0000000000000000000000000000000000000000..2fe559cc4b3c92efcb72abbad9545328477e72d1
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCAWriter.m
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXEAN13Writer.h"
+#import "ZXUPCAWriter.h"
+
+@interface ZXUPCAWriter ()
+
+- (ZXEAN13Writer *)subWriter;
+- (NSString *)preencode:(NSString *)contents;
+
+@end
+
+@implementation ZXUPCAWriter
+
+- (ZXEAN13Writer *)subWriter {
+ static ZXEAN13Writer *subWriter = nil;
+ if (!subWriter) {
+ subWriter = [[ZXEAN13Writer alloc] init];
+ }
+
+ return subWriter;
+}
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height error:(NSError **)error {
+ return [self encode:contents format:format width:width height:height hints:nil error:error];
+}
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height hints:(ZXEncodeHints *)hints error:(NSError **)error {
+ if (format != kBarcodeFormatUPCA) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:[NSString stringWithFormat:@"Can only encode UPC-A, but got %d", format]
+ userInfo:nil];
+ }
+ return [self.subWriter encode:[self preencode:contents] format:kBarcodeFormatEan13 width:width height:height hints:hints error:error];
+}
+
+/**
+ * Transform a UPC-A code into the equivalent EAN-13 code, and add a check digit if it is not
+ * already present.
+ */
+- (NSString *)preencode:(NSString *)contents {
+ int length = [contents length];
+ if (length == 11) {
+ int sum = 0;
+
+ for (int i = 0; i < 11; ++i) {
+ sum += ([contents characterAtIndex:i] - '0') * (i % 2 == 0 ? 3 : 1);
+ }
+
+ contents = [contents stringByAppendingFormat:@"%d", (1000 - sum) % 10];
+ } else if (length != 12) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:[NSString stringWithFormat:@"Requested contents should be 11 or 12 digits long, but got %d", [contents length]]
+ userInfo:nil];
+ }
+ return [NSString stringWithFormat:@"0%@", contents];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtension2Support.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtension2Support.h
new file mode 100644
index 0000000000000000000000000000000000000000..438076c961931c04d5d654c4a57fe3123f07be5f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtension2Support.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXBitArray, ZXResult;
+
+@interface ZXUPCEANExtension2Support : NSObject
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row extensionStartRange:(NSRange)extensionStartRange error:(NSError **)error;
+- (int)decodeMiddle:(ZXBitArray *)row startRange:(NSRange)startRange result:(NSMutableString *)result error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtension2Support.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtension2Support.m
new file mode 100644
index 0000000000000000000000000000000000000000..10b30f4b7e8999edf48374a54e254e36527ae61a
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtension2Support.m
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeFormat.h"
+#import "ZXBitArray.h"
+#import "ZXErrors.h"
+#import "ZXResult.h"
+#import "ZXResultMetadataType.h"
+#import "ZXResultPoint.h"
+#import "ZXUPCEANExtension2Support.h"
+#import "ZXUPCEANReader.h"
+
+@interface ZXUPCEANExtension2Support ()
+
+- (NSMutableDictionary *)parseExtensionString:(NSString *)raw;
+
+@end
+
+@implementation ZXUPCEANExtension2Support
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row extensionStartRange:(NSRange)extensionStartRange error:(NSError **)error {
+ NSMutableString *resultString = [NSMutableString string];
+ int end = [self decodeMiddle:row startRange:extensionStartRange result:resultString error:error];
+ if (end == -1) {
+ return nil;
+ }
+
+ NSMutableDictionary *extensionData = [self parseExtensionString:resultString];
+
+ ZXResult *extensionResult = [[[ZXResult alloc] initWithText:resultString
+ rawBytes:nil
+ length:0
+ resultPoints:[NSArray arrayWithObjects:
+ [[[ZXResultPoint alloc] initWithX:(extensionStartRange.location + NSMaxRange(extensionStartRange)) / 2.0f y:rowNumber] autorelease],
+ [[[ZXResultPoint alloc] initWithX:end y:rowNumber] autorelease], nil]
+ format:kBarcodeFormatUPCEANExtension] autorelease];
+ if (extensionData != nil) {
+ [extensionResult putAllMetadata:extensionData];
+ }
+ return extensionResult;
+}
+
+- (int)decodeMiddle:(ZXBitArray *)row startRange:(NSRange)startRange result:(NSMutableString *)result error:(NSError **)error {
+ const int countersLen = 4;
+ int counters[countersLen];
+ memset(counters, 0, countersLen * sizeof(int));
+
+ int end = [row size];
+ int rowOffset = NSMaxRange(startRange);
+
+ int checkParity = 0;
+
+ for (int x = 0; x < 2 && rowOffset < end; x++) {
+ int bestMatch = [ZXUPCEANReader decodeDigit:row counters:counters countersLen:countersLen rowOffset:rowOffset patternType:UPC_EAN_PATTERNS_L_AND_G_PATTERNS error:error];
+ if (bestMatch == -1) {
+ return -1;
+ }
+ [result appendFormat:@"%C", (unichar)('0' + bestMatch % 10)];
+ for (int i = 0; i < countersLen; i++) {
+ rowOffset += counters[i];
+ }
+ if (bestMatch >= 10) {
+ checkParity |= 1 << (1 - x);
+ }
+ if (x != 1) {
+ // Read off separator if not last
+ rowOffset = [row nextSet:rowOffset];
+ rowOffset = [row nextUnset:rowOffset];
+ }
+ }
+
+ if (result.length != 2) {
+ if (error) *error = NotFoundErrorInstance();
+ return -1;
+ }
+
+ if ([result intValue] % 4 != checkParity) {
+ if (error) *error = NotFoundErrorInstance();
+ return -1;
+ }
+
+ return rowOffset;
+}
+
+- (NSMutableDictionary *)parseExtensionString:(NSString *)raw {
+ if (raw.length != 2) {
+ return nil;
+ }
+ return [NSMutableDictionary dictionaryWithObject:[NSNumber numberWithInt:[raw intValue]]
+ forKey:[NSNumber numberWithInt:kResultMetadataTypeIssueNumber]];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtension5Support.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtension5Support.h
new file mode 100644
index 0000000000000000000000000000000000000000..31d1a16213929d8c6a100ea467a97041f32fc22e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtension5Support.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXBitArray, ZXResult;
+
+@interface ZXUPCEANExtension5Support : NSObject
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row extensionStartRange:(NSRange)extensionStartRange error:(NSError **)error;
+- (int)decodeMiddle:(ZXBitArray *)row startRange:(NSRange)startRange result:(NSMutableString *)result error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtension5Support.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtension5Support.m
new file mode 100644
index 0000000000000000000000000000000000000000..1b0030beb78b20b7b85301dc9545aa60a1a7d9d7
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtension5Support.m
@@ -0,0 +1,176 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeFormat.h"
+#import "ZXBitArray.h"
+#import "ZXErrors.h"
+#import "ZXResult.h"
+#import "ZXResultMetadataType.h"
+#import "ZXResultPoint.h"
+#import "ZXUPCEANExtension5Support.h"
+#import "ZXUPCEANReader.h"
+
+const int CHECK_DIGIT_ENCODINGS[10] = {
+ 0x18, 0x14, 0x12, 0x11, 0x0C, 0x06, 0x03, 0x0A, 0x09, 0x05
+};
+
+@interface ZXUPCEANExtension5Support ()
+
+- (int)extensionChecksum:(NSString *)s;
+- (int)determineCheckDigit:(int)lgPatternFound;
+- (NSMutableDictionary *)parseExtensionString:(NSString *)raw;
+- (NSString *)parseExtension5String:(NSString *)raw;
+
+@end
+
+@implementation ZXUPCEANExtension5Support
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row extensionStartRange:(NSRange)extensionStartRange error:(NSError **)error {
+ NSMutableString *resultString = [NSMutableString string];
+ int end = [self decodeMiddle:row startRange:extensionStartRange result:resultString error:error];
+ if (end == -1) {
+ return nil;
+ }
+
+ NSMutableDictionary *extensionData = [self parseExtensionString:resultString];
+
+ ZXResult *extensionResult = [[[ZXResult alloc] initWithText:resultString
+ rawBytes:nil
+ length:0
+ resultPoints:[NSArray arrayWithObjects:
+ [[[ZXResultPoint alloc] initWithX:(extensionStartRange.location + NSMaxRange(extensionStartRange)) / 2.0f y:rowNumber] autorelease],
+ [[[ZXResultPoint alloc] initWithX:end y:rowNumber] autorelease], nil]
+ format:kBarcodeFormatUPCEANExtension] autorelease];
+ if (extensionData != nil) {
+ [extensionResult putAllMetadata:extensionData];
+ }
+ return extensionResult;
+}
+
+- (int)decodeMiddle:(ZXBitArray *)row startRange:(NSRange)startRange result:(NSMutableString *)result error:(NSError **)error {
+ const int countersLen = 4;
+ int counters[countersLen];
+ memset(counters, 0, countersLen * sizeof(int));
+
+ int end = [row size];
+ int rowOffset = NSMaxRange(startRange);
+
+ int lgPatternFound = 0;
+
+ for (int x = 0; x < 5 && rowOffset < end; x++) {
+ int bestMatch = [ZXUPCEANReader decodeDigit:row counters:counters countersLen:countersLen rowOffset:rowOffset patternType:UPC_EAN_PATTERNS_L_AND_G_PATTERNS error:error];
+ if (bestMatch == -1) {
+ return -1;
+ }
+ [result appendFormat:@"%C", (unichar)('0' + bestMatch % 10)];
+ for (int i = 0; i < countersLen; i++) {
+ rowOffset += counters[i];
+ }
+ if (bestMatch >= 10) {
+ lgPatternFound |= 1 << (4 - x);
+ }
+ if (x != 4) {
+ rowOffset = [row nextSet:rowOffset];
+ rowOffset = [row nextUnset:rowOffset];
+ }
+ }
+
+ if (result.length != 5) {
+ if (error) *error = NotFoundErrorInstance();
+ return -1;
+ }
+
+ int checkDigit = [self determineCheckDigit:lgPatternFound];
+ if (checkDigit == -1) {
+ if (error) *error = NotFoundErrorInstance();
+ return -1;
+ } else if ([self extensionChecksum:result] != checkDigit) {
+ if (error) *error = NotFoundErrorInstance();
+ return -1;
+ }
+
+ return rowOffset;
+}
+
+- (int)extensionChecksum:(NSString *)s {
+ int length = [s length];
+ int sum = 0;
+ for (int i = length - 2; i >= 0; i -= 2) {
+ sum += (int)[s characterAtIndex:i] - (int)'0';
+ }
+ sum *= 3;
+ for (int i = length - 1; i >= 0; i -= 2) {
+ sum += (int)[s characterAtIndex:i] - (int)'0';
+ }
+ sum *= 3;
+ return sum % 10;
+}
+
+- (int)determineCheckDigit:(int)lgPatternFound {
+ for (int d = 0; d < 10; d++) {
+ if (lgPatternFound == CHECK_DIGIT_ENCODINGS[d]) {
+ return d;
+ }
+ }
+ return -1;
+}
+
+- (NSMutableDictionary *)parseExtensionString:(NSString *)raw {
+ if (raw.length != 5) {
+ return nil;
+ }
+ id value = [self parseExtension5String:raw];
+ if (value) {
+ return [NSMutableDictionary dictionaryWithObject:value forKey:[NSNumber numberWithInt:kResultMetadataTypeSuggestedPrice]];
+ } else {
+ return nil;
+ }
+}
+
+- (NSString *)parseExtension5String:(NSString *)raw {
+ NSString *currency;
+ switch ([raw characterAtIndex:0]) {
+ case '0':
+ currency = @"£";
+ break;
+ case '5':
+ currency = @"$";
+ break;
+ case '9':
+ if ([@"90000" isEqualToString:raw]) {
+ return nil;
+ }
+ if ([@"99991" isEqualToString:raw]) {
+ return @"0.00";
+ }
+ if ([@"99990" isEqualToString:raw]) {
+ return @"Used";
+ }
+ currency = @"";
+ break;
+ default:
+ currency = @"";
+ break;
+ }
+ int rawAmount = [[raw substringFromIndex:1] intValue];
+ NSString *unitsString = [[NSNumber numberWithInt:rawAmount / 100] stringValue];
+ int hundredths = rawAmount % 100;
+ NSString *hundredthsString = hundredths < 10 ?
+ [NSString stringWithFormat:@"0%d", hundredths] : [[NSNumber numberWithInt:hundredths] stringValue];
+ return [NSString stringWithFormat:@"%@%@.%@", currency, unitsString, hundredthsString];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtensionSupport.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtensionSupport.h
new file mode 100644
index 0000000000000000000000000000000000000000..b94101ca53573a86aa52debd2f87fe0067a9d110
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtensionSupport.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXBitArray, ZXResult;
+
+@interface ZXUPCEANExtensionSupport : NSObject
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row rowOffset:(int)rowOffset error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtensionSupport.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtensionSupport.m
new file mode 100644
index 0000000000000000000000000000000000000000..d7036f35a439402ca6e96be65303057894fa41cb
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANExtensionSupport.m
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXUPCEANExtensionSupport.h"
+#import "ZXUPCEANExtension2Support.h"
+#import "ZXUPCEANExtension5Support.h"
+#import "ZXUPCEANReader.h"
+
+#define EXTENSION_START_PATTERN_LEN 3
+const int EXTENSION_START_PATTERN[EXTENSION_START_PATTERN_LEN] = {1,1,2};
+
+@interface ZXUPCEANExtensionSupport ()
+
+@property (nonatomic, retain) ZXUPCEANExtension2Support *twoSupport;
+@property (nonatomic, retain) ZXUPCEANExtension5Support *fiveSupport;
+
+@end
+
+@implementation ZXUPCEANExtensionSupport
+
+@synthesize twoSupport;
+@synthesize fiveSupport;
+
+- (id)init {
+ if (self = [super init]) {
+ self.twoSupport = [[[ZXUPCEANExtension2Support alloc] init] autorelease];
+ self.fiveSupport = [[[ZXUPCEANExtension5Support alloc] init] autorelease];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [twoSupport release];
+ [fiveSupport release];
+
+ [super dealloc];
+}
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row rowOffset:(int)rowOffset error:(NSError **)error {
+ NSRange extensionStartRange = [ZXUPCEANReader findGuardPattern:row rowOffset:rowOffset whiteFirst:NO pattern:(int *)EXTENSION_START_PATTERN patternLen:EXTENSION_START_PATTERN_LEN error:error];
+
+ ZXResult *result = [self.fiveSupport decodeRow:rowNumber row:row extensionStartRange:extensionStartRange error:error];
+ if (!result) {
+ result = [self.twoSupport decodeRow:rowNumber row:row extensionStartRange:extensionStartRange error:error];
+ }
+
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..225210c122740686af58e9d45db021b5c2b78c83
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANReader.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeFormat.h"
+#import "ZXOneDReader.h"
+
+/**
+ * Encapsulates functionality and implementation that is common to UPC and EAN families
+ * of one-dimensional barcodes.
+ */
+
+typedef enum {
+ UPC_EAN_PATTERNS_L_PATTERNS = 0,
+ UPC_EAN_PATTERNS_L_AND_G_PATTERNS
+} UPC_EAN_PATTERNS;
+
+#define START_END_PATTERN_LEN 3
+extern const int START_END_PATTERN[];
+#define MIDDLE_PATTERN_LEN 5
+extern const int MIDDLE_PATTERN[];
+#define L_PATTERNS_LEN 10
+#define L_PATTERNS_SUB_LEN 4
+extern const int L_PATTERNS[][4];
+extern const int L_AND_G_PATTERNS[][4];
+
+@class ZXDecodeHints, ZXEANManufacturerOrgSupport, ZXResult, ZXUPCEANExtensionSupport;
+
+@interface ZXUPCEANReader : ZXOneDReader
+
++ (NSRange)findStartGuardPattern:(ZXBitArray *)row error:(NSError **)error;
+- (ZXBarcodeFormat)barcodeFormat;
+- (BOOL)checkChecksum:(NSString *)s error:(NSError **)error;
++ (BOOL)checkStandardUPCEANChecksum:(NSString *)s;
++ (int)decodeDigit:(ZXBitArray *)row counters:(int[])counters countersLen:(int)countersLen rowOffset:(int)rowOffset patternType:(UPC_EAN_PATTERNS)patternType error:(NSError **)error;
+- (NSRange)decodeEnd:(ZXBitArray *)row endStart:(int)endStart error:(NSError **)error;
+- (int)decodeMiddle:(ZXBitArray *)row startRange:(NSRange)startRange result:(NSMutableString *)result error:(NSError **)error;
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row startGuardRange:(NSRange)startGuardRange hints:(ZXDecodeHints *)hints error:(NSError **)error;
++ (NSRange)findGuardPattern:(ZXBitArray *)row rowOffset:(int)rowOffset whiteFirst:(BOOL)whiteFirst pattern:(int *)pattern patternLen:(int)patternLen error:(NSError **)error;
++ (NSRange)findGuardPattern:(ZXBitArray *)row rowOffset:(int)rowOffset whiteFirst:(BOOL)whiteFirst pattern:(int *)pattern patternLen:(int)patternLen counters:(int *)counters error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..326a740fdfb0dab13fbca8b56fdf7c1b250f8e89
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANReader.m
@@ -0,0 +1,379 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXDecodeHints.h"
+#import "ZXEANManufacturerOrgSupport.h"
+#import "ZXErrors.h"
+#import "ZXResult.h"
+#import "ZXResultPoint.h"
+#import "ZXResultPointCallback.h"
+#import "ZXUPCEANReader.h"
+#import "ZXUPCEANExtensionSupport.h"
+
+#define MAX_AVG_VARIANCE (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.48f)
+#define MAX_INDIVIDUAL_VARIANCE (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.7f)
+
+/**
+ * Start/end guard pattern.
+ */
+const int START_END_PATTERN[START_END_PATTERN_LEN] = {1, 1, 1};
+
+/**
+ * Pattern marking the middle of a UPC/EAN pattern, separating the two halves.
+ */
+const int MIDDLE_PATTERN[MIDDLE_PATTERN_LEN] = {1, 1, 1, 1, 1};
+
+/**
+ * "Odd", or "L" patterns used to encode UPC/EAN digits.
+ */
+const int L_PATTERNS[L_PATTERNS_LEN][L_PATTERNS_SUB_LEN] = {
+ {3, 2, 1, 1}, // 0
+ {2, 2, 2, 1}, // 1
+ {2, 1, 2, 2}, // 2
+ {1, 4, 1, 1}, // 3
+ {1, 1, 3, 2}, // 4
+ {1, 2, 3, 1}, // 5
+ {1, 1, 1, 4}, // 6
+ {1, 3, 1, 2}, // 7
+ {1, 2, 1, 3}, // 8
+ {3, 1, 1, 2} // 9
+};
+
+/**
+ * As above but also including the "even", or "G" patterns used to encode UPC/EAN digits.
+ */
+#define L_AND_G_PATTERNS_LEN 20
+#define L_AND_G_PATTERNS_SUB_LEN 4
+const int L_AND_G_PATTERNS[L_AND_G_PATTERNS_LEN][L_AND_G_PATTERNS_SUB_LEN] = {
+ {3, 2, 1, 1}, // 0
+ {2, 2, 2, 1}, // 1
+ {2, 1, 2, 2}, // 2
+ {1, 4, 1, 1}, // 3
+ {1, 1, 3, 2}, // 4
+ {1, 2, 3, 1}, // 5
+ {1, 1, 1, 4}, // 6
+ {1, 3, 1, 2}, // 7
+ {1, 2, 1, 3}, // 8
+ {3, 1, 1, 2}, // 9
+ {1, 1, 2, 3}, // 10 reversed 0
+ {1, 2, 2, 2}, // 11 reversed 1
+ {2, 2, 1, 2}, // 12 reversed 2
+ {1, 1, 4, 1}, // 13 reversed 3
+ {2, 3, 1, 1}, // 14 reversed 4
+ {1, 3, 2, 1}, // 15 reversed 5
+ {4, 1, 1, 1}, // 16 reversed 6
+ {2, 1, 3, 1}, // 17 reversed 7
+ {3, 1, 2, 1}, // 18 reversed 8
+ {2, 1, 1, 3} // 19 reversed 9
+};
+
+@interface ZXUPCEANReader ()
+
+@property (nonatomic, retain) NSMutableString *decodeRowNSMutableString;
+@property (nonatomic, retain) ZXUPCEANExtensionSupport *extensionReader;
+@property (nonatomic, retain) ZXEANManufacturerOrgSupport *eanManSupport;
+
+@end
+
+@implementation ZXUPCEANReader
+
+@synthesize decodeRowNSMutableString;
+@synthesize extensionReader;
+@synthesize eanManSupport;
+
+- (id)init {
+ if (self = [super init]) {
+ self.decodeRowNSMutableString = [NSMutableString stringWithCapacity:20];
+ self.extensionReader = [[[ZXUPCEANExtensionSupport alloc] init] autorelease];
+ self.eanManSupport = [[[ZXEANManufacturerOrgSupport alloc] init] autorelease];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [decodeRowNSMutableString release];
+ [extensionReader release];
+ [eanManSupport release];
+
+ [super dealloc];
+}
+
++ (NSRange)findStartGuardPattern:(ZXBitArray *)row error:(NSError **)error {
+ BOOL foundStart = NO;
+ NSRange startRange = NSMakeRange(NSNotFound, 0);
+ int nextStart = 0;
+ int counters[START_END_PATTERN_LEN];
+
+ while (!foundStart) {
+ startRange = [self findGuardPattern:row rowOffset:nextStart whiteFirst:NO pattern:(int *)START_END_PATTERN patternLen:START_END_PATTERN_LEN counters:counters error:error];
+ if (startRange.location == NSNotFound) {
+ return startRange;
+ }
+ int start = startRange.location;
+ nextStart = NSMaxRange(startRange);
+ // Make sure there is a quiet zone at least as big as the start pattern before the barcode.
+ // If this check would run off the left edge of the image, do not accept this barcode,
+ // as it is very likely to be a false positive.
+ int quietStart = start - (nextStart - start);
+ if (quietStart >= 0) {
+ foundStart = [row isRange:quietStart end:start value:NO];
+ }
+ }
+ return startRange;
+}
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ return [self decodeRow:rowNumber row:row startGuardRange:[[self class] findStartGuardPattern:row error:error] hints:hints error:error];
+}
+
+/**
+ * Like decodeRow:row:hints:, but allows caller to inform method about where the UPC/EAN start pattern is
+ * found. This allows this to be computed once and reused across many implementations.
+ */
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row startGuardRange:(NSRange)startGuardRange hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ id<ZXResultPointCallback> resultPointCallback = hints == nil ? nil : hints.resultPointCallback;
+
+ if (resultPointCallback != nil) {
+ [resultPointCallback foundPossibleResultPoint:[[[ZXResultPoint alloc] initWithX:(startGuardRange.location + NSMaxRange(startGuardRange)) / 2.0f y:rowNumber] autorelease]];
+ }
+
+ NSMutableString *result = [NSMutableString string];
+ int endStart = [self decodeMiddle:row startRange:startGuardRange result:result error:error];
+ if (endStart == -1) {
+ return nil;
+ }
+
+ if (resultPointCallback != nil) {
+ [resultPointCallback foundPossibleResultPoint:[[[ZXResultPoint alloc] initWithX:endStart y:rowNumber] autorelease]];
+ }
+
+ NSRange endRange = [self decodeEnd:row endStart:endStart error:error];
+ if (endRange.location == NSNotFound) {
+ return nil;
+ }
+
+ if (resultPointCallback != nil) {
+ [resultPointCallback foundPossibleResultPoint:[[[ZXResultPoint alloc] initWithX:(endRange.location + NSMaxRange(endRange)) / 2.0f y:rowNumber] autorelease]];
+ }
+
+ // Make sure there is a quiet zone at least as big as the end pattern after the barcode. The
+ // spec might want more whitespace, but in practice this is the maximum we can count on.
+ int end = NSMaxRange(endRange);
+ int quietEnd = end + (end - endRange.location);
+ if (quietEnd >= [row size] || ![row isRange:end end:quietEnd value:NO]) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ NSString *resultString = [result description];
+ if (![self checkChecksum:resultString error:error]) {
+ if (error) *error = ChecksumErrorInstance();
+ return nil;
+ }
+
+ float left = (float)(NSMaxRange(startGuardRange) + startGuardRange.location) / 2.0f;
+ float right = (float)(NSMaxRange(endRange) + endRange.location) / 2.0f;
+ ZXBarcodeFormat format = [self barcodeFormat];
+ ZXResult *decodeResult = [ZXResult resultWithText:resultString
+ rawBytes:NULL
+ length:0
+ resultPoints:[NSArray arrayWithObjects:[[[ZXResultPoint alloc] initWithX:left y:(float)rowNumber] autorelease], [[[ZXResultPoint alloc] initWithX:right y:(float)rowNumber] autorelease], nil]
+ format:format];
+
+ ZXResult *extensionResult = [extensionReader decodeRow:rowNumber row:row rowOffset:NSMaxRange(endRange) error:error];
+ if (extensionResult) {
+ [decodeResult putMetadata:kResultMetadataTypeUPCEANExtension value:extensionResult.text];
+ [decodeResult putAllMetadata:[extensionResult resultMetadata]];
+ [decodeResult addResultPoints:[extensionResult resultPoints]];
+ }
+
+ if (format == kBarcodeFormatEan13 || format == kBarcodeFormatUPCA) {
+ NSString *countryID = [eanManSupport lookupCountryIdentifier:resultString];
+ if (countryID != nil) {
+ [decodeResult putMetadata:kResultMetadataTypePossibleCountry value:countryID];
+ }
+ }
+ return decodeResult;
+}
+
+- (BOOL)checkChecksum:(NSString *)s error:(NSError **)error {
+ if ([[self class] checkStandardUPCEANChecksum:s]) {
+ return YES;
+ } else {
+ if (error) *error = FormatErrorInstance();
+ return NO;
+ }
+}
+
+
+/**
+ * Computes the UPC/EAN checksum on a string of digits, and reports
+ * whether the checksum is correct or not.
+ */
++ (BOOL)checkStandardUPCEANChecksum:(NSString *)s {
+ int length = [s length];
+ if (length == 0) {
+ return NO;
+ }
+ int sum = 0;
+
+ for (int i = length - 2; i >= 0; i -= 2) {
+ int digit = (int)[s characterAtIndex:i] - (int)'0';
+ if (digit < 0 || digit > 9) {
+ return NO;
+ }
+ sum += digit;
+ }
+
+ sum *= 3;
+
+ for (int i = length - 1; i >= 0; i -= 2) {
+ int digit = (int)[s characterAtIndex:i] - (int)'0';
+ if (digit < 0 || digit > 9) {
+ return NO;
+ }
+ sum += digit;
+ }
+
+ return sum % 10 == 0;
+}
+
+- (NSRange)decodeEnd:(ZXBitArray *)row endStart:(int)endStart error:(NSError **)error {
+ return [[self class] findGuardPattern:row rowOffset:endStart whiteFirst:NO pattern:(int *)START_END_PATTERN patternLen:START_END_PATTERN_LEN error:error];
+}
+
++ (NSRange)findGuardPattern:(ZXBitArray *)row rowOffset:(int)rowOffset whiteFirst:(BOOL)whiteFirst pattern:(int *)pattern patternLen:(int)patternLen error:(NSError **)error {
+ int counters[patternLen];
+ return [self findGuardPattern:row rowOffset:rowOffset whiteFirst:whiteFirst pattern:pattern patternLen:patternLen counters:counters error:error];
+}
+
++ (NSRange)findGuardPattern:(ZXBitArray *)row rowOffset:(int)rowOffset whiteFirst:(BOOL)whiteFirst pattern:(int *)pattern patternLen:(int)patternLen counters:(int *)counters error:(NSError **)error {
+ int patternLength = patternLen;
+ memset(counters, 0, patternLength * sizeof(int));
+ int width = row.size;
+
+ BOOL isWhite = whiteFirst;
+ rowOffset = whiteFirst ? [row nextUnset:rowOffset] : [row nextSet:rowOffset];
+ int counterPosition = 0;
+ int patternStart = rowOffset;
+
+ for (int x = rowOffset; x < width; x++) {
+ if ([row get:x] ^ isWhite) {
+ counters[counterPosition]++;
+ } else {
+ if (counterPosition == patternLength - 1) {
+ if ([self patternMatchVariance:counters countersSize:patternLength pattern:pattern maxIndividualVariance:MAX_INDIVIDUAL_VARIANCE] < MAX_AVG_VARIANCE) {
+ return NSMakeRange(patternStart, x - patternStart);
+ }
+ patternStart += counters[0] + counters[1];
+
+ for (int y = 2; y < patternLength; y++) {
+ counters[y - 2] = counters[y];
+ }
+
+ counters[patternLength - 2] = 0;
+ counters[patternLength - 1] = 0;
+ counterPosition--;
+ } else {
+ counterPosition++;
+ }
+ counters[counterPosition] = 1;
+ isWhite = !isWhite;
+ }
+ }
+
+ if (error) *error = NotFoundErrorInstance();
+ return NSMakeRange(NSNotFound, 0);
+}
+
+
+/**
+ * Attempts to decode a single UPC/EAN-encoded digit.
+ */
++ (int)decodeDigit:(ZXBitArray *)row counters:(int[])counters countersLen:(int)countersLen rowOffset:(int)rowOffset patternType:(UPC_EAN_PATTERNS)patternType error:(NSError **)error {
+ if (![self recordPattern:row start:rowOffset counters:counters countersSize:countersLen]) {
+ if (error) *error = NotFoundErrorInstance();
+ return -1;
+ }
+ int bestVariance = MAX_AVG_VARIANCE;
+ int bestMatch = -1;
+ int max = 0;
+ switch (patternType) {
+ case UPC_EAN_PATTERNS_L_PATTERNS:
+ max = L_PATTERNS_LEN;
+ for (int i = 0; i < max; i++) {
+ int pattern[countersLen];
+ for(int j = 0; j < countersLen; j++){
+ pattern[j] = L_PATTERNS[i][j];
+ }
+
+ int variance = [self patternMatchVariance:counters countersSize:countersLen pattern:pattern maxIndividualVariance:MAX_INDIVIDUAL_VARIANCE];
+ if (variance < bestVariance) {
+ bestVariance = variance;
+ bestMatch = i;
+ }
+ }
+ break;
+ case UPC_EAN_PATTERNS_L_AND_G_PATTERNS:
+ max = L_AND_G_PATTERNS_LEN;
+ for (int i = 0; i < max; i++) {
+ int pattern[countersLen];
+ for(int j = 0; j< countersLen; j++){
+ pattern[j] = L_AND_G_PATTERNS[i][j];
+ }
+
+ int variance = [self patternMatchVariance:counters countersSize:countersLen pattern:pattern maxIndividualVariance:MAX_INDIVIDUAL_VARIANCE];
+ if (variance < bestVariance) {
+ bestVariance = variance;
+ bestMatch = i;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (bestMatch >= 0) {
+ return bestMatch;
+ } else {
+ if (error) *error = NotFoundErrorInstance();
+ return -1;
+ }
+}
+
+/**
+ * Get the format of this decoder.
+ */
+- (ZXBarcodeFormat)barcodeFormat {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+
+/**
+ * Subclasses override this to decode the portion of a barcode between the start
+ * and end guard patterns.
+ */
+- (int)decodeMiddle:(ZXBitArray *)row startRange:(NSRange)startRange result:(NSMutableString *)result error:(NSError **)error {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANWriter.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..0236191a5e830ccdaa924217e1d0817fda55c6f3
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANWriter.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXOneDimensionalCodeWriter.h"
+
+/**
+ * Encapsulates functionality and implementation that is common to UPC and EAN families
+ * of one-dimensional barcodes.
+ */
+
+@interface ZXUPCEANWriter : ZXOneDimensionalCodeWriter
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANWriter.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANWriter.m
new file mode 100644
index 0000000000000000000000000000000000000000..84b1b3b14f540c9d9eae8e98d73740fb6cd94126
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEANWriter.m
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeFormat.h"
+#import "ZXBitMatrix.h"
+#import "ZXUPCEANReader.h"
+#import "ZXUPCEANWriter.h"
+
+@implementation ZXUPCEANWriter
+
+- (int)defaultMargin {
+ // Use a different default more appropriate for UPC/EAN
+ return START_END_PATTERN_LEN;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..b64c56aaae152c09a5ff89c5020e5812117e3d9d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEReader.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeFormat.h"
+#import "ZXUPCEANReader.h"
+
+/**
+ * Implements decoding of the UPC-E format.
+ *
+ * http://www.barcodeisland.com/upce.phtml is a great reference for UPC-E information.
+ */
+
+@interface ZXUPCEReader : ZXUPCEANReader
+
++ (NSString *)convertUPCEtoUPCA:(NSString *)upce;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..94b73257bd4babb5c66cabd7c1a3709da01df5e8
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/ZXUPCEReader.m
@@ -0,0 +1,166 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXErrors.h"
+#import "ZXUPCEReader.h"
+
+/**
+ * The pattern that marks the middle, and end, of a UPC-E pattern.
+ * There is no "second half" to a UPC-E barcode.
+ */
+#define MIDDLE_END_PATTERN_LEN 6
+const int MIDDLE_END_PATTERN[MIDDLE_END_PATTERN_LEN] = {1, 1, 1, 1, 1, 1};
+
+/**
+ * See {@link #L_AND_G_PATTERNS}; these values similarly represent patterns of
+ * even-odd parity encodings of digits that imply both the number system (0 or 1)
+ * used, and the check digit.
+ */
+const int NUMSYS_AND_CHECK_DIGIT_PATTERNS[2][10] = {
+ {0x38, 0x34, 0x32, 0x31, 0x2C, 0x26, 0x23, 0x2A, 0x29, 0x25},
+ {0x07, 0x0B, 0x0D, 0x0E, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A}
+};
+
+@interface ZXUPCEReader ()
+
+@property (nonatomic, assign) int *decodeMiddleCounters;
+
+- (BOOL)determineNumSysAndCheckDigit:(NSMutableString *)resultString lgPatternFound:(int)lgPatternFound;
+
+@end
+
+@implementation ZXUPCEReader
+
+@synthesize decodeMiddleCounters;
+
+- (id)init {
+ if (self = [super init]) {
+ self.decodeMiddleCounters = (int *)malloc(sizeof(4) * sizeof(int));
+ self.decodeMiddleCounters[0] = 0;
+ self.decodeMiddleCounters[1] = 0;
+ self.decodeMiddleCounters[2] = 0;
+ self.decodeMiddleCounters[3] = 0;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ if (self.decodeMiddleCounters != NULL) {
+ free(self.decodeMiddleCounters);
+ self.decodeMiddleCounters = NULL;
+ }
+
+ [super dealloc];
+}
+
+- (int)decodeMiddle:(ZXBitArray *)row startRange:(NSRange)startRange result:(NSMutableString *)result error:(NSError **)error {
+ const int countersLen = 4;
+ int counters[countersLen];
+ memset(counters, 0, countersLen * sizeof(int));
+
+ int end = [row size];
+ int rowOffset = NSMaxRange(startRange);
+ int lgPatternFound = 0;
+
+ for (int x = 0; x < 6 && rowOffset < end; x++) {
+ int bestMatch = [ZXUPCEANReader decodeDigit:row counters:counters countersLen:countersLen rowOffset:rowOffset patternType:UPC_EAN_PATTERNS_L_AND_G_PATTERNS error:error];
+ if (bestMatch == -1) {
+ return -1;
+ }
+ [result appendFormat:@"%C", (unichar)('0' + bestMatch % 10)];
+
+ for (int i = 0; i < sizeof(counters) / sizeof(int); i++) {
+ rowOffset += counters[i];
+ }
+
+ if (bestMatch >= 10) {
+ lgPatternFound |= 1 << (5 - x);
+ }
+ }
+
+ if (![self determineNumSysAndCheckDigit:result lgPatternFound:lgPatternFound]) {
+ if (error) *error = NotFoundErrorInstance();
+ return -1;
+ }
+ return rowOffset;
+}
+
+- (NSRange)decodeEnd:(ZXBitArray *)row endStart:(int)endStart error:(NSError **)error {
+ return [ZXUPCEANReader findGuardPattern:row rowOffset:endStart whiteFirst:YES pattern:(int *)MIDDLE_END_PATTERN patternLen:MIDDLE_END_PATTERN_LEN error:error];
+}
+
+- (BOOL)checkChecksum:(NSString *)s error:(NSError **)error {
+ return [super checkChecksum:[ZXUPCEReader convertUPCEtoUPCA:s] error:error];
+}
+
+- (BOOL)determineNumSysAndCheckDigit:(NSMutableString *)resultString lgPatternFound:(int)lgPatternFound {
+ for (int numSys = 0; numSys <= 1; numSys++) {
+ for (int d = 0; d < 10; d++) {
+ if (lgPatternFound == NUMSYS_AND_CHECK_DIGIT_PATTERNS[numSys][d]) {
+ [resultString insertString:[NSString stringWithFormat:@"%C", (unichar)('0' + numSys)] atIndex:0];
+ [resultString appendFormat:@"%C", (unichar)('0' + d)];
+ return YES;
+ }
+ }
+ }
+
+ return NO;
+}
+
+- (ZXBarcodeFormat)barcodeFormat {
+ return kBarcodeFormatUPCE;
+}
+
+/**
+ * Expands a UPC-E value back into its full, equivalent UPC-A code value.
+ */
++ (NSString *)convertUPCEtoUPCA:(NSString *)upce {
+ NSString *upceChars = [upce substringWithRange:NSMakeRange(1, 6)];
+ NSMutableString *result = [NSMutableString stringWithCapacity:12];
+ [result appendFormat:@"%C", [upce characterAtIndex:0]];
+ unichar lastChar = [upceChars characterAtIndex:5];
+ switch (lastChar) {
+ case '0':
+ case '1':
+ case '2':
+ [result appendString:[upceChars substringToIndex:2]];
+ [result appendFormat:@"%C", lastChar];
+ [result appendString:@"0000"];
+ [result appendString:[upceChars substringWithRange:NSMakeRange(2, 3)]];
+ break;
+ case '3':
+ [result appendString:[upceChars substringToIndex:3]];
+ [result appendString:@"00000"];
+ [result appendString:[upceChars substringWithRange:NSMakeRange(3, 2)]];
+ break;
+ case '4':
+ [result appendString:[upceChars substringToIndex:4]];
+ [result appendString:@"00000"];
+ [result appendString:[upceChars substringWithRange:NSMakeRange(4, 1)]];
+ break;
+ default:
+ [result appendString:[upceChars substringToIndex:5]];
+ [result appendString:@"0000"];
+ [result appendFormat:@"%C", lastChar];
+ break;
+ }
+ [result appendFormat:@"%C", [upce characterAtIndex:7]];
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXAbstractRSSReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXAbstractRSSReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..1737ba13b584c500a6ac6cf8a44cfd837fead0ff
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXAbstractRSSReader.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXOneDReader.h"
+
+typedef enum {
+ RSS_PATTERNS_RSS14_PATTERNS = 0,
+ RSS_PATTERNS_RSS_EXPANDED_PATTERNS
+} RSS_PATTERNS;
+
+@interface ZXAbstractRSSReader : ZXOneDReader
+
+@property (nonatomic, assign, readonly) int *decodeFinderCounters;
+@property (nonatomic, assign, readonly) unsigned int decodeFinderCountersLen;
+@property (nonatomic, assign, readonly) int *dataCharacterCounters;
+@property (nonatomic, assign, readonly) unsigned int dataCharacterCountersLen;
+@property (nonatomic, assign, readonly) float *oddRoundingErrors;
+@property (nonatomic, assign, readonly) unsigned int oddRoundingErrorsLen;
+@property (nonatomic, assign, readonly) float *evenRoundingErrors;
+@property (nonatomic, assign, readonly) unsigned int evenRoundingErrorsLen;
+@property (nonatomic, assign, readonly) int *oddCounts;
+@property (nonatomic, assign, readonly) unsigned int oddCountsLen;
+@property (nonatomic, assign, readonly) int *evenCounts;
+@property (nonatomic, assign, readonly) unsigned int evenCountsLen;
+
++ (int)parseFinderValue:(int *)counters countersSize:(unsigned int)countersSize finderPatternType:(RSS_PATTERNS)finderPatternType;
++ (int)count:(int *)array arrayLen:(unsigned int)arrayLen;
++ (void)increment:(int *)array arrayLen:(unsigned int)arrayLen errors:(float *)errors;
++ (void)decrement:(int *)array arrayLen:(unsigned int)arrayLen errors:(float *)errors;
++ (BOOL)isFinderPattern:(int *)counters countersLen:(unsigned int)countersLen;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXAbstractRSSReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXAbstractRSSReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..8941ba3f4b08ba36abb71080cf39762d05d0e152
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXAbstractRSSReader.m
@@ -0,0 +1,232 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractRSSReader.h"
+
+static int MAX_AVG_VARIANCE;
+static int MAX_INDIVIDUAL_VARIANCE;
+
+float const MIN_FINDER_PATTERN_RATIO = 9.5f / 12.0f;
+float const MAX_FINDER_PATTERN_RATIO = 12.5f / 14.0f;
+
+#define RSS14_FINDER_PATTERNS_LEN 9
+#define RSS14_FINDER_PATTERNS_SUB_LEN 4
+const int RSS14_FINDER_PATTERNS[RSS14_FINDER_PATTERNS_LEN][RSS14_FINDER_PATTERNS_SUB_LEN] = {
+ {3,8,2,1},
+ {3,5,5,1},
+ {3,3,7,1},
+ {3,1,9,1},
+ {2,7,4,1},
+ {2,5,6,1},
+ {2,3,8,1},
+ {1,5,7,1},
+ {1,3,9,1},
+};
+
+#define RSS_EXPANDED_FINDER_PATTERNS_LEN 6
+#define RSS_EXPANDED_FINDER_PATTERNS_SUB_LEN 4
+const int RSS_EXPANDED_FINDER_PATTERNS[RSS_EXPANDED_FINDER_PATTERNS_LEN][RSS_EXPANDED_FINDER_PATTERNS_SUB_LEN] = {
+ {1,8,4,1}, // A
+ {3,6,4,1}, // B
+ {3,4,6,1}, // C
+ {3,2,8,1}, // D
+ {2,6,5,1}, // E
+ {2,2,9,1} // F
+};
+
+@interface ZXAbstractRSSReader ()
+
+@property (nonatomic, assign) int *decodeFinderCounters;
+@property (nonatomic, assign) unsigned int decodeFinderCountersLen;
+@property (nonatomic, assign) int *dataCharacterCounters;
+@property (nonatomic, assign) unsigned int dataCharacterCountersLen;
+@property (nonatomic, assign) float *oddRoundingErrors;
+@property (nonatomic, assign) unsigned int oddRoundingErrorsLen;
+@property (nonatomic, assign) float *evenRoundingErrors;
+@property (nonatomic, assign) unsigned int evenRoundingErrorsLen;
+@property (nonatomic, assign) int *oddCounts;
+@property (nonatomic, assign) unsigned int oddCountsLen;
+@property (nonatomic, assign) int *evenCounts;
+@property (nonatomic, assign) unsigned int evenCountsLen;
+
+@end
+
+@implementation ZXAbstractRSSReader
+
+@synthesize decodeFinderCounters;
+@synthesize decodeFinderCountersLen;
+@synthesize dataCharacterCounters;
+@synthesize dataCharacterCountersLen;
+@synthesize oddRoundingErrors;
+@synthesize oddRoundingErrorsLen;
+@synthesize evenRoundingErrors;
+@synthesize evenRoundingErrorsLen;
+@synthesize oddCounts;
+@synthesize oddCountsLen;
+@synthesize evenCounts;
+@synthesize evenCountsLen;
+
++ (void)initialize {
+ MAX_AVG_VARIANCE = (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.2f);
+ MAX_INDIVIDUAL_VARIANCE = (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.45f);
+}
+
+- (id)init {
+ if (self = [super init]) {
+ self.decodeFinderCountersLen = 4;
+ self.decodeFinderCounters = (int *)malloc(self.decodeFinderCountersLen * sizeof(int));
+ memset(self.decodeFinderCounters, 0, self.decodeFinderCountersLen * sizeof(int));
+
+ self.dataCharacterCountersLen = 8;
+ self.dataCharacterCounters = (int *)malloc(self.dataCharacterCountersLen * sizeof(int));
+ memset(self.dataCharacterCounters, 0, self.dataCharacterCountersLen * sizeof(int));
+
+ self.oddRoundingErrorsLen = 4;
+ self.oddRoundingErrors = (float *)malloc(self.oddRoundingErrorsLen * sizeof(float));
+ memset(self.oddRoundingErrors, 0, self.oddRoundingErrorsLen * sizeof(float));
+
+ self.evenRoundingErrorsLen = 4;
+ self.evenRoundingErrors = (float *)malloc(self.evenRoundingErrorsLen * sizeof(float));
+ memset(self.evenRoundingErrors, 0, self.evenRoundingErrorsLen * sizeof(float));
+
+ self.oddCountsLen = self.dataCharacterCountersLen / 2;
+ self.oddCounts = (int *)malloc(self.oddCountsLen * sizeof(int));
+ memset(self.oddCounts, 0, self.oddCountsLen * sizeof(int));
+
+ self.evenCountsLen = self.dataCharacterCountersLen / 2;
+ self.evenCounts = (int *)malloc(self.evenCountsLen * sizeof(int));
+ memset(self.evenCounts, 0, self.evenCountsLen * sizeof(int));
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ if (self.decodeFinderCounters != NULL) {
+ free(self.decodeFinderCounters);
+ self.decodeFinderCounters = NULL;
+ }
+
+ if (self.dataCharacterCounters != NULL) {
+ free(self.dataCharacterCounters);
+ self.dataCharacterCounters = NULL;
+ }
+
+ if (self.oddRoundingErrors != NULL) {
+ free(self.oddRoundingErrors);
+ self.oddRoundingErrors = NULL;
+ }
+
+ if (self.evenRoundingErrors != NULL) {
+ free(self.evenRoundingErrors);
+ self.evenRoundingErrors = NULL;
+ }
+
+ if (self.oddCounts != NULL) {
+ free(self.oddCounts);
+ self.oddCounts = NULL;
+ }
+
+ if (self.evenCounts != NULL) {
+ free(self.evenCounts);
+ self.evenCounts = NULL;
+ }
+
+ [super dealloc];
+}
+
++ (int)parseFinderValue:(int *)counters countersSize:(unsigned int)countersSize finderPatternType:(RSS_PATTERNS)finderPatternType {
+ switch (finderPatternType) {
+ case RSS_PATTERNS_RSS14_PATTERNS:
+ for (int value = 0; value < RSS14_FINDER_PATTERNS_LEN; value++) {
+ if ([self patternMatchVariance:counters countersSize:countersSize pattern:(int *)RSS14_FINDER_PATTERNS[value] maxIndividualVariance:MAX_INDIVIDUAL_VARIANCE] < MAX_AVG_VARIANCE) {
+ return value;
+ }
+ }
+ break;
+
+ case RSS_PATTERNS_RSS_EXPANDED_PATTERNS:
+ for (int value = 0; value < RSS_EXPANDED_FINDER_PATTERNS_LEN; value++) {
+ if ([self patternMatchVariance:counters countersSize:countersSize pattern:(int *)RSS_EXPANDED_FINDER_PATTERNS[value] maxIndividualVariance:MAX_INDIVIDUAL_VARIANCE] < MAX_AVG_VARIANCE) {
+ return value;
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return -1;
+}
+
++ (int)count:(int *)array arrayLen:(unsigned int)arrayLen {
+ int count = 0;
+
+ for (int i = 0; i < arrayLen; i++) {
+ count += array[i];
+ }
+
+ return count;
+}
+
++ (void)increment:(int *)array arrayLen:(unsigned int)arrayLen errors:(float *)errors {
+ int index = 0;
+ float biggestError = errors[0];
+ for (int i = 1; i < arrayLen; i++) {
+ if (errors[i] > biggestError) {
+ biggestError = errors[i];
+ index = i;
+ }
+ }
+ array[index]++;
+}
+
++ (void)decrement:(int *)array arrayLen:(unsigned int)arrayLen errors:(float *)errors {
+ int index = 0;
+ float biggestError = errors[0];
+ for (int i = 1; i < arrayLen; i++) {
+ if (errors[i] < biggestError) {
+ biggestError = errors[i];
+ index = i;
+ }
+ }
+ array[index]--;
+}
+
++ (BOOL)isFinderPattern:(int *)counters countersLen:(unsigned int)countersLen {
+ int firstTwoSum = counters[0] + counters[1];
+ int sum = firstTwoSum + counters[2] + counters[3];
+ float ratio = (float)firstTwoSum / (float)sum;
+ if (ratio >= MIN_FINDER_PATTERN_RATIO && ratio <= MAX_FINDER_PATTERN_RATIO) {
+ int minCounter = NSIntegerMax;
+ int maxCounter = NSIntegerMin;
+ for (int i = 0; i < countersLen; i++) {
+ int counter = counters[i];
+ if (counter > maxCounter) {
+ maxCounter = counter;
+ }
+ if (counter < minCounter) {
+ minCounter = counter;
+ }
+ }
+
+ return maxCounter < 10 * minCounter;
+ }
+ return NO;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXDataCharacter.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXDataCharacter.h
new file mode 100644
index 0000000000000000000000000000000000000000..21bb259c92a62acd678b625e54758da6824bdbf5
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXDataCharacter.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@interface ZXDataCharacter : NSObject
+
+@property (nonatomic, assign, readonly) int value;
+@property (nonatomic, assign, readonly) int checksumPortion;
+
+- (id)initWithValue:(int)value checksumPortion:(int)checksumPortion;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXDataCharacter.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXDataCharacter.m
new file mode 100644
index 0000000000000000000000000000000000000000..03a81418d528323c6917b716555badca5fbe7018
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXDataCharacter.m
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDataCharacter.h"
+
+@interface ZXDataCharacter ()
+
+@property (nonatomic, assign) int value;
+@property (nonatomic, assign) int checksumPortion;
+
+@end
+
+@implementation ZXDataCharacter
+
+@synthesize value;
+@synthesize checksumPortion;
+
+- (id)initWithValue:(int)aValue checksumPortion:(int)aChecksumPortion {
+ if (self = [super init]) {
+ self.value = aValue;
+ self.checksumPortion = aChecksumPortion;
+ }
+
+ return self;
+}
+
+- (NSString *)description {
+ return [NSString stringWithFormat:@"%d(%d)", self.value, self.checksumPortion];
+}
+
+- (BOOL)isEqual:(id)object {
+ if (![object isKindOfClass:[ZXDataCharacter class]]) {
+ return NO;
+ }
+
+ ZXDataCharacter *that = (ZXDataCharacter *)object;
+ return (self.value == that.value) && (self.checksumPortion == that.checksumPortion);
+}
+
+- (NSUInteger)hash {
+ return self.value ^ self.checksumPortion;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXPair.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXPair.h
new file mode 100644
index 0000000000000000000000000000000000000000..d888839a7cbd7bdcf6d8a90595954e9645ba3367
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXPair.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDataCharacter.h"
+
+@class ZXRSSFinderPattern;
+
+@interface ZXPair : ZXDataCharacter
+
+@property (nonatomic, assign, readonly) int count;
+@property (nonatomic, retain, readonly) ZXRSSFinderPattern *finderPattern;
+
+- (id)initWithValue:(int)value checksumPortion:(int)checksumPortion finderPattern:(ZXRSSFinderPattern *)finderPattern;
+- (void)incrementCount;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXPair.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXPair.m
new file mode 100644
index 0000000000000000000000000000000000000000..f00d7478b404ef64053dc6c195c820d4502f95a2
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXPair.m
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXRSSFinderPattern.h"
+#import "ZXPair.h"
+
+@interface ZXPair ()
+
+@property (nonatomic, assign) int count;
+@property (nonatomic, retain) ZXRSSFinderPattern *finderPattern;
+
+@end
+
+@implementation ZXPair
+
+@synthesize count;
+@synthesize finderPattern;
+
+- (id)initWithValue:(int)aValue checksumPortion:(int)aChecksumPortion finderPattern:(ZXRSSFinderPattern *)aFinderPattern {
+ if (self = [super initWithValue:aValue checksumPortion:aChecksumPortion]) {
+ self.finderPattern = aFinderPattern;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [finderPattern release];
+
+ [super dealloc];
+}
+
+
+- (void)incrementCount {
+ self.count++;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSS14Reader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSS14Reader.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d1b60f8a8816716cd20ed10c35bff36407422ce
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSS14Reader.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractRSSReader.h"
+
+/**
+ * Decodes RSS-14, including truncated and stacked variants. See ISO/IEC 24724:2006.
+ */
+
+@class ZXDecodeHints, ZXResult;
+
+@interface ZXRSS14Reader : ZXAbstractRSSReader
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSS14Reader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSS14Reader.m
new file mode 100644
index 0000000000000000000000000000000000000000..0fc57f6174bf75902866a3514b9cb2e44f47bd52
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSS14Reader.m
@@ -0,0 +1,469 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXBarcodeFormat.h"
+#import "ZXDecodeHints.h"
+#import "ZXErrors.h"
+#import "ZXPair.h"
+#import "ZXResult.h"
+#import "ZXResultPointCallback.h"
+#import "ZXRSS14Reader.h"
+#import "ZXRSSFinderPattern.h"
+#import "ZXRSSUtils.h"
+
+const int OUTSIDE_EVEN_TOTAL_SUBSET[5] = {1,10,34,70,126};
+const int INSIDE_ODD_TOTAL_SUBSET[4] = {4,20,48,81};
+const int OUTSIDE_GSUM[5] = {0,161,961,2015,2715};
+const int INSIDE_GSUM[4] = {0,336,1036,1516};
+const int OUTSIDE_ODD_WIDEST[5] = {8,6,4,3,1};
+const int INSIDE_ODD_WIDEST[4] = {2,4,6,8};
+
+@interface ZXRSS14Reader ()
+
+@property (nonatomic, retain) NSMutableArray *possibleLeftPairs;
+@property (nonatomic, retain) NSMutableArray *possibleRightPairs;
+
+- (void)addOrTally:(NSMutableArray *)possiblePairs pair:(ZXPair *)pair;
+- (BOOL)adjustOddEvenCounts:(BOOL)outsideChar numModules:(int)numModules;
+- (BOOL)checkChecksum:(ZXPair *)leftPair rightPair:(ZXPair *)rightPair;
+- (ZXResult *)constructResult:(ZXPair *)leftPair rightPair:(ZXPair *)rightPair;
+- (ZXDataCharacter *)decodeDataCharacter:(ZXBitArray *)row pattern:(ZXRSSFinderPattern *)pattern outsideChar:(BOOL)outsideChar;
+- (ZXPair *)decodePair:(ZXBitArray *)row right:(BOOL)right rowNumber:(int)rowNumber hints:(ZXDecodeHints *)hints;
+- (NSArray *)findFinderPattern:(ZXBitArray *)row rowOffset:(int)rowOffset rightFinderPattern:(BOOL)rightFinderPattern;
+- (ZXRSSFinderPattern *)parseFoundFinderPattern:(ZXBitArray *)row rowNumber:(int)rowNumber right:(BOOL)right startEnd:(NSArray *)startEnd;
+
+@end
+
+@implementation ZXRSS14Reader
+
+@synthesize possibleLeftPairs;
+@synthesize possibleRightPairs;
+
+- (id)init {
+ if (self = [super init]) {
+ self.possibleLeftPairs = [NSMutableArray array];
+ self.possibleRightPairs = [NSMutableArray array];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [possibleLeftPairs release];
+ [possibleRightPairs release];
+
+ [super dealloc];
+}
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ ZXPair *leftPair = [self decodePair:row right:NO rowNumber:rowNumber hints:hints];
+ [self addOrTally:self.possibleLeftPairs pair:leftPair];
+ [row reverse];
+ ZXPair *rightPair = [self decodePair:row right:YES rowNumber:rowNumber hints:hints];
+ [self addOrTally:self.possibleRightPairs pair:rightPair];
+ [row reverse];
+
+ for (ZXPair *left in self.possibleLeftPairs) {
+ if ([left count] > 1) {
+ for (ZXPair *right in self.possibleRightPairs) {
+ if ([right count] > 1) {
+ if ([self checkChecksum:left rightPair:right]) {
+ return [self constructResult:left rightPair:right];
+ }
+ }
+ }
+ }
+ }
+
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+}
+
+- (void)addOrTally:(NSMutableArray *)possiblePairs pair:(ZXPair *)pair {
+ if (pair == nil) {
+ return;
+ }
+ BOOL found = NO;
+ for (ZXPair *other in possiblePairs) {
+ if (other.value == pair.value) {
+ [other incrementCount];
+ found = YES;
+ break;
+ }
+ }
+
+ if (!found) {
+ [possiblePairs addObject:pair];
+ }
+}
+
+- (void)reset {
+ [self.possibleLeftPairs removeAllObjects];
+ [self.possibleRightPairs removeAllObjects];
+}
+
+- (ZXResult *)constructResult:(ZXPair *)leftPair rightPair:(ZXPair *)rightPair {
+ long long symbolValue = 4537077LL * leftPair.value + rightPair.value;
+ NSString *text = [[NSNumber numberWithLongLong:symbolValue] stringValue];
+ NSMutableString *buffer = [NSMutableString stringWithCapacity:14];
+
+ for (int i = 13 - [text length]; i > 0; i--) {
+ [buffer appendString:@"0"];
+ }
+
+ [buffer appendString:text];
+ int checkDigit = 0;
+
+ for (int i = 0; i < 13; i++) {
+ int digit = [buffer characterAtIndex:i] - '0';
+ checkDigit += (i & 0x01) == 0 ? 3 * digit : digit;
+ }
+
+ checkDigit = 10 - (checkDigit % 10);
+ if (checkDigit == 10) {
+ checkDigit = 0;
+ }
+ [buffer appendFormat:@"%d", checkDigit];
+ NSArray *leftPoints = [[leftPair finderPattern] resultPoints];
+ NSArray *rightPoints = [[rightPair finderPattern] resultPoints];
+ return [ZXResult resultWithText:buffer
+ rawBytes:NULL
+ length:0
+ resultPoints:[NSArray arrayWithObjects:[leftPoints objectAtIndex:0], [leftPoints objectAtIndex:1], [rightPoints objectAtIndex:0], [rightPoints objectAtIndex:1], nil]
+ format:kBarcodeFormatRSS14];
+}
+
+- (BOOL)checkChecksum:(ZXPair *)leftPair rightPair:(ZXPair *)rightPair {
+// int leftFPValue = leftPair.finderPattern.value;
+// int rightFPValue = rightPair.finderPattern.value;
+// if ((leftFPValue == 0 && rightFPValue == 8) || (leftFPValue == 8 && rightFPValue == 0)) {
+// }
+ int checkValue = (leftPair.checksumPortion + 16 * rightPair.checksumPortion) % 79;
+ int targetCheckValue = 9 * leftPair.finderPattern.value + rightPair.finderPattern.value;
+ if (targetCheckValue > 72) {
+ targetCheckValue--;
+ }
+ if (targetCheckValue > 8) {
+ targetCheckValue--;
+ }
+ return checkValue == targetCheckValue;
+}
+
+- (ZXPair *)decodePair:(ZXBitArray *)row right:(BOOL)right rowNumber:(int)rowNumber hints:(ZXDecodeHints *)hints {
+ NSArray *startEnd = [self findFinderPattern:row rowOffset:0 rightFinderPattern:right];
+ if (!startEnd) {
+ return nil;
+ }
+ ZXRSSFinderPattern *pattern = [self parseFoundFinderPattern:row rowNumber:rowNumber right:right startEnd:startEnd];
+ if (!pattern) {
+ return nil;
+ }
+ id<ZXResultPointCallback> resultPointCallback = hints == nil ? nil : hints.resultPointCallback;
+ if (resultPointCallback != nil) {
+ float center = ([[startEnd objectAtIndex:0] intValue] + [[startEnd objectAtIndex:1] intValue]) / 2.0f;
+ if (right) {
+ center = [row size] - 1 - center;
+ }
+ [resultPointCallback foundPossibleResultPoint:[[[ZXResultPoint alloc] initWithX:center y:rowNumber] autorelease]];
+ }
+ ZXDataCharacter *outside = [self decodeDataCharacter:row pattern:pattern outsideChar:YES];
+ ZXDataCharacter *inside = [self decodeDataCharacter:row pattern:pattern outsideChar:NO];
+ if (!outside || !inside) {
+ return nil;
+ }
+ return [[[ZXPair alloc] initWithValue:1597 * outside.value + inside.value
+ checksumPortion:outside.checksumPortion + 4 * inside.checksumPortion
+ finderPattern:pattern] autorelease];
+}
+
+- (ZXDataCharacter *)decodeDataCharacter:(ZXBitArray *)row pattern:(ZXRSSFinderPattern *)pattern outsideChar:(BOOL)outsideChar {
+ int countersLen = self.dataCharacterCountersLen;
+ int *counters = self.dataCharacterCounters;
+ counters[0] = 0;
+ counters[1] = 0;
+ counters[2] = 0;
+ counters[3] = 0;
+ counters[4] = 0;
+ counters[5] = 0;
+ counters[6] = 0;
+ counters[7] = 0;
+
+ if (outsideChar) {
+ if (![ZXOneDReader recordPatternInReverse:row start:[[[pattern startEnd] objectAtIndex:0] intValue] counters:counters countersSize:countersLen]) {
+ return nil;
+ }
+ } else {
+ if (![ZXOneDReader recordPattern:row start:[[[pattern startEnd] objectAtIndex:1] intValue] counters:counters countersSize:countersLen]) {
+ return nil;
+ }
+
+ for (int i = 0, j = countersLen - 1; i < j; i++, j--) {
+ int temp = counters[i];
+ counters[i] = counters[j];
+ counters[j] = temp;
+ }
+ }
+
+ int numModules = outsideChar ? 16 : 15;
+ float elementWidth = (float)[ZXAbstractRSSReader count:counters arrayLen:countersLen] / (float)numModules;
+
+ for (int i = 0; i < countersLen; i++) {
+ float value = (float) counters[i] / elementWidth;
+ int count = (int)(value + 0.5f);
+ if (count < 1) {
+ count = 1;
+ } else if (count > 8) {
+ count = 8;
+ }
+ int offset = i >> 1;
+ if ((i & 0x01) == 0) {
+ self.oddCounts[offset] = count;
+ self.oddRoundingErrors[offset] = value - count;
+ } else {
+ self.evenCounts[offset] = count;
+ self.evenRoundingErrors[offset] = value - count;
+ }
+ }
+
+ if (![self adjustOddEvenCounts:outsideChar numModules:numModules]) {
+ return nil;
+ }
+
+ int oddSum = 0;
+ int oddChecksumPortion = 0;
+ for (int i = self.oddCountsLen - 1; i >= 0; i--) {
+ oddChecksumPortion *= 9;
+ oddChecksumPortion += self.oddCounts[i];
+ oddSum += self.oddCounts[i];
+ }
+ int evenChecksumPortion = 0;
+ int evenSum = 0;
+ for (int i = self.evenCountsLen - 1; i >= 0; i--) {
+ evenChecksumPortion *= 9;
+ evenChecksumPortion += self.evenCounts[i];
+ evenSum += self.evenCounts[i];
+ }
+ int checksumPortion = oddChecksumPortion + 3 * evenChecksumPortion;
+
+ if (outsideChar) {
+ if ((oddSum & 0x01) != 0 || oddSum > 12 || oddSum < 4) {
+ return nil;
+ }
+ int group = (12 - oddSum) / 2;
+ int oddWidest = OUTSIDE_ODD_WIDEST[group];
+ int evenWidest = 9 - oddWidest;
+ int vOdd = [ZXRSSUtils rssValue:self.oddCounts widthsLen:self.oddCountsLen maxWidth:oddWidest noNarrow:NO];
+ int vEven = [ZXRSSUtils rssValue:self.evenCounts widthsLen:self.evenCountsLen maxWidth:evenWidest noNarrow:YES];
+ int tEven = OUTSIDE_EVEN_TOTAL_SUBSET[group];
+ int gSum = OUTSIDE_GSUM[group];
+ return [[[ZXDataCharacter alloc] initWithValue:vOdd * tEven + vEven + gSum checksumPortion:checksumPortion] autorelease];
+ } else {
+ if ((evenSum & 0x01) != 0 || evenSum > 10 || evenSum < 4) {
+ return nil;
+ }
+ int group = (10 - evenSum) / 2;
+ int oddWidest = INSIDE_ODD_WIDEST[group];
+ int evenWidest = 9 - oddWidest;
+ int vOdd = [ZXRSSUtils rssValue:self.oddCounts widthsLen:self.oddCountsLen maxWidth:oddWidest noNarrow:YES];
+ int vEven = [ZXRSSUtils rssValue:self.evenCounts widthsLen:self.evenCountsLen maxWidth:evenWidest noNarrow:NO];
+ int tOdd = INSIDE_ODD_TOTAL_SUBSET[group];
+ int gSum = INSIDE_GSUM[group];
+ return [[[ZXDataCharacter alloc] initWithValue:vEven * tOdd + vOdd + gSum checksumPortion:checksumPortion] autorelease];
+ }
+}
+
+- (NSArray *)findFinderPattern:(ZXBitArray *)row rowOffset:(int)rowOffset rightFinderPattern:(BOOL)rightFinderPattern {
+ int countersLen = self.decodeFinderCountersLen;
+ int *counters = self.decodeFinderCounters;
+ counters[0] = 0;
+ counters[1] = 0;
+ counters[2] = 0;
+ counters[3] = 0;
+
+ int width = row.size;
+ BOOL isWhite = NO;
+ while (rowOffset < width) {
+ isWhite = ![row get:rowOffset];
+ if (rightFinderPattern == isWhite) {
+ break;
+ }
+ rowOffset++;
+ }
+
+ int counterPosition = 0;
+ int patternStart = rowOffset;
+ for (int x = rowOffset; x < width; x++) {
+ if ([row get:x] ^ isWhite) {
+ counters[counterPosition]++;
+ } else {
+ if (counterPosition == 3) {
+ if ([ZXAbstractRSSReader isFinderPattern:counters countersLen:countersLen]) {
+ return [NSArray arrayWithObjects:[NSNumber numberWithInt:patternStart], [NSNumber numberWithInt:x], nil];
+ }
+ patternStart += counters[0] + counters[1];
+ counters[0] = counters[2];
+ counters[1] = counters[3];
+ counters[2] = 0;
+ counters[3] = 0;
+ counterPosition--;
+ } else {
+ counterPosition++;
+ }
+ counters[counterPosition] = 1;
+ isWhite = !isWhite;
+ }
+ }
+
+ return nil;
+}
+
+- (ZXRSSFinderPattern *)parseFoundFinderPattern:(ZXBitArray *)row rowNumber:(int)rowNumber right:(BOOL)right startEnd:(NSArray *)startEnd {
+ BOOL firstIsBlack = [row get:[[startEnd objectAtIndex:0] intValue]];
+ int firstElementStart = [[startEnd objectAtIndex:0] intValue] - 1;
+
+ while (firstElementStart >= 0 && firstIsBlack ^ [row get:firstElementStart]) {
+ firstElementStart--;
+ }
+
+ firstElementStart++;
+ int firstCounter = [[startEnd objectAtIndex:0] intValue] - firstElementStart;
+
+ int countersLen = self.decodeFinderCountersLen;
+ int *counters = self.decodeFinderCounters;
+ for (int i = countersLen - 1; i > 0; i--) {
+ counters[i] = counters[i-1];
+ }
+ counters[0] = firstCounter;
+ int value = [ZXAbstractRSSReader parseFinderValue:counters countersSize:countersLen finderPatternType:RSS_PATTERNS_RSS14_PATTERNS];
+ if (value == -1) {
+ return nil;
+ }
+ int start = firstElementStart;
+ int end = [[startEnd objectAtIndex:1] intValue];
+ if (right) {
+ start = [row size] - 1 - start;
+ end = [row size] - 1 - end;
+ }
+ return [[[ZXRSSFinderPattern alloc] initWithValue:value
+ startEnd:[NSArray arrayWithObjects:[NSNumber numberWithInt:firstElementStart], [startEnd objectAtIndex:1], nil]
+ start:start
+ end:end
+ rowNumber:rowNumber] autorelease];
+}
+
+- (BOOL)adjustOddEvenCounts:(BOOL)outsideChar numModules:(int)numModules {
+ int oddSum = [ZXAbstractRSSReader count:self.oddCounts arrayLen:self.oddCountsLen];
+ int evenSum = [ZXAbstractRSSReader count:self.evenCounts arrayLen:self.evenCountsLen];
+ int mismatch = oddSum + evenSum - numModules;
+ BOOL oddParityBad = (oddSum & 0x01) == (outsideChar ? 1 : 0);
+ BOOL evenParityBad = (evenSum & 0x01) == 1;
+
+ BOOL incrementOdd = NO;
+ BOOL decrementOdd = NO;
+ BOOL incrementEven = NO;
+ BOOL decrementEven = NO;
+
+ if (outsideChar) {
+ if (oddSum > 12) {
+ decrementOdd = YES;
+ } else if (oddSum < 4) {
+ incrementOdd = YES;
+ }
+ if (evenSum > 12) {
+ decrementEven = YES;
+ } else if (evenSum < 4) {
+ incrementEven = YES;
+ }
+ } else {
+ if (oddSum > 11) {
+ decrementOdd = YES;
+ } else if (oddSum < 5) {
+ incrementOdd = YES;
+ }
+ if (evenSum > 10) {
+ decrementEven = YES;
+ } else if (evenSum < 4) {
+ incrementEven = YES;
+ }
+ }
+
+ if (mismatch == 1) {
+ if (oddParityBad) {
+ if (evenParityBad) {
+ return NO;
+ }
+ decrementOdd = YES;
+ } else {
+ if (!evenParityBad) {
+ return NO;
+ }
+ decrementEven = YES;
+ }
+ } else if (mismatch == -1) {
+ if (oddParityBad) {
+ if (evenParityBad) {
+ return NO;
+ }
+ incrementOdd = YES;
+ } else {
+ if (!evenParityBad) {
+ return NO;
+ }
+ incrementEven = YES;
+ }
+ } else if (mismatch == 0) {
+ if (oddParityBad) {
+ if (!evenParityBad) {
+ return NO;
+ }
+ if (oddSum < evenSum) {
+ incrementOdd = YES;
+ decrementEven = YES;
+ } else {
+ decrementOdd = YES;
+ incrementEven = YES;
+ }
+ } else {
+ if (evenParityBad) {
+ return NO;
+ }
+ }
+ } else {
+ return NO;
+ }
+ if (incrementOdd) {
+ if (decrementOdd) {
+ return NO;
+ }
+ [ZXAbstractRSSReader increment:self.oddCounts arrayLen:self.oddCountsLen errors:self.oddRoundingErrors];
+ }
+ if (decrementOdd) {
+ [ZXAbstractRSSReader decrement:self.oddCounts arrayLen:self.oddCountsLen errors:self.oddRoundingErrors];
+ }
+ if (incrementEven) {
+ if (decrementEven) {
+ return NO;
+ }
+ [ZXAbstractRSSReader increment:self.evenCounts arrayLen:self.evenCountsLen errors:self.oddRoundingErrors];
+ }
+ if (decrementEven) {
+ [ZXAbstractRSSReader decrement:self.evenCounts arrayLen:self.evenCountsLen errors:self.evenRoundingErrors];
+ }
+ return YES;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSSFinderPattern.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSSFinderPattern.h
new file mode 100644
index 0000000000000000000000000000000000000000..5de00cf3c0657cb01be0eada1b85bd7fae0eb0a3
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSSFinderPattern.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultPoint.h"
+
+@interface ZXRSSFinderPattern : NSObject
+
+@property (nonatomic, assign, readonly) int value;
+@property (nonatomic, retain, readonly) NSMutableArray *startEnd;
+@property (nonatomic, retain, readonly) NSMutableArray *resultPoints;
+
+- (id)initWithValue:(int)value startEnd:(NSMutableArray *)startEnd start:(int)start end:(int)end rowNumber:(int)rowNumber;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSSFinderPattern.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSSFinderPattern.m
new file mode 100644
index 0000000000000000000000000000000000000000..f68c5f1100e4801fbf01baffb3b266c0268824f5
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSSFinderPattern.m
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXRSSFinderPattern.h"
+
+@interface ZXRSSFinderPattern ()
+
+@property (nonatomic, assign) int value;
+@property (nonatomic, retain) NSMutableArray *startEnd;
+@property (nonatomic, retain) NSMutableArray *resultPoints;
+
+@end
+
+@implementation ZXRSSFinderPattern
+
+@synthesize value;
+@synthesize startEnd;
+@synthesize resultPoints;
+
+- (id)initWithValue:(int)aValue startEnd:(NSMutableArray *)aStartEnd start:(int)aStart end:(int)anEnd rowNumber:(int)aRowNumber {
+ if (self = [super init]) {
+ self.value = aValue;
+ self.startEnd = aStartEnd;
+ self.resultPoints = [NSArray arrayWithObjects:
+ [[[ZXResultPoint alloc] initWithX:(float)aStart y:(float)aRowNumber] autorelease],
+ [[[ZXResultPoint alloc] initWithX:(float)anEnd y:(float)aRowNumber] autorelease],
+ nil];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [startEnd release];
+ [resultPoints release];
+
+ [super dealloc];
+}
+
+- (BOOL)isEqual:(id)object {
+ if (![object isKindOfClass:[ZXRSSFinderPattern class]]) {
+ return NO;
+ }
+
+ ZXRSSFinderPattern *that = (ZXRSSFinderPattern *)object;
+ return self.value == that.value;
+}
+
+- (NSUInteger)hash {
+ return self.value;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSSUtils.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSSUtils.h
new file mode 100644
index 0000000000000000000000000000000000000000..1613bb7794f87b726f6fd5b78a33ec1013256675
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSSUtils.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Adapted from listings in ISO/IEC 24724 Appendix B and Appendix G.
+ */
+
+@interface ZXRSSUtils : NSObject
+
++ (NSArray *)rssWidths:(int)val n:(int)n elements:(int)elements maxWidth:(int)maxWidth noNarrow:(BOOL)noNarrow;
++ (int)rssValue:(int *)widths widthsLen:(unsigned int)widthsLen maxWidth:(int)maxWidth noNarrow:(BOOL)noNarrow;
++ (NSArray *)elements:(NSArray *)eDist N:(int)N K:(int)K;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSSUtils.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSSUtils.m
new file mode 100644
index 0000000000000000000000000000000000000000..4343328c3d8f97d5bf0651452d319d1c5674eb35
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/ZXRSSUtils.m
@@ -0,0 +1,161 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXRSSUtils.h"
+
+@interface ZXRSSUtils ()
+
++ (int)combins:(int)n r:(int)r;
+
+@end
+
+@implementation ZXRSSUtils
+
++ (NSArray *)rssWidths:(int)val n:(int)n elements:(int)elements maxWidth:(int)maxWidth noNarrow:(BOOL)noNarrow {
+ NSMutableArray *widths = [NSMutableArray arrayWithCapacity:elements];
+ int bar;
+ int narrowMask = 0;
+ for (bar = 0; bar < elements - 1; bar++) {
+ narrowMask |= 1 << bar;
+ int elmWidth = 1;
+ int subVal;
+ while (YES) {
+ subVal = [self combins:n - elmWidth - 1 r:elements - bar - 2];
+ if (noNarrow && (narrowMask == 0) && (n - elmWidth - (elements - bar - 1) >= elements - bar - 1)) {
+ subVal -= [self combins:n - elmWidth - (elements - bar) r:elements - bar - 2];
+ }
+ if (elements - bar - 1 > 1) {
+ int lessVal = 0;
+ for (int mxwElement = n - elmWidth - (elements - bar - 2); mxwElement > maxWidth; mxwElement--) {
+ lessVal += [self combins:n - elmWidth - mxwElement - 1 r:elements - bar - 3];
+ }
+ subVal -= lessVal * (elements - 1 - bar);
+ } else if (n - elmWidth > maxWidth) {
+ subVal--;
+ }
+ val -= subVal;
+ if (val < 0) {
+ break;
+ }
+ elmWidth++;
+ narrowMask &= ~(1 << bar);
+ }
+ val += subVal;
+ n -= elmWidth;
+ [widths addObject:[NSNumber numberWithInt:elmWidth]];
+ }
+
+ [widths addObject:[NSNumber numberWithInt:n]];
+ return widths;
+}
+
++ (int)rssValue:(int *)widths widthsLen:(unsigned int)widthsLen maxWidth:(int)maxWidth noNarrow:(BOOL)noNarrow {
+ int elements = widthsLen;
+ int n = 0;
+ for (int i = 0; i < elements; i++) {
+ n += widths[i];
+ }
+ int val = 0;
+ int narrowMask = 0;
+ for (int bar = 0; bar < elements - 1; bar++) {
+ int elmWidth;
+ for (elmWidth = 1, narrowMask |= 1 << bar;
+ elmWidth < widths[bar];
+ elmWidth++, narrowMask &= ~(1 << bar)) {
+ int subVal = [self combins:n - elmWidth - 1 r:elements - bar - 2];
+ if (noNarrow && (narrowMask == 0) &&
+ (n - elmWidth - (elements - bar - 1) >= elements - bar - 1)) {
+ subVal -= [self combins:n - elmWidth - (elements - bar)
+ r:elements - bar - 2];
+ }
+ if (elements - bar - 1 > 1) {
+ int lessVal = 0;
+ for (int mxwElement = n - elmWidth - (elements - bar - 2);
+ mxwElement > maxWidth; mxwElement--) {
+ lessVal += [self combins:n - elmWidth - mxwElement - 1
+ r:elements - bar - 3];
+ }
+ subVal -= lessVal * (elements - 1 - bar);
+ } else if (n - elmWidth > maxWidth) {
+ subVal--;
+ }
+ val += subVal;
+ }
+ n -= elmWidth;
+ }
+ return val;
+}
+
++ (int)combins:(int)n r:(int)r {
+ int maxDenom;
+ int minDenom;
+ if (n - r > r) {
+ minDenom = r;
+ maxDenom = n - r;
+ } else {
+ minDenom = n - r;
+ maxDenom = r;
+ }
+ int val = 1;
+ int j = 1;
+ for (int i = n; i > maxDenom; i--) {
+ val *= i;
+ if (j <= minDenom) {
+ val /= j;
+ j++;
+ }
+ }
+ while (j <= minDenom) {
+ val /= j;
+ j++;
+ }
+ return val;
+}
+
++ (NSArray *)elements:(NSArray *)eDist N:(int)N K:(int)K {
+ NSMutableArray *widths = [NSMutableArray arrayWithCapacity:[eDist count] + 2];
+ int twoK = K << 1;
+ [widths addObject:[NSNumber numberWithInt:1]];
+ int i;
+ int minEven = 10;
+ int barSum = 1;
+ for (i = 1; i < twoK - 2; i += 2) {
+ [widths addObject:[NSNumber numberWithInt:
+ [[eDist objectAtIndex:i - 1] intValue] - [[widths objectAtIndex:i - 1] intValue]]];
+ [widths addObject:[NSNumber numberWithInt:
+ [[eDist objectAtIndex:i] intValue] - [[widths objectAtIndex:i] intValue]]];
+ barSum += [[widths objectAtIndex:i] intValue] + [[widths objectAtIndex:i + 1] intValue];
+ if ([[widths objectAtIndex:i] intValue] < minEven) {
+ minEven = [[widths objectAtIndex:i] intValue];
+ }
+ }
+
+ [widths addObject:[NSNumber numberWithInt:N - barSum]];
+ if ([[widths objectAtIndex:twoK - 1] intValue] < minEven) {
+ minEven = [[widths objectAtIndex:twoK - 1] intValue];
+ }
+ if (minEven > 1) {
+ for (i = 0; i < twoK; i += 2) {
+ [widths replaceObjectAtIndex:i
+ withObject:[NSNumber numberWithInt:[[widths objectAtIndex:i] intValue] + minEven - 1]];
+ [widths replaceObjectAtIndex:i + 1
+ withObject:[NSNumber numberWithInt:[[widths objectAtIndex:i + 1] intValue] - minEven - 1]];
+ }
+ }
+ return widths;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXBitArrayBuilder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXBitArrayBuilder.h
new file mode 100644
index 0000000000000000000000000000000000000000..058b7cbcaff77f6a0ef7f92c03e4d3f67ce8cb54
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXBitArrayBuilder.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXBitArray;
+
+@interface ZXBitArrayBuilder : NSObject
+
++ (ZXBitArray *)buildBitArray:(NSArray *)pairs;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXBitArrayBuilder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXBitArrayBuilder.m
new file mode 100644
index 0000000000000000000000000000000000000000..6cb7cadbafc3281b0e35b9825aac44092863b493
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXBitArrayBuilder.m
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXBitArrayBuilder.h"
+#import "ZXDataCharacter.h"
+#import "ZXExpandedPair.h"
+
+@implementation ZXBitArrayBuilder
+
++ (ZXBitArray *)buildBitArray:(NSArray *)pairs {
+ int charNumber = ([pairs count] << 1) - 1;
+ if ([[pairs objectAtIndex:pairs.count - 1] rightChar] == nil) {
+ charNumber -= 1;
+ }
+
+ int size = 12 * charNumber;
+
+ ZXBitArray *binary = [[[ZXBitArray alloc] initWithSize:size] autorelease];
+ int accPos = 0;
+
+ ZXExpandedPair *firstPair = [pairs objectAtIndex:0];
+ int firstValue = [[firstPair rightChar] value];
+ for (int i = 11; i >= 0; --i) {
+ if ((firstValue & (1 << i)) != 0) {
+ [binary set:accPos];
+ }
+ accPos++;
+ }
+
+ for (int i = 1; i < [pairs count]; ++i) {
+ ZXExpandedPair *currentPair = [pairs objectAtIndex:i];
+ int leftValue = [[currentPair leftChar] value];
+
+ for (int j = 11; j >= 0; --j) {
+ if ((leftValue & (1 << j)) != 0) {
+ [binary set:accPos];
+ }
+ accPos++;
+ }
+
+ if ([currentPair rightChar] != nil) {
+ int rightValue = [[currentPair rightChar] value];
+
+ for (int j = 11; j >= 0; --j) {
+ if ((rightValue & (1 << j)) != 0) {
+ [binary set:accPos];
+ }
+ accPos++;
+ }
+ }
+ }
+
+ return binary;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXExpandedPair.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXExpandedPair.h
new file mode 100644
index 0000000000000000000000000000000000000000..9e237b854ee034fdd24f608de09cb010bb068936
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXExpandedPair.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXDataCharacter, ZXRSSFinderPattern;
+
+@interface ZXExpandedPair : NSObject
+
+@property (nonatomic, retain, readonly) ZXDataCharacter *leftChar;
+@property (nonatomic, retain, readonly) ZXDataCharacter *rightChar;
+@property (nonatomic, retain, readonly) ZXRSSFinderPattern *finderPattern;
+@property (nonatomic, assign, readonly) BOOL mayBeLast;
+@property (nonatomic, assign, readonly) BOOL mustBeLast;
+
+- (id)initWithLeftChar:(ZXDataCharacter *)leftChar rightChar:(ZXDataCharacter *)rightChar finderPattern:(ZXRSSFinderPattern *)finderPattern mayBeLast:(BOOL)mayBeLast;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXExpandedPair.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXExpandedPair.m
new file mode 100644
index 0000000000000000000000000000000000000000..e3c4db940f77bf6453b50c548c967e830994a004
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXExpandedPair.m
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXExpandedPair.h"
+#import "ZXDataCharacter.h"
+#import "ZXRSSFinderPattern.h"
+
+@interface ZXExpandedPair ()
+
+@property (nonatomic, retain) ZXDataCharacter *leftChar;
+@property (nonatomic, retain) ZXDataCharacter *rightChar;
+@property (nonatomic, retain) ZXRSSFinderPattern *finderPattern;
+@property (nonatomic, assign) BOOL mayBeLast;
+
+@end
+
+@implementation ZXExpandedPair
+
+@synthesize finderPattern;
+@synthesize leftChar;
+@synthesize mayBeLast;
+@synthesize rightChar;
+
+- (id)initWithLeftChar:(ZXDataCharacter *)aLeftChar rightChar:(ZXDataCharacter *)aRightChar
+ finderPattern:(ZXRSSFinderPattern *)aFinderPattern mayBeLast:(BOOL)aMayBeLast {
+ if (self = [super init]) {
+ self.leftChar = aLeftChar;
+ self.rightChar = aRightChar;
+ self.finderPattern = aFinderPattern;
+ mayBeLast = aMayBeLast;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [leftChar release];
+ [rightChar release];
+ [finderPattern release];
+
+ [super dealloc];
+}
+
+- (BOOL)mustBeLast {
+ return self.rightChar == nil;
+}
+
+- (NSString *)description {
+ return [NSString stringWithFormat:@"[ %@, %@ : %@ ]",
+ self.leftChar, self.rightChar,
+ self.finderPattern == nil ? @"null" : [NSString stringWithFormat:@"%d", self.finderPattern.value]];
+}
+
+- (BOOL)isEqual:(id)object {
+ if (![object isKindOfClass:[ZXExpandedPair class]]) {
+ return NO;
+ }
+ ZXExpandedPair *that = (ZXExpandedPair *)object;
+ return
+ [ZXExpandedPair isEqualOrNil:self.leftChar toObject:that.leftChar] &&
+ [ZXExpandedPair isEqualOrNil:self.rightChar toObject:that.rightChar] &&
+ [ZXExpandedPair isEqualOrNil:self.finderPattern toObject:that.finderPattern];
+}
+
++ (BOOL)isEqualOrNil:(id)o1 toObject:(id)o2 {
+ return o1 == nil ? o2 == nil : [o1 isEqual:o2];
+}
+
+- (NSUInteger)hash {
+ return [self hashNotNil:self.leftChar] ^ [self hashNotNil:self.rightChar] ^ [self hashNotNil:self.finderPattern];
+}
+
+- (NSUInteger)hashNotNil:(NSObject *)o {
+ return o == nil ? 0 : o.hash;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXExpandedRow.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXExpandedRow.h
new file mode 100644
index 0000000000000000000000000000000000000000..2e4039dd09c899277c5c7fe3845bc536236def36
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXExpandedRow.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * One row of an RSS Expanded Stacked symbol, consisting of 1+ expanded pairs.
+ */
+@interface ZXExpandedRow : NSObject
+
+@property (nonatomic, retain, readonly) NSArray *pairs;
+@property (nonatomic, assign, readonly) int rowNumber;
+@property (nonatomic, assign, readonly) BOOL wasReversed;
+
+- (id)initWithPairs:(NSArray *)pairs rowNumber:(int)rowNumber wasReversed:(BOOL)wasReversed;
+- (BOOL)isReversed;
+- (BOOL)isEquivalent:(NSArray *)otherPairs;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXExpandedRow.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXExpandedRow.m
new file mode 100644
index 0000000000000000000000000000000000000000..73b5a493efe904db0fc242ee5f7366b4f64ba95f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXExpandedRow.m
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXExpandedRow.h"
+
+@interface ZXExpandedRow ()
+
+@property (nonatomic, retain) NSArray *pairs;
+@property (nonatomic, assign) int rowNumber;
+@property (nonatomic, assign) BOOL wasReversed;
+
+@end
+
+@implementation ZXExpandedRow
+
+@synthesize rowNumber;
+@synthesize wasReversed;
+@synthesize pairs;
+
+- (id)initWithPairs:(NSArray *)_pairs rowNumber:(int)_rowNumber wasReversed:(BOOL)_wasReversed {
+ if (self = [super init]) {
+ self.pairs = [NSArray arrayWithArray:_pairs];
+ self.rowNumber = _rowNumber;
+ self.wasReversed = _wasReversed;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [pairs release];
+
+ [super dealloc];
+}
+
+- (BOOL)isReversed {
+ return self.wasReversed;
+}
+
+- (BOOL)isEquivalent:(NSArray *)otherPairs {
+ return [self.pairs isEqualToArray:otherPairs];
+}
+
+- (NSString *)description {
+ return [NSString stringWithFormat:@"{%@}", self.pairs];
+}
+
+/**
+ * Two rows are equal if they contain the same pairs in the same order.
+ */
+- (BOOL)isEqual:(id)object {
+ if (![object isKindOfClass:[ZXExpandedRow class]]) {
+ return NO;
+ }
+ ZXExpandedRow *that = (ZXExpandedRow *)object;
+ return [self.pairs isEqual:that.pairs] && (self.wasReversed == that.wasReversed);
+}
+
+- (NSUInteger)hash {
+ return self.pairs.hash ^ [NSNumber numberWithBool:self.wasReversed].hash;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXRSSExpandedReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXRSSExpandedReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..da4479fc0ba9e485b9c7d1ce7be33fcc4a403bdb
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXRSSExpandedReader.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractRSSReader.h"
+
+@class ZXDataCharacter, ZXExpandedPair, ZXResult, ZXRSSFinderPattern;
+
+@interface ZXRSSExpandedReader : ZXAbstractRSSReader
+
+- (ZXDataCharacter *)decodeDataCharacter:(ZXBitArray *)row pattern:(ZXRSSFinderPattern *)pattern isOddPattern:(BOOL)isOddPattern leftChar:(BOOL)leftChar;
+
+// for tests
+- (NSMutableArray *)decodeRow2pairs:(int)rowNumber row:(ZXBitArray *)row;
+- (ZXResult *)constructResult:(NSMutableArray *)pairs error:(NSError **)error;
+- (NSMutableArray *)rows;
+- (ZXExpandedPair *)retrieveNextPair:(ZXBitArray *)row previousPairs:(NSMutableArray *)previousPairs rowNumber:(int)rowNumber;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXRSSExpandedReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXRSSExpandedReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..1a07eb9c575776b22a1371d52062fe884ff97e6b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/ZXRSSExpandedReader.m
@@ -0,0 +1,786 @@
+ /*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractExpandedDecoder.h"
+#import "ZXBitArray.h"
+#import "ZXBitArrayBuilder.h"
+#import "ZXDataCharacter.h"
+#import "ZXErrors.h"
+#import "ZXExpandedPair.h"
+#import "ZXExpandedRow.h"
+#import "ZXResult.h"
+#import "ZXRSSExpandedReader.h"
+#import "ZXRSSFinderPattern.h"
+#import "ZXRSSUtils.h"
+
+const int SYMBOL_WIDEST[5] = {7, 5, 4, 3, 1};
+const int EVEN_TOTAL_SUBSET[5] = {4, 20, 52, 104, 204};
+const int GSUM[5] = {0, 348, 1388, 2948, 3988};
+
+const int WEIGHTS[23][8] = {
+ { 1, 3, 9, 27, 81, 32, 96, 77},
+ { 20, 60, 180, 118, 143, 7, 21, 63},
+ {189, 145, 13, 39, 117, 140, 209, 205},
+ {193, 157, 49, 147, 19, 57, 171, 91},
+ { 62, 186, 136, 197, 169, 85, 44, 132},
+ {185, 133, 188, 142, 4, 12, 36, 108},
+ {113, 128, 173, 97, 80, 29, 87, 50},
+ {150, 28, 84, 41, 123, 158, 52, 156},
+ { 46, 138, 203, 187, 139, 206, 196, 166},
+ { 76, 17, 51, 153, 37, 111, 122, 155},
+ { 43, 129, 176, 106, 107, 110, 119, 146},
+ { 16, 48, 144, 10, 30, 90, 59, 177},
+ {109, 116, 137, 200, 178, 112, 125, 164},
+ { 70, 210, 208, 202, 184, 130, 179, 115},
+ {134, 191, 151, 31, 93, 68, 204, 190},
+ {148, 22, 66, 198, 172, 94, 71, 2},
+ { 6, 18, 54, 162, 64, 192,154, 40},
+ {120, 149, 25, 75, 14, 42,126, 167},
+ { 79, 26, 78, 23, 69, 207,199, 175},
+ {103, 98, 83, 38, 114, 131, 182, 124},
+ {161, 61, 183, 127, 170, 88, 53, 159},
+ { 55, 165, 73, 8, 24, 72, 5, 15},
+ { 45, 135, 194, 160, 58, 174, 100, 89}
+};
+
+const int FINDER_PAT_A = 0;
+const int FINDER_PAT_B = 1;
+const int FINDER_PAT_C = 2;
+const int FINDER_PAT_D = 3;
+const int FINDER_PAT_E = 4;
+const int FINDER_PAT_F = 5;
+
+#define FINDER_PATTERN_SEQUENCES_LEN 10
+#define FINDER_PATTERN_SEQUENCES_SUBLEN 11
+const int FINDER_PATTERN_SEQUENCES[FINDER_PATTERN_SEQUENCES_LEN][FINDER_PATTERN_SEQUENCES_SUBLEN] = {
+ { FINDER_PAT_A, FINDER_PAT_A },
+ { FINDER_PAT_A, FINDER_PAT_B, FINDER_PAT_B },
+ { FINDER_PAT_A, FINDER_PAT_C, FINDER_PAT_B, FINDER_PAT_D },
+ { FINDER_PAT_A, FINDER_PAT_E, FINDER_PAT_B, FINDER_PAT_D, FINDER_PAT_C },
+ { FINDER_PAT_A, FINDER_PAT_E, FINDER_PAT_B, FINDER_PAT_D, FINDER_PAT_D, FINDER_PAT_F },
+ { FINDER_PAT_A, FINDER_PAT_E, FINDER_PAT_B, FINDER_PAT_D, FINDER_PAT_E, FINDER_PAT_F, FINDER_PAT_F },
+ { FINDER_PAT_A, FINDER_PAT_A, FINDER_PAT_B, FINDER_PAT_B, FINDER_PAT_C, FINDER_PAT_C, FINDER_PAT_D, FINDER_PAT_D },
+ { FINDER_PAT_A, FINDER_PAT_A, FINDER_PAT_B, FINDER_PAT_B, FINDER_PAT_C, FINDER_PAT_C, FINDER_PAT_D, FINDER_PAT_E, FINDER_PAT_E },
+ { FINDER_PAT_A, FINDER_PAT_A, FINDER_PAT_B, FINDER_PAT_B, FINDER_PAT_C, FINDER_PAT_C, FINDER_PAT_D, FINDER_PAT_E, FINDER_PAT_F, FINDER_PAT_F },
+ { FINDER_PAT_A, FINDER_PAT_A, FINDER_PAT_B, FINDER_PAT_B, FINDER_PAT_C, FINDER_PAT_D, FINDER_PAT_D, FINDER_PAT_E, FINDER_PAT_E, FINDER_PAT_F, FINDER_PAT_F },
+};
+
+//#define LONGEST_SEQUENCE_SIZE FINDER_PATTERN_SEQUENCES_SUBLEN
+
+const int MAX_PAIRS = 11;
+
+@interface ZXRSSExpandedReader () {
+ int startEnd[2];
+// int currentSequence[LONGEST_SEQUENCE_SIZE];
+ BOOL startFromEven;
+}
+
+@property (nonatomic, retain) NSMutableArray *pairs;
+@property (nonatomic, retain) NSMutableArray *rows;
+
+- (BOOL)adjustOddEvenCounts:(int)numModules;
+- (ZXResult *)constructResult:(NSMutableArray *)pairs error:(NSError **)error;
+- (BOOL)checkChecksum;
+- (ZXDataCharacter *)decodeDataCharacter:(ZXBitArray *)row pattern:(ZXRSSFinderPattern *)pattern isOddPattern:(BOOL)isOddPattern leftChar:(BOOL)leftChar;
+- (BOOL)findNextPair:(ZXBitArray *)row previousPairs:(NSMutableArray *)previousPairs forcedOffset:(int)forcedOffset;
+- (int)nextSecondBar:(ZXBitArray *)row initialPos:(int)initialPos;
+- (BOOL)isNotA1left:(ZXRSSFinderPattern *)pattern isOddPattern:(BOOL)isOddPattern leftChar:(BOOL)leftChar;
+- (ZXRSSFinderPattern *)parseFoundFinderPattern:(ZXBitArray *)row rowNumber:(int)rowNumber oddPattern:(BOOL)oddPattern;
+- (void)reverseCounters:(int *)counters length:(unsigned int)length;
+- (NSMutableArray *)checkRows:(BOOL)reversed;
+- (NSMutableArray *)checkRows:(NSMutableArray *)rows current:(int)currentRow;
+- (BOOL)isValidSequence:(NSArray *)pairs;
+- (void)storeRow:(int)rowNumber wasReversed:(BOOL)reversed;
+- (BOOL)isPartialRow:(NSArray *)pairs of:(NSArray *)rows;
+- (void)removePartialRows:(NSArray *)pairs from:(NSMutableArray *)rows;
+
+@end
+
+@implementation ZXRSSExpandedReader
+
+@synthesize pairs;
+@synthesize rows;
+
+- (id)init {
+ if (self = [super init]) {
+ self.pairs = [NSMutableArray array];
+ self.rows = [NSMutableArray array];
+ startFromEven = NO;
+ startEnd[0] = 0;
+ startEnd[1] = 0;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [pairs release];
+ [rows release];
+
+ [super dealloc];
+}
+
+- (ZXResult *)decodeRow:(int)rowNumber row:(ZXBitArray *)row hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ // Rows can start with even pattern in case in prev rows there where odd number of patters.
+ // So lets try twice
+ [self.pairs removeAllObjects];
+ startFromEven = NO;
+ NSMutableArray* _pairs = [self decodeRow2pairs:rowNumber row:row];
+ if (_pairs) {
+ ZXResult *result = [self constructResult:_pairs error:error];
+ if (result) {
+ return result;
+ }
+ }
+
+ [self.pairs removeAllObjects];
+ startFromEven = YES;
+ _pairs = [self decodeRow2pairs:rowNumber row:row];
+ if (!_pairs) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ return [self constructResult:_pairs error:error];
+}
+
+- (void)reset {
+ [self.pairs removeAllObjects];
+ [self.rows removeAllObjects];
+}
+
+- (NSMutableArray *)decodeRow2pairs:(int)rowNumber row:(ZXBitArray *)row {
+ while (YES) {
+ ZXExpandedPair *nextPair = [self retrieveNextPair:row previousPairs:self.pairs rowNumber:rowNumber];
+ if (!nextPair) {
+ if ([self.pairs count] == 0) {
+ return nil;
+ }
+ break;
+ }
+ [self.pairs addObject:nextPair];
+ }
+
+ // TODO: verify sequence of finder patterns as in checkPairSequence()
+ if ([self checkChecksum]) {
+ return self.pairs;
+ }
+
+ BOOL tryStackedDecode = [self.rows count] > 0;
+ BOOL wasReversed = NO; // TODO: deal with reversed rows
+ [self storeRow:rowNumber wasReversed:wasReversed];
+ if (tryStackedDecode) {
+ // When the image is 180-rotated, then rows are sorted in wrong dirrection.
+ // Try twice with both the directions.
+ NSMutableArray *ps = [self checkRows:NO];
+ if (ps) {
+ return ps;
+ }
+ ps = [self checkRows:YES];
+ if (ps) {
+ return ps;
+ }
+ }
+
+ return nil;
+}
+
+- (NSMutableArray *)checkRows:(BOOL)reverse {
+ // Limit number of rows we are checking
+ // We use recursive algorithm with pure complexity and don't want it to take forever
+ // Stacked barcode can have up to 11 rows, so 25 seems resonable enough
+ if (self.rows.count > 25) {
+ [self.rows removeAllObjects];
+ return nil;
+ }
+
+ [self.pairs removeAllObjects];
+ if (reverse) {
+ self.rows = [[[[self.rows reverseObjectEnumerator] allObjects] mutableCopy] autorelease];
+ }
+
+ NSMutableArray *ps = [self checkRows:[NSMutableArray array] current:0];
+
+ if (reverse) {
+ self.rows = [[[[self.rows reverseObjectEnumerator] allObjects] mutableCopy] autorelease];
+ }
+
+ return ps;
+}
+
+// Try to construct a valid rows sequence
+// Recursion is used to implement backtracking
+- (NSMutableArray *)checkRows:(NSMutableArray *)collectedRows current:(int)currentRow {
+ for (int i = currentRow; i < [self.rows count]; i++) {
+ ZXExpandedRow *row = [self.rows objectAtIndex:i];
+ [self.pairs removeAllObjects];
+ int size = [collectedRows count];
+ for (int j = 0; j < size; j++) {
+ [self.pairs addObjectsFromArray:[[collectedRows objectAtIndex:j] pairs]];
+ }
+ [self.pairs addObjectsFromArray:row.pairs];
+
+ if (![self isValidSequence:self.pairs]) {
+ continue;
+ }
+
+ if ([self checkChecksum]) {
+ return self.pairs;
+ }
+
+ NSMutableArray *rs = [NSMutableArray array];
+ [rs addObjectsFromArray:collectedRows];
+ [rs addObject:row];
+ NSMutableArray *ps = [self checkRows:rs current:i + 1];
+ if (ps) {
+ return ps;
+ }
+ }
+ return nil;
+}
+
+// Whether the pairs form a valid find pattern seqience,
+// either complete or a prefix
+- (BOOL)isValidSequence:(NSArray *)pairs {
+ for (int i = 0, sz = 2; i < FINDER_PATTERN_SEQUENCES_LEN; i++, sz++) {
+ if ([self.pairs count] > sz) {
+ continue;
+ }
+
+ BOOL stop = YES;
+ for (int j = 0; j < [self.pairs count]; j++) {
+ if ([[[self.pairs objectAtIndex:j] finderPattern] value] != FINDER_PATTERN_SEQUENCES[i][j]) {
+ stop = NO;
+ break;
+ }
+ }
+
+ if (stop) {
+ return YES;
+ }
+ }
+
+ return NO;
+}
+
+- (void)storeRow:(int)rowNumber wasReversed:(BOOL)wasReversed {
+ // Discard if duplicate above or below; otherwise insert in order by row number.
+ int insertPos = 0;
+ BOOL prevIsSame = NO;
+ BOOL nextIsSame = NO;
+ while (insertPos < [self.rows count]) {
+ ZXExpandedRow *erow = [self.rows objectAtIndex:insertPos];
+ if (erow.rowNumber > rowNumber) {
+ nextIsSame = [erow isEquivalent:self.pairs];
+ break;
+ }
+ prevIsSame = [erow isEquivalent:self.pairs];
+ insertPos++;
+ }
+ if (nextIsSame || prevIsSame) {
+ return;
+ }
+
+ // When the row was partially decoded (e.g. 2 pairs found instead of 3),
+ // it will prevent us from detecting the barcode.
+ // Try to merge partial rows
+
+ // Check whether the row is part of an allready detected row
+ if ([self isPartialRow:self.pairs of:self.rows]) {
+ return;
+ }
+
+ [self.rows insertObject:[[[ZXExpandedRow alloc] initWithPairs:self.pairs rowNumber:rowNumber wasReversed:wasReversed] autorelease] atIndex:insertPos];
+
+ [self removePartialRows:self.pairs from:self.rows];
+}
+
+// Remove all the rows that contains only specified pairs
+- (void)removePartialRows:(NSArray *)_pairs from:(NSMutableArray *)_rows {
+ NSMutableArray *toRemove = [NSMutableArray array];
+ for (ZXExpandedRow *r in _rows) {
+ if ([r.pairs count] == [_pairs count]) {
+ continue;
+ }
+ BOOL allFound = YES;
+ for (ZXExpandedPair *p in r.pairs) {
+ BOOL found = NO;
+ for (ZXExpandedPair *pp in _pairs) {
+ if ([p isEqual:pp]) {
+ found = YES;
+ break;
+ }
+ }
+ if (!found) {
+ allFound = NO;
+ break;
+ }
+ }
+ if (allFound) {
+ [toRemove addObject:r];
+ }
+ }
+
+ for (ZXExpandedRow *r in toRemove) {
+ [_rows removeObject:r];
+ }
+}
+
+- (BOOL)isPartialRow:(NSArray *)_pairs of:(NSArray *)_rows {
+ for (ZXExpandedRow *r in _rows) {
+ BOOL allFound = YES;
+ for (ZXExpandedPair *p in _pairs) {
+ BOOL found = NO;
+ for (ZXExpandedPair *pp in r.pairs) {
+ if ([p isEqual:pp]) {
+ found = YES;
+ break;
+ }
+ }
+ if (!found) {
+ allFound = NO;
+ break;
+ }
+ }
+ if (allFound) {
+ // the row 'r' contain all the pairs from 'pairs'
+ return YES;
+ }
+ }
+ return NO;
+}
+
+- (NSMutableArray *)rows {
+ return rows;
+}
+
+- (ZXResult *)constructResult:(NSMutableArray *)_pairs error:(NSError **)error {
+ ZXBitArray *binary = [ZXBitArrayBuilder buildBitArray:_pairs];
+
+ ZXAbstractExpandedDecoder *decoder = [ZXAbstractExpandedDecoder createDecoder:binary];
+ NSString *resultingString = [decoder parseInformationWithError:error];
+ if (!resultingString) {
+ return nil;
+ }
+
+ NSArray *firstPoints = [[((ZXExpandedPair *)[_pairs objectAtIndex:0]) finderPattern] resultPoints];
+ NSArray *lastPoints = [[((ZXExpandedPair *)[_pairs lastObject]) finderPattern] resultPoints];
+
+ return [ZXResult resultWithText:resultingString
+ rawBytes:NULL
+ length:0
+ resultPoints:[NSArray arrayWithObjects:[firstPoints objectAtIndex:0], [firstPoints objectAtIndex:1], [lastPoints objectAtIndex:0], [lastPoints objectAtIndex:1], nil]
+ format:kBarcodeFormatRSSExpanded];
+}
+
+- (BOOL)checkChecksum {
+ ZXExpandedPair *firstPair = [self.pairs objectAtIndex:0];
+ ZXDataCharacter *checkCharacter = firstPair.leftChar;
+ ZXDataCharacter *firstCharacter = firstPair.rightChar;
+
+ if (!firstCharacter) {
+ return NO;
+ }
+
+ int checksum = [firstCharacter checksumPortion];
+ int s = 2;
+
+ for (int i = 1; i < self.pairs.count; ++i) {
+ ZXExpandedPair *currentPair = [self.pairs objectAtIndex:i];
+ checksum += currentPair.leftChar.checksumPortion;
+ s++;
+ ZXDataCharacter *currentRightChar = currentPair.rightChar;
+ if (currentRightChar != nil) {
+ checksum += currentRightChar.checksumPortion;
+ s++;
+ }
+ }
+
+ checksum %= 211;
+
+ int checkCharacterValue = 211 * (s - 4) + checksum;
+
+ return checkCharacterValue == checkCharacter.value;
+}
+
+- (int)nextSecondBar:(ZXBitArray *)row initialPos:(int)initialPos {
+ int currentPos;
+ if ([row get:initialPos]) {
+ currentPos = [row nextUnset:initialPos];
+ currentPos = [row nextSet:currentPos];
+ } else {
+ currentPos = [row nextSet:initialPos];
+ currentPos = [row nextUnset:currentPos];
+ }
+ return currentPos;
+}
+
+- (ZXExpandedPair *)retrieveNextPair:(ZXBitArray *)row previousPairs:(NSMutableArray *)previousPairs rowNumber:(int)rowNumber {
+ BOOL isOddPattern = [previousPairs count] % 2 == 0;
+ if (startFromEven) {
+ isOddPattern = !isOddPattern;
+ }
+
+ ZXRSSFinderPattern *pattern;
+
+ BOOL keepFinding = YES;
+ int forcedOffset = -1;
+ do {
+ if (![self findNextPair:row previousPairs:previousPairs forcedOffset:forcedOffset]) {
+ return nil;
+ }
+ pattern = [self parseFoundFinderPattern:row rowNumber:rowNumber oddPattern:isOddPattern];
+ if (pattern == nil) {
+ forcedOffset = [self nextSecondBar:row initialPos:startEnd[0]];
+ } else {
+ keepFinding = NO;
+ }
+ } while (keepFinding);
+
+ // When stacked symbol is split over multiple rows, there's no way to guess if this pair can be last or not.
+ // boolean mayBeLast = checkPairSequence(previousPairs, pattern);
+
+ ZXDataCharacter *leftChar = [self decodeDataCharacter:row pattern:pattern isOddPattern:isOddPattern leftChar:YES];
+ if (!leftChar) {
+ return nil;
+ }
+
+ if (previousPairs.count > 0 && [[previousPairs lastObject] mustBeLast]) {
+ return nil;
+ }
+
+ ZXDataCharacter *rightChar = [self decodeDataCharacter:row pattern:pattern isOddPattern:isOddPattern leftChar:NO];
+ BOOL mayBeLast = YES;
+ return [[[ZXExpandedPair alloc] initWithLeftChar:leftChar rightChar:rightChar finderPattern:pattern mayBeLast:mayBeLast] autorelease];
+}
+
+- (BOOL)findNextPair:(ZXBitArray *)row previousPairs:(NSMutableArray *)previousPairs forcedOffset:(int)forcedOffset {
+ const int countersLen = self.decodeFinderCountersLen;
+ int *counters = self.decodeFinderCounters;
+ counters[0] = 0;
+ counters[1] = 0;
+ counters[2] = 0;
+ counters[3] = 0;
+
+ int width = row.size;
+
+ int rowOffset;
+ if (forcedOffset >= 0) {
+ rowOffset = forcedOffset;
+ } else if ([previousPairs count] == 0) {
+ rowOffset = 0;
+ } else {
+ ZXExpandedPair *lastPair = [previousPairs lastObject];
+ rowOffset = [[[[lastPair finderPattern] startEnd] objectAtIndex:1] intValue];
+ }
+ BOOL searchingEvenPair = [previousPairs count] % 2 != 0;
+ if (startFromEven) {
+ searchingEvenPair = !searchingEvenPair;
+ }
+
+ BOOL isWhite = NO;
+ while (rowOffset < width) {
+ isWhite = ![row get:rowOffset];
+ if (!isWhite) {
+ break;
+ }
+ rowOffset++;
+ }
+
+ int counterPosition = 0;
+ int patternStart = rowOffset;
+ for (int x = rowOffset; x < width; x++) {
+ if ([row get:x] ^ isWhite) {
+ counters[counterPosition]++;
+ } else {
+ if (counterPosition == 3) {
+ if (searchingEvenPair) {
+ [self reverseCounters:counters length:countersLen];
+ }
+
+ if ([ZXAbstractRSSReader isFinderPattern:counters countersLen:countersLen]) {
+ startEnd[0] = patternStart;
+ startEnd[1] = x;
+ return YES;
+ }
+
+ if (searchingEvenPair) {
+ [self reverseCounters:counters length:countersLen];
+ }
+
+ patternStart += counters[0] + counters[1];
+ counters[0] = counters[2];
+ counters[1] = counters[3];
+ counters[2] = 0;
+ counters[3] = 0;
+ counterPosition--;
+ } else {
+ counterPosition++;
+ }
+ counters[counterPosition] = 1;
+ isWhite = !isWhite;
+ }
+ }
+ return NO;
+}
+
+- (void)reverseCounters:(int *)counters length:(unsigned int)length {
+ for(int i = 0; i < length / 2; ++i){
+ int tmp = counters[i];
+ counters[i] = counters[length - i - 1];
+ counters[length - i - 1] = tmp;
+ }
+}
+
+- (ZXRSSFinderPattern *)parseFoundFinderPattern:(ZXBitArray *)row rowNumber:(int)rowNumber oddPattern:(BOOL)oddPattern {
+ // Actually we found elements 2-5.
+ int firstCounter;
+ int start;
+ int end;
+
+ if (oddPattern) {
+ // If pattern number is odd, we need to locate element 1 *before *the current block.
+
+ int firstElementStart = startEnd[0] - 1;
+ // Locate element 1
+ while (firstElementStart >= 0 && ![row get:firstElementStart]) {
+ firstElementStart--;
+ }
+
+ firstElementStart++;
+ firstCounter = startEnd[0] - firstElementStart;
+ start = firstElementStart;
+ end = startEnd[1];
+ } else {
+ // If pattern number is even, the pattern is reversed, so we need to locate element 1 *after *the current block.
+
+ start = startEnd[0];
+
+ end = [row nextUnset:startEnd[1] + 1];
+ firstCounter = end - startEnd[1];
+ }
+
+ // Make 'counters' hold 1-4
+ int countersLen = self.decodeFinderCountersLen;
+ int counters[countersLen];
+ counters[0] = self.decodeFinderCounters[0];
+ for (int i = 1; i < countersLen; i++) {
+ counters[i] = self.decodeFinderCounters[i - 1];
+ }
+
+ counters[0] = firstCounter;
+ int value = [ZXAbstractRSSReader parseFinderValue:counters countersSize:countersLen
+ finderPatternType:RSS_PATTERNS_RSS_EXPANDED_PATTERNS];
+ if (value == -1) {
+ return nil;
+ }
+ return [[[ZXRSSFinderPattern alloc] initWithValue:value startEnd:[NSMutableArray arrayWithObjects:[NSNumber numberWithInt:start], [NSNumber numberWithInt:end], nil] start:start end:end rowNumber:rowNumber] autorelease];
+}
+
+- (ZXDataCharacter *)decodeDataCharacter:(ZXBitArray *)row pattern:(ZXRSSFinderPattern *)pattern isOddPattern:(BOOL)isOddPattern leftChar:(BOOL)leftChar {
+ int countersLen = self.dataCharacterCountersLen;
+ int *counters = self.dataCharacterCounters;
+ counters[0] = 0;
+ counters[1] = 0;
+ counters[2] = 0;
+ counters[3] = 0;
+ counters[4] = 0;
+ counters[5] = 0;
+ counters[6] = 0;
+ counters[7] = 0;
+
+ if (leftChar) {
+ if (![ZXOneDReader recordPatternInReverse:row start:[[[pattern startEnd] objectAtIndex:0] intValue] counters:counters countersSize:countersLen]) {
+ return nil;
+ }
+ } else {
+ if (![ZXOneDReader recordPattern:row start:[[[pattern startEnd] objectAtIndex:1] intValue] counters:counters countersSize:countersLen]) {
+ return nil;
+ }
+ // reverse it
+ for (int i = 0, j = countersLen - 1; i < j; i++, j--) {
+ int temp = counters[i];
+ counters[i] = counters[j];
+ counters[j] = temp;
+ }
+ }//counters[] has the pixels of the module
+
+ int numModules = 17; //left and right data characters have all the same length
+ float elementWidth = (float)[ZXAbstractRSSReader count:counters arrayLen:countersLen] / (float)numModules;
+
+ // Sanity check: element width for pattern and the character should match
+ float expectedElementWidth = ([[pattern.startEnd objectAtIndex:1] intValue] - [[pattern.startEnd objectAtIndex:0] intValue]) / 15.0f;
+ if (fabsf(elementWidth - expectedElementWidth) / expectedElementWidth > 0.3f) {
+ return nil;
+ }
+
+ for (int i = 0; i < countersLen; i++) {
+ float value = 1.0f * counters[i] / elementWidth;
+ int count = (int)(value + 0.5f);
+ if (count < 1) {
+ if (value < 0.3f) {
+ return nil;
+ }
+ count = 1;
+ } else if (count > 8) {
+ if (value > 8.7f) {
+ return nil;
+ }
+ count = 8;
+ }
+ int offset = i >> 1;
+ if ((i & 0x01) == 0) {
+ self.oddCounts[offset] = count;
+ self.oddRoundingErrors[offset] = value - count;
+ } else {
+ self.evenCounts[offset] = count;
+ self.evenRoundingErrors[offset] = value - count;
+ }
+ }
+
+ if (![self adjustOddEvenCounts:numModules]) {
+ return nil;
+ }
+
+ int weightRowNumber = 4 * pattern.value + (isOddPattern ? 0 : 2) + (leftChar ? 0 : 1) - 1;
+
+ int oddSum = 0;
+ int oddChecksumPortion = 0;
+ for (int i = self.oddCountsLen - 1; i >= 0; i--) {
+ if ([self isNotA1left:pattern isOddPattern:isOddPattern leftChar:leftChar]) {
+ int weight = WEIGHTS[weightRowNumber][2 * i];
+ oddChecksumPortion += self.oddCounts[i] * weight;
+ }
+ oddSum += self.oddCounts[i];
+ }
+ int evenChecksumPortion = 0;
+ int evenSum = 0;
+ for (int i = self.evenCountsLen - 1; i >= 0; i--) {
+ if ([self isNotA1left:pattern isOddPattern:isOddPattern leftChar:leftChar]) {
+ int weight = WEIGHTS[weightRowNumber][2 * i + 1];
+ evenChecksumPortion += self.evenCounts[i] * weight;
+ }
+ evenSum += self.evenCounts[i];
+ }
+ int checksumPortion = oddChecksumPortion + evenChecksumPortion;
+
+ if ((oddSum & 0x01) != 0 || oddSum > 13 || oddSum < 4) {
+ return nil;
+ }
+
+ int group = (13 - oddSum) / 2;
+ int oddWidest = SYMBOL_WIDEST[group];
+ int evenWidest = 9 - oddWidest;
+ int vOdd = [ZXRSSUtils rssValue:self.oddCounts widthsLen:self.oddCountsLen maxWidth:oddWidest noNarrow:YES];
+ int vEven = [ZXRSSUtils rssValue:self.evenCounts widthsLen:self.evenCountsLen maxWidth:evenWidest noNarrow:NO];
+ int tEven = EVEN_TOTAL_SUBSET[group];
+ int gSum = GSUM[group];
+ int value = vOdd * tEven + vEven + gSum;
+ return [[[ZXDataCharacter alloc] initWithValue:value checksumPortion:checksumPortion] autorelease];
+}
+
+- (BOOL)isNotA1left:(ZXRSSFinderPattern *)pattern isOddPattern:(BOOL)isOddPattern leftChar:(BOOL)leftChar {
+ return !([pattern value] == 0 && isOddPattern && leftChar);
+}
+
+- (BOOL)adjustOddEvenCounts:(int)numModules {
+ int oddSum = [ZXAbstractRSSReader count:self.oddCounts arrayLen:self.oddCountsLen];
+ int evenSum = [ZXAbstractRSSReader count:self.evenCounts arrayLen:self.evenCountsLen];
+ int mismatch = oddSum + evenSum - numModules;
+ BOOL oddParityBad = (oddSum & 0x01) == 1;
+ BOOL evenParityBad = (evenSum & 0x01) == 0;
+ BOOL incrementOdd = NO;
+ BOOL decrementOdd = NO;
+ if (oddSum > 13) {
+ decrementOdd = YES;
+ } else if (oddSum < 4) {
+ incrementOdd = YES;
+ }
+ BOOL incrementEven = NO;
+ BOOL decrementEven = NO;
+ if (evenSum > 13) {
+ decrementEven = YES;
+ } else if (evenSum < 4) {
+ incrementEven = YES;
+ }
+
+ if (mismatch == 1) {
+ if (oddParityBad) {
+ if (evenParityBad) {
+ return NO;
+ }
+ decrementOdd = YES;
+ } else {
+ if (!evenParityBad) {
+ return NO;
+ }
+ decrementEven = YES;
+ }
+ } else if (mismatch == -1) {
+ if (oddParityBad) {
+ if (evenParityBad) {
+ return NO;
+ }
+ incrementOdd = YES;
+ } else {
+ if (!evenParityBad) {
+ return NO;
+ }
+ incrementEven = YES;
+ }
+ } else if (mismatch == 0) {
+ if (oddParityBad) {
+ if (!evenParityBad) {
+ return NO;
+ }
+ if (oddSum < evenSum) {
+ incrementOdd = YES;
+ decrementEven = YES;
+ } else {
+ decrementOdd = YES;
+ incrementEven = YES;
+ }
+ } else {
+ if (evenParityBad) {
+ return NO;
+ }
+ }
+ } else {
+ return NO;
+ }
+
+ if (incrementOdd) {
+ if (decrementOdd) {
+ return NO;
+ }
+ [ZXAbstractRSSReader increment:self.oddCounts arrayLen:self.oddCountsLen errors:self.oddRoundingErrors];
+ }
+ if (decrementOdd) {
+ [ZXAbstractRSSReader decrement:self.oddCounts arrayLen:self.oddCountsLen errors:self.oddRoundingErrors];
+ }
+ if (incrementEven) {
+ if (decrementEven) {
+ return NO;
+ }
+ [ZXAbstractRSSReader increment:self.evenCounts arrayLen:self.evenCountsLen errors:self.oddRoundingErrors];
+ }
+ if (decrementEven) {
+ [ZXAbstractRSSReader decrement:self.evenCounts arrayLen:self.evenCountsLen errors:self.evenRoundingErrors];
+ }
+ return YES;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013103decoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013103decoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..66aeb9226d888337d320fa020ab887c583dd7ed0
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013103decoder.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI013x0xDecoder.h"
+
+@interface ZXAI013103decoder : ZXAI013x0xDecoder
+
+- (void)addWeightCode:(NSMutableString *)buf weight:(int)weight;
+- (int)checkWeight:(int)weight;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013103decoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013103decoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..06ce8d028e5790612a5d9daa2a9093dc09d99ec4
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013103decoder.m
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI013103decoder.h"
+#import "ZXBitArray.h"
+
+@implementation ZXAI013103decoder
+
+- (void)addWeightCode:(NSMutableString *)buf weight:(int)weight {
+ [buf appendString:@"(3103)"];
+}
+
+- (int)checkWeight:(int)weight {
+ return weight;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01320xDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01320xDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea1d339f47eff6223e43cff78a54eabe0455e67d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01320xDecoder.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI013x0xDecoder.h"
+
+@interface ZXAI01320xDecoder : ZXAI013x0xDecoder
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01320xDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01320xDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..714331c83168bf7ad367d3767eaaa63739e187b6
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01320xDecoder.m
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI01320xDecoder.h"
+
+@implementation ZXAI01320xDecoder
+
+- (void)addWeightCode:(NSMutableString *)buf weight:(int)weight {
+ if (weight < 10000) {
+ [buf appendString:@"(3202)"];
+ } else {
+ [buf appendString:@"(3203)"];
+ }
+}
+
+- (int)checkWeight:(int)weight {
+ if (weight < 10000) {
+ return weight;
+ }
+ return weight - 10000;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01392xDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01392xDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ae02ccb6f8b8290fdb1716750d9ffb0ec7b0bd7
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01392xDecoder.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI01decoder.h"
+
+@interface ZXAI01392xDecoder : ZXAI01decoder
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01392xDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01392xDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..d29e211a843fa258866c0b27c4b2efa5ffbdb289
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01392xDecoder.m
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI01392xDecoder.h"
+#import "ZXBitArray.h"
+#import "ZXDecodedInformation.h"
+#import "ZXErrors.h"
+#import "ZXGeneralAppIdDecoder.h"
+
+int const AI01392x_HEADER_SIZE = 5 + 1 + 2;
+int const AI01392x_LAST_DIGIT_SIZE = 2;
+
+@implementation ZXAI01392xDecoder
+
+- (NSString *)parseInformationWithError:(NSError **)error {
+ if (self.information.size < AI01392x_HEADER_SIZE + GTIN_SIZE) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ NSMutableString *buf = [NSMutableString string];
+ [self encodeCompressedGtin:buf currentPos:AI01392x_HEADER_SIZE];
+ int lastAIdigit = [self.generalDecoder extractNumericValueFromBitArray:AI01392x_HEADER_SIZE + GTIN_SIZE bits:AI01392x_LAST_DIGIT_SIZE];
+ [buf appendFormat:@"(392%d)", lastAIdigit];
+ ZXDecodedInformation *decodedInformation = [self.generalDecoder decodeGeneralPurposeField:AI01392x_HEADER_SIZE + GTIN_SIZE + AI01392x_LAST_DIGIT_SIZE remaining:nil];
+ [buf appendString:decodedInformation.theNewString];
+ return buf;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01393xDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01393xDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..9fac1347528f1be7c111b2746abcb9ca60d23edc
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01393xDecoder.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI01decoder.h"
+
+@interface ZXAI01393xDecoder : ZXAI01decoder
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01393xDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01393xDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..ff43dbbd83b223587e5b81a6b92c4aa74c261c2a
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01393xDecoder.m
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI01393xDecoder.h"
+#import "ZXBitArray.h"
+#import "ZXDecodedInformation.h"
+#import "ZXErrors.h"
+#import "ZXGeneralAppIdDecoder.h"
+
+@implementation ZXAI01393xDecoder
+
+int const AI01393xDecoder_HEADER_SIZE = 5 + 1 + 2;
+int const AI01393xDecoder_LAST_DIGIT_SIZE = 2;
+int const AI01393xDecoder_FIRST_THREE_DIGITS_SIZE = 10;
+
+- (NSString *)parseInformationWithError:(NSError **)error {
+ if (self.information.size < AI01393xDecoder_HEADER_SIZE + GTIN_SIZE) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ NSMutableString *buf = [NSMutableString string];
+
+ [self encodeCompressedGtin:buf currentPos:AI01393xDecoder_HEADER_SIZE];
+
+ int lastAIdigit = [self.generalDecoder extractNumericValueFromBitArray:AI01393xDecoder_HEADER_SIZE + GTIN_SIZE bits:AI01393xDecoder_LAST_DIGIT_SIZE];
+
+ [buf appendFormat:@"(393%d)", lastAIdigit];
+
+ int firstThreeDigits = [self.generalDecoder extractNumericValueFromBitArray:AI01393xDecoder_HEADER_SIZE + GTIN_SIZE + AI01393xDecoder_LAST_DIGIT_SIZE bits:AI01393xDecoder_FIRST_THREE_DIGITS_SIZE];
+ if (firstThreeDigits / 100 == 0) {
+ [buf appendString:@"0"];
+ }
+ if (firstThreeDigits / 10 == 0) {
+ [buf appendString:@"0"];
+ }
+ [buf appendFormat:@"%d", firstThreeDigits];
+
+ ZXDecodedInformation *generalInformation = [self.generalDecoder decodeGeneralPurposeField:AI01393xDecoder_HEADER_SIZE + GTIN_SIZE + AI01393xDecoder_LAST_DIGIT_SIZE + AI01393xDecoder_FIRST_THREE_DIGITS_SIZE remaining:nil];
+ [buf appendString:generalInformation.theNewString];
+
+ return buf;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013x0x1xDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013x0x1xDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..3f2211d18a2f99014cef1da46b2b3e7a86e5dab4
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013x0x1xDecoder.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI01weightDecoder.h"
+
+@interface ZXAI013x0x1xDecoder : ZXAI01weightDecoder
+
+- (id)initWithInformation:(ZXBitArray *)information firstAIdigits:(NSString *)firstAIdigits dateCode:(NSString *)dateCode;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013x0x1xDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013x0x1xDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..bbb299204905a5d0818177f7a80f74308fb5c2a8
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013x0x1xDecoder.m
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI013x0x1xDecoder.h"
+#import "ZXBitArray.h"
+#import "ZXErrors.h"
+#import "ZXGeneralAppIdDecoder.h"
+
+int const AI013x0x1x_HEADER_SIZE = 7 + 1;
+int const AI013x0x1x_WEIGHT_SIZE = 20;
+int const AI013x0x1x_DATE_SIZE = 16;
+
+@interface ZXAI013x0x1xDecoder ()
+
+@property (nonatomic, copy) NSString *dateCode;
+@property (nonatomic, copy) NSString *firstAIdigits;
+
+- (void)encodeCompressedDate:(NSMutableString *)buf currentPos:(int)currentPos;
+
+@end
+
+@implementation ZXAI013x0x1xDecoder
+
+@synthesize dateCode;
+@synthesize firstAIdigits;
+
+- (id)initWithInformation:(ZXBitArray *)anInformation firstAIdigits:(NSString *)aFirstAIdigits dateCode:(NSString *)aDateCode {
+ if (self = [super initWithInformation:anInformation]) {
+ self.dateCode = aDateCode;
+ self.firstAIdigits = aFirstAIdigits;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [dateCode release];
+ [firstAIdigits release];
+
+ [super dealloc];
+}
+
+- (NSString *)parseInformationWithError:(NSError **)error {
+ if (self.information.size != AI013x0x1x_HEADER_SIZE + GTIN_SIZE + AI013x0x1x_WEIGHT_SIZE + AI013x0x1x_DATE_SIZE) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ NSMutableString *buf = [NSMutableString string];
+ [self encodeCompressedGtin:buf currentPos:AI013x0x1x_HEADER_SIZE];
+ [self encodeCompressedWeight:buf currentPos:AI013x0x1x_HEADER_SIZE + GTIN_SIZE weightSize:AI013x0x1x_WEIGHT_SIZE];
+ [self encodeCompressedDate:buf currentPos:AI013x0x1x_HEADER_SIZE + GTIN_SIZE + AI013x0x1x_WEIGHT_SIZE];
+ return buf;
+}
+
+- (void)encodeCompressedDate:(NSMutableString *)buf currentPos:(int)currentPos {
+ int numericDate = [self.generalDecoder extractNumericValueFromBitArray:currentPos bits:AI013x0x1x_DATE_SIZE];
+ if (numericDate == 38400) {
+ return;
+ }
+ [buf appendFormat:@"(%@)", dateCode];
+ int day = numericDate % 32;
+ numericDate /= 32;
+ int month = numericDate % 12 + 1;
+ numericDate /= 12;
+ int year = numericDate;
+ if (year / 10 == 0) {
+ [buf appendString:@"0"];
+ }
+ [buf appendFormat:@"%d", year];
+ if (month / 10 == 0) {
+ [buf appendString:@"0"];
+ }
+ [buf appendFormat:@"%d", month];
+ if (day / 10 == 0) {
+ [buf appendString:@"0"];
+ }
+ [buf appendFormat:@"%d", day];
+}
+
+- (void)addWeightCode:(NSMutableString *)buf weight:(int)weight {
+ int lastAI = weight / 100000;
+ [buf appendFormat:@"(%@%d)", firstAIdigits, lastAI];
+}
+
+- (int)checkWeight:(int)weight {
+ return weight % 100000;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013x0xDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013x0xDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f02d6c0dc6cf25c57e3a997520f368d618463a1
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013x0xDecoder.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI01weightDecoder.h"
+
+@interface ZXAI013x0xDecoder : ZXAI01weightDecoder
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013x0xDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013x0xDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..d6163c9ec50321777d9f04092d40352e200c88d7
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI013x0xDecoder.m
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI013x0xDecoder.h"
+#import "ZXBitArray.h"
+#import "ZXErrors.h"
+
+int const AI013x0x_HEADER_SIZE = 4 + 1;
+int const AI013x0x_WEIGHT_SIZE = 15;
+
+@implementation ZXAI013x0xDecoder
+
+- (NSString *)parseInformationWithError:(NSError **)error {
+ if (self.information.size != AI013x0x_HEADER_SIZE + GTIN_SIZE + AI013x0x_WEIGHT_SIZE) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ NSMutableString *buf = [NSMutableString string];
+
+ [self encodeCompressedGtin:buf currentPos:AI013x0x_HEADER_SIZE];
+ [self encodeCompressedWeight:buf currentPos:AI013x0x_HEADER_SIZE + GTIN_SIZE weightSize:AI013x0x_WEIGHT_SIZE];
+
+ return buf;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01AndOtherAIs.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01AndOtherAIs.h
new file mode 100644
index 0000000000000000000000000000000000000000..4299580ed345912312e16e4195bf97f59e43d84d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01AndOtherAIs.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI01decoder.h"
+
+@interface ZXAI01AndOtherAIs : ZXAI01decoder
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01AndOtherAIs.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01AndOtherAIs.m
new file mode 100644
index 0000000000000000000000000000000000000000..4d505a0db8767beb662d7017a5bb9c825a5bb0e0
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01AndOtherAIs.m
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI01AndOtherAIs.h"
+#import "ZXGeneralAppIdDecoder.h"
+
+int const AI01_HEADER_SIZE = 1 + 1 + 2;
+
+@implementation ZXAI01AndOtherAIs
+
+- (NSString *)parseInformationWithError:(NSError **)error {
+ NSMutableString *buff = [NSMutableString string];
+
+ [buff appendString:@"(01)"];
+ int initialGtinPosition = [buff length];
+ int firstGtinDigit = [self.generalDecoder extractNumericValueFromBitArray:AI01_HEADER_SIZE bits:4];
+ [buff appendFormat:@"%d", firstGtinDigit];
+
+ [self encodeCompressedGtinWithoutAI:buff currentPos:AI01_HEADER_SIZE + 4 initialBufferPosition:initialGtinPosition];
+
+ return [self.generalDecoder decodeAllCodes:buff initialPosition:AI01_HEADER_SIZE + 44 error:error];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01decoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01decoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..e562ffb7f5b6f885f80e7ad5c9fe4ee6e940d792
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01decoder.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractExpandedDecoder.h"
+
+extern const int GTIN_SIZE;
+
+@interface ZXAI01decoder : ZXAbstractExpandedDecoder
+
+- (void)encodeCompressedGtin:(NSMutableString *)buf currentPos:(int)currentPos;
+- (void)encodeCompressedGtinWithoutAI:(NSMutableString *)buf currentPos:(int)currentPos initialBufferPosition:(int)initialBufferPosition;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01decoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01decoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..6138a8b08ffbc17a0d16f5d4c62331b97a760e6a
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01decoder.m
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI01decoder.h"
+#import "ZXBitArray.h"
+#import "ZXGeneralAppIdDecoder.h"
+
+int const GTIN_SIZE = 40;
+
+@interface ZXAI01decoder ()
+
+- (void)appendCheckDigit:(NSMutableString *)buf currentPos:(int)currentPos;
+
+@end
+
+
+@implementation ZXAI01decoder
+
+- (void)encodeCompressedGtin:(NSMutableString *)buf currentPos:(int)currentPos {
+ [buf appendString:@"(01)"];
+ int initialPosition = [buf length];
+ [buf appendString:@"9"];
+
+ [self encodeCompressedGtinWithoutAI:buf currentPos:currentPos initialBufferPosition:initialPosition];
+}
+
+- (void)encodeCompressedGtinWithoutAI:(NSMutableString *)buf currentPos:(int)currentPos initialBufferPosition:(int)initialBufferPosition {
+ for (int i = 0; i < 4; ++i) {
+ int currentBlock = [self.generalDecoder extractNumericValueFromBitArray:currentPos + 10 * i bits:10];
+ if (currentBlock / 100 == 0) {
+ [buf appendString:@"0"];
+ }
+ if (currentBlock / 10 == 0) {
+ [buf appendString:@"0"];
+ }
+ [buf appendFormat:@"%d", currentBlock];
+ }
+
+ [self appendCheckDigit:buf currentPos:initialBufferPosition];
+}
+
+- (void)appendCheckDigit:(NSMutableString *)buf currentPos:(int)currentPos {
+ int checkDigit = 0;
+ for (int i = 0; i < 13; i++) {
+ int digit = [buf characterAtIndex:i + currentPos] - '0';
+ checkDigit += (i & 0x01) == 0 ? 3 * digit : digit;
+ }
+
+ checkDigit = 10 - (checkDigit % 10);
+ if (checkDigit == 10) {
+ checkDigit = 0;
+ }
+
+ [buf appendFormat:@"%d", checkDigit];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01weightDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01weightDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..40750a23a66344c2b0ad8ceddef2aad1a657f467
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01weightDecoder.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI01decoder.h"
+
+@class ZXBitArray;
+
+@interface ZXAI01weightDecoder : ZXAI01decoder
+
+- (void)encodeCompressedWeight:(NSMutableString *)buf currentPos:(int)currentPos weightSize:(int)weightSize;
+- (void)addWeightCode:(NSMutableString *)buf weight:(int)weight;
+- (int)checkWeight:(int)weight;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01weightDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01weightDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..fe71cb85e0834f968bbd55a6d9a8f2792e0d32cf
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAI01weightDecoder.m
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAI01weightDecoder.h"
+#import "ZXGeneralAppIdDecoder.h"
+
+@implementation ZXAI01weightDecoder
+
+- (void)encodeCompressedWeight:(NSMutableString *)buf currentPos:(int)currentPos weightSize:(int)weightSize {
+ int originalWeightNumeric = [self.generalDecoder extractNumericValueFromBitArray:currentPos bits:weightSize];
+ [self addWeightCode:buf weight:originalWeightNumeric];
+
+ int weightNumeric = [self checkWeight:originalWeightNumeric];
+
+ int currentDivisor = 100000;
+ for (int i = 0; i < 5; ++i) {
+ if (weightNumeric / currentDivisor == 0) {
+ [buf appendString:@"0"];
+ }
+ currentDivisor /= 10;
+ }
+
+ [buf appendFormat:@"%d", weightNumeric];
+}
+
+- (void)addWeightCode:(NSMutableString *)buf weight:(int)weight {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+- (int)checkWeight:(int)weight {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAbstractExpandedDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAbstractExpandedDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..a210f92096d71f8162f385bc959be6bf8d6c7ae6
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAbstractExpandedDecoder.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXBitArray, ZXGeneralAppIdDecoder;
+
+@interface ZXAbstractExpandedDecoder : NSObject
+
+@property (nonatomic, retain, readonly) ZXGeneralAppIdDecoder *generalDecoder;
+@property (nonatomic, retain, readonly) ZXBitArray *information;
+
+- (id)initWithInformation:(ZXBitArray *)information;
+- (NSString *)parseInformationWithError:(NSError **)error;
++ (ZXAbstractExpandedDecoder *)createDecoder:(ZXBitArray *)information;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAbstractExpandedDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAbstractExpandedDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..8f6e553096ca6a76ca469dffc57ffabd3496b1b1
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAbstractExpandedDecoder.m
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractExpandedDecoder.h"
+#import "ZXAI013103decoder.h"
+#import "ZXAI01320xDecoder.h"
+#import "ZXAI01392xDecoder.h"
+#import "ZXAI01393xDecoder.h"
+#import "ZXAI013x0x1xDecoder.h"
+#import "ZXAI01AndOtherAIs.h"
+#import "ZXAnyAIDecoder.h"
+#import "ZXBitArray.h"
+#import "ZXGeneralAppIdDecoder.h"
+
+@interface ZXAbstractExpandedDecoder ()
+
+@property (nonatomic, retain) ZXGeneralAppIdDecoder *generalDecoder;
+@property (nonatomic, retain) ZXBitArray *information;
+
+@end
+
+@implementation ZXAbstractExpandedDecoder
+
+@synthesize generalDecoder;
+@synthesize information;
+
+- (id)initWithInformation:(ZXBitArray *)anInformation {
+ if (self = [super init]) {
+ self.information = anInformation;
+ self.generalDecoder = [[[ZXGeneralAppIdDecoder alloc] initWithInformation:anInformation] autorelease];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [information release];
+ [generalDecoder release];
+
+ [super dealloc];
+}
+
+- (NSString *)parseInformationWithError:(NSError **)error {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
++ (ZXAbstractExpandedDecoder *)createDecoder:(ZXBitArray *)information {
+ if ([information get:1]) {
+ return [[[ZXAI01AndOtherAIs alloc] initWithInformation:information] autorelease];
+ }
+ if (![information get:2]) {
+ return [[[ZXAnyAIDecoder alloc] initWithInformation:information] autorelease];
+ }
+
+ int fourBitEncodationMethod = [ZXGeneralAppIdDecoder extractNumericValueFromBitArray:information pos:1 bits:4];
+
+ switch (fourBitEncodationMethod) {
+ case 4:
+ return [[[ZXAI013103decoder alloc] initWithInformation:information] autorelease];
+ case 5:
+ return [[[ZXAI01320xDecoder alloc] initWithInformation:information] autorelease];
+ }
+
+ int fiveBitEncodationMethod = [ZXGeneralAppIdDecoder extractNumericValueFromBitArray:information pos:1 bits:5];
+ switch (fiveBitEncodationMethod) {
+ case 12:
+ return [[[ZXAI01392xDecoder alloc] initWithInformation:information] autorelease];
+ case 13:
+ return [[[ZXAI01393xDecoder alloc] initWithInformation:information] autorelease];
+ }
+
+ int sevenBitEncodationMethod = [ZXGeneralAppIdDecoder extractNumericValueFromBitArray:information pos:1 bits:7];
+ switch (sevenBitEncodationMethod) {
+ case 56:
+ return [[[ZXAI013x0x1xDecoder alloc] initWithInformation:information firstAIdigits:@"310" dateCode:@"11"] autorelease];
+ case 57:
+ return [[[ZXAI013x0x1xDecoder alloc] initWithInformation:information firstAIdigits:@"320" dateCode:@"11"] autorelease];
+ case 58:
+ return [[[ZXAI013x0x1xDecoder alloc] initWithInformation:information firstAIdigits:@"310" dateCode:@"13"] autorelease];
+ case 59:
+ return [[[ZXAI013x0x1xDecoder alloc] initWithInformation:information firstAIdigits:@"320" dateCode:@"13"] autorelease];
+ case 60:
+ return [[[ZXAI013x0x1xDecoder alloc] initWithInformation:information firstAIdigits:@"310" dateCode:@"15"] autorelease];
+ case 61:
+ return [[[ZXAI013x0x1xDecoder alloc] initWithInformation:information firstAIdigits:@"320" dateCode:@"15"] autorelease];
+ case 62:
+ return [[[ZXAI013x0x1xDecoder alloc] initWithInformation:information firstAIdigits:@"310" dateCode:@"17"] autorelease];
+ case 63:
+ return [[[ZXAI013x0x1xDecoder alloc] initWithInformation:information firstAIdigits:@"320" dateCode:@"17"] autorelease];
+ }
+
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"unknown decoder: %@", information]
+ userInfo:nil];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAnyAIDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAnyAIDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..3dfda9595a676470a21eeab569d729269ef108e9
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAnyAIDecoder.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractExpandedDecoder.h"
+
+@interface ZXAnyAIDecoder : ZXAbstractExpandedDecoder
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAnyAIDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAnyAIDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..09283304ebb0973dad7603898b15bdcd001f595f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXAnyAIDecoder.m
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAnyAIDecoder.h"
+#import "ZXGeneralAppIdDecoder.h"
+
+int const ANY_AI_HEADER_SIZE = 2 + 1 + 2;
+
+@implementation ZXAnyAIDecoder
+
+- (NSString *)parseInformationWithError:(NSError **)error {
+ NSMutableString *buf = [NSMutableString string];
+ return [self.generalDecoder decodeAllCodes:buf initialPosition:ANY_AI_HEADER_SIZE error:error];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXBlockParsedResult.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXBlockParsedResult.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c13d9bf638377f4d8fe1d0c6e009392dcc0f0a5
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXBlockParsedResult.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXDecodedInformation;
+
+@interface ZXBlockParsedResult : NSObject
+
+@property (nonatomic, retain, readonly) ZXDecodedInformation *decodedInformation;
+@property (nonatomic, assign, readonly) BOOL finished;
+
+- (id)initWithFinished:(BOOL)finished;
+- (id)initWithInformation:(ZXDecodedInformation *)information finished:(BOOL)finished;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXBlockParsedResult.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXBlockParsedResult.m
new file mode 100644
index 0000000000000000000000000000000000000000..bedc94ef73fc25dc71b9222117877648bca9e7bc
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXBlockParsedResult.m
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBlockParsedResult.h"
+#import "ZXDecodedInformation.h"
+
+@interface ZXBlockParsedResult ()
+
+@property (nonatomic, retain) ZXDecodedInformation *decodedInformation;
+@property (nonatomic, assign) BOOL finished;
+
+@end
+
+@implementation ZXBlockParsedResult
+
+@synthesize decodedInformation;
+@synthesize finished;
+
+- (id)initWithFinished:(BOOL)isFinished {
+ return [self initWithInformation:nil finished:isFinished];
+}
+
+- (id)initWithInformation:(ZXDecodedInformation *)information finished:(BOOL)isFinished {
+ if (self = [super init]) {
+ self.decodedInformation = information;
+ self.finished = isFinished;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [decodedInformation release];
+
+ [super dealloc];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXCurrentParsingState.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXCurrentParsingState.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a20935fe93c7eac69f22ea5c28853b82b47d381
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXCurrentParsingState.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@interface ZXCurrentParsingState : NSObject
+
+@property (nonatomic, assign) int position;
+
+- (BOOL)alpha;
+- (BOOL)numeric;
+- (BOOL)isoIec646;
+- (void)setNumeric;
+- (void)setAlpha;
+- (void)setIsoIec646;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXCurrentParsingState.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXCurrentParsingState.m
new file mode 100644
index 0000000000000000000000000000000000000000..5ddc6691f63335cc1aee2e0878f838c45baec3e4
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXCurrentParsingState.m
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXCurrentParsingState.h"
+
+enum {
+ NUMERIC_STATE,
+ ALPHA_STATE,
+ ISO_IEC_646_STATE
+};
+
+@interface ZXCurrentParsingState ()
+
+@property (nonatomic, assign) int encoding;
+
+@end
+
+@implementation ZXCurrentParsingState
+
+@synthesize encoding;
+@synthesize position;
+
+- (id)init {
+ if (self = [super init]) {
+ self.position = 0;
+ self.encoding = NUMERIC_STATE;
+ }
+ return self;
+}
+
+- (BOOL)alpha {
+ return self.encoding == ALPHA_STATE;
+}
+
+- (BOOL)numeric {
+ return self.encoding == NUMERIC_STATE;
+}
+
+- (BOOL)isoIec646 {
+ return self.encoding == ISO_IEC_646_STATE;
+}
+
+- (void)setNumeric {
+ self.encoding = NUMERIC_STATE;
+}
+
+- (void)setAlpha {
+ self.encoding = ALPHA_STATE;
+}
+
+- (void)setIsoIec646 {
+ self.encoding = ISO_IEC_646_STATE;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedChar.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedChar.h
new file mode 100644
index 0000000000000000000000000000000000000000..f589413b17bbfd015383ac23eb87a2947ec814a4
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedChar.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecodedObject.h"
+
+extern unichar const FNC1char;
+
+@interface ZXDecodedChar : ZXDecodedObject
+
+@property (nonatomic, assign, readonly) unichar value;
+
+- (id)initWithNewPosition:(int)newPosition value:(unichar)value;
+- (BOOL)fnc1;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedChar.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedChar.m
new file mode 100644
index 0000000000000000000000000000000000000000..278c969355e9e82cad0795efc9da9d3d017f37d6
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedChar.m
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecodedChar.h"
+
+unichar const FNC1char = '$';
+
+@interface ZXDecodedChar ()
+
+@property (nonatomic, assign) unichar value;
+
+@end
+
+@implementation ZXDecodedChar
+
+@synthesize value;
+
+- (id) initWithNewPosition:(int)aNewPosition value:(unichar)aValue {
+ if (self = [super initWithNewPosition:aNewPosition]) {
+ self.value = aValue;
+ }
+
+ return self;
+}
+
+- (BOOL)fnc1 {
+ return self.value == FNC1char;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedInformation.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedInformation.h
new file mode 100644
index 0000000000000000000000000000000000000000..d0531a91250d220de8dde0ca8e686da375d0ea40
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedInformation.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecodedObject.h"
+
+@interface ZXDecodedInformation : ZXDecodedObject
+
+@property (nonatomic, copy, readonly) NSString *theNewString;
+@property (nonatomic, assign, readonly) int remainingValue;
+@property (nonatomic, assign, readonly) BOOL remaining;
+
+- (id)initWithNewPosition:(int)newPosition newString:(NSString *)newString;
+- (id)initWithNewPosition:(int)newPosition newString:(NSString *)newString remainingValue:(int)remainingValue;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedInformation.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedInformation.m
new file mode 100644
index 0000000000000000000000000000000000000000..2b4fc5f7111b78f609366f30d47f2138418d4fd8
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedInformation.m
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecodedInformation.h"
+
+@interface ZXDecodedInformation ()
+
+@property (nonatomic, copy) NSString *theNewString;
+@property (nonatomic, assign) int remainingValue;
+@property (nonatomic, assign) BOOL remaining;
+
+@end
+
+@implementation ZXDecodedInformation
+
+@synthesize remaining;
+@synthesize remainingValue;
+@synthesize theNewString;
+
+- (id)initWithNewPosition:(int)aNewPosition newString:(NSString *)aNewString {
+ if (self = [super initWithNewPosition:aNewPosition]) {
+ self.remaining = NO;
+ self.remainingValue = 0;
+ self.theNewString = aNewString;
+ }
+
+ return self;
+}
+
+- (id)initWithNewPosition:(int)aNewPosition newString:(NSString *)aNewString remainingValue:(int)aRemainingValue {
+ if (self = [super initWithNewPosition:aNewPosition]) {
+ self.remaining = YES;
+ self.remainingValue = aRemainingValue;
+ self.theNewString = aNewString;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [theNewString release];
+
+ [super dealloc];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedNumeric.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedNumeric.h
new file mode 100644
index 0000000000000000000000000000000000000000..1583f4f4f1566884df1fe3ef8997f3565fd85c89
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedNumeric.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecodedObject.h"
+
+extern const int FNC1;
+
+@interface ZXDecodedNumeric : ZXDecodedObject
+
+@property (nonatomic, assign, readonly) int firstDigit;
+@property (nonatomic, assign, readonly) int secondDigit;
+@property (nonatomic, assign, readonly) int value;
+
+- (id)initWithNewPosition:(int)newPosition firstDigit:(int)firstDigit secondDigit:(int)secondDigit;
+- (BOOL)firstDigitFNC1;
+- (BOOL)secondDigitFNC1;
+- (BOOL)anyFNC1;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedNumeric.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedNumeric.m
new file mode 100644
index 0000000000000000000000000000000000000000..ec74c943db4a1ccf1cfd768c992420c3194a2376
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedNumeric.m
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecodedNumeric.h"
+
+const int FNC1 = 10;
+
+@interface ZXDecodedNumeric ()
+
+@property (nonatomic, assign) int firstDigit;
+@property (nonatomic, assign) int secondDigit;
+
+@end
+
+
+@implementation ZXDecodedNumeric
+
+@synthesize firstDigit;
+@synthesize secondDigit;
+
+- (id)initWithNewPosition:(int)newPosition firstDigit:(int)aFirstDigit secondDigit:(int)aSecondDigit {
+ if (self = [super initWithNewPosition:newPosition]) {
+ self.firstDigit = aFirstDigit;
+ self.secondDigit = aSecondDigit;
+
+ if (self.firstDigit < 0 || self.firstDigit > 10) {
+ [NSException raise:NSInvalidArgumentException format:@"Invalid firstDigit: %d", firstDigit];
+ }
+
+ if (self.secondDigit < 0 || self.secondDigit > 10) {
+ [NSException raise:NSInvalidArgumentException format:@"Invalid secondDigit: %d", secondDigit];
+ }
+ }
+
+ return self;
+}
+
+- (int)value {
+ return self.firstDigit * 10 + self.secondDigit;
+}
+
+- (BOOL)firstDigitFNC1 {
+ return self.firstDigit == FNC1;
+}
+
+- (BOOL)secondDigitFNC1 {
+ return self.secondDigit == FNC1;
+}
+
+- (BOOL)anyFNC1 {
+ return self.firstDigit == FNC1 || self.secondDigit == FNC1;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedObject.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedObject.h
new file mode 100644
index 0000000000000000000000000000000000000000..fe682708223b6666b89adbf5adc1c164100db7e3
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedObject.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@interface ZXDecodedObject : NSObject
+
+@property (nonatomic, assign, readonly) int theNewPosition;
+
+- (id)initWithNewPosition:(int)newPosition;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedObject.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedObject.m
new file mode 100644
index 0000000000000000000000000000000000000000..46271c5a6f0e24664dd820cc0fc64ab7844b3dcb
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXDecodedObject.m
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecodedObject.h"
+
+@interface ZXDecodedObject ()
+
+@property (nonatomic, assign) int theNewPosition;
+
+@end
+
+@implementation ZXDecodedObject
+
+@synthesize theNewPosition;
+
+- (id)initWithNewPosition:(int)aNewPosition {
+ if (self = [super init]) {
+ self.theNewPosition = aNewPosition;
+ }
+
+ return self;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXFieldParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXFieldParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..1ab916862652723298f523ecd7938ba0beed6247
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXFieldParser.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@interface ZXFieldParser : NSObject
+
++ (NSString *)parseFieldsInGeneralPurpose:(NSString *)rawInformation error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXFieldParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXFieldParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..14b06f3110a2b21afc8d356a093705ff44e91fb9
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXFieldParser.m
@@ -0,0 +1,332 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXErrors.h"
+#import "ZXFieldParser.h"
+
+static NSObject *VARIABLE_LENGTH = nil;
+static NSArray *TWO_DIGIT_DATA_LENGTH = nil;
+static NSArray *THREE_DIGIT_DATA_LENGTH = nil;
+static NSArray *THREE_DIGIT_PLUS_DIGIT_DATA_LENGTH = nil;
+static NSArray *FOUR_DIGIT_DATA_LENGTH = nil;
+
+@interface ZXFieldParser ()
+
++ (NSString *)processFixedAI:(int)aiSize fieldSize:(int)fieldSize rawInformation:(NSString *)rawInformation;
++ (NSString *)processVariableAI:(int)aiSize variableFieldSize:(int)variableFieldSize rawInformation:(NSString *)rawInformation;
+
+@end
+
+@implementation ZXFieldParser
+
++ (void)initialize {
+ if (VARIABLE_LENGTH == nil) {
+ VARIABLE_LENGTH = [[NSObject alloc] init];
+ }
+
+ if (TWO_DIGIT_DATA_LENGTH == nil) {
+ TWO_DIGIT_DATA_LENGTH = [[NSArray alloc] initWithObjects:
+ [NSArray arrayWithObjects:@"00", [NSNumber numberWithInt:18], nil],
+ [NSArray arrayWithObjects:@"01", [NSNumber numberWithInt:14], nil],
+ [NSArray arrayWithObjects:@"02", [NSNumber numberWithInt:14], nil],
+
+ [NSArray arrayWithObjects:@"10", VARIABLE_LENGTH, [NSNumber numberWithInt:20], nil],
+ [NSArray arrayWithObjects:@"11", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"12", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"13", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"15", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"17", [NSNumber numberWithInt:6], nil],
+
+ [NSArray arrayWithObjects:@"20", [NSNumber numberWithInt:2], nil],
+ [NSArray arrayWithObjects:@"21", VARIABLE_LENGTH, [NSNumber numberWithInt:20], nil],
+ [NSArray arrayWithObjects:@"22", VARIABLE_LENGTH, [NSNumber numberWithInt:29], nil],
+
+ [NSArray arrayWithObjects:@"30", VARIABLE_LENGTH, [NSNumber numberWithInt: 8], nil],
+ [NSArray arrayWithObjects:@"37", VARIABLE_LENGTH, [NSNumber numberWithInt: 8], nil],
+
+ //internal company codes
+ [NSArray arrayWithObjects:@"90", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"91", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"92", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"93", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"94", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"95", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"96", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"97", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"98", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"99", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ nil];
+ }
+
+ if (THREE_DIGIT_DATA_LENGTH == nil) {
+ THREE_DIGIT_DATA_LENGTH = [[NSArray alloc] initWithObjects:
+ [NSArray arrayWithObjects:@"240", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"241", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"242", VARIABLE_LENGTH, [NSNumber numberWithInt: 6], nil],
+ [NSArray arrayWithObjects:@"250", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"251", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"253", VARIABLE_LENGTH, [NSNumber numberWithInt:17], nil],
+ [NSArray arrayWithObjects:@"254", VARIABLE_LENGTH, [NSNumber numberWithInt:20], nil],
+
+ [NSArray arrayWithObjects:@"400", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"401", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"402", [NSNumber numberWithInt:17], nil],
+ [NSArray arrayWithObjects:@"403", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"410", [NSNumber numberWithInt:13], nil],
+ [NSArray arrayWithObjects:@"411", [NSNumber numberWithInt:13], nil],
+ [NSArray arrayWithObjects:@"412", [NSNumber numberWithInt:13], nil],
+ [NSArray arrayWithObjects:@"413", [NSNumber numberWithInt:13], nil],
+ [NSArray arrayWithObjects:@"414", [NSNumber numberWithInt:13], nil],
+ [NSArray arrayWithObjects:@"420", VARIABLE_LENGTH, [NSNumber numberWithInt:20], nil],
+ [NSArray arrayWithObjects:@"421", VARIABLE_LENGTH, [NSNumber numberWithInt:15], nil],
+ [NSArray arrayWithObjects:@"422", [NSNumber numberWithInt:3], nil],
+ [NSArray arrayWithObjects:@"423", VARIABLE_LENGTH, [NSNumber numberWithInt:15], nil],
+ [NSArray arrayWithObjects:@"424", [NSNumber numberWithInt:3], nil],
+ [NSArray arrayWithObjects:@"425", [NSNumber numberWithInt:3], nil],
+ [NSArray arrayWithObjects:@"426", [NSNumber numberWithInt:3], nil],
+ nil];
+
+ }
+
+ if (THREE_DIGIT_PLUS_DIGIT_DATA_LENGTH == nil) {
+ THREE_DIGIT_PLUS_DIGIT_DATA_LENGTH = [[NSArray alloc] initWithObjects:
+ [NSArray arrayWithObjects:@"310", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"311", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"312", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"313", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"314", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"315", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"316", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"320", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"321", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"322", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"323", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"324", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"325", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"326", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"327", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"328", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"329", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"330", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"331", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"332", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"333", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"334", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"335", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"336", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"340", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"341", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"342", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"343", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"344", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"345", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"346", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"347", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"348", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"349", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"350", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"351", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"352", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"353", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"354", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"355", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"356", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"357", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"360", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"361", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"362", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"363", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"364", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"365", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"366", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"367", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"368", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"369", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"390", VARIABLE_LENGTH, [NSNumber numberWithInt:15], nil],
+ [NSArray arrayWithObjects:@"391", VARIABLE_LENGTH, [NSNumber numberWithInt:18], nil],
+ [NSArray arrayWithObjects:@"392", VARIABLE_LENGTH, [NSNumber numberWithInt:15], nil],
+ [NSArray arrayWithObjects:@"393", VARIABLE_LENGTH, [NSNumber numberWithInt:18], nil],
+ [NSArray arrayWithObjects:@"703", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ nil];
+ }
+
+ if (FOUR_DIGIT_DATA_LENGTH == nil) {
+ FOUR_DIGIT_DATA_LENGTH = [[NSArray alloc] initWithObjects:
+ [NSArray arrayWithObjects:@"7001", [NSNumber numberWithInt:13], nil],
+ [NSArray arrayWithObjects:@"7002", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"7003", [NSNumber numberWithInt:10], nil],
+
+ [NSArray arrayWithObjects:@"8001", [NSNumber numberWithInt:14], nil],
+ [NSArray arrayWithObjects:@"8002", VARIABLE_LENGTH, [NSNumber numberWithInt:20], nil],
+ [NSArray arrayWithObjects:@"8003", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"8004", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"8005", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"8006", [NSNumber numberWithInt:18], nil],
+ [NSArray arrayWithObjects:@"8007", VARIABLE_LENGTH, [NSNumber numberWithInt:30], nil],
+ [NSArray arrayWithObjects:@"8008", VARIABLE_LENGTH, [NSNumber numberWithInt:12], nil],
+ [NSArray arrayWithObjects:@"8018", [NSNumber numberWithInt:18], nil],
+ [NSArray arrayWithObjects:@"8020", VARIABLE_LENGTH, [NSNumber numberWithInt:25], nil],
+ [NSArray arrayWithObjects:@"8100", [NSNumber numberWithInt:6], nil],
+ [NSArray arrayWithObjects:@"8101", [NSNumber numberWithInt:10], nil],
+ [NSArray arrayWithObjects:@"8102", [NSNumber numberWithInt:2], nil],
+ [NSArray arrayWithObjects:@"8110", VARIABLE_LENGTH, [NSNumber numberWithInt:70], nil],
+ [NSArray arrayWithObjects:@"8200", VARIABLE_LENGTH, [NSNumber numberWithInt:70], nil],
+ nil];
+ }
+}
+
++ (NSString *)parseFieldsInGeneralPurpose:(NSString *)rawInformation error:(NSError **)error {
+ if ([rawInformation length] == 0) {
+ return @"";
+ }
+ if ([rawInformation length] < 2) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ NSString *firstTwoDigits = [rawInformation substringWithRange:NSMakeRange(0, 2)];
+
+ for (int i = 0; i < [TWO_DIGIT_DATA_LENGTH count]; ++i) {
+ if ([[[TWO_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:0] isEqualToString:firstTwoDigits]) {
+ if ([[[TWO_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:1] isEqual:VARIABLE_LENGTH]) {
+ return [self processVariableAI:2
+ variableFieldSize:[[[TWO_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:2] intValue]
+ rawInformation:rawInformation];
+ }
+ NSString *result = [self processFixedAI:2
+ fieldSize:[[[TWO_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:1] intValue]
+ rawInformation:rawInformation];
+ if (!result) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ return result;
+ }
+ }
+
+ if ([rawInformation length] < 3) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ NSString *firstThreeDigits = [rawInformation substringWithRange:NSMakeRange(0, 3)];
+
+ for (int i = 0; i < [THREE_DIGIT_DATA_LENGTH count]; ++i) {
+ if ([[[THREE_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:0] isEqualToString:firstThreeDigits]) {
+ if ([[[THREE_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:1] isEqual:VARIABLE_LENGTH]) {
+ return [self processVariableAI:3
+ variableFieldSize:[[[THREE_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:2] intValue]
+ rawInformation:rawInformation];
+ }
+ NSString *result = [self processFixedAI:3
+ fieldSize:[[[THREE_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:1] intValue]
+ rawInformation:rawInformation];
+ if (!result) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ return result;
+ }
+ }
+
+ for (int i = 0; i < [THREE_DIGIT_PLUS_DIGIT_DATA_LENGTH count]; ++i) {
+ if ([[[THREE_DIGIT_PLUS_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:0] isEqualToString:firstThreeDigits]) {
+ if ([[[THREE_DIGIT_PLUS_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:1] isEqual:VARIABLE_LENGTH]) {
+ return [self processVariableAI:4
+ variableFieldSize:[[[THREE_DIGIT_PLUS_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:2] intValue]
+ rawInformation:rawInformation];
+ }
+ NSString *result = [self processFixedAI:4
+ fieldSize:[[[THREE_DIGIT_PLUS_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:1] intValue]
+ rawInformation:rawInformation];
+ if (!result) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ return result;
+ }
+ }
+
+ if ([rawInformation length] < 4) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ NSString *firstFourDigits = [rawInformation substringWithRange:NSMakeRange(0, 4)];
+
+ for (int i = 0; i < [FOUR_DIGIT_DATA_LENGTH count]; ++i) {
+ if ([[[FOUR_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:0] isEqualToString:firstFourDigits]) {
+ if ([[[FOUR_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:1] isEqual:VARIABLE_LENGTH]) {
+ NSString *result = [self processVariableAI:4
+ variableFieldSize:[[[FOUR_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:2] intValue]
+ rawInformation:rawInformation];
+ if (!result) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ return result;
+ }
+ NSString *result = [self processFixedAI:4
+ fieldSize:[[[FOUR_DIGIT_DATA_LENGTH objectAtIndex:i] objectAtIndex:1] intValue]
+ rawInformation:rawInformation];
+ if (!result) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ return result;
+ }
+ }
+
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+}
+
++ (NSString *)processFixedAI:(int)aiSize fieldSize:(int)fieldSize rawInformation:(NSString *)rawInformation {
+ if ([rawInformation length] < aiSize) {
+ return nil;
+ }
+
+ NSString *ai = [rawInformation substringWithRange:NSMakeRange(0, aiSize)];
+ if ([rawInformation length] < aiSize + fieldSize) {
+ return nil;
+ }
+
+ NSString *field = [rawInformation substringWithRange:NSMakeRange(aiSize, fieldSize)];
+ NSString *remaining;
+ if (aiSize + fieldSize == rawInformation.length) {
+ remaining = @"";
+ } else {
+ remaining = [rawInformation substringFromIndex:aiSize + fieldSize];
+ }
+
+ NSString *result = [NSString stringWithFormat:@"(%@)%@", ai, field];
+ NSString *parsedAI = [self parseFieldsInGeneralPurpose:remaining error:nil];
+ return parsedAI == nil ? result : [result stringByAppendingString:parsedAI];
+}
+
++ (NSString *)processVariableAI:(int)aiSize variableFieldSize:(int)variableFieldSize rawInformation:(NSString *)rawInformation {
+ NSString *ai = [rawInformation substringWithRange:NSMakeRange(0, aiSize)];
+ int maxSize;
+ if ([rawInformation length] < aiSize + variableFieldSize) {
+ maxSize = [rawInformation length];
+ } else {
+ maxSize = aiSize + variableFieldSize;
+ }
+ NSString *field = [rawInformation substringWithRange:NSMakeRange(aiSize, maxSize - aiSize)];
+ NSString *remaining = [rawInformation substringFromIndex:maxSize];
+ NSString *result = [NSString stringWithFormat:@"(%@)%@", ai, field];
+ NSString *parsedAI = [self parseFieldsInGeneralPurpose:remaining error:nil];
+ return parsedAI == nil ? result : [result stringByAppendingString:parsedAI];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXGeneralAppIdDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXGeneralAppIdDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..ae13a80bed823df55ad312567ef4cb8684269d68
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXGeneralAppIdDecoder.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXBitArray, ZXDecodedInformation;
+
+@interface ZXGeneralAppIdDecoder : NSObject
+
+- (id)initWithInformation:(ZXBitArray *)information;
+- (NSString *)decodeAllCodes:(NSMutableString *)buff initialPosition:(int)initialPosition error:(NSError **)error;
+- (int)extractNumericValueFromBitArray:(int)pos bits:(int)bits;
++ (int)extractNumericValueFromBitArray:(ZXBitArray *)information pos:(int)pos bits:(int)bits;
+- (ZXDecodedInformation *)decodeGeneralPurposeField:(int)pos remaining:(NSString *)remaining;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXGeneralAppIdDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXGeneralAppIdDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..c7d4a9cf677e259cdfa9478b838b73f2ee6b593c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/oned/rss/expanded/decoders/ZXGeneralAppIdDecoder.m
@@ -0,0 +1,515 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXBlockParsedResult.h"
+#import "ZXCurrentParsingState.h"
+#import "ZXDecodedChar.h"
+#import "ZXDecodedInformation.h"
+#import "ZXDecodedNumeric.h"
+#import "ZXFieldParser.h"
+#import "ZXGeneralAppIdDecoder.h"
+
+@interface ZXGeneralAppIdDecoder ()
+
+@property (nonatomic, retain) ZXBitArray *information;
+@property (nonatomic, retain) ZXCurrentParsingState *current;
+@property (nonatomic, retain) NSMutableString *buffer;
+
+- (ZXDecodedChar *)decodeAlphanumeric:(int)pos;
+- (ZXDecodedChar *)decodeIsoIec646:(int)pos;
+- (ZXDecodedNumeric *)decodeNumeric:(int)pos;
+- (BOOL)isAlphaOr646ToNumericLatch:(int)pos;
+- (BOOL)isAlphaTo646ToAlphaLatch:(int)pos;
+- (BOOL)isNumericToAlphaNumericLatch:(int)pos;
+- (BOOL)isStillAlpha:(int)pos;
+- (BOOL)isStillIsoIec646:(int)pos;
+- (BOOL)isStillNumeric:(int)pos;
+- (ZXBlockParsedResult *)parseAlphaBlock;
+- (ZXDecodedInformation *)parseBlocks;
+- (ZXBlockParsedResult *)parseIsoIec646Block;
+- (ZXBlockParsedResult *)parseNumericBlock;
+
+@end
+
+@implementation ZXGeneralAppIdDecoder
+
+@synthesize information;
+@synthesize current;
+@synthesize buffer;
+
+- (id)initWithInformation:(ZXBitArray *)anInformation {
+ if (self = [super init]) {
+ self.current = [[[ZXCurrentParsingState alloc] init] autorelease];
+ self.buffer = [NSMutableString string];
+ self.information = anInformation;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [information release];
+ [current release];
+ [buffer release];
+
+ [super dealloc];
+}
+
+- (NSString *)decodeAllCodes:(NSMutableString *)buff initialPosition:(int)initialPosition error:(NSError **)error {
+ int currentPosition = initialPosition;
+ NSString *remaining = nil;
+ do {
+ ZXDecodedInformation *info = [self decodeGeneralPurposeField:currentPosition remaining:remaining];
+ NSString *parsedFields = [ZXFieldParser parseFieldsInGeneralPurpose:[info theNewString] error:error];
+ if (!parsedFields) {
+ return nil;
+ } else if (parsedFields.length > 0) {
+ [buff appendString:parsedFields];
+ }
+
+ if ([info remaining]) {
+ remaining = [[NSNumber numberWithInt:[info remainingValue]] stringValue];
+ } else {
+ remaining = nil;
+ }
+
+ if (currentPosition == [info theNewPosition]) {
+ break;
+ }
+ currentPosition = [info theNewPosition];
+ } while (YES);
+
+ return buff;
+}
+
+- (BOOL)isStillNumeric:(int)pos {
+ if (pos + 7 > self.information.size) {
+ return pos + 4 <= self.information.size;
+ }
+
+ for (int i = pos; i < pos + 3; ++i) {
+ if ([self.information get:i]) {
+ return YES;
+ }
+ }
+
+ return [self.information get:pos + 3];
+}
+
+- (ZXDecodedNumeric *)decodeNumeric:(int)pos {
+ if (pos + 7 > self.information.size) {
+ int numeric = [self extractNumericValueFromBitArray:pos bits:4];
+ if (numeric == 0) {
+ return [[[ZXDecodedNumeric alloc] initWithNewPosition:self.information.size
+ firstDigit:FNC1
+ secondDigit:FNC1] autorelease];
+ }
+ return [[[ZXDecodedNumeric alloc] initWithNewPosition:self.information.size
+ firstDigit:numeric - 1
+ secondDigit:FNC1] autorelease];
+ }
+ int numeric = [self extractNumericValueFromBitArray:pos bits:7];
+
+ int digit1 = (numeric - 8) / 11;
+ int digit2 = (numeric - 8) % 11;
+
+ return [[[ZXDecodedNumeric alloc] initWithNewPosition:pos + 7
+ firstDigit:digit1
+ secondDigit:digit2] autorelease];
+}
+
+- (int)extractNumericValueFromBitArray:(int)pos bits:(int)bits {
+ return [ZXGeneralAppIdDecoder extractNumericValueFromBitArray:information pos:pos bits:bits];
+}
+
++ (int)extractNumericValueFromBitArray:(ZXBitArray *)information pos:(int)pos bits:(int)bits {
+ if (bits > 32) {
+ [NSException raise:NSInvalidArgumentException format:@"extractNumberValueFromBitArray can't handle more than 32 bits"];
+ }
+
+ int value = 0;
+ for (int i = 0; i < bits; ++i) {
+ if ([information get:pos + i]) {
+ value |= 1 << (bits - i - 1);
+ }
+ }
+
+ return value;
+}
+
+- (ZXDecodedInformation *)decodeGeneralPurposeField:(int)pos remaining:(NSString *)remaining {
+ [self.buffer setString:@""];
+
+ if (remaining != nil) {
+ [self.buffer appendString:remaining];
+ }
+
+ self.current.position = pos;
+
+ ZXDecodedInformation *lastDecoded = [self parseBlocks];
+ if (lastDecoded != nil && [lastDecoded remaining]) {
+ return [[[ZXDecodedInformation alloc] initWithNewPosition:self.current.position
+ newString:self.buffer
+ remainingValue:lastDecoded.remainingValue] autorelease];
+ }
+ return [[[ZXDecodedInformation alloc] initWithNewPosition:self.current.position newString:self.buffer] autorelease];
+}
+
+- (ZXDecodedInformation *)parseBlocks {
+ BOOL isFinished;
+ ZXBlockParsedResult *result;
+ do {
+ int initialPosition = self.current.position;
+
+ if (self.current.alpha) {
+ result = [self parseAlphaBlock];
+ isFinished = result.finished;
+ } else if (self.current.isoIec646) {
+ result = [self parseIsoIec646Block];
+ isFinished = result.finished;
+ } else {
+ result = [self parseNumericBlock];
+ isFinished = result.finished;
+ }
+
+ BOOL positionChanged = initialPosition != self.current.position;
+ if (!positionChanged && !isFinished) {
+ break;
+ }
+ } while (!isFinished);
+ return result.decodedInformation;
+}
+
+- (ZXBlockParsedResult *)parseNumericBlock {
+ while ([self isStillNumeric:self.current.position]) {
+ ZXDecodedNumeric *numeric = [self decodeNumeric:self.current.position];
+ self.current.position = numeric.theNewPosition;
+
+ if ([numeric firstDigitFNC1]) {
+ ZXDecodedInformation *_information;
+ if ([numeric secondDigitFNC1]) {
+ _information = [[[ZXDecodedInformation alloc] initWithNewPosition:self.current.position
+ newString:self.buffer] autorelease];
+ } else {
+ _information = [[[ZXDecodedInformation alloc] initWithNewPosition:self.current.position
+ newString:self.buffer
+ remainingValue:numeric.secondDigit] autorelease];
+ }
+ return [[[ZXBlockParsedResult alloc] initWithInformation:_information finished:YES] autorelease];
+ }
+ [self.buffer appendFormat:@"%d", numeric.firstDigit];
+
+ if (numeric.secondDigitFNC1) {
+ ZXDecodedInformation *_information = [[[ZXDecodedInformation alloc] initWithNewPosition:self.current.position
+ newString:self.buffer] autorelease];
+ return [[[ZXBlockParsedResult alloc] initWithInformation:_information finished:YES] autorelease];
+ }
+ [self.buffer appendFormat:@"%d", numeric.secondDigit];
+ }
+
+ if ([self isNumericToAlphaNumericLatch:self.current.position]) {
+ [self.current setAlpha];
+ self.current.position += 4;
+ }
+ return [[[ZXBlockParsedResult alloc] initWithFinished:NO] autorelease];
+}
+
+- (ZXBlockParsedResult *)parseIsoIec646Block {
+ while ([self isStillIsoIec646:self.current.position]) {
+ ZXDecodedChar *iso = [self decodeIsoIec646:self.current.position];
+ self.current.position = iso.theNewPosition;
+
+ if (iso.fnc1) {
+ ZXDecodedInformation *_information = [[[ZXDecodedInformation alloc] initWithNewPosition:self.current.position
+ newString:self.buffer] autorelease];
+ return [[[ZXBlockParsedResult alloc] initWithInformation:_information finished:YES] autorelease];
+ }
+ [self.buffer appendFormat:@"%C", iso.value];
+ }
+
+ if ([self isAlphaOr646ToNumericLatch:self.current.position]) {
+ self.current.position += 3;
+ [self.current setNumeric];
+ } else if ([self isAlphaTo646ToAlphaLatch:current.position]) {
+ if (self.current.position + 5 < self.information.size) {
+ self.current.position += 5;
+ } else {
+ self.current.position = self.information.size;
+ }
+
+ [self.current setAlpha];
+ }
+ return [[[ZXBlockParsedResult alloc] initWithFinished:NO] autorelease];
+}
+
+- (ZXBlockParsedResult *)parseAlphaBlock {
+ while ([self isStillAlpha:self.current.position]) {
+ ZXDecodedChar *alpha = [self decodeAlphanumeric:self.current.position];
+ self.current.position = alpha.theNewPosition;
+
+ if (alpha.fnc1) {
+ ZXDecodedInformation *_information = [[[ZXDecodedInformation alloc] initWithNewPosition:self.current.position
+ newString:self.buffer] autorelease];
+ return [[[ZXBlockParsedResult alloc] initWithInformation:_information finished:YES] autorelease];
+ }
+
+ [self.buffer appendFormat:@"%C", alpha.value];
+ }
+
+ if ([self isAlphaOr646ToNumericLatch:self.current.position]) {
+ self.current.position += 3;
+ [self.current setNumeric];
+ } else if ([self isAlphaTo646ToAlphaLatch:self.current.position]) {
+ if (self.current.position + 5 < self.information.size) {
+ self.current.position += 5;
+ } else {
+ self.current.position = self.information.size;
+ }
+
+ [self.current setIsoIec646];
+ }
+ return [[[ZXBlockParsedResult alloc] initWithFinished:NO] autorelease];
+}
+
+- (BOOL)isStillIsoIec646:(int)pos {
+ if (pos + 5 > self.information.size) {
+ return NO;
+ }
+
+ int fiveBitValue = [self extractNumericValueFromBitArray:pos bits:5];
+ if (fiveBitValue >= 5 && fiveBitValue < 16) {
+ return YES;
+ }
+
+ if (pos + 7 > self.information.size) {
+ return NO;
+ }
+
+ int sevenBitValue = [self extractNumericValueFromBitArray:pos bits:7];
+ if (sevenBitValue >= 64 && sevenBitValue < 116) {
+ return YES;
+ }
+
+ if (pos + 8 > self.information.size) {
+ return NO;
+ }
+
+ int eightBitValue = [self extractNumericValueFromBitArray:pos bits:8];
+ return eightBitValue >= 232 && eightBitValue < 253;
+}
+
+- (ZXDecodedChar *)decodeIsoIec646:(int)pos {
+ int fiveBitValue = [self extractNumericValueFromBitArray:pos bits:5];
+ if (fiveBitValue == 15) {
+ return [[[ZXDecodedChar alloc] initWithNewPosition:pos + 5 value:FNC1char] autorelease];
+ }
+
+ if (fiveBitValue >= 5 && fiveBitValue < 15) {
+ return [[[ZXDecodedChar alloc] initWithNewPosition:pos + 5 value:(unichar)('0' + fiveBitValue - 5)] autorelease];
+ }
+
+ int sevenBitValue = [self extractNumericValueFromBitArray:pos bits:7];
+
+ if (sevenBitValue >= 64 && sevenBitValue < 90) {
+ return [[[ZXDecodedChar alloc] initWithNewPosition:pos + 7 value:(unichar)(sevenBitValue + 1)] autorelease];
+ }
+
+ if (sevenBitValue >= 90 && sevenBitValue < 116) {
+ return [[[ZXDecodedChar alloc] initWithNewPosition:pos + 7 value:(unichar)(sevenBitValue + 7)] autorelease];
+ }
+
+ int eightBitValue = [self extractNumericValueFromBitArray:pos bits:8];
+ unichar c;
+ switch (eightBitValue) {
+ case 232:
+ c = '!';
+ break;
+ case 233:
+ c = '"';
+ break;
+ case 234:
+ c ='%';
+ break;
+ case 235:
+ c = '&';
+ break;
+ case 236:
+ c = '\'';
+ break;
+ case 237:
+ c = '(';
+ break;
+ case 238:
+ c = ')';
+ break;
+ case 239:
+ c = '*';
+ break;
+ case 240:
+ c = '+';
+ break;
+ case 241:
+ c = ',';
+ break;
+ case 242:
+ c = '-';
+ break;
+ case 243:
+ c = '.';
+ break;
+ case 244:
+ c = '/';
+ break;
+ case 245:
+ c = ':';
+ break;
+ case 246:
+ c = ';';
+ break;
+ case 247:
+ c = '<';
+ break;
+ case 248:
+ c = '=';
+ break;
+ case 249:
+ c = '>';
+ break;
+ case 250:
+ c = '?';
+ break;
+ case 251:
+ c = '_';
+ break;
+ case 252:
+ c = ' ';
+ break;
+ default:
+ @throw [NSException exceptionWithName:@"RuntimeException"
+ reason:[NSString stringWithFormat:@"Decoding invalid ISO/IEC 646 value: %d", eightBitValue]
+ userInfo:nil];
+ }
+ return [[[ZXDecodedChar alloc] initWithNewPosition:pos + 8 value:c] autorelease];
+}
+
+- (BOOL)isStillAlpha:(int)pos {
+ if (pos + 5 > self.information.size) {
+ return NO;
+ }
+
+ int fiveBitValue = [self extractNumericValueFromBitArray:pos bits:5];
+ if (fiveBitValue >= 5 && fiveBitValue < 16) {
+ return YES;
+ }
+
+ if (pos + 6 > self.information.size) {
+ return NO;
+ }
+
+ int sixBitValue = [self extractNumericValueFromBitArray:pos bits:6];
+ return sixBitValue >= 16 && sixBitValue < 63;
+}
+
+- (ZXDecodedChar *)decodeAlphanumeric:(int)pos {
+ int fiveBitValue = [self extractNumericValueFromBitArray:pos bits:5];
+ if (fiveBitValue == 15) {
+ return [[[ZXDecodedChar alloc] initWithNewPosition:pos + 5 value:FNC1char] autorelease];
+ }
+
+ if (fiveBitValue >= 5 && fiveBitValue < 15) {
+ return [[[ZXDecodedChar alloc] initWithNewPosition:pos + 5 value:(unichar)('0' + fiveBitValue - 5)] autorelease];
+ }
+
+ int sixBitValue = [self extractNumericValueFromBitArray:pos bits:6];
+
+ if (sixBitValue >= 32 && sixBitValue < 58) {
+ return [[[ZXDecodedChar alloc] initWithNewPosition:pos + 6 value:(unichar)(sixBitValue + 33)] autorelease];
+ }
+
+ unichar c;
+ switch (sixBitValue){
+ case 58:
+ c = '*';
+ break;
+ case 59:
+ c = ',';
+ break;
+ case 60:
+ c = '-';
+ break;
+ case 61:
+ c = '.';
+ break;
+ case 62:
+ c = '/';
+ break;
+ default:
+ @throw [NSException exceptionWithName:@"RuntimeException"
+ reason:[NSString stringWithFormat:@"Decoding invalid alphanumeric value: %d", sixBitValue]
+ userInfo:nil];
+ }
+
+ return [[[ZXDecodedChar alloc] initWithNewPosition:pos + 6 value:c] autorelease];
+}
+
+- (BOOL)isAlphaTo646ToAlphaLatch:(int)pos {
+ if (pos + 1 > self.information.size) {
+ return NO;
+ }
+
+ for (int i = 0; i < 5 && i + pos < self.information.size; ++i) {
+ if (i == 2) {
+ if (![self.information get:pos + 2]) {
+ return NO;
+ }
+ } else if ([self.information get:pos + i]) {
+ return NO;
+ }
+ }
+
+ return YES;
+}
+
+- (BOOL)isAlphaOr646ToNumericLatch:(int)pos {
+ if (pos + 3 > self.information.size) {
+ return NO;
+ }
+
+ for (int i = pos; i < pos + 3; ++i) {
+ if ([self.information get:i]) {
+ return NO;
+ }
+ }
+
+ return YES;
+}
+
+- (BOOL)isNumericToAlphaNumericLatch:(int)pos {
+ if (pos + 1 > self.information.size) {
+ return NO;
+ }
+
+ for (int i = 0; i < 4 && i + pos < self.information.size; ++i) {
+ if ([self.information get:pos + i]) {
+ return NO;
+ }
+ }
+
+ return YES;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/ZXPDF417Reader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/ZXPDF417Reader.h
new file mode 100644
index 0000000000000000000000000000000000000000..c8056b8c33d4e1232239f8a64525097c73f3037e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/ZXPDF417Reader.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXReader.h"
+
+/**
+ * This implementation can detect and decode PDF417 codes in an image.
+ */
+
+@class ZXDecodeHints, ZXPDF417Decoder, ZXResult;
+
+@interface ZXPDF417Reader : NSObject <ZXReader>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/ZXPDF417Reader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/ZXPDF417Reader.m
new file mode 100644
index 0000000000000000000000000000000000000000..dada1a06e837ab8f5efec0f7eece6120e044ce18
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/ZXPDF417Reader.m
@@ -0,0 +1,221 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeFormat.h"
+#import "ZXBinaryBitmap.h"
+#import "ZXBitMatrix.h"
+#import "ZXDecodeHints.h"
+#import "ZXDecoderResult.h"
+#import "ZXDetectorResult.h"
+#import "ZXErrors.h"
+#import "ZXPDF417Decoder.h"
+#import "ZXPDF417Detector.h"
+#import "ZXPDF417Reader.h"
+#import "ZXResult.h"
+
+@interface ZXPDF417Reader ()
+
+@property (nonatomic, retain) ZXPDF417Decoder *decoder;
+
+- (ZXBitMatrix *)extractPureBits:(ZXBitMatrix *)image;
+- (int)findPatternStart:(int)x y:(int)y image:(ZXBitMatrix *)image;
+- (int)findPatternEnd:(int)x y:(int)y image:(ZXBitMatrix *)image;
+- (int)moduleSize:(NSArray *)leftTopBlack image:(ZXBitMatrix *)image;
+
+@end
+
+@implementation ZXPDF417Reader
+
+@synthesize decoder;
+
+- (id)init {
+ if (self = [super init]) {
+ self.decoder = [[[ZXPDF417Decoder alloc] init] autorelease];
+ }
+ return self;
+}
+
+
+- (void)dealloc {
+ [decoder release];
+
+ [super dealloc];
+}
+
+/**
+ * Locates and decodes a PDF417 code in an image.
+ */
+- (ZXResult *)decode:(ZXBinaryBitmap *)image error:(NSError **)error {
+ return [self decode:image hints:nil error:error];
+}
+
+- (ZXResult *)decode:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ ZXDecoderResult *decoderResult;
+ NSArray *points;
+ if (hints != nil && hints.pureBarcode) {
+ ZXBitMatrix *matrix = [image blackMatrixWithError:error];
+ if (!matrix) {
+ return nil;
+ }
+ ZXBitMatrix *bits = [self extractPureBits:matrix];
+ if (!bits) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ decoderResult = [decoder decodeMatrix:bits error:error];
+ if (!decoderResult) {
+ return nil;
+ }
+ points = [NSArray array];
+ } else {
+ ZXDetectorResult *detectorResult = [[[[ZXPDF417Detector alloc] initWithImage:image] autorelease] detectWithError:error];
+ if (!detectorResult) {
+ return nil;
+ }
+ decoderResult = [decoder decodeMatrix:detectorResult.bits error:error];
+ if (!decoderResult) {
+ return nil;
+ }
+ points = detectorResult.points;
+ }
+ return [ZXResult resultWithText:decoderResult.text
+ rawBytes:decoderResult.rawBytes
+ length:decoderResult.length
+ resultPoints:points
+ format:kBarcodeFormatPDF417];
+}
+
+- (void)reset {
+ // do nothing
+}
+
+
+/**
+ * This method detects a code in a "pure" image -- that is, pure monochrome image
+ * which contains only an unrotated, unskewed, image of a code, with some white border
+ * around it. This is a specialized method that works exceptionally fast in this special
+ * case.
+ */
+- (ZXBitMatrix *)extractPureBits:(ZXBitMatrix *)image {
+ NSArray *leftTopBlack = image.topLeftOnBit;
+ NSArray *rightBottomBlack = image.bottomRightOnBit;
+ if (leftTopBlack == nil || rightBottomBlack == nil) {
+ return nil;
+ }
+
+ int moduleSize = [self moduleSize:leftTopBlack image:image];
+ if (moduleSize == -1) {
+ return nil;
+ }
+
+ int top = [[leftTopBlack objectAtIndex:1] intValue];
+ int bottom = [[rightBottomBlack objectAtIndex:1] intValue];
+ int left = [self findPatternStart:[[leftTopBlack objectAtIndex:0] intValue] y:top image:image];
+ if (left == -1) {
+ return nil;
+ }
+ int right = [self findPatternEnd:[[leftTopBlack objectAtIndex:0] intValue] y:top image:image];
+ if (right == -1) {
+ return nil;
+ }
+
+ int matrixWidth = (right - left + 1) / moduleSize;
+ int matrixHeight = (bottom - top + 1) / moduleSize;
+ if (matrixWidth <= 0 || matrixHeight <= 0) {
+ return nil;
+ }
+
+ int nudge = moduleSize >> 1;
+ top += nudge;
+ left += nudge;
+
+ ZXBitMatrix *bits = [[[ZXBitMatrix alloc] initWithWidth:matrixWidth height:matrixHeight] autorelease];
+ for (int y = 0; y < matrixHeight; y++) {
+ int iOffset = top + y * moduleSize;
+ for (int x = 0; x < matrixWidth; x++) {
+ if ([image getX:left + x * moduleSize y:iOffset]) {
+ [bits setX:x y:y];
+ }
+ }
+ }
+
+ return bits;
+}
+
+- (int)moduleSize:(NSArray *)leftTopBlack image:(ZXBitMatrix *)image {
+ int x = [[leftTopBlack objectAtIndex:0] intValue];
+ int y = [[leftTopBlack objectAtIndex:1] intValue];
+ int width = [image width];
+ while (x < width && [image getX:x y:y]) {
+ x++;
+ }
+ if (x == width) {
+ return -1;
+ }
+
+ int moduleSize = (int)((unsigned int)(x - [[leftTopBlack objectAtIndex:0] intValue]) >> 3);
+ if (moduleSize == 0) {
+ return -1;
+ }
+
+ return moduleSize;
+}
+
+- (int)findPatternStart:(int)x y:(int)y image:(ZXBitMatrix *)image {
+ int width = image.width;
+ int start = x;
+
+ int transitions = 0;
+ BOOL black = YES;
+ while (start < width - 1 && transitions < 8) {
+ start++;
+ BOOL newBlack = [image getX:start y:y];
+ if (black != newBlack) {
+ transitions++;
+ }
+ black = newBlack;
+ }
+ if (start == width - 1) {
+ return -1;
+ }
+ return start;
+}
+
+- (int)findPatternEnd:(int)x y:(int)y image:(ZXBitMatrix *)image {
+ int width = image.width;
+ int end = width - 1;
+
+ while (end > x && ![image getX:end y:y]) {
+ end--;
+ }
+ int transitions = 0;
+ BOOL black = YES;
+ while (end > x && transitions < 9) {
+ end--;
+ BOOL newBlack = [image getX:end y:y];
+ if (black != newBlack) {
+ transitions++;
+ }
+ black = newBlack;
+ }
+
+ if (end == x) {
+ return -1;
+ }
+ return end;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417BitMatrixParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417BitMatrixParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..ba811b72bfbb172ddb3f90118eee38b0561bda80
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417BitMatrixParser.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This class parses the BitMatrix image into codewords.
+ */
+
+@class ZXBitMatrix;
+
+@interface ZXPDF417BitMatrixParser : NSObject
+
+@property (nonatomic, retain, readonly) NSMutableArray *erasures;
+@property (nonatomic, assign, readonly) int ecLevel;
+
+- (id)initWithBitMatrix:(ZXBitMatrix *)bitMatrix;
+- (NSArray *)readCodewords;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417BitMatrixParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417BitMatrixParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..9f1fc393d84824035b4ff2af43661ef1bfe9cf93
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417BitMatrixParser.m
@@ -0,0 +1,917 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXPDF417BitMatrixParser.h"
+
+int const *NO_ERRORS = nil;
+int const MAX_ROW_DIFFERENCE = 6;
+int const MAX_ROWS = 90;
+int const MAX_CW_CAPACITY = 929;
+int const MODULES_IN_SYMBOL = 17;
+
+/**
+ * The sorted table of all possible symbols. Extracted from the PDF417
+ * specification. The index of a symbol in this table corresponds to the
+ * index into the codeword table.
+ */
+const int SYMBOL_TABLE[2787] = {0x1025e, 0x1027a, 0x1029e,
+ 0x102bc, 0x102f2, 0x102f4, 0x1032e, 0x1034e, 0x1035c, 0x10396,
+ 0x103a6, 0x103ac, 0x10422, 0x10428, 0x10436, 0x10442, 0x10444,
+ 0x10448, 0x10450, 0x1045e, 0x10466, 0x1046c, 0x1047a, 0x10482,
+ 0x1049e, 0x104a0, 0x104bc, 0x104c6, 0x104d8, 0x104ee, 0x104f2,
+ 0x104f4, 0x10504, 0x10508, 0x10510, 0x1051e, 0x10520, 0x1053c,
+ 0x10540, 0x10578, 0x10586, 0x1058c, 0x10598, 0x105b0, 0x105be,
+ 0x105ce, 0x105dc, 0x105e2, 0x105e4, 0x105e8, 0x105f6, 0x1062e,
+ 0x1064e, 0x1065c, 0x1068e, 0x1069c, 0x106b8, 0x106de, 0x106fa,
+ 0x10716, 0x10726, 0x1072c, 0x10746, 0x1074c, 0x10758, 0x1076e,
+ 0x10792, 0x10794, 0x107a2, 0x107a4, 0x107a8, 0x107b6, 0x10822,
+ 0x10828, 0x10842, 0x10848, 0x10850, 0x1085e, 0x10866, 0x1086c,
+ 0x1087a, 0x10882, 0x10884, 0x10890, 0x1089e, 0x108a0, 0x108bc,
+ 0x108c6, 0x108cc, 0x108d8, 0x108ee, 0x108f2, 0x108f4, 0x10902,
+ 0x10908, 0x1091e, 0x10920, 0x1093c, 0x10940, 0x10978, 0x10986,
+ 0x10998, 0x109b0, 0x109be, 0x109ce, 0x109dc, 0x109e2, 0x109e4,
+ 0x109e8, 0x109f6, 0x10a08, 0x10a10, 0x10a1e, 0x10a20, 0x10a3c,
+ 0x10a40, 0x10a78, 0x10af0, 0x10b06, 0x10b0c, 0x10b18, 0x10b30,
+ 0x10b3e, 0x10b60, 0x10b7c, 0x10b8e, 0x10b9c, 0x10bb8, 0x10bc2,
+ 0x10bc4, 0x10bc8, 0x10bd0, 0x10bde, 0x10be6, 0x10bec, 0x10c2e,
+ 0x10c4e, 0x10c5c, 0x10c62, 0x10c64, 0x10c68, 0x10c76, 0x10c8e,
+ 0x10c9c, 0x10cb8, 0x10cc2, 0x10cc4, 0x10cc8, 0x10cd0, 0x10cde,
+ 0x10ce6, 0x10cec, 0x10cfa, 0x10d0e, 0x10d1c, 0x10d38, 0x10d70,
+ 0x10d7e, 0x10d82, 0x10d84, 0x10d88, 0x10d90, 0x10d9e, 0x10da0,
+ 0x10dbc, 0x10dc6, 0x10dcc, 0x10dd8, 0x10dee, 0x10df2, 0x10df4,
+ 0x10e16, 0x10e26, 0x10e2c, 0x10e46, 0x10e58, 0x10e6e, 0x10e86,
+ 0x10e8c, 0x10e98, 0x10eb0, 0x10ebe, 0x10ece, 0x10edc, 0x10f0a,
+ 0x10f12, 0x10f14, 0x10f22, 0x10f28, 0x10f36, 0x10f42, 0x10f44,
+ 0x10f48, 0x10f50, 0x10f5e, 0x10f66, 0x10f6c, 0x10fb2, 0x10fb4,
+ 0x11022, 0x11028, 0x11042, 0x11048, 0x11050, 0x1105e, 0x1107a,
+ 0x11082, 0x11084, 0x11090, 0x1109e, 0x110a0, 0x110bc, 0x110c6,
+ 0x110cc, 0x110d8, 0x110ee, 0x110f2, 0x110f4, 0x11102, 0x1111e,
+ 0x11120, 0x1113c, 0x11140, 0x11178, 0x11186, 0x11198, 0x111b0,
+ 0x111be, 0x111ce, 0x111dc, 0x111e2, 0x111e4, 0x111e8, 0x111f6,
+ 0x11208, 0x1121e, 0x11220, 0x11278, 0x112f0, 0x1130c, 0x11330,
+ 0x1133e, 0x11360, 0x1137c, 0x1138e, 0x1139c, 0x113b8, 0x113c2,
+ 0x113c8, 0x113d0, 0x113de, 0x113e6, 0x113ec, 0x11408, 0x11410,
+ 0x1141e, 0x11420, 0x1143c, 0x11440, 0x11478, 0x114f0, 0x115e0,
+ 0x1160c, 0x11618, 0x11630, 0x1163e, 0x11660, 0x1167c, 0x116c0,
+ 0x116f8, 0x1171c, 0x11738, 0x11770, 0x1177e, 0x11782, 0x11784,
+ 0x11788, 0x11790, 0x1179e, 0x117a0, 0x117bc, 0x117c6, 0x117cc,
+ 0x117d8, 0x117ee, 0x1182e, 0x11834, 0x1184e, 0x1185c, 0x11862,
+ 0x11864, 0x11868, 0x11876, 0x1188e, 0x1189c, 0x118b8, 0x118c2,
+ 0x118c8, 0x118d0, 0x118de, 0x118e6, 0x118ec, 0x118fa, 0x1190e,
+ 0x1191c, 0x11938, 0x11970, 0x1197e, 0x11982, 0x11984, 0x11990,
+ 0x1199e, 0x119a0, 0x119bc, 0x119c6, 0x119cc, 0x119d8, 0x119ee,
+ 0x119f2, 0x119f4, 0x11a0e, 0x11a1c, 0x11a38, 0x11a70, 0x11a7e,
+ 0x11ae0, 0x11afc, 0x11b08, 0x11b10, 0x11b1e, 0x11b20, 0x11b3c,
+ 0x11b40, 0x11b78, 0x11b8c, 0x11b98, 0x11bb0, 0x11bbe, 0x11bce,
+ 0x11bdc, 0x11be2, 0x11be4, 0x11be8, 0x11bf6, 0x11c16, 0x11c26,
+ 0x11c2c, 0x11c46, 0x11c4c, 0x11c58, 0x11c6e, 0x11c86, 0x11c98,
+ 0x11cb0, 0x11cbe, 0x11cce, 0x11cdc, 0x11ce2, 0x11ce4, 0x11ce8,
+ 0x11cf6, 0x11d06, 0x11d0c, 0x11d18, 0x11d30, 0x11d3e, 0x11d60,
+ 0x11d7c, 0x11d8e, 0x11d9c, 0x11db8, 0x11dc4, 0x11dc8, 0x11dd0,
+ 0x11dde, 0x11de6, 0x11dec, 0x11dfa, 0x11e0a, 0x11e12, 0x11e14,
+ 0x11e22, 0x11e24, 0x11e28, 0x11e36, 0x11e42, 0x11e44, 0x11e50,
+ 0x11e5e, 0x11e66, 0x11e6c, 0x11e82, 0x11e84, 0x11e88, 0x11e90,
+ 0x11e9e, 0x11ea0, 0x11ebc, 0x11ec6, 0x11ecc, 0x11ed8, 0x11eee,
+ 0x11f1a, 0x11f2e, 0x11f32, 0x11f34, 0x11f4e, 0x11f5c, 0x11f62,
+ 0x11f64, 0x11f68, 0x11f76, 0x12048, 0x1205e, 0x12082, 0x12084,
+ 0x12090, 0x1209e, 0x120a0, 0x120bc, 0x120d8, 0x120f2, 0x120f4,
+ 0x12108, 0x1211e, 0x12120, 0x1213c, 0x12140, 0x12178, 0x12186,
+ 0x12198, 0x121b0, 0x121be, 0x121e2, 0x121e4, 0x121e8, 0x121f6,
+ 0x12204, 0x12210, 0x1221e, 0x12220, 0x12278, 0x122f0, 0x12306,
+ 0x1230c, 0x12330, 0x1233e, 0x12360, 0x1237c, 0x1238e, 0x1239c,
+ 0x123b8, 0x123c2, 0x123c8, 0x123d0, 0x123e6, 0x123ec, 0x1241e,
+ 0x12420, 0x1243c, 0x124f0, 0x125e0, 0x12618, 0x1263e, 0x12660,
+ 0x1267c, 0x126c0, 0x126f8, 0x12738, 0x12770, 0x1277e, 0x12782,
+ 0x12784, 0x12790, 0x1279e, 0x127a0, 0x127bc, 0x127c6, 0x127cc,
+ 0x127d8, 0x127ee, 0x12820, 0x1283c, 0x12840, 0x12878, 0x128f0,
+ 0x129e0, 0x12bc0, 0x12c18, 0x12c30, 0x12c3e, 0x12c60, 0x12c7c,
+ 0x12cc0, 0x12cf8, 0x12df0, 0x12e1c, 0x12e38, 0x12e70, 0x12e7e,
+ 0x12ee0, 0x12efc, 0x12f04, 0x12f08, 0x12f10, 0x12f20, 0x12f3c,
+ 0x12f40, 0x12f78, 0x12f86, 0x12f8c, 0x12f98, 0x12fb0, 0x12fbe,
+ 0x12fce, 0x12fdc, 0x1302e, 0x1304e, 0x1305c, 0x13062, 0x13068,
+ 0x1308e, 0x1309c, 0x130b8, 0x130c2, 0x130c8, 0x130d0, 0x130de,
+ 0x130ec, 0x130fa, 0x1310e, 0x13138, 0x13170, 0x1317e, 0x13182,
+ 0x13184, 0x13190, 0x1319e, 0x131a0, 0x131bc, 0x131c6, 0x131cc,
+ 0x131d8, 0x131f2, 0x131f4, 0x1320e, 0x1321c, 0x13270, 0x1327e,
+ 0x132e0, 0x132fc, 0x13308, 0x1331e, 0x13320, 0x1333c, 0x13340,
+ 0x13378, 0x13386, 0x13398, 0x133b0, 0x133be, 0x133ce, 0x133dc,
+ 0x133e2, 0x133e4, 0x133e8, 0x133f6, 0x1340e, 0x1341c, 0x13438,
+ 0x13470, 0x1347e, 0x134e0, 0x134fc, 0x135c0, 0x135f8, 0x13608,
+ 0x13610, 0x1361e, 0x13620, 0x1363c, 0x13640, 0x13678, 0x136f0,
+ 0x1370c, 0x13718, 0x13730, 0x1373e, 0x13760, 0x1377c, 0x1379c,
+ 0x137b8, 0x137c2, 0x137c4, 0x137c8, 0x137d0, 0x137de, 0x137e6,
+ 0x137ec, 0x13816, 0x13826, 0x1382c, 0x13846, 0x1384c, 0x13858,
+ 0x1386e, 0x13874, 0x13886, 0x13898, 0x138b0, 0x138be, 0x138ce,
+ 0x138dc, 0x138e2, 0x138e4, 0x138e8, 0x13906, 0x1390c, 0x13930,
+ 0x1393e, 0x13960, 0x1397c, 0x1398e, 0x1399c, 0x139b8, 0x139c8,
+ 0x139d0, 0x139de, 0x139e6, 0x139ec, 0x139fa, 0x13a06, 0x13a0c,
+ 0x13a18, 0x13a30, 0x13a3e, 0x13a60, 0x13a7c, 0x13ac0, 0x13af8,
+ 0x13b0e, 0x13b1c, 0x13b38, 0x13b70, 0x13b7e, 0x13b88, 0x13b90,
+ 0x13b9e, 0x13ba0, 0x13bbc, 0x13bcc, 0x13bd8, 0x13bee, 0x13bf2,
+ 0x13bf4, 0x13c12, 0x13c14, 0x13c22, 0x13c24, 0x13c28, 0x13c36,
+ 0x13c42, 0x13c48, 0x13c50, 0x13c5e, 0x13c66, 0x13c6c, 0x13c82,
+ 0x13c84, 0x13c90, 0x13c9e, 0x13ca0, 0x13cbc, 0x13cc6, 0x13ccc,
+ 0x13cd8, 0x13cee, 0x13d02, 0x13d04, 0x13d08, 0x13d10, 0x13d1e,
+ 0x13d20, 0x13d3c, 0x13d40, 0x13d78, 0x13d86, 0x13d8c, 0x13d98,
+ 0x13db0, 0x13dbe, 0x13dce, 0x13ddc, 0x13de4, 0x13de8, 0x13df6,
+ 0x13e1a, 0x13e2e, 0x13e32, 0x13e34, 0x13e4e, 0x13e5c, 0x13e62,
+ 0x13e64, 0x13e68, 0x13e76, 0x13e8e, 0x13e9c, 0x13eb8, 0x13ec2,
+ 0x13ec4, 0x13ec8, 0x13ed0, 0x13ede, 0x13ee6, 0x13eec, 0x13f26,
+ 0x13f2c, 0x13f3a, 0x13f46, 0x13f4c, 0x13f58, 0x13f6e, 0x13f72,
+ 0x13f74, 0x14082, 0x1409e, 0x140a0, 0x140bc, 0x14104, 0x14108,
+ 0x14110, 0x1411e, 0x14120, 0x1413c, 0x14140, 0x14178, 0x1418c,
+ 0x14198, 0x141b0, 0x141be, 0x141e2, 0x141e4, 0x141e8, 0x14208,
+ 0x14210, 0x1421e, 0x14220, 0x1423c, 0x14240, 0x14278, 0x142f0,
+ 0x14306, 0x1430c, 0x14318, 0x14330, 0x1433e, 0x14360, 0x1437c,
+ 0x1438e, 0x143c2, 0x143c4, 0x143c8, 0x143d0, 0x143e6, 0x143ec,
+ 0x14408, 0x14410, 0x1441e, 0x14420, 0x1443c, 0x14440, 0x14478,
+ 0x144f0, 0x145e0, 0x1460c, 0x14618, 0x14630, 0x1463e, 0x14660,
+ 0x1467c, 0x146c0, 0x146f8, 0x1471c, 0x14738, 0x14770, 0x1477e,
+ 0x14782, 0x14784, 0x14788, 0x14790, 0x147a0, 0x147bc, 0x147c6,
+ 0x147cc, 0x147d8, 0x147ee, 0x14810, 0x14820, 0x1483c, 0x14840,
+ 0x14878, 0x148f0, 0x149e0, 0x14bc0, 0x14c30, 0x14c3e, 0x14c60,
+ 0x14c7c, 0x14cc0, 0x14cf8, 0x14df0, 0x14e38, 0x14e70, 0x14e7e,
+ 0x14ee0, 0x14efc, 0x14f04, 0x14f08, 0x14f10, 0x14f1e, 0x14f20,
+ 0x14f3c, 0x14f40, 0x14f78, 0x14f86, 0x14f8c, 0x14f98, 0x14fb0,
+ 0x14fce, 0x14fdc, 0x15020, 0x15040, 0x15078, 0x150f0, 0x151e0,
+ 0x153c0, 0x15860, 0x1587c, 0x158c0, 0x158f8, 0x159f0, 0x15be0,
+ 0x15c70, 0x15c7e, 0x15ce0, 0x15cfc, 0x15dc0, 0x15df8, 0x15e08,
+ 0x15e10, 0x15e20, 0x15e40, 0x15e78, 0x15ef0, 0x15f0c, 0x15f18,
+ 0x15f30, 0x15f60, 0x15f7c, 0x15f8e, 0x15f9c, 0x15fb8, 0x1604e,
+ 0x1605c, 0x1608e, 0x1609c, 0x160b8, 0x160c2, 0x160c4, 0x160c8,
+ 0x160de, 0x1610e, 0x1611c, 0x16138, 0x16170, 0x1617e, 0x16184,
+ 0x16188, 0x16190, 0x1619e, 0x161a0, 0x161bc, 0x161c6, 0x161cc,
+ 0x161d8, 0x161f2, 0x161f4, 0x1620e, 0x1621c, 0x16238, 0x16270,
+ 0x1627e, 0x162e0, 0x162fc, 0x16304, 0x16308, 0x16310, 0x1631e,
+ 0x16320, 0x1633c, 0x16340, 0x16378, 0x16386, 0x1638c, 0x16398,
+ 0x163b0, 0x163be, 0x163ce, 0x163dc, 0x163e2, 0x163e4, 0x163e8,
+ 0x163f6, 0x1640e, 0x1641c, 0x16438, 0x16470, 0x1647e, 0x164e0,
+ 0x164fc, 0x165c0, 0x165f8, 0x16610, 0x1661e, 0x16620, 0x1663c,
+ 0x16640, 0x16678, 0x166f0, 0x16718, 0x16730, 0x1673e, 0x16760,
+ 0x1677c, 0x1678e, 0x1679c, 0x167b8, 0x167c2, 0x167c4, 0x167c8,
+ 0x167d0, 0x167de, 0x167e6, 0x167ec, 0x1681c, 0x16838, 0x16870,
+ 0x168e0, 0x168fc, 0x169c0, 0x169f8, 0x16bf0, 0x16c10, 0x16c1e,
+ 0x16c20, 0x16c3c, 0x16c40, 0x16c78, 0x16cf0, 0x16de0, 0x16e18,
+ 0x16e30, 0x16e3e, 0x16e60, 0x16e7c, 0x16ec0, 0x16ef8, 0x16f1c,
+ 0x16f38, 0x16f70, 0x16f7e, 0x16f84, 0x16f88, 0x16f90, 0x16f9e,
+ 0x16fa0, 0x16fbc, 0x16fc6, 0x16fcc, 0x16fd8, 0x17026, 0x1702c,
+ 0x17046, 0x1704c, 0x17058, 0x1706e, 0x17086, 0x1708c, 0x17098,
+ 0x170b0, 0x170be, 0x170ce, 0x170dc, 0x170e8, 0x17106, 0x1710c,
+ 0x17118, 0x17130, 0x1713e, 0x17160, 0x1717c, 0x1718e, 0x1719c,
+ 0x171b8, 0x171c2, 0x171c4, 0x171c8, 0x171d0, 0x171de, 0x171e6,
+ 0x171ec, 0x171fa, 0x17206, 0x1720c, 0x17218, 0x17230, 0x1723e,
+ 0x17260, 0x1727c, 0x172c0, 0x172f8, 0x1730e, 0x1731c, 0x17338,
+ 0x17370, 0x1737e, 0x17388, 0x17390, 0x1739e, 0x173a0, 0x173bc,
+ 0x173cc, 0x173d8, 0x173ee, 0x173f2, 0x173f4, 0x1740c, 0x17418,
+ 0x17430, 0x1743e, 0x17460, 0x1747c, 0x174c0, 0x174f8, 0x175f0,
+ 0x1760e, 0x1761c, 0x17638, 0x17670, 0x1767e, 0x176e0, 0x176fc,
+ 0x17708, 0x17710, 0x1771e, 0x17720, 0x1773c, 0x17740, 0x17778,
+ 0x17798, 0x177b0, 0x177be, 0x177dc, 0x177e2, 0x177e4, 0x177e8,
+ 0x17822, 0x17824, 0x17828, 0x17836, 0x17842, 0x17844, 0x17848,
+ 0x17850, 0x1785e, 0x17866, 0x1786c, 0x17882, 0x17884, 0x17888,
+ 0x17890, 0x1789e, 0x178a0, 0x178bc, 0x178c6, 0x178cc, 0x178d8,
+ 0x178ee, 0x178f2, 0x178f4, 0x17902, 0x17904, 0x17908, 0x17910,
+ 0x1791e, 0x17920, 0x1793c, 0x17940, 0x17978, 0x17986, 0x1798c,
+ 0x17998, 0x179b0, 0x179be, 0x179ce, 0x179dc, 0x179e2, 0x179e4,
+ 0x179e8, 0x179f6, 0x17a04, 0x17a08, 0x17a10, 0x17a1e, 0x17a20,
+ 0x17a3c, 0x17a40, 0x17a78, 0x17af0, 0x17b06, 0x17b0c, 0x17b18,
+ 0x17b30, 0x17b3e, 0x17b60, 0x17b7c, 0x17b8e, 0x17b9c, 0x17bb8,
+ 0x17bc4, 0x17bc8, 0x17bd0, 0x17bde, 0x17be6, 0x17bec, 0x17c2e,
+ 0x17c32, 0x17c34, 0x17c4e, 0x17c5c, 0x17c62, 0x17c64, 0x17c68,
+ 0x17c76, 0x17c8e, 0x17c9c, 0x17cb8, 0x17cc2, 0x17cc4, 0x17cc8,
+ 0x17cd0, 0x17cde, 0x17ce6, 0x17cec, 0x17d0e, 0x17d1c, 0x17d38,
+ 0x17d70, 0x17d82, 0x17d84, 0x17d88, 0x17d90, 0x17d9e, 0x17da0,
+ 0x17dbc, 0x17dc6, 0x17dcc, 0x17dd8, 0x17dee, 0x17e26, 0x17e2c,
+ 0x17e3a, 0x17e46, 0x17e4c, 0x17e58, 0x17e6e, 0x17e72, 0x17e74,
+ 0x17e86, 0x17e8c, 0x17e98, 0x17eb0, 0x17ece, 0x17edc, 0x17ee2,
+ 0x17ee4, 0x17ee8, 0x17ef6, 0x1813a, 0x18172, 0x18174, 0x18216,
+ 0x18226, 0x1823a, 0x1824c, 0x18258, 0x1826e, 0x18272, 0x18274,
+ 0x18298, 0x182be, 0x182e2, 0x182e4, 0x182e8, 0x182f6, 0x1835e,
+ 0x1837a, 0x183ae, 0x183d6, 0x18416, 0x18426, 0x1842c, 0x1843a,
+ 0x18446, 0x18458, 0x1846e, 0x18472, 0x18474, 0x18486, 0x184b0,
+ 0x184be, 0x184ce, 0x184dc, 0x184e2, 0x184e4, 0x184e8, 0x184f6,
+ 0x18506, 0x1850c, 0x18518, 0x18530, 0x1853e, 0x18560, 0x1857c,
+ 0x1858e, 0x1859c, 0x185b8, 0x185c2, 0x185c4, 0x185c8, 0x185d0,
+ 0x185de, 0x185e6, 0x185ec, 0x185fa, 0x18612, 0x18614, 0x18622,
+ 0x18628, 0x18636, 0x18642, 0x18650, 0x1865e, 0x1867a, 0x18682,
+ 0x18684, 0x18688, 0x18690, 0x1869e, 0x186a0, 0x186bc, 0x186c6,
+ 0x186cc, 0x186d8, 0x186ee, 0x186f2, 0x186f4, 0x1872e, 0x1874e,
+ 0x1875c, 0x18796, 0x187a6, 0x187ac, 0x187d2, 0x187d4, 0x18826,
+ 0x1882c, 0x1883a, 0x18846, 0x1884c, 0x18858, 0x1886e, 0x18872,
+ 0x18874, 0x18886, 0x18898, 0x188b0, 0x188be, 0x188ce, 0x188dc,
+ 0x188e2, 0x188e4, 0x188e8, 0x188f6, 0x1890c, 0x18930, 0x1893e,
+ 0x18960, 0x1897c, 0x1898e, 0x189b8, 0x189c2, 0x189c8, 0x189d0,
+ 0x189de, 0x189e6, 0x189ec, 0x189fa, 0x18a18, 0x18a30, 0x18a3e,
+ 0x18a60, 0x18a7c, 0x18ac0, 0x18af8, 0x18b1c, 0x18b38, 0x18b70,
+ 0x18b7e, 0x18b82, 0x18b84, 0x18b88, 0x18b90, 0x18b9e, 0x18ba0,
+ 0x18bbc, 0x18bc6, 0x18bcc, 0x18bd8, 0x18bee, 0x18bf2, 0x18bf4,
+ 0x18c22, 0x18c24, 0x18c28, 0x18c36, 0x18c42, 0x18c48, 0x18c50,
+ 0x18c5e, 0x18c66, 0x18c7a, 0x18c82, 0x18c84, 0x18c90, 0x18c9e,
+ 0x18ca0, 0x18cbc, 0x18ccc, 0x18cf2, 0x18cf4, 0x18d04, 0x18d08,
+ 0x18d10, 0x18d1e, 0x18d20, 0x18d3c, 0x18d40, 0x18d78, 0x18d86,
+ 0x18d98, 0x18dce, 0x18de2, 0x18de4, 0x18de8, 0x18e2e, 0x18e32,
+ 0x18e34, 0x18e4e, 0x18e5c, 0x18e62, 0x18e64, 0x18e68, 0x18e8e,
+ 0x18e9c, 0x18eb8, 0x18ec2, 0x18ec4, 0x18ec8, 0x18ed0, 0x18efa,
+ 0x18f16, 0x18f26, 0x18f2c, 0x18f46, 0x18f4c, 0x18f58, 0x18f6e,
+ 0x18f8a, 0x18f92, 0x18f94, 0x18fa2, 0x18fa4, 0x18fa8, 0x18fb6,
+ 0x1902c, 0x1903a, 0x19046, 0x1904c, 0x19058, 0x19072, 0x19074,
+ 0x19086, 0x19098, 0x190b0, 0x190be, 0x190ce, 0x190dc, 0x190e2,
+ 0x190e8, 0x190f6, 0x19106, 0x1910c, 0x19130, 0x1913e, 0x19160,
+ 0x1917c, 0x1918e, 0x1919c, 0x191b8, 0x191c2, 0x191c8, 0x191d0,
+ 0x191de, 0x191e6, 0x191ec, 0x191fa, 0x19218, 0x1923e, 0x19260,
+ 0x1927c, 0x192c0, 0x192f8, 0x19338, 0x19370, 0x1937e, 0x19382,
+ 0x19384, 0x19390, 0x1939e, 0x193a0, 0x193bc, 0x193c6, 0x193cc,
+ 0x193d8, 0x193ee, 0x193f2, 0x193f4, 0x19430, 0x1943e, 0x19460,
+ 0x1947c, 0x194c0, 0x194f8, 0x195f0, 0x19638, 0x19670, 0x1967e,
+ 0x196e0, 0x196fc, 0x19702, 0x19704, 0x19708, 0x19710, 0x19720,
+ 0x1973c, 0x19740, 0x19778, 0x19786, 0x1978c, 0x19798, 0x197b0,
+ 0x197be, 0x197ce, 0x197dc, 0x197e2, 0x197e4, 0x197e8, 0x19822,
+ 0x19824, 0x19842, 0x19848, 0x19850, 0x1985e, 0x19866, 0x1987a,
+ 0x19882, 0x19884, 0x19890, 0x1989e, 0x198a0, 0x198bc, 0x198cc,
+ 0x198f2, 0x198f4, 0x19902, 0x19908, 0x1991e, 0x19920, 0x1993c,
+ 0x19940, 0x19978, 0x19986, 0x19998, 0x199ce, 0x199e2, 0x199e4,
+ 0x199e8, 0x19a08, 0x19a10, 0x19a1e, 0x19a20, 0x19a3c, 0x19a40,
+ 0x19a78, 0x19af0, 0x19b18, 0x19b3e, 0x19b60, 0x19b9c, 0x19bc2,
+ 0x19bc4, 0x19bc8, 0x19bd0, 0x19be6, 0x19c2e, 0x19c34, 0x19c4e,
+ 0x19c5c, 0x19c62, 0x19c64, 0x19c68, 0x19c8e, 0x19c9c, 0x19cb8,
+ 0x19cc2, 0x19cc8, 0x19cd0, 0x19ce6, 0x19cfa, 0x19d0e, 0x19d1c,
+ 0x19d38, 0x19d70, 0x19d7e, 0x19d82, 0x19d84, 0x19d88, 0x19d90,
+ 0x19da0, 0x19dcc, 0x19df2, 0x19df4, 0x19e16, 0x19e26, 0x19e2c,
+ 0x19e46, 0x19e4c, 0x19e58, 0x19e74, 0x19e86, 0x19e8c, 0x19e98,
+ 0x19eb0, 0x19ebe, 0x19ece, 0x19ee2, 0x19ee4, 0x19ee8, 0x19f0a,
+ 0x19f12, 0x19f14, 0x19f22, 0x19f24, 0x19f28, 0x19f42, 0x19f44,
+ 0x19f48, 0x19f50, 0x19f5e, 0x19f6c, 0x19f9a, 0x19fae, 0x19fb2,
+ 0x19fb4, 0x1a046, 0x1a04c, 0x1a072, 0x1a074, 0x1a086, 0x1a08c,
+ 0x1a098, 0x1a0b0, 0x1a0be, 0x1a0e2, 0x1a0e4, 0x1a0e8, 0x1a0f6,
+ 0x1a106, 0x1a10c, 0x1a118, 0x1a130, 0x1a13e, 0x1a160, 0x1a17c,
+ 0x1a18e, 0x1a19c, 0x1a1b8, 0x1a1c2, 0x1a1c4, 0x1a1c8, 0x1a1d0,
+ 0x1a1de, 0x1a1e6, 0x1a1ec, 0x1a218, 0x1a230, 0x1a23e, 0x1a260,
+ 0x1a27c, 0x1a2c0, 0x1a2f8, 0x1a31c, 0x1a338, 0x1a370, 0x1a37e,
+ 0x1a382, 0x1a384, 0x1a388, 0x1a390, 0x1a39e, 0x1a3a0, 0x1a3bc,
+ 0x1a3c6, 0x1a3cc, 0x1a3d8, 0x1a3ee, 0x1a3f2, 0x1a3f4, 0x1a418,
+ 0x1a430, 0x1a43e, 0x1a460, 0x1a47c, 0x1a4c0, 0x1a4f8, 0x1a5f0,
+ 0x1a61c, 0x1a638, 0x1a670, 0x1a67e, 0x1a6e0, 0x1a6fc, 0x1a702,
+ 0x1a704, 0x1a708, 0x1a710, 0x1a71e, 0x1a720, 0x1a73c, 0x1a740,
+ 0x1a778, 0x1a786, 0x1a78c, 0x1a798, 0x1a7b0, 0x1a7be, 0x1a7ce,
+ 0x1a7dc, 0x1a7e2, 0x1a7e4, 0x1a7e8, 0x1a830, 0x1a860, 0x1a87c,
+ 0x1a8c0, 0x1a8f8, 0x1a9f0, 0x1abe0, 0x1ac70, 0x1ac7e, 0x1ace0,
+ 0x1acfc, 0x1adc0, 0x1adf8, 0x1ae04, 0x1ae08, 0x1ae10, 0x1ae20,
+ 0x1ae3c, 0x1ae40, 0x1ae78, 0x1aef0, 0x1af06, 0x1af0c, 0x1af18,
+ 0x1af30, 0x1af3e, 0x1af60, 0x1af7c, 0x1af8e, 0x1af9c, 0x1afb8,
+ 0x1afc4, 0x1afc8, 0x1afd0, 0x1afde, 0x1b042, 0x1b05e, 0x1b07a,
+ 0x1b082, 0x1b084, 0x1b088, 0x1b090, 0x1b09e, 0x1b0a0, 0x1b0bc,
+ 0x1b0cc, 0x1b0f2, 0x1b0f4, 0x1b102, 0x1b104, 0x1b108, 0x1b110,
+ 0x1b11e, 0x1b120, 0x1b13c, 0x1b140, 0x1b178, 0x1b186, 0x1b198,
+ 0x1b1ce, 0x1b1e2, 0x1b1e4, 0x1b1e8, 0x1b204, 0x1b208, 0x1b210,
+ 0x1b21e, 0x1b220, 0x1b23c, 0x1b240, 0x1b278, 0x1b2f0, 0x1b30c,
+ 0x1b33e, 0x1b360, 0x1b39c, 0x1b3c2, 0x1b3c4, 0x1b3c8, 0x1b3d0,
+ 0x1b3e6, 0x1b410, 0x1b41e, 0x1b420, 0x1b43c, 0x1b440, 0x1b478,
+ 0x1b4f0, 0x1b5e0, 0x1b618, 0x1b660, 0x1b67c, 0x1b6c0, 0x1b738,
+ 0x1b782, 0x1b784, 0x1b788, 0x1b790, 0x1b79e, 0x1b7a0, 0x1b7cc,
+ 0x1b82e, 0x1b84e, 0x1b85c, 0x1b88e, 0x1b89c, 0x1b8b8, 0x1b8c2,
+ 0x1b8c4, 0x1b8c8, 0x1b8d0, 0x1b8e6, 0x1b8fa, 0x1b90e, 0x1b91c,
+ 0x1b938, 0x1b970, 0x1b97e, 0x1b982, 0x1b984, 0x1b988, 0x1b990,
+ 0x1b99e, 0x1b9a0, 0x1b9cc, 0x1b9f2, 0x1b9f4, 0x1ba0e, 0x1ba1c,
+ 0x1ba38, 0x1ba70, 0x1ba7e, 0x1bae0, 0x1bafc, 0x1bb08, 0x1bb10,
+ 0x1bb20, 0x1bb3c, 0x1bb40, 0x1bb98, 0x1bbce, 0x1bbe2, 0x1bbe4,
+ 0x1bbe8, 0x1bc16, 0x1bc26, 0x1bc2c, 0x1bc46, 0x1bc4c, 0x1bc58,
+ 0x1bc72, 0x1bc74, 0x1bc86, 0x1bc8c, 0x1bc98, 0x1bcb0, 0x1bcbe,
+ 0x1bcce, 0x1bce2, 0x1bce4, 0x1bce8, 0x1bd06, 0x1bd0c, 0x1bd18,
+ 0x1bd30, 0x1bd3e, 0x1bd60, 0x1bd7c, 0x1bd9c, 0x1bdc2, 0x1bdc4,
+ 0x1bdc8, 0x1bdd0, 0x1bde6, 0x1bdfa, 0x1be12, 0x1be14, 0x1be22,
+ 0x1be24, 0x1be28, 0x1be42, 0x1be44, 0x1be48, 0x1be50, 0x1be5e,
+ 0x1be66, 0x1be82, 0x1be84, 0x1be88, 0x1be90, 0x1be9e, 0x1bea0,
+ 0x1bebc, 0x1becc, 0x1bef4, 0x1bf1a, 0x1bf2e, 0x1bf32, 0x1bf34,
+ 0x1bf4e, 0x1bf5c, 0x1bf62, 0x1bf64, 0x1bf68, 0x1c09a, 0x1c0b2,
+ 0x1c0b4, 0x1c11a, 0x1c132, 0x1c134, 0x1c162, 0x1c164, 0x1c168,
+ 0x1c176, 0x1c1ba, 0x1c21a, 0x1c232, 0x1c234, 0x1c24e, 0x1c25c,
+ 0x1c262, 0x1c264, 0x1c268, 0x1c276, 0x1c28e, 0x1c2c2, 0x1c2c4,
+ 0x1c2c8, 0x1c2d0, 0x1c2de, 0x1c2e6, 0x1c2ec, 0x1c2fa, 0x1c316,
+ 0x1c326, 0x1c33a, 0x1c346, 0x1c34c, 0x1c372, 0x1c374, 0x1c41a,
+ 0x1c42e, 0x1c432, 0x1c434, 0x1c44e, 0x1c45c, 0x1c462, 0x1c464,
+ 0x1c468, 0x1c476, 0x1c48e, 0x1c49c, 0x1c4b8, 0x1c4c2, 0x1c4c8,
+ 0x1c4d0, 0x1c4de, 0x1c4e6, 0x1c4ec, 0x1c4fa, 0x1c51c, 0x1c538,
+ 0x1c570, 0x1c57e, 0x1c582, 0x1c584, 0x1c588, 0x1c590, 0x1c59e,
+ 0x1c5a0, 0x1c5bc, 0x1c5c6, 0x1c5cc, 0x1c5d8, 0x1c5ee, 0x1c5f2,
+ 0x1c5f4, 0x1c616, 0x1c626, 0x1c62c, 0x1c63a, 0x1c646, 0x1c64c,
+ 0x1c658, 0x1c66e, 0x1c672, 0x1c674, 0x1c686, 0x1c68c, 0x1c698,
+ 0x1c6b0, 0x1c6be, 0x1c6ce, 0x1c6dc, 0x1c6e2, 0x1c6e4, 0x1c6e8,
+ 0x1c712, 0x1c714, 0x1c722, 0x1c728, 0x1c736, 0x1c742, 0x1c744,
+ 0x1c748, 0x1c750, 0x1c75e, 0x1c766, 0x1c76c, 0x1c77a, 0x1c7ae,
+ 0x1c7d6, 0x1c7ea, 0x1c81a, 0x1c82e, 0x1c832, 0x1c834, 0x1c84e,
+ 0x1c85c, 0x1c862, 0x1c864, 0x1c868, 0x1c876, 0x1c88e, 0x1c89c,
+ 0x1c8b8, 0x1c8c2, 0x1c8c8, 0x1c8d0, 0x1c8de, 0x1c8e6, 0x1c8ec,
+ 0x1c8fa, 0x1c90e, 0x1c938, 0x1c970, 0x1c97e, 0x1c982, 0x1c984,
+ 0x1c990, 0x1c99e, 0x1c9a0, 0x1c9bc, 0x1c9c6, 0x1c9cc, 0x1c9d8,
+ 0x1c9ee, 0x1c9f2, 0x1c9f4, 0x1ca38, 0x1ca70, 0x1ca7e, 0x1cae0,
+ 0x1cafc, 0x1cb02, 0x1cb04, 0x1cb08, 0x1cb10, 0x1cb20, 0x1cb3c,
+ 0x1cb40, 0x1cb78, 0x1cb86, 0x1cb8c, 0x1cb98, 0x1cbb0, 0x1cbbe,
+ 0x1cbce, 0x1cbdc, 0x1cbe2, 0x1cbe4, 0x1cbe8, 0x1cbf6, 0x1cc16,
+ 0x1cc26, 0x1cc2c, 0x1cc3a, 0x1cc46, 0x1cc58, 0x1cc72, 0x1cc74,
+ 0x1cc86, 0x1ccb0, 0x1ccbe, 0x1ccce, 0x1cce2, 0x1cce4, 0x1cce8,
+ 0x1cd06, 0x1cd0c, 0x1cd18, 0x1cd30, 0x1cd3e, 0x1cd60, 0x1cd7c,
+ 0x1cd9c, 0x1cdc2, 0x1cdc4, 0x1cdc8, 0x1cdd0, 0x1cdde, 0x1cde6,
+ 0x1cdfa, 0x1ce22, 0x1ce28, 0x1ce42, 0x1ce50, 0x1ce5e, 0x1ce66,
+ 0x1ce7a, 0x1ce82, 0x1ce84, 0x1ce88, 0x1ce90, 0x1ce9e, 0x1cea0,
+ 0x1cebc, 0x1cecc, 0x1cef2, 0x1cef4, 0x1cf2e, 0x1cf32, 0x1cf34,
+ 0x1cf4e, 0x1cf5c, 0x1cf62, 0x1cf64, 0x1cf68, 0x1cf96, 0x1cfa6,
+ 0x1cfac, 0x1cfca, 0x1cfd2, 0x1cfd4, 0x1d02e, 0x1d032, 0x1d034,
+ 0x1d04e, 0x1d05c, 0x1d062, 0x1d064, 0x1d068, 0x1d076, 0x1d08e,
+ 0x1d09c, 0x1d0b8, 0x1d0c2, 0x1d0c4, 0x1d0c8, 0x1d0d0, 0x1d0de,
+ 0x1d0e6, 0x1d0ec, 0x1d0fa, 0x1d11c, 0x1d138, 0x1d170, 0x1d17e,
+ 0x1d182, 0x1d184, 0x1d188, 0x1d190, 0x1d19e, 0x1d1a0, 0x1d1bc,
+ 0x1d1c6, 0x1d1cc, 0x1d1d8, 0x1d1ee, 0x1d1f2, 0x1d1f4, 0x1d21c,
+ 0x1d238, 0x1d270, 0x1d27e, 0x1d2e0, 0x1d2fc, 0x1d302, 0x1d304,
+ 0x1d308, 0x1d310, 0x1d31e, 0x1d320, 0x1d33c, 0x1d340, 0x1d378,
+ 0x1d386, 0x1d38c, 0x1d398, 0x1d3b0, 0x1d3be, 0x1d3ce, 0x1d3dc,
+ 0x1d3e2, 0x1d3e4, 0x1d3e8, 0x1d3f6, 0x1d470, 0x1d47e, 0x1d4e0,
+ 0x1d4fc, 0x1d5c0, 0x1d5f8, 0x1d604, 0x1d608, 0x1d610, 0x1d620,
+ 0x1d640, 0x1d678, 0x1d6f0, 0x1d706, 0x1d70c, 0x1d718, 0x1d730,
+ 0x1d73e, 0x1d760, 0x1d77c, 0x1d78e, 0x1d79c, 0x1d7b8, 0x1d7c2,
+ 0x1d7c4, 0x1d7c8, 0x1d7d0, 0x1d7de, 0x1d7e6, 0x1d7ec, 0x1d826,
+ 0x1d82c, 0x1d83a, 0x1d846, 0x1d84c, 0x1d858, 0x1d872, 0x1d874,
+ 0x1d886, 0x1d88c, 0x1d898, 0x1d8b0, 0x1d8be, 0x1d8ce, 0x1d8e2,
+ 0x1d8e4, 0x1d8e8, 0x1d8f6, 0x1d90c, 0x1d918, 0x1d930, 0x1d93e,
+ 0x1d960, 0x1d97c, 0x1d99c, 0x1d9c2, 0x1d9c4, 0x1d9c8, 0x1d9d0,
+ 0x1d9e6, 0x1d9fa, 0x1da0c, 0x1da18, 0x1da30, 0x1da3e, 0x1da60,
+ 0x1da7c, 0x1dac0, 0x1daf8, 0x1db38, 0x1db82, 0x1db84, 0x1db88,
+ 0x1db90, 0x1db9e, 0x1dba0, 0x1dbcc, 0x1dbf2, 0x1dbf4, 0x1dc22,
+ 0x1dc42, 0x1dc44, 0x1dc48, 0x1dc50, 0x1dc5e, 0x1dc66, 0x1dc7a,
+ 0x1dc82, 0x1dc84, 0x1dc88, 0x1dc90, 0x1dc9e, 0x1dca0, 0x1dcbc,
+ 0x1dccc, 0x1dcf2, 0x1dcf4, 0x1dd04, 0x1dd08, 0x1dd10, 0x1dd1e,
+ 0x1dd20, 0x1dd3c, 0x1dd40, 0x1dd78, 0x1dd86, 0x1dd98, 0x1ddce,
+ 0x1dde2, 0x1dde4, 0x1dde8, 0x1de2e, 0x1de32, 0x1de34, 0x1de4e,
+ 0x1de5c, 0x1de62, 0x1de64, 0x1de68, 0x1de8e, 0x1de9c, 0x1deb8,
+ 0x1dec2, 0x1dec4, 0x1dec8, 0x1ded0, 0x1dee6, 0x1defa, 0x1df16,
+ 0x1df26, 0x1df2c, 0x1df46, 0x1df4c, 0x1df58, 0x1df72, 0x1df74,
+ 0x1df8a, 0x1df92, 0x1df94, 0x1dfa2, 0x1dfa4, 0x1dfa8, 0x1e08a,
+ 0x1e092, 0x1e094, 0x1e0a2, 0x1e0a4, 0x1e0a8, 0x1e0b6, 0x1e0da,
+ 0x1e10a, 0x1e112, 0x1e114, 0x1e122, 0x1e124, 0x1e128, 0x1e136,
+ 0x1e142, 0x1e144, 0x1e148, 0x1e150, 0x1e166, 0x1e16c, 0x1e17a,
+ 0x1e19a, 0x1e1b2, 0x1e1b4, 0x1e20a, 0x1e212, 0x1e214, 0x1e222,
+ 0x1e224, 0x1e228, 0x1e236, 0x1e242, 0x1e248, 0x1e250, 0x1e25e,
+ 0x1e266, 0x1e26c, 0x1e27a, 0x1e282, 0x1e284, 0x1e288, 0x1e290,
+ 0x1e2a0, 0x1e2bc, 0x1e2c6, 0x1e2cc, 0x1e2d8, 0x1e2ee, 0x1e2f2,
+ 0x1e2f4, 0x1e31a, 0x1e332, 0x1e334, 0x1e35c, 0x1e362, 0x1e364,
+ 0x1e368, 0x1e3ba, 0x1e40a, 0x1e412, 0x1e414, 0x1e422, 0x1e428,
+ 0x1e436, 0x1e442, 0x1e448, 0x1e450, 0x1e45e, 0x1e466, 0x1e46c,
+ 0x1e47a, 0x1e482, 0x1e484, 0x1e490, 0x1e49e, 0x1e4a0, 0x1e4bc,
+ 0x1e4c6, 0x1e4cc, 0x1e4d8, 0x1e4ee, 0x1e4f2, 0x1e4f4, 0x1e502,
+ 0x1e504, 0x1e508, 0x1e510, 0x1e51e, 0x1e520, 0x1e53c, 0x1e540,
+ 0x1e578, 0x1e586, 0x1e58c, 0x1e598, 0x1e5b0, 0x1e5be, 0x1e5ce,
+ 0x1e5dc, 0x1e5e2, 0x1e5e4, 0x1e5e8, 0x1e5f6, 0x1e61a, 0x1e62e,
+ 0x1e632, 0x1e634, 0x1e64e, 0x1e65c, 0x1e662, 0x1e668, 0x1e68e,
+ 0x1e69c, 0x1e6b8, 0x1e6c2, 0x1e6c4, 0x1e6c8, 0x1e6d0, 0x1e6e6,
+ 0x1e6fa, 0x1e716, 0x1e726, 0x1e72c, 0x1e73a, 0x1e746, 0x1e74c,
+ 0x1e758, 0x1e772, 0x1e774, 0x1e792, 0x1e794, 0x1e7a2, 0x1e7a4,
+ 0x1e7a8, 0x1e7b6, 0x1e812, 0x1e814, 0x1e822, 0x1e824, 0x1e828,
+ 0x1e836, 0x1e842, 0x1e844, 0x1e848, 0x1e850, 0x1e85e, 0x1e866,
+ 0x1e86c, 0x1e87a, 0x1e882, 0x1e884, 0x1e888, 0x1e890, 0x1e89e,
+ 0x1e8a0, 0x1e8bc, 0x1e8c6, 0x1e8cc, 0x1e8d8, 0x1e8ee, 0x1e8f2,
+ 0x1e8f4, 0x1e902, 0x1e904, 0x1e908, 0x1e910, 0x1e920, 0x1e93c,
+ 0x1e940, 0x1e978, 0x1e986, 0x1e98c, 0x1e998, 0x1e9b0, 0x1e9be,
+ 0x1e9ce, 0x1e9dc, 0x1e9e2, 0x1e9e4, 0x1e9e8, 0x1e9f6, 0x1ea04,
+ 0x1ea08, 0x1ea10, 0x1ea20, 0x1ea40, 0x1ea78, 0x1eaf0, 0x1eb06,
+ 0x1eb0c, 0x1eb18, 0x1eb30, 0x1eb3e, 0x1eb60, 0x1eb7c, 0x1eb8e,
+ 0x1eb9c, 0x1ebb8, 0x1ebc2, 0x1ebc4, 0x1ebc8, 0x1ebd0, 0x1ebde,
+ 0x1ebe6, 0x1ebec, 0x1ec1a, 0x1ec2e, 0x1ec32, 0x1ec34, 0x1ec4e,
+ 0x1ec5c, 0x1ec62, 0x1ec64, 0x1ec68, 0x1ec8e, 0x1ec9c, 0x1ecb8,
+ 0x1ecc2, 0x1ecc4, 0x1ecc8, 0x1ecd0, 0x1ece6, 0x1ecfa, 0x1ed0e,
+ 0x1ed1c, 0x1ed38, 0x1ed70, 0x1ed7e, 0x1ed82, 0x1ed84, 0x1ed88,
+ 0x1ed90, 0x1ed9e, 0x1eda0, 0x1edcc, 0x1edf2, 0x1edf4, 0x1ee16,
+ 0x1ee26, 0x1ee2c, 0x1ee3a, 0x1ee46, 0x1ee4c, 0x1ee58, 0x1ee6e,
+ 0x1ee72, 0x1ee74, 0x1ee86, 0x1ee8c, 0x1ee98, 0x1eeb0, 0x1eebe,
+ 0x1eece, 0x1eedc, 0x1eee2, 0x1eee4, 0x1eee8, 0x1ef12, 0x1ef22,
+ 0x1ef24, 0x1ef28, 0x1ef36, 0x1ef42, 0x1ef44, 0x1ef48, 0x1ef50,
+ 0x1ef5e, 0x1ef66, 0x1ef6c, 0x1ef7a, 0x1efae, 0x1efb2, 0x1efb4,
+ 0x1efd6, 0x1f096, 0x1f0a6, 0x1f0ac, 0x1f0ba, 0x1f0ca, 0x1f0d2,
+ 0x1f0d4, 0x1f116, 0x1f126, 0x1f12c, 0x1f13a, 0x1f146, 0x1f14c,
+ 0x1f158, 0x1f16e, 0x1f172, 0x1f174, 0x1f18a, 0x1f192, 0x1f194,
+ 0x1f1a2, 0x1f1a4, 0x1f1a8, 0x1f1da, 0x1f216, 0x1f226, 0x1f22c,
+ 0x1f23a, 0x1f246, 0x1f258, 0x1f26e, 0x1f272, 0x1f274, 0x1f286,
+ 0x1f28c, 0x1f298, 0x1f2b0, 0x1f2be, 0x1f2ce, 0x1f2dc, 0x1f2e2,
+ 0x1f2e4, 0x1f2e8, 0x1f2f6, 0x1f30a, 0x1f312, 0x1f314, 0x1f322,
+ 0x1f328, 0x1f342, 0x1f344, 0x1f348, 0x1f350, 0x1f35e, 0x1f366,
+ 0x1f37a, 0x1f39a, 0x1f3ae, 0x1f3b2, 0x1f3b4, 0x1f416, 0x1f426,
+ 0x1f42c, 0x1f43a, 0x1f446, 0x1f44c, 0x1f458, 0x1f46e, 0x1f472,
+ 0x1f474, 0x1f486, 0x1f48c, 0x1f498, 0x1f4b0, 0x1f4be, 0x1f4ce,
+ 0x1f4dc, 0x1f4e2, 0x1f4e4, 0x1f4e8, 0x1f4f6, 0x1f506, 0x1f50c,
+ 0x1f518, 0x1f530, 0x1f53e, 0x1f560, 0x1f57c, 0x1f58e, 0x1f59c,
+ 0x1f5b8, 0x1f5c2, 0x1f5c4, 0x1f5c8, 0x1f5d0, 0x1f5de, 0x1f5e6,
+ 0x1f5ec, 0x1f5fa, 0x1f60a, 0x1f612, 0x1f614, 0x1f622, 0x1f624,
+ 0x1f628, 0x1f636, 0x1f642, 0x1f644, 0x1f648, 0x1f650, 0x1f65e,
+ 0x1f666, 0x1f67a, 0x1f682, 0x1f684, 0x1f688, 0x1f690, 0x1f69e,
+ 0x1f6a0, 0x1f6bc, 0x1f6cc, 0x1f6f2, 0x1f6f4, 0x1f71a, 0x1f72e,
+ 0x1f732, 0x1f734, 0x1f74e, 0x1f75c, 0x1f762, 0x1f764, 0x1f768,
+ 0x1f776, 0x1f796, 0x1f7a6, 0x1f7ac, 0x1f7ba, 0x1f7d2, 0x1f7d4,
+ 0x1f89a, 0x1f8ae, 0x1f8b2, 0x1f8b4, 0x1f8d6, 0x1f8ea, 0x1f91a,
+ 0x1f92e, 0x1f932, 0x1f934, 0x1f94e, 0x1f95c, 0x1f962, 0x1f964,
+ 0x1f968, 0x1f976, 0x1f996, 0x1f9a6, 0x1f9ac, 0x1f9ba, 0x1f9ca,
+ 0x1f9d2, 0x1f9d4, 0x1fa1a, 0x1fa2e, 0x1fa32, 0x1fa34, 0x1fa4e,
+ 0x1fa5c, 0x1fa62, 0x1fa64, 0x1fa68, 0x1fa76, 0x1fa8e, 0x1fa9c,
+ 0x1fab8, 0x1fac2, 0x1fac4, 0x1fac8, 0x1fad0, 0x1fade, 0x1fae6,
+ 0x1faec, 0x1fb16, 0x1fb26, 0x1fb2c, 0x1fb3a, 0x1fb46, 0x1fb4c,
+ 0x1fb58, 0x1fb6e, 0x1fb72, 0x1fb74, 0x1fb8a, 0x1fb92, 0x1fb94,
+ 0x1fba2, 0x1fba4, 0x1fba8, 0x1fbb6, 0x1fbda};
+
+/**
+ * This table contains to codewords for all symbols.
+ */
+const int CODEWORD_TABLE[2787] = {2627, 1819, 2622, 2621, 1813,
+ 1812, 2729, 2724, 2723, 2779, 2774, 2773, 902, 896, 908, 868, 865,
+ 861, 859, 2511, 873, 871, 1780, 835, 2493, 825, 2491, 842, 837, 844,
+ 1764, 1762, 811, 810, 809, 2483, 807, 2482, 806, 2480, 815, 814, 813,
+ 812, 2484, 817, 816, 1745, 1744, 1742, 1746, 2655, 2637, 2635, 2626,
+ 2625, 2623, 2628, 1820, 2752, 2739, 2737, 2728, 2727, 2725, 2730,
+ 2785, 2783, 2778, 2777, 2775, 2780, 787, 781, 747, 739, 736, 2413,
+ 754, 752, 1719, 692, 689, 681, 2371, 678, 2369, 700, 697, 694, 703,
+ 1688, 1686, 642, 638, 2343, 631, 2341, 627, 2338, 651, 646, 643, 2345,
+ 654, 652, 1652, 1650, 1647, 1654, 601, 599, 2322, 596, 2321, 594,
+ 2319, 2317, 611, 610, 608, 606, 2324, 603, 2323, 615, 614, 612, 1617,
+ 1616, 1614, 1612, 616, 1619, 1618, 2575, 2538, 2536, 905, 901, 898,
+ 909, 2509, 2507, 2504, 870, 867, 864, 860, 2512, 875, 872, 1781, 2490,
+ 2489, 2487, 2485, 1748, 836, 834, 832, 830, 2494, 827, 2492, 843, 841,
+ 839, 845, 1765, 1763, 2701, 2676, 2674, 2653, 2648, 2656, 2634, 2633,
+ 2631, 2629, 1821, 2638, 2636, 2770, 2763, 2761, 2750, 2745, 2753,
+ 2736, 2735, 2733, 2731, 1848, 2740, 2738, 2786, 2784, 591, 588, 576,
+ 569, 566, 2296, 1590, 537, 534, 526, 2276, 522, 2274, 545, 542, 539,
+ 548, 1572, 1570, 481, 2245, 466, 2242, 462, 2239, 492, 485, 482, 2249,
+ 496, 494, 1534, 1531, 1528, 1538, 413, 2196, 406, 2191, 2188, 425,
+ 419, 2202, 415, 2199, 432, 430, 427, 1472, 1467, 1464, 433, 1476,
+ 1474, 368, 367, 2160, 365, 2159, 362, 2157, 2155, 2152, 378, 377, 375,
+ 2166, 372, 2165, 369, 2162, 383, 381, 379, 2168, 1419, 1418, 1416,
+ 1414, 385, 1411, 384, 1423, 1422, 1420, 1424, 2461, 802, 2441, 2439,
+ 790, 786, 783, 794, 2409, 2406, 2403, 750, 742, 738, 2414, 756, 753,
+ 1720, 2367, 2365, 2362, 2359, 1663, 693, 691, 684, 2373, 680, 2370,
+ 702, 699, 696, 704, 1690, 1687, 2337, 2336, 2334, 2332, 1624, 2329,
+ 1622, 640, 637, 2344, 634, 2342, 630, 2340, 650, 648, 645, 2346, 655,
+ 653, 1653, 1651, 1649, 1655, 2612, 2597, 2595, 2571, 2568, 2565, 2576,
+ 2534, 2529, 2526, 1787, 2540, 2537, 907, 904, 900, 910, 2503, 2502,
+ 2500, 2498, 1768, 2495, 1767, 2510, 2508, 2506, 869, 866, 863, 2513,
+ 876, 874, 1782, 2720, 2713, 2711, 2697, 2694, 2691, 2702, 2672, 2670,
+ 2664, 1828, 2678, 2675, 2647, 2646, 2644, 2642, 1823, 2639, 1822,
+ 2654, 2652, 2650, 2657, 2771, 1855, 2765, 2762, 1850, 1849, 2751,
+ 2749, 2747, 2754, 353, 2148, 344, 342, 336, 2142, 332, 2140, 345,
+ 1375, 1373, 306, 2130, 299, 2128, 295, 2125, 319, 314, 311, 2132,
+ 1354, 1352, 1349, 1356, 262, 257, 2101, 253, 2096, 2093, 274, 273,
+ 267, 2107, 263, 2104, 280, 278, 275, 1316, 1311, 1308, 1320, 1318,
+ 2052, 202, 2050, 2044, 2040, 219, 2063, 212, 2060, 208, 2055, 224,
+ 221, 2066, 1260, 1258, 1252, 231, 1248, 229, 1266, 1264, 1261, 1268,
+ 155, 1998, 153, 1996, 1994, 1991, 1988, 165, 164, 2007, 162, 2006,
+ 159, 2003, 2000, 172, 171, 169, 2012, 166, 2010, 1186, 1184, 1182,
+ 1179, 175, 1176, 173, 1192, 1191, 1189, 1187, 176, 1194, 1193, 2313,
+ 2307, 2305, 592, 589, 2294, 2292, 2289, 578, 572, 568, 2297, 580,
+ 1591, 2272, 2267, 2264, 1547, 538, 536, 529, 2278, 525, 2275, 547,
+ 544, 541, 1574, 1571, 2237, 2235, 2229, 1493, 2225, 1489, 478, 2247,
+ 470, 2244, 465, 2241, 493, 488, 484, 2250, 498, 495, 1536, 1533, 1530,
+ 1539, 2187, 2186, 2184, 2182, 1432, 2179, 1430, 2176, 1427, 414, 412,
+ 2197, 409, 2195, 405, 2193, 2190, 426, 424, 421, 2203, 418, 2201, 431,
+ 429, 1473, 1471, 1469, 1466, 434, 1477, 1475, 2478, 2472, 2470, 2459,
+ 2457, 2454, 2462, 803, 2437, 2432, 2429, 1726, 2443, 2440, 792, 789,
+ 785, 2401, 2399, 2393, 1702, 2389, 1699, 2411, 2408, 2405, 745, 741,
+ 2415, 758, 755, 1721, 2358, 2357, 2355, 2353, 1661, 2350, 1660, 2347,
+ 1657, 2368, 2366, 2364, 2361, 1666, 690, 687, 2374, 683, 2372, 701,
+ 698, 705, 1691, 1689, 2619, 2617, 2610, 2608, 2605, 2613, 2593, 2588,
+ 2585, 1803, 2599, 2596, 2563, 2561, 2555, 1797, 2551, 1795, 2573,
+ 2570, 2567, 2577, 2525, 2524, 2522, 2520, 1786, 2517, 1785, 2514,
+ 1783, 2535, 2533, 2531, 2528, 1788, 2541, 2539, 906, 903, 911, 2721,
+ 1844, 2715, 2712, 1838, 1836, 2699, 2696, 2693, 2703, 1827, 1826,
+ 1824, 2673, 2671, 2669, 2666, 1829, 2679, 2677, 1858, 1857, 2772,
+ 1854, 1853, 1851, 1856, 2766, 2764, 143, 1987, 139, 1986, 135, 133,
+ 131, 1984, 128, 1983, 125, 1981, 138, 137, 136, 1985, 1133, 1132,
+ 1130, 112, 110, 1974, 107, 1973, 104, 1971, 1969, 122, 121, 119, 117,
+ 1977, 114, 1976, 124, 1115, 1114, 1112, 1110, 1117, 1116, 84, 83,
+ 1953, 81, 1952, 78, 1950, 1948, 1945, 94, 93, 91, 1959, 88, 1958, 85,
+ 1955, 99, 97, 95, 1961, 1086, 1085, 1083, 1081, 1078, 100, 1090, 1089,
+ 1087, 1091, 49, 47, 1917, 44, 1915, 1913, 1910, 1907, 59, 1926, 56,
+ 1925, 53, 1922, 1919, 66, 64, 1931, 61, 1929, 1042, 1040, 1038, 71,
+ 1035, 70, 1032, 68, 1048, 1047, 1045, 1043, 1050, 1049, 12, 10, 1869,
+ 1867, 1864, 1861, 21, 1880, 19, 1877, 1874, 1871, 28, 1888, 25, 1886,
+ 22, 1883, 982, 980, 977, 974, 32, 30, 991, 989, 987, 984, 34, 995,
+ 994, 992, 2151, 2150, 2147, 2146, 2144, 356, 355, 354, 2149, 2139,
+ 2138, 2136, 2134, 1359, 343, 341, 338, 2143, 335, 2141, 348, 347, 346,
+ 1376, 1374, 2124, 2123, 2121, 2119, 1326, 2116, 1324, 310, 308, 305,
+ 2131, 302, 2129, 298, 2127, 320, 318, 316, 313, 2133, 322, 321, 1355,
+ 1353, 1351, 1357, 2092, 2091, 2089, 2087, 1276, 2084, 1274, 2081,
+ 1271, 259, 2102, 256, 2100, 252, 2098, 2095, 272, 269, 2108, 266,
+ 2106, 281, 279, 277, 1317, 1315, 1313, 1310, 282, 1321, 1319, 2039,
+ 2037, 2035, 2032, 1203, 2029, 1200, 1197, 207, 2053, 205, 2051, 201,
+ 2049, 2046, 2043, 220, 218, 2064, 215, 2062, 211, 2059, 228, 226, 223,
+ 2069, 1259, 1257, 1254, 232, 1251, 230, 1267, 1265, 1263, 2316, 2315,
+ 2312, 2311, 2309, 2314, 2304, 2303, 2301, 2299, 1593, 2308, 2306, 590,
+ 2288, 2287, 2285, 2283, 1578, 2280, 1577, 2295, 2293, 2291, 579, 577,
+ 574, 571, 2298, 582, 581, 1592, 2263, 2262, 2260, 2258, 1545, 2255,
+ 1544, 2252, 1541, 2273, 2271, 2269, 2266, 1550, 535, 532, 2279, 528,
+ 2277, 546, 543, 549, 1575, 1573, 2224, 2222, 2220, 1486, 2217, 1485,
+ 2214, 1482, 1479, 2238, 2236, 2234, 2231, 1496, 2228, 1492, 480, 477,
+ 2248, 473, 2246, 469, 2243, 490, 487, 2251, 497, 1537, 1535, 1532,
+ 2477, 2476, 2474, 2479, 2469, 2468, 2466, 2464, 1730, 2473, 2471,
+ 2453, 2452, 2450, 2448, 1729, 2445, 1728, 2460, 2458, 2456, 2463, 805,
+ 804, 2428, 2427, 2425, 2423, 1725, 2420, 1724, 2417, 1722, 2438, 2436,
+ 2434, 2431, 1727, 2444, 2442, 793, 791, 788, 795, 2388, 2386, 2384,
+ 1697, 2381, 1696, 2378, 1694, 1692, 2402, 2400, 2398, 2395, 1703,
+ 2392, 1701, 2412, 2410, 2407, 751, 748, 744, 2416, 759, 757, 1807,
+ 2620, 2618, 1806, 1805, 2611, 2609, 2607, 2614, 1802, 1801, 1799,
+ 2594, 2592, 2590, 2587, 1804, 2600, 2598, 1794, 1793, 1791, 1789,
+ 2564, 2562, 2560, 2557, 1798, 2554, 1796, 2574, 2572, 2569, 2578,
+ 1847, 1846, 2722, 1843, 1842, 1840, 1845, 2716, 2714, 1835, 1834,
+ 1832, 1830, 1839, 1837, 2700, 2698, 2695, 2704, 1817, 1811, 1810, 897,
+ 862, 1777, 829, 826, 838, 1760, 1758, 808, 2481, 1741, 1740, 1738,
+ 1743, 2624, 1818, 2726, 2776, 782, 740, 737, 1715, 686, 679, 695,
+ 1682, 1680, 639, 628, 2339, 647, 644, 1645, 1643, 1640, 1648, 602,
+ 600, 597, 595, 2320, 593, 2318, 609, 607, 604, 1611, 1610, 1608, 1606,
+ 613, 1615, 1613, 2328, 926, 924, 892, 886, 899, 857, 850, 2505, 1778,
+ 824, 823, 821, 819, 2488, 818, 2486, 833, 831, 828, 840, 1761, 1759,
+ 2649, 2632, 2630, 2746, 2734, 2732, 2782, 2781, 570, 567, 1587, 531,
+ 527, 523, 540, 1566, 1564, 476, 467, 463, 2240, 486, 483, 1524, 1521,
+ 1518, 1529, 411, 403, 2192, 399, 2189, 423, 416, 1462, 1457, 1454,
+ 428, 1468, 1465, 2210, 366, 363, 2158, 360, 2156, 357, 2153, 376, 373,
+ 370, 2163, 1410, 1409, 1407, 1405, 382, 1402, 380, 1417, 1415, 1412,
+ 1421, 2175, 2174, 777, 774, 771, 784, 732, 725, 722, 2404, 743, 1716,
+ 676, 674, 668, 2363, 665, 2360, 685, 1684, 1681, 626, 624, 622, 2335,
+ 620, 2333, 617, 2330, 641, 635, 649, 1646, 1644, 1642, 2566, 928, 925,
+ 2530, 2527, 894, 891, 888, 2501, 2499, 2496, 858, 856, 854, 851, 1779,
+ 2692, 2668, 2665, 2645, 2643, 2640, 2651, 2768, 2759, 2757, 2744,
+ 2743, 2741, 2748, 352, 1382, 340, 337, 333, 1371, 1369, 307, 300, 296,
+ 2126, 315, 312, 1347, 1342, 1350, 261, 258, 250, 2097, 246, 2094, 271,
+ 268, 264, 1306, 1301, 1298, 276, 1312, 1309, 2115, 203, 2048, 195,
+ 2045, 191, 2041, 213, 209, 2056, 1246, 1244, 1238, 225, 1234, 222,
+ 1256, 1253, 1249, 1262, 2080, 2079, 154, 1997, 150, 1995, 147, 1992,
+ 1989, 163, 160, 2004, 156, 2001, 1175, 1174, 1172, 1170, 1167, 170,
+ 1164, 167, 1185, 1183, 1180, 1177, 174, 1190, 1188, 2025, 2024, 2022,
+ 587, 586, 564, 559, 556, 2290, 573, 1588, 520, 518, 512, 2268, 508,
+ 2265, 530, 1568, 1565, 461, 457, 2233, 450, 2230, 446, 2226, 479, 471,
+ 489, 1526, 1523, 1520, 397, 395, 2185, 392, 2183, 389, 2180, 2177,
+ 410, 2194, 402, 422, 1463, 1461, 1459, 1456, 1470, 2455, 799, 2433,
+ 2430, 779, 776, 773, 2397, 2394, 2390, 734, 728, 724, 746, 1717, 2356,
+ 2354, 2351, 2348, 1658, 677, 675, 673, 670, 667, 688, 1685, 1683,
+ 2606, 2589, 2586, 2559, 2556, 2552, 927, 2523, 2521, 2518, 2515, 1784,
+ 2532, 895, 893, 890, 2718, 2709, 2707, 2689, 2687, 2684, 2663, 2662,
+ 2660, 2658, 1825, 2667, 2769, 1852, 2760, 2758, 142, 141, 1139, 1138,
+ 134, 132, 129, 126, 1982, 1129, 1128, 1126, 1131, 113, 111, 108, 105,
+ 1972, 101, 1970, 120, 118, 115, 1109, 1108, 1106, 1104, 123, 1113,
+ 1111, 82, 79, 1951, 75, 1949, 72, 1946, 92, 89, 86, 1956, 1077, 1076,
+ 1074, 1072, 98, 1069, 96, 1084, 1082, 1079, 1088, 1968, 1967, 48, 45,
+ 1916, 42, 1914, 39, 1911, 1908, 60, 57, 54, 1923, 50, 1920, 1031,
+ 1030, 1028, 1026, 67, 1023, 65, 1020, 62, 1041, 1039, 1036, 1033, 69,
+ 1046, 1044, 1944, 1943, 1941, 11, 9, 1868, 7, 1865, 1862, 1859, 20,
+ 1878, 16, 1875, 13, 1872, 970, 968, 966, 963, 29, 960, 26, 23, 983,
+ 981, 978, 975, 33, 971, 31, 990, 988, 985, 1906, 1904, 1902, 993, 351,
+ 2145, 1383, 331, 330, 328, 326, 2137, 323, 2135, 339, 1372, 1370, 294,
+ 293, 291, 289, 2122, 286, 2120, 283, 2117, 309, 303, 317, 1348, 1346,
+ 1344, 245, 244, 242, 2090, 239, 2088, 236, 2085, 2082, 260, 2099, 249,
+ 270, 1307, 1305, 1303, 1300, 1314, 189, 2038, 186, 2036, 183, 2033,
+ 2030, 2026, 206, 198, 2047, 194, 216, 1247, 1245, 1243, 1240, 227,
+ 1237, 1255, 2310, 2302, 2300, 2286, 2284, 2281, 565, 563, 561, 558,
+ 575, 1589, 2261, 2259, 2256, 2253, 1542, 521, 519, 517, 514, 2270,
+ 511, 533, 1569, 1567, 2223, 2221, 2218, 2215, 1483, 2211, 1480, 459,
+ 456, 453, 2232, 449, 474, 491, 1527, 1525, 1522, 2475, 2467, 2465,
+ 2451, 2449, 2446, 801, 800, 2426, 2424, 2421, 2418, 1723, 2435, 780,
+ 778, 775, 2387, 2385, 2382, 2379, 1695, 2375, 1693, 2396, 735, 733,
+ 730, 727, 749, 1718, 2616, 2615, 2604, 2603, 2601, 2584, 2583, 2581,
+ 2579, 1800, 2591, 2550, 2549, 2547, 2545, 1792, 2542, 1790, 2558, 929,
+ 2719, 1841, 2710, 2708, 1833, 1831, 2690, 2688, 2686, 1815, 1809,
+ 1808, 1774, 1756, 1754, 1737, 1736, 1734, 1739, 1816, 1711, 1676,
+ 1674, 633, 629, 1638, 1636, 1633, 1641, 598, 1605, 1604, 1602, 1600,
+ 605, 1609, 1607, 2327, 887, 853, 1775, 822, 820, 1757, 1755, 1584,
+ 524, 1560, 1558, 468, 464, 1514, 1511, 1508, 1519, 408, 404, 400,
+ 1452, 1447, 1444, 417, 1458, 1455, 2208, 364, 361, 358, 2154, 1401,
+ 1400, 1398, 1396, 374, 1393, 371, 1408, 1406, 1403, 1413, 2173, 2172,
+ 772, 726, 723, 1712, 672, 669, 666, 682, 1678, 1675, 625, 623, 621,
+ 618, 2331, 636, 632, 1639, 1637, 1635, 920, 918, 884, 880, 889, 849,
+ 848, 847, 846, 2497, 855, 852, 1776, 2641, 2742, 2787, 1380, 334,
+ 1367, 1365, 301, 297, 1340, 1338, 1335, 1343, 255, 251, 247, 1296,
+ 1291, 1288, 265, 1302, 1299, 2113, 204, 196, 192, 2042, 1232, 1230,
+ 1224, 214, 1220, 210, 1242, 1239, 1235, 1250, 2077, 2075, 151, 148,
+ 1993, 144, 1990, 1163, 1162, 1160, 1158, 1155, 161, 1152, 157, 1173,
+ 1171, 1168, 1165, 168, 1181, 1178, 2021, 2020, 2018, 2023, 585, 560,
+ 557, 1585, 516, 509, 1562, 1559, 458, 447, 2227, 472, 1516, 1513,
+ 1510, 398, 396, 393, 390, 2181, 386, 2178, 407, 1453, 1451, 1449,
+ 1446, 420, 1460, 2209, 769, 764, 720, 712, 2391, 729, 1713, 664, 663,
+ 661, 659, 2352, 656, 2349, 671, 1679, 1677, 2553, 922, 919, 2519,
+ 2516, 885, 883, 881, 2685, 2661, 2659, 2767, 2756, 2755, 140, 1137,
+ 1136, 130, 127, 1125, 1124, 1122, 1127, 109, 106, 102, 1103, 1102,
+ 1100, 1098, 116, 1107, 1105, 1980, 80, 76, 73, 1947, 1068, 1067, 1065,
+ 1063, 90, 1060, 87, 1075, 1073, 1070, 1080, 1966, 1965, 46, 43, 40,
+ 1912, 36, 1909, 1019, 1018, 1016, 1014, 58, 1011, 55, 1008, 51, 1029,
+ 1027, 1024, 1021, 63, 1037, 1034, 1940, 1939, 1937, 1942, 8, 1866, 4,
+ 1863, 1, 1860, 956, 954, 952, 949, 946, 17, 14, 969, 967, 964, 961,
+ 27, 957, 24, 979, 976, 972, 1901, 1900, 1898, 1896, 986, 1905, 1903,
+ 350, 349, 1381, 329, 327, 324, 1368, 1366, 292, 290, 287, 284, 2118,
+ 304, 1341, 1339, 1337, 1345, 243, 240, 237, 2086, 233, 2083, 254,
+ 1297, 1295, 1293, 1290, 1304, 2114, 190, 187, 184, 2034, 180, 2031,
+ 177, 2027, 199, 1233, 1231, 1229, 1226, 217, 1223, 1241, 2078, 2076,
+ 584, 555, 554, 552, 550, 2282, 562, 1586, 507, 506, 504, 502, 2257,
+ 499, 2254, 515, 1563, 1561, 445, 443, 441, 2219, 438, 2216, 435, 2212,
+ 460, 454, 475, 1517, 1515, 1512, 2447, 798, 797, 2422, 2419, 770, 768,
+ 766, 2383, 2380, 2376, 721, 719, 717, 714, 731, 1714, 2602, 2582,
+ 2580, 2548, 2546, 2543, 923, 921, 2717, 2706, 2705, 2683, 2682, 2680,
+ 1771, 1752, 1750, 1733, 1732, 1731, 1735, 1814, 1707, 1670, 1668,
+ 1631, 1629, 1626, 1634, 1599, 1598, 1596, 1594, 1603, 1601, 2326,
+ 1772, 1753, 1751, 1581, 1554, 1552, 1504, 1501, 1498, 1509, 1442,
+ 1437, 1434, 401, 1448, 1445, 2206, 1392, 1391, 1389, 1387, 1384, 359,
+ 1399, 1397, 1394, 1404, 2171, 2170, 1708, 1672, 1669, 619, 1632, 1630,
+ 1628, 1773, 1378, 1363, 1361, 1333, 1328, 1336, 1286, 1281, 1278, 248,
+ 1292, 1289, 2111, 1218, 1216, 1210, 197, 1206, 193, 1228, 1225, 1221,
+ 1236, 2073, 2071, 1151, 1150, 1148, 1146, 152, 1143, 149, 1140, 145,
+ 1161, 1159, 1156, 1153, 158, 1169, 1166, 2017, 2016, 2014, 2019, 1582,
+ 510, 1556, 1553, 452, 448, 1506, 1500, 394, 391, 387, 1443, 1441,
+ 1439, 1436, 1450, 2207, 765, 716, 713, 1709, 662, 660, 657, 1673,
+ 1671, 916, 914, 879, 878, 877, 882, 1135, 1134, 1121, 1120, 1118,
+ 1123, 1097, 1096, 1094, 1092, 103, 1101, 1099, 1979, 1059, 1058, 1056,
+ 1054, 77, 1051, 74, 1066, 1064, 1061, 1071, 1964, 1963, 1007, 1006,
+ 1004, 1002, 999, 41, 996, 37, 1017, 1015, 1012, 1009, 52, 1025, 1022,
+ 1936, 1935, 1933, 1938, 942, 940, 938, 935, 932, 5, 2, 955, 953, 950,
+ 947, 18, 943, 15, 965, 962, 958, 1895, 1894, 1892, 1890, 973, 1899,
+ 1897, 1379, 325, 1364, 1362, 288, 285, 1334, 1332, 1330, 241, 238,
+ 234, 1287, 1285, 1283, 1280, 1294, 2112, 188, 185, 181, 178, 2028,
+ 1219, 1217, 1215, 1212, 200, 1209, 1227, 2074, 2072, 583, 553, 551,
+ 1583, 505, 503, 500, 513, 1557, 1555, 444, 442, 439, 436, 2213, 455,
+ 451, 1507, 1505, 1502, 796, 763, 762, 760, 767, 711, 710, 708, 706,
+ 2377, 718, 715, 1710, 2544, 917, 915, 2681, 1627, 1597, 1595, 2325,
+ 1769, 1749, 1747, 1499, 1438, 1435, 2204, 1390, 1388, 1385, 1395,
+ 2169, 2167, 1704, 1665, 1662, 1625, 1623, 1620, 1770, 1329, 1282,
+ 1279, 2109, 1214, 1207, 1222, 2068, 2065, 1149, 1147, 1144, 1141, 146,
+ 1157, 1154, 2013, 2011, 2008, 2015, 1579, 1549, 1546, 1495, 1487,
+ 1433, 1431, 1428, 1425, 388, 1440, 2205, 1705, 658, 1667, 1664, 1119,
+ 1095, 1093, 1978, 1057, 1055, 1052, 1062, 1962, 1960, 1005, 1003,
+ 1000, 997, 38, 1013, 1010, 1932, 1930, 1927, 1934, 941, 939, 936, 933,
+ 6, 930, 3, 951, 948, 944, 1889, 1887, 1884, 1881, 959, 1893, 1891, 35,
+ 1377, 1360, 1358, 1327, 1325, 1322, 1331, 1277, 1275, 1272, 1269, 235,
+ 1284, 2110, 1205, 1204, 1201, 1198, 182, 1195, 179, 1213, 2070, 2067,
+ 1580, 501, 1551, 1548, 440, 437, 1497, 1494, 1490, 1503, 761, 709,
+ 707, 1706, 913, 912, 2198, 1386, 2164, 2161, 1621, 1766, 2103, 1208,
+ 2058, 2054, 1145, 1142, 2005, 2002, 1999, 2009, 1488, 1429, 1426,
+ 2200, 1698, 1659, 1656, 1975, 1053, 1957, 1954, 1001, 998, 1924, 1921,
+ 1918, 1928, 937, 934, 931, 1879, 1876, 1873, 1870, 945, 1885, 1882,
+ 1323, 1273, 1270, 2105, 1202, 1199, 1196, 1211, 2061, 2057, 1576,
+ 1543, 1540, 1484, 1481, 1478, 1491, 1700};
+
+@interface ZXPDF417BitMatrixParser ()
+
+@property (nonatomic, retain) ZXBitMatrix *bitMatrix;
+@property (nonatomic, assign) int rows;
+@property (nonatomic, assign) int leftColumnECData;
+@property (nonatomic, assign) int rightColumnECData;
+@property (nonatomic, assign) int eraseCount;
+@property (nonatomic, retain) NSMutableArray *erasures;
+@property (nonatomic, assign) int ecLevel;
+
+- (int)codeword:(long)symbol;
+- (int)findCodewordIndex:(long)symbol;
+- (int)processRow:(int *)rowCounters rowCountersLen:(unsigned int)rowCountersLen rowNumber:(int)rowNumber rowHeight:(int)rowHeight codewords:(NSMutableArray *)codewords next:(int)next;
+
+@end
+
+@implementation ZXPDF417BitMatrixParser
+
+@synthesize bitMatrix;
+@synthesize rows;
+@synthesize leftColumnECData;
+@synthesize rightColumnECData;
+@synthesize eraseCount;
+@synthesize erasures;
+@synthesize ecLevel;
+
+- (id)initWithBitMatrix:(ZXBitMatrix *)aBitMatrix {
+ if (self = [super init]) {
+ self.rows = 0;
+ self.leftColumnECData = 0;
+ self.rightColumnECData = 0;
+ self.eraseCount = 0;
+ self.erasures = nil;
+ self.ecLevel = -1;
+ self.bitMatrix = aBitMatrix;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [bitMatrix release];
+ [erasures release];
+
+ [super dealloc];
+}
+
+
+/**
+ * To ensure separability of rows, codewords of consecutive rows belong to
+ * different subsets of all possible codewords. This routine scans the
+ * symbols in the barcode. When it finds a number of consecutive rows which
+ * are the same, it assumes that this is a row of codewords and processes
+ * them into a codeword array.
+ */
+- (NSArray *)readCodewords {
+ int width = bitMatrix.width;
+ int height = bitMatrix.height;
+
+ self.erasures = [NSMutableArray arrayWithCapacity:MAX_CW_CAPACITY];
+ for (int i = 0; i < MAX_CW_CAPACITY; i++) {
+ [self.erasures addObject:[NSNumber numberWithInt:0]];
+ }
+
+ // Get the number of pixels in a module across the X dimension
+ //float moduleWidth = bitMatrix.getModuleWidth();
+ float moduleWidth = 1.0f; // Image has been sampled and reduced
+
+ int rowCounters[width];
+ memset(rowCounters, 0, width * sizeof(int));
+
+ NSMutableArray *codewords = [NSMutableArray arrayWithCapacity:MAX_CW_CAPACITY];
+ for (int i = 0; i < MAX_CW_CAPACITY; i++) {
+ [codewords addObject:[NSNumber numberWithInt:0]];
+ }
+
+ int next = 0;
+ int matchingConsecutiveScans = 0;
+ BOOL rowInProgress = NO;
+ int rowNumber = 0;
+ int rowHeight = 0;
+ for (int i = 1; i < height; i++) {
+ if (rowNumber >= MAX_ROWS) {
+ // Something is wrong, since we have exceeded
+ // the maximum rows in the specification.
+ return nil;
+ }
+ int rowDifference = 0;
+ // Scan a line of modules and check the
+ // difference between this and the previous line
+ for (int j = 0; j < width; j++) {
+ // Accumulate differences between this line and the
+ // previous line.
+ if ([self.bitMatrix getX:j y:i] != [self.bitMatrix getX:j y:i - 1]) {
+ rowDifference++;
+ }
+ }
+ if (rowDifference <= moduleWidth * MAX_ROW_DIFFERENCE) {
+ for (int j = 0; j < width; j++) {
+ // Accumulate the black pixels on this line
+ if ([self.bitMatrix getX:j y:i]) {
+ rowCounters[j]++;
+ }
+ }
+ // Increment the number of consecutive rows of pixels
+ // that are more or less the same
+ matchingConsecutiveScans++;
+ // Height of a row is a multiple of the module size in pixels
+ // It's supposed to be >= 3x module width, but, accept anything >= 2x
+ if ((matchingConsecutiveScans + 1) >= 2.0f * moduleWidth) {
+ // We have some previous matches as well as a match here
+ // Set processing a unique row.
+ rowInProgress = YES;
+ }
+ } else {
+ if (rowInProgress) {
+ // Process Row
+ next = [self processRow:rowCounters rowCountersLen:width rowNumber:rowNumber rowHeight:rowHeight codewords:codewords next:next];
+ if (next == -1) {
+ // Something is wrong, since we have exceeded
+ // the maximum columns in the specification.
+ return nil;
+ }
+ // Reinitialize the row counters.
+ for (int j = 0; j < width; j++) {
+ rowCounters[j] = 0;
+ }
+ rowNumber++;
+ rowHeight = 0;
+ }
+ matchingConsecutiveScans = 0;
+ rowInProgress = NO;
+ }
+ rowHeight++;
+ }
+ // Check for a row that was in progress before we exited above.
+ if (rowInProgress) {
+ // Process Row
+ if (rowNumber >= MAX_ROWS) {
+ // Something is wrong, since we have exceeded
+ // the maximum rows in the specification.
+ return nil;
+ }
+ next = [self processRow:rowCounters rowCountersLen:width rowNumber:rowNumber rowHeight:rowHeight codewords:codewords next:next];
+ if (next == -1) {
+ return nil;
+ }
+ rowNumber++;
+ self.rows = rowNumber;
+ }
+ self.erasures = [[[self.erasures subarrayWithRange:NSMakeRange(0, self.eraseCount)] mutableCopy] autorelease];
+ return [codewords subarrayWithRange:NSMakeRange(0, next)];
+}
+
+
+/**
+ * Convert the symbols in the row to codewords.
+ * Each PDF417 symbol character consists of four bar elements and four space
+ * elements, each of which can be one to six modules wide. The four bar and
+ * four space elements shall measure 17 modules in total.
+ */
+- (int)processRow:(int *)rowCounters rowCountersLen:(unsigned int)rowCountersLen rowNumber:(int)rowNumber rowHeight:(int)rowHeight codewords:(NSMutableArray *)codewords next:(int)next {
+ int width = bitMatrix.width;
+ int columnNumber = 0;
+ long symbol = 0;
+ for (int i = 0; i < width; i += MODULES_IN_SYMBOL) {
+ // This happens in real life and is almost surely a rare misdecode
+ if (i + MODULES_IN_SYMBOL > rowCountersLen) {
+ return -1;
+ }
+ for (int mask = MODULES_IN_SYMBOL - 1; mask >= 0; mask--) {
+ if (rowCounters[i + (MODULES_IN_SYMBOL - 1 - mask)] >= (int)((unsigned int)rowHeight >> 1)) {
+ symbol |= 1L << mask;
+ }
+ }
+ if (columnNumber > 0) {
+ int cw = [self codeword:symbol];
+ if (cw < 0 && i < width - MODULES_IN_SYMBOL) {
+ // Skip errors on the Right row indicator column
+ if (eraseCount >= erasures.count) {
+ return -1;
+ }
+ [self.erasures addObject:[NSNumber numberWithInt:next]];
+ next++;
+ self.eraseCount++;
+ } else {
+ [codewords replaceObjectAtIndex:next++ withObject:[NSNumber numberWithInt:cw]];
+ }
+ } else {
+ // Left row indicator column
+ int cw = [self codeword:symbol];
+ if (ecLevel < 0 && rowNumber % 3 == 1) {
+ leftColumnECData = cw;
+ }
+ }
+ symbol = 0;
+ //columns = columnNumber;
+ columnNumber++;
+ }
+ if (columnNumber > 1) {
+ // Right row indicator column is in codeword[next]
+ //columns--;
+ // Overwrite the last codeword i.e. Right Row Indicator
+ --next;
+ if (ecLevel < 0 && rowNumber % 3 == 2) {
+ self.rightColumnECData = [[codewords objectAtIndex:next] intValue];
+ if (self.rightColumnECData == self.leftColumnECData && self.leftColumnECData != 0) {
+ self.ecLevel = ((self.rightColumnECData % 30) - self.rows % 3) / 3;
+ }
+ }
+ [codewords replaceObjectAtIndex:next withObject:[NSNumber numberWithInt:0]];
+ }
+ return next;
+}
+
+
+/**
+ * Translate the symbol into a codeword.
+ */
+- (int)codeword:(long)symbol {
+ long sym = symbol & 0x3FFFF;
+ int i = [self findCodewordIndex:sym];
+ if (i == -1) {
+ return -1;
+ } else {
+ long cw = CODEWORD_TABLE[i] - 1;
+ cw %= 929;
+ return (int)cw;
+ }
+}
+
+
+/**
+ * Use a binary search to find the index of the codeword corresponding to
+ * this symbol.
+ */
+- (int)findCodewordIndex:(long)symbol {
+ int first = 0;
+ int upto = sizeof(SYMBOL_TABLE) / sizeof(int);
+ while (first < upto) {
+ int mid = (int)((unsigned int)(first + upto) >> 1);
+ if (symbol < SYMBOL_TABLE[mid]) {
+ upto = mid;
+ } else if (symbol > SYMBOL_TABLE[mid]) {
+ first = mid + 1;
+ } else {
+ return mid;
+ }
+ }
+
+ return -1;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417DecodedBitStreamParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417DecodedBitStreamParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ca50468d4e1ba08679c8b770ac038420ec1035c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417DecodedBitStreamParser.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This class contains the methods for decoding the PDF417 codewords.
+ */
+
+@class ZXDecoderResult;
+
+@interface ZXPDF417DecodedBitStreamParser : NSObject
+
++ (ZXDecoderResult *)decode:(NSArray *)codewords error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417DecodedBitStreamParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417DecodedBitStreamParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..c5a0dd9a2e5d763af4689c46e71f5d0475fd1dfb
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417DecodedBitStreamParser.m
@@ -0,0 +1,531 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDecoderResult.h"
+#import "ZXErrors.h"
+#import "ZXPDF417DecodedBitStreamParser.h"
+
+enum {
+ ALPHA,
+ LOWER,
+ MIXED,
+ PUNCT,
+ ALPHA_SHIFT,
+ PUNCT_SHIFT
+};
+
+int const TEXT_COMPACTION_MODE_LATCH = 900;
+int const BYTE_COMPACTION_MODE_LATCH = 901;
+int const NUMERIC_COMPACTION_MODE_LATCH = 902;
+int const BYTE_COMPACTION_MODE_LATCH_6 = 924;
+int const BEGIN_MACRO_PDF417_CONTROL_BLOCK = 928;
+int const BEGIN_MACRO_PDF417_OPTIONAL_FIELD = 923;
+int const MACRO_PDF417_TERMINATOR = 922;
+int const MODE_SHIFT_TO_BYTE_COMPACTION_MODE = 913;
+int const MAX_NUMERIC_CODEWORDS = 15;
+
+int const PL = 25;
+int const LL = 27;
+int const AS = 27;
+int const ML = 28;
+int const AL = 28;
+int const PS = 29;
+int const PAL = 29;
+
+char const PUNCT_CHARS[29] = {
+ ';', '<', '>', '@', '[', '\\', '}', '_', '`', '~', '!',
+ '\r', '\t', ',', ':', '\n', '-', '.', '$', '/', '"', '|', '*',
+ '(', ')', '?', '{', '}', '\''};
+
+char const MIXED_CHARS[25] = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '&',
+ '\r', '\t', ',', ':', '#', '-', '.', '$', '/', '+', '%', '*',
+ '=', '^'};
+
+/**
+ * Table containing values for the exponent of 900.
+ * This is used in the numeric compaction decode algorithm.
+ */
+static NSArray *EXP900 = nil;
+
+@interface ZXPDF417DecodedBitStreamParser ()
+
++ (int)byteCompaction:(int)mode codewords:(NSArray *)codewords codeIndex:(int)codeIndex result:(NSMutableString *)result;
++ (NSString *)decodeBase900toBase10:(int *)codewords count:(int)count;
++ (void)decodeTextCompaction:(int *)textCompactionData byteCompactionData:(int *)byteCompactionData length:(unsigned int)length result:(NSMutableString *)result;
++ (int)numericCompaction:(NSArray *)codewords codeIndex:(int)codeIndex result:(NSMutableString *)result;
++ (int)textCompaction:(NSArray *)codewords codeIndex:(int)codeIndex result:(NSMutableString *)result;
+
+@end
+
+@implementation ZXPDF417DecodedBitStreamParser
+
++ (void)initialize {
+ NSMutableArray *exponents = [NSMutableArray arrayWithCapacity:16];
+ [exponents addObject:[NSDecimalNumber one]];
+ NSDecimalNumber *nineHundred = [NSDecimalNumber decimalNumberWithString:@"900"];
+ [exponents addObject:nineHundred];
+ for (int i = 2; i < 16; i++) {
+ [exponents addObject:[[exponents objectAtIndex:i - 1] decimalNumberByMultiplyingBy:nineHundred]];
+ }
+ EXP900 = [[NSArray alloc] initWithArray:exponents];
+}
+
++ (ZXDecoderResult *)decode:(NSArray *)codewords error:(NSError **)error {
+ if (!codewords) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ NSMutableString *result = [NSMutableString stringWithCapacity:100];
+ int codeIndex = 1;
+ int code = [[codewords objectAtIndex:codeIndex++] intValue];
+ while (codeIndex < [[codewords objectAtIndex:0] intValue]) {
+ switch (code) {
+ case TEXT_COMPACTION_MODE_LATCH:
+ codeIndex = [self textCompaction:codewords codeIndex:codeIndex result:result];
+ break;
+ case BYTE_COMPACTION_MODE_LATCH:
+ codeIndex = [self byteCompaction:code codewords:codewords codeIndex:codeIndex result:result];
+ break;
+ case NUMERIC_COMPACTION_MODE_LATCH:
+ codeIndex = [self numericCompaction:codewords codeIndex:codeIndex result:result];
+ break;
+ case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
+ codeIndex = [self byteCompaction:code codewords:codewords codeIndex:codeIndex result:result];
+ break;
+ case BYTE_COMPACTION_MODE_LATCH_6:
+ codeIndex = [self byteCompaction:code codewords:codewords codeIndex:codeIndex result:result];
+ break;
+ default:
+ codeIndex--;
+ codeIndex = [self textCompaction:codewords codeIndex:codeIndex result:result];
+ break;
+ }
+ if (codeIndex < [codewords count]) {
+ code = [[codewords objectAtIndex:codeIndex++] intValue];
+ } else {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ }
+ if (!result || result.length == 0) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ return [[[ZXDecoderResult alloc] initWithRawBytes:NULL length:0 text:result byteSegments:nil ecLevel:nil] autorelease];
+}
+
+
+/**
+ * Text Compaction mode (see 5.4.1.5) permits all printable ASCII characters to be
+ * encoded, i.e. values 32 - 126 inclusive in accordance with ISO/IEC 646 (IRV), as
+ * well as selected control characters.
+ */
++ (int)textCompaction:(NSArray *)codewords codeIndex:(int)codeIndex result:(NSMutableString *)result {
+ int count = [[codewords objectAtIndex:0] intValue] << 1;
+ // 2 character per codeword
+ int textCompactionData[count];
+ // Used to hold the byte compaction value if there is a mode shift
+ int byteCompactionData[count];
+
+ for (int i = 0; i < count; i++) {
+ textCompactionData[0] = 0;
+ byteCompactionData[0] = 0;
+ }
+
+ int index = 0;
+ BOOL end = NO;
+ while ((codeIndex < [[codewords objectAtIndex:0] intValue]) && !end) {
+ int code = [[codewords objectAtIndex:codeIndex++] intValue];
+ if (code < TEXT_COMPACTION_MODE_LATCH) {
+ textCompactionData[index] = code / 30;
+ textCompactionData[index + 1] = code % 30;
+ index += 2;
+ } else {
+ switch (code) {
+ case TEXT_COMPACTION_MODE_LATCH:
+ // reinitialize text compaction mode to alpha sub mode
+ textCompactionData[index++] = TEXT_COMPACTION_MODE_LATCH;
+ break;
+ case BYTE_COMPACTION_MODE_LATCH:
+ codeIndex--;
+ end = YES;
+ break;
+ case NUMERIC_COMPACTION_MODE_LATCH:
+ codeIndex--;
+ end = YES;
+ break;
+ case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
+ textCompactionData[index] = MODE_SHIFT_TO_BYTE_COMPACTION_MODE;
+ code = [[codewords objectAtIndex:codeIndex++] intValue];
+ byteCompactionData[index] = code;
+ index++;
+ break;
+ case BYTE_COMPACTION_MODE_LATCH_6:
+ codeIndex--;
+ end = YES;
+ break;
+ }
+ }
+ }
+
+ [self decodeTextCompaction:textCompactionData byteCompactionData:byteCompactionData length:index result:result];
+ return codeIndex;
+}
+
+
+/**
+ * The Text Compaction mode includes all the printable ASCII characters
+ * (i.e. values from 32 to 126) and three ASCII control characters: HT or tab
+ * (ASCII value 9), LF or line feed (ASCII value 10), and CR or carriage
+ * return (ASCII value 13). The Text Compaction mode also includes various latch
+ * and shift characters which are used exclusively within the mode. The Text
+ * Compaction mode encodes up to 2 characters per codeword. The compaction rules
+ * for converting data into PDF417 codewords are defined in 5.4.2.2. The sub-mode
+ * switches are defined in 5.4.2.3.
+ */
++ (void)decodeTextCompaction:(int *)textCompactionData byteCompactionData:(int *)byteCompactionData length:(unsigned int)length result:(NSMutableString *)result {
+ // Beginning from an initial state of the Alpha sub-mode
+ // The default compaction mode for PDF417 in effect at the start of each symbol shall always be Text
+ // Compaction mode Alpha sub-mode (uppercase alphabetic). A latch codeword from another mode to the Text
+ // Compaction mode shall always switch to the Text Compaction Alpha sub-mode.
+ int subMode = ALPHA;
+ int priorToShiftMode = ALPHA;
+ int i = 0;
+ while (i < length) {
+ int subModeCh = textCompactionData[i];
+ unichar ch = 0;
+ switch (subMode) {
+ case ALPHA:
+ // Alpha (uppercase alphabetic)
+ if (subModeCh < 26) {
+ // Upper case Alpha Character
+ ch = (unichar)('A' + subModeCh);
+ } else {
+ if (subModeCh == 26) {
+ ch = ' ';
+ } else if (subModeCh == LL) {
+ subMode = LOWER;
+ } else if (subModeCh == ML) {
+ subMode = MIXED;
+ } else if (subModeCh == PS) {
+ // Shift to punctuation
+ priorToShiftMode = subMode;
+ subMode = PUNCT_SHIFT;
+ } else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
+ [result appendFormat:@"%C", (unichar)byteCompactionData[i]];
+ } else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
+ subMode = ALPHA;
+ }
+ }
+ break;
+
+ case LOWER:
+ // Lower (lowercase alphabetic)
+ if (subModeCh < 26) {
+ ch = (unichar)('a' + subModeCh);
+ } else {
+ if (subModeCh == 26) {
+ ch = ' ';
+ } else if (subModeCh == AS) {
+ // Shift to alpha
+ priorToShiftMode = subMode;
+ subMode = ALPHA_SHIFT;
+ } else if (subModeCh == ML) {
+ subMode = MIXED;
+ } else if (subModeCh == PS) {
+ // Shift to punctuation
+ priorToShiftMode = subMode;
+ subMode = PUNCT_SHIFT;
+ } else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
+ [result appendFormat:@"%C", (unichar)byteCompactionData[i]];
+ } else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
+ subMode = ALPHA;
+ }
+ }
+ break;
+
+ case MIXED:
+ // Mixed (numeric and some punctuation)
+ if (subModeCh < PL) {
+ ch = MIXED_CHARS[subModeCh];
+ } else {
+ if (subModeCh == PL) {
+ subMode = PUNCT;
+ } else if (subModeCh == 26) {
+ ch = ' ';
+ } else if (subModeCh == LL) {
+ subMode = LOWER;
+ } else if (subModeCh == AL) {
+ subMode = ALPHA;
+ } else if (subModeCh == PS) {
+ // Shift to punctuation
+ priorToShiftMode = subMode;
+ subMode = PUNCT_SHIFT;
+ } else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
+ [result appendFormat:@"%C", (unichar)byteCompactionData[i]];
+ } else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
+ subMode = ALPHA;
+ }
+ }
+ break;
+
+ case PUNCT:
+ // Punctuation
+ if (subModeCh < PAL) {
+ ch = PUNCT_CHARS[subModeCh];
+ } else {
+ if (subModeCh == PAL) {
+ subMode = ALPHA;
+ } else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
+ [result appendFormat:@"%C", (unichar)byteCompactionData[i]];
+ } else if (TEXT_COMPACTION_MODE_LATCH) {
+ subMode = ALPHA;
+ }
+ }
+ break;
+
+ case ALPHA_SHIFT:
+ // Restore sub-mode
+ subMode = priorToShiftMode;
+ if (subModeCh < 26) {
+ ch = (unichar)('A' + subModeCh);
+ } else {
+ if (subModeCh == 26) {
+ ch = ' ';
+ } else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
+ subMode = ALPHA;
+ }
+ }
+ break;
+
+ case PUNCT_SHIFT:
+ // Restore sub-mode
+ subMode = priorToShiftMode;
+ if (subModeCh < PAL) {
+ ch = PUNCT_CHARS[subModeCh];
+ } else {
+ if (subModeCh == PAL) {
+ subMode = ALPHA;
+ } else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
+ // PS before Shift-to-Byte is used as a padding character,
+ // see 5.4.2.4 of the specification
+ [result appendFormat:@"%C", (unichar)byteCompactionData[i]];
+ } else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
+ subMode = ALPHA;
+ }
+ }
+ break;
+ }
+ if (ch != 0) {
+ // Append decoded character to result
+ [result appendFormat:@"%C", ch];
+ }
+ i++;
+ }
+}
+
+
+/**
+ * Byte Compaction mode (see 5.4.3) permits all 256 possible 8-bit byte values to be encoded.
+ * This includes all ASCII characters value 0 to 127 inclusive and provides for international
+ * character set support.
+ */
++ (int)byteCompaction:(int)mode codewords:(NSArray *)codewords codeIndex:(int)codeIndex result:(NSMutableString *)result {
+ if (mode == BYTE_COMPACTION_MODE_LATCH) {
+ // Total number of Byte Compaction characters to be encoded
+ // is not a multiple of 6
+ int count = 0;
+ long long value = 0;
+ char decodedData[6] = {0, 0, 0, 0, 0, 0};
+ int byteCompactedCodewords[6] = {0, 0, 0, 0, 0, 0};
+ BOOL end = NO;
+ int nextCode = [[codewords objectAtIndex:codeIndex++] intValue];
+ while ((codeIndex < [[codewords objectAtIndex:0] intValue]) && !end) {
+ byteCompactedCodewords[count++] = nextCode;
+ // Base 900
+ value = 900 * value + nextCode;
+ nextCode = [[codewords objectAtIndex:codeIndex++] intValue];
+ // perhaps it should be ok to check only nextCode >= TEXT_COMPACTION_MODE_LATCH
+ if (nextCode == TEXT_COMPACTION_MODE_LATCH ||
+ nextCode == BYTE_COMPACTION_MODE_LATCH ||
+ nextCode == NUMERIC_COMPACTION_MODE_LATCH ||
+ nextCode == BYTE_COMPACTION_MODE_LATCH_6 ||
+ nextCode == BEGIN_MACRO_PDF417_CONTROL_BLOCK ||
+ nextCode == BEGIN_MACRO_PDF417_OPTIONAL_FIELD ||
+ nextCode == MACRO_PDF417_TERMINATOR) {
+ codeIndex--;
+ end = YES;
+ } else {
+ if ((count % 5 == 0) && (count > 0)) {
+ // Decode every 5 codewords
+ // Convert to Base 256
+ for (int j = 0; j < 6; ++j) {
+ decodedData[5 - j] = (char) (value % 256);
+ value >>= 8;
+ }
+ [result appendString:[NSString stringWithCString:decodedData encoding:NSASCIIStringEncoding]];
+ count = 0;
+ }
+ }
+ }
+
+ // if the end of all codewords is reached the last codeword needs to be added
+ if (codeIndex == [[codewords objectAtIndex:0] intValue] && nextCode < TEXT_COMPACTION_MODE_LATCH) {
+ byteCompactedCodewords[count++] = nextCode;
+ }
+
+ // If Byte Compaction mode is invoked with codeword 901,
+ // the last group of codewords is interpreted directly
+ // as one byte per codeword, without compaction.
+ for (int i = 0; i < count; i++) {
+ [result appendFormat:@"%C", (unichar)byteCompactedCodewords[i]];
+ }
+ } else if (mode == BYTE_COMPACTION_MODE_LATCH_6) {
+ // Total number of Byte Compaction characters to be encoded
+ // is an integer multiple of 6
+ int count = 0;
+ long value = 0;
+ BOOL end = NO;
+ while (codeIndex < [[codewords objectAtIndex:0] intValue] && !end) {
+ int code = [[codewords objectAtIndex:codeIndex++] intValue];
+ if (code < TEXT_COMPACTION_MODE_LATCH) {
+ count++;
+ // Base 900
+ value = 900 * value + code;
+ } else {
+ if (code == TEXT_COMPACTION_MODE_LATCH ||
+ code == BYTE_COMPACTION_MODE_LATCH ||
+ code == NUMERIC_COMPACTION_MODE_LATCH ||
+ code == BYTE_COMPACTION_MODE_LATCH_6 ||
+ code == BEGIN_MACRO_PDF417_CONTROL_BLOCK ||
+ code == BEGIN_MACRO_PDF417_OPTIONAL_FIELD ||
+ code == MACRO_PDF417_TERMINATOR) {
+ codeIndex--;
+ end = YES;
+ }
+ }
+ if ((count % 5 == 0) && (count > 0)) {
+ // Decode every 5 codewords
+ // Convert to Base 256
+ unichar decodedData[6];
+ for (int j = 0; j < 6; ++j) {
+ decodedData[5 - j] = (unichar)(value & 0xFF);
+ value >>= 8;
+ }
+ [result appendString:[NSString stringWithCharacters:decodedData length:6]];
+ count = 0;
+ }
+ }
+ }
+ return codeIndex;
+}
+
+
+/**
+ * Numeric Compaction mode (see 5.4.4) permits efficient encoding of numeric data strings.
+ */
++ (int)numericCompaction:(NSArray *)codewords codeIndex:(int)codeIndex result:(NSMutableString *)result {
+ int count = 0;
+ BOOL end = NO;
+
+ int numericCodewords[MAX_NUMERIC_CODEWORDS];
+ memset(numericCodewords, 0, MAX_NUMERIC_CODEWORDS * sizeof(int));
+
+ while (codeIndex < [[codewords objectAtIndex:0] intValue] && !end) {
+ int code = [[codewords objectAtIndex:codeIndex++] intValue];
+ if (codeIndex == [[codewords objectAtIndex:0] intValue]) {
+ end = YES;
+ }
+ if (code < TEXT_COMPACTION_MODE_LATCH) {
+ numericCodewords[count] = code;
+ count++;
+ } else {
+ if (code == TEXT_COMPACTION_MODE_LATCH ||
+ code == BYTE_COMPACTION_MODE_LATCH ||
+ code == BYTE_COMPACTION_MODE_LATCH_6 ||
+ code == BEGIN_MACRO_PDF417_CONTROL_BLOCK ||
+ code == BEGIN_MACRO_PDF417_OPTIONAL_FIELD ||
+ code == MACRO_PDF417_TERMINATOR) {
+ codeIndex--;
+ end = YES;
+ }
+ }
+ if (count % MAX_NUMERIC_CODEWORDS == 0 || code == NUMERIC_COMPACTION_MODE_LATCH || end) {
+ NSString *s = [self decodeBase900toBase10:numericCodewords count:count];
+ if (s == nil) {
+ return NSIntegerMax;
+ }
+ [result appendString:s];
+ count = 0;
+ }
+ }
+ return codeIndex;
+}
+
+/**
+ * Convert a list of Numeric Compacted codewords from Base 900 to Base 10.
+ */
+/*
+ EXAMPLE
+ Encode the fifteen digit numeric string 000213298174000
+ Prefix the numeric string with a 1 and set the initial value of
+ t = 1 000 213 298 174 000
+ Calculate codeword 0
+ d0 = 1 000 213 298 174 000 mod 900 = 200
+
+ t = 1 000 213 298 174 000 div 900 = 1 111 348 109 082
+ Calculate codeword 1
+ d1 = 1 111 348 109 082 mod 900 = 282
+
+ t = 1 111 348 109 082 div 900 = 1 234 831 232
+ Calculate codeword 2
+ d2 = 1 234 831 232 mod 900 = 632
+
+ t = 1 234 831 232 div 900 = 1 372 034
+ Calculate codeword 3
+ d3 = 1 372 034 mod 900 = 434
+
+ t = 1 372 034 div 900 = 1 524
+ Calculate codeword 4
+ d4 = 1 524 mod 900 = 624
+
+ t = 1 524 div 900 = 1
+ Calculate codeword 5
+ d5 = 1 mod 900 = 1
+ t = 1 div 900 = 0
+ Codeword sequence is: 1, 624, 434, 632, 282, 200
+
+ Decode the above codewords involves
+ 1 x 900 power of 5 + 624 x 900 power of 4 + 434 x 900 power of 3 +
+ 632 x 900 power of 2 + 282 x 900 power of 1 + 200 x 900 power of 0 = 1000213298174000
+
+ Remove leading 1 => Result is 000213298174000
+ */
++ (NSString *)decodeBase900toBase10:(int[])codewords count:(int)count {
+ NSDecimalNumber *result = [NSDecimalNumber zero];
+ for (int i = 0; i < count; i++) {
+ result = [[result decimalNumberByAdding:[EXP900 objectAtIndex:count - i - 1]] decimalNumberByMultiplyingBy:
+ [NSDecimalNumber decimalNumberWithDecimal:[[NSNumber numberWithInt:codewords[i]] decimalValue]]];
+ }
+ NSString *resultString = [result stringValue];
+ if (![resultString hasPrefix:@"1"]) {
+ return nil;
+ }
+ return [resultString substringFromIndex:1];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417Decoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417Decoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..586fdd30343d7ae71d45584b94a098daa8a445fb
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417Decoder.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The main class which implements PDF417 Code decoding -- as
+ * opposed to locating and extracting the PDF417 Code from an image.
+ */
+
+@class ZXBitMatrix, ZXDecoderResult;
+
+@interface ZXPDF417Decoder : NSObject
+
+- (ZXDecoderResult *)decode:(BOOL **)image length:(unsigned int)length error:(NSError **)error;
+- (ZXDecoderResult *)decodeMatrix:(ZXBitMatrix *)bits error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417Decoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417Decoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..b0601a540b0fc85aad302204b3f1815feafcefc6
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ZXPDF417Decoder.m
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXErrors.h"
+#import "ZXPDF417BitMatrixParser.h"
+#import "ZXPDF417DecodedBitStreamParser.h"
+#import "ZXPDF417Decoder.h"
+#import "ZXPDF417ECErrorCorrection.h"
+
+int const ZX_PDF_MAX_ERRORS = 3;
+int const MAX_EC_CODEWORDS = 512;
+
+@interface ZXPDF417Decoder ()
+
+@property (nonatomic, retain) ZXPDF417ECErrorCorrection *errorCorrection;
+
+- (BOOL)correctErrors:(NSMutableArray *)codewords erasures:(NSArray *)erasures numECCodewords:(int)numECCodewords;
+- (BOOL)verifyCodewordCount:(NSMutableArray *)codewords numECCodewords:(int)numECCodewords;
+
+@end
+
+@implementation ZXPDF417Decoder
+
+@synthesize errorCorrection;
+
+- (id)init {
+ if (self = [super init]) {
+ self.errorCorrection = [[ZXPDF417ECErrorCorrection alloc] init];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [errorCorrection release];
+
+ [super dealloc];
+}
+
+/**
+ * Convenience method that can decode a PDF417 Code represented as a 2D array of booleans.
+ * "true" is taken to mean a black module.
+ */
+- (ZXDecoderResult *)decode:(BOOL **)image length:(unsigned int)length error:(NSError **)error {
+ int dimension = length;
+ ZXBitMatrix *bits = [[[ZXBitMatrix alloc] initWithDimension:dimension] autorelease];
+ for (int i = 0; i < dimension; i++) {
+ for (int j = 0; j < dimension; j++) {
+ if (image[j][i]) {
+ [bits setX:j y:i];
+ }
+ }
+ }
+ return [self decodeMatrix:bits error:error];
+}
+
+
+/**
+ * Decodes a PDF417 Code represented as a ZXBitMatrix.
+ * A 1 or "true" is taken to mean a black module.
+ */
+- (ZXDecoderResult *)decodeMatrix:(ZXBitMatrix *)bits error:(NSError **)error {
+ ZXPDF417BitMatrixParser *parser = [[[ZXPDF417BitMatrixParser alloc] initWithBitMatrix:bits] autorelease];
+ NSMutableArray *codewords = [[[parser readCodewords] mutableCopy] autorelease];
+ if (codewords.count == 0) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+
+ int ecLevel = parser.ecLevel;
+ int numECCodewords = 1 << (ecLevel + 1);
+ NSArray *erasures = parser.erasures;
+
+ if (![self correctErrors:codewords erasures:erasures numECCodewords:numECCodewords]) {
+ if (error) *error = ChecksumErrorInstance();
+ return nil;
+ }
+
+ if (![self verifyCodewordCount:codewords numECCodewords:numECCodewords]) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+
+ return [ZXPDF417DecodedBitStreamParser decode:codewords error:error];
+}
+
+
+/**
+ * Verify that all is OK with the codeword array.
+ */
+- (BOOL)verifyCodewordCount:(NSMutableArray *)codewords numECCodewords:(int)numECCodewords {
+ if ([codewords count] < 4) {
+ return NO;
+ }
+
+ int numberOfCodewords = [[codewords objectAtIndex:0] intValue];
+ if (numberOfCodewords > [codewords count]) {
+ return NO;
+ }
+ if (numberOfCodewords == 0) {
+ if (numECCodewords < [codewords count]) {
+ [codewords replaceObjectAtIndex:0 withObject:[NSNumber numberWithInt:[codewords count] - numECCodewords]];
+ } else {
+ return NO;
+ }
+ }
+ return YES;
+}
+
+
+/**
+ * Given data and error-correction codewords received, possibly corrupted by errors, attempts to
+ * orrect the errors in-place.
+ */
+- (BOOL)correctErrors:(NSMutableArray *)codewords erasures:(NSArray *)erasures numECCodewords:(int)numECCodewords {
+ if (erasures.count > numECCodewords / 2 + ZX_PDF_MAX_ERRORS ||
+ numECCodewords < 0 || numECCodewords > MAX_EC_CODEWORDS) {
+ // Too many errors or EC Codewords is corrupted
+ return NO;
+ }
+
+ return [self.errorCorrection decode:codewords numECCodewords:numECCodewords erasures:erasures];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXModulusGF.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXModulusGF.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b438536c5cbbf1d110933bc5acf3451c87bdac4
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXModulusGF.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXModulusPoly;
+
+@interface ZXModulusGF : NSObject
+
+@property (nonatomic, retain) ZXModulusPoly *one;
+@property (nonatomic, retain) ZXModulusPoly *zero;
+
++ (ZXModulusGF *)PDF417_GF;
+
+- (id)initWithModulus:(int)modulus generator:(int)generator;
+
+- (ZXModulusPoly *)buildMonomial:(int)degree coefficient:(int)coefficient;
+- (int)add:(int)a b:(int)b;
+- (int)subtract:(int)a b:(int)b;
+- (int)exp:(int)a;
+- (int)log:(int)a;
+- (int)inverse:(int)a;
+- (int)multiply:(int)a b:(int)b;
+- (int)size;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXModulusGF.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXModulusGF.m
new file mode 100644
index 0000000000000000000000000000000000000000..2e5d5338b2134e079f3e792e0ef47e3bc5828ca5
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXModulusGF.m
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXModulusGF.h"
+#import "ZXModulusPoly.h"
+
+@interface ZXModulusGF ()
+
+@property (nonatomic, retain) NSMutableArray *expTable;
+@property (nonatomic, retain) NSMutableArray *logTable;
+@property (nonatomic, assign) int modulus;
+
+@end
+
+@implementation ZXModulusGF
+
+@synthesize expTable;
+@synthesize logTable;
+@synthesize modulus;
+@synthesize one;
+@synthesize zero;
+
++ (ZXModulusGF *)PDF417_GF {
+ return [[[ZXModulusGF alloc] initWithModulus:929 generator:3] autorelease];
+}
+
+- (id)initWithModulus:(int)aModulus generator:(int)generator {
+ if (self = [super init]) {
+ self.modulus = aModulus;
+ self.expTable = [NSMutableArray arrayWithCapacity:self.modulus];
+ self.logTable = [NSMutableArray arrayWithCapacity:self.modulus];
+ int x = 1;
+ for (int i = 0; i < self.modulus; i++) {
+ [self.expTable addObject:[NSNumber numberWithInt:x]];
+ x = (x * generator) % self.modulus;
+ }
+
+ for (int i = 0; i < self.size; i++) {
+ [self.logTable addObject:[NSNumber numberWithInt:0]];
+ }
+
+ for (int i = 0; i < self.size - 1; i++) {
+ [self.logTable replaceObjectAtIndex:[[self.expTable objectAtIndex:i] intValue] withObject:[NSNumber numberWithInt:i]];
+ }
+ // logTable[0] == 0 but this should never be used
+ int zeroInt = 0;
+ self.zero = [[[ZXModulusPoly alloc] initWithField:self coefficients:&zeroInt coefficientsLen:1] autorelease];
+
+ int oneInt = 1;
+ self.one = [[[ZXModulusPoly alloc] initWithField:self coefficients:&oneInt coefficientsLen:1] autorelease];
+ }
+
+ return self;
+}
+
+- (ZXModulusPoly *)buildMonomial:(int)degree coefficient:(int)coefficient {
+ if (degree < 0) {
+ [NSException raise:NSInvalidArgumentException format:@"Degree must be greater than 0."];
+ }
+ if (coefficient == 0) {
+ return self.zero;
+ }
+
+ int coefficientsLen = degree + 1;
+ int coefficients[coefficientsLen];
+ coefficients[0] = coefficient;
+ for (int i = 1; i < coefficientsLen; i++) {
+ coefficients[i] = 0;
+ }
+ return [[[ZXModulusPoly alloc] initWithField:self coefficients:coefficients coefficientsLen:coefficientsLen] autorelease];
+}
+
+- (int)add:(int)a b:(int)b {
+ return (a + b) % self.modulus;
+}
+
+- (int)subtract:(int)a b:(int)b {
+ return (self.modulus + a - b) % self.modulus;
+}
+
+- (int)exp:(int)a {
+ return [[self.expTable objectAtIndex:a] intValue];
+}
+
+- (int)log:(int)a {
+ if (a == 0) {
+ [NSException raise:NSInvalidArgumentException format:@"Argument must be non-zero."];
+ }
+ return [[self.logTable objectAtIndex:a] intValue];
+}
+
+- (int)inverse:(int)a {
+ if (a == 0) {
+ [NSException raise:NSInvalidArgumentException format:@"Argument must be non-zero."];
+ }
+ return [[self.expTable objectAtIndex:self.size - [[self.logTable objectAtIndex:a] intValue] - 1] intValue];
+}
+
+- (int)multiply:(int)a b:(int)b {
+ if (a == 0 || b == 0) {
+ return 0;
+ }
+
+ int logSum = [[self.logTable objectAtIndex:a] intValue] + [[self.logTable objectAtIndex:b] intValue];
+ return [[self.expTable objectAtIndex:logSum % (self.modulus - 1)] intValue];
+}
+
+- (int)size {
+ return self.modulus;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXModulusPoly.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXModulusPoly.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c491cb327e6f8b01feb6d9ee876821f6d3c8955
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXModulusPoly.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXModulusGF;
+
+@interface ZXModulusPoly : NSObject
+
+- (id)initWithField:(ZXModulusGF *)field coefficients:(int *)coefficients coefficientsLen:(int)coefficientsLen;
+- (int)degree;
+- (BOOL)zero;
+- (int)coefficient:(int)degree;
+- (int)evaluateAt:(int)a;
+- (ZXModulusPoly *)add:(ZXModulusPoly *)other;
+- (ZXModulusPoly *)subtract:(ZXModulusPoly *)other;
+- (ZXModulusPoly *)multiply:(ZXModulusPoly *)other;
+- (ZXModulusPoly *)negative;
+- (ZXModulusPoly *)multiplyScalar:(int)scalar;
+- (ZXModulusPoly *)multiplyByMonomial:(int)degree coefficient:(int)coefficient;
+- (NSArray *)divide:(ZXModulusPoly *)other;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXModulusPoly.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXModulusPoly.m
new file mode 100644
index 0000000000000000000000000000000000000000..3cb0edcba1a13edc12815b1d9e42ab939c567a39
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXModulusPoly.m
@@ -0,0 +1,276 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXModulusGF.h"
+#import "ZXModulusPoly.h"
+
+@interface ZXModulusPoly ()
+
+@property (nonatomic, assign) int *coefficients;
+@property (nonatomic, assign) int coefficientsLen;
+@property (nonatomic, retain) ZXModulusGF *field;
+
+@end
+
+@implementation ZXModulusPoly
+
+@synthesize coefficients;
+@synthesize coefficientsLen;
+@synthesize field;
+
+- (id)initWithField:(ZXModulusGF *)aField coefficients:(int *)aCoefficients coefficientsLen:(int)aCoefficientsLen {
+ if (self = [super init]) {
+ self.field = aField;
+ if (aCoefficientsLen > 1 && aCoefficients[0] == 0) {
+ // Leading term must be non-zero for anything except the constant polynomial "0"
+ int firstNonZero = 1;
+ while (firstNonZero < aCoefficientsLen && aCoefficients[firstNonZero] == 0) {
+ firstNonZero++;
+ }
+ if (firstNonZero == aCoefficientsLen) {
+ ZXModulusPoly *zero = self.field.zero;
+ self.coefficients = (int *)malloc(zero.coefficientsLen * sizeof(int));
+ memcpy(self.coefficients, zero.coefficients, zero.coefficientsLen * sizeof(int));
+ } else {
+ self.coefficientsLen = (aCoefficientsLen - firstNonZero);
+ self.coefficients = (int *)malloc(self.coefficientsLen * sizeof(int));
+ for (int i = 0; i < self.coefficientsLen; i++) {
+ self.coefficients[i] = aCoefficients[firstNonZero + i];
+ }
+ }
+ } else {
+ self.coefficients = (int *)malloc(aCoefficientsLen * sizeof(int));
+ memcpy(self.coefficients, aCoefficients, aCoefficientsLen * sizeof(int));
+ self.coefficientsLen = aCoefficientsLen;
+ }
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ if (self.coefficients != NULL) {
+ free(self.coefficients);
+ self.coefficients = NULL;
+ }
+ [field release];
+
+ [super dealloc];
+}
+
+- (int)degree {
+ return self.coefficientsLen - 1;
+}
+
+- (BOOL)zero {
+ return self.coefficients[0] == 0;
+}
+
+- (int)coefficient:(int)degree {
+ return self.coefficients[self.coefficientsLen - 1 - degree];
+}
+
+- (int)evaluateAt:(int)a {
+ if (a == 0) {
+ return [self coefficient:0];
+ }
+ int size = self.coefficientsLen;
+ if (a == 1) {
+ // Just the sum of the coefficients
+ int result = 0;
+ for (int i = 0; i < size; i++) {
+ result = [self.field add:result b:self.coefficients[i]];
+ }
+ return result;
+ }
+ int result = self.coefficients[0];
+ for (int i = 1; i < size; i++) {
+ result = [self.field add:[self.field multiply:a b:result] b:self.coefficients[i]];
+ }
+ return result;
+}
+
+- (ZXModulusPoly *)add:(ZXModulusPoly *)other {
+ if (![self.field isEqual:other->field]) {
+ [NSException raise:NSInvalidArgumentException format:@"ZXModulusPolys do not have same ZXModulusGF field"];
+ }
+ if (self.zero) {
+ return other;
+ }
+ if (other.zero) {
+ return self;
+ }
+
+ int *smallerCoefficients = self.coefficients;
+ int smallerCoefficientsLen = self.coefficientsLen;
+ int *largerCoefficients = other.coefficients;
+ int largerCoefficientsLen = other.coefficientsLen;
+ if (smallerCoefficientsLen > largerCoefficientsLen) {
+ int *temp = smallerCoefficients;
+ int tempLen = smallerCoefficientsLen;
+ smallerCoefficients = largerCoefficients;
+ smallerCoefficientsLen = largerCoefficientsLen;
+ largerCoefficients = temp;
+ largerCoefficientsLen = tempLen;
+ }
+ int sumDiff[largerCoefficientsLen];
+ int lengthDiff = largerCoefficientsLen - smallerCoefficientsLen;
+ for (int i = 0; i < lengthDiff; i++) {
+ sumDiff[i] = largerCoefficients[i];
+ }
+ for (int i = lengthDiff; i < largerCoefficientsLen; i++) {
+ sumDiff[i] = [self.field add:smallerCoefficients[i - lengthDiff] b:largerCoefficients[i]];
+ }
+
+ return [[[ZXModulusPoly alloc] initWithField:self.field coefficients:sumDiff coefficientsLen:largerCoefficientsLen] autorelease];
+}
+
+- (ZXModulusPoly *)subtract:(ZXModulusPoly *)other {
+ if (![self.field isEqual:other->field]) {
+ [NSException raise:NSInvalidArgumentException format:@"ZXModulusPolys do not have same ZXModulusGF field"];
+ }
+ if (self.zero) {
+ return self;
+ }
+ return [self add:[other negative]];
+}
+
+- (ZXModulusPoly *)multiply:(ZXModulusPoly *)other {
+ if (![self.field isEqual:other->field]) {
+ [NSException raise:NSInvalidArgumentException format:@"ZXModulusPolys do not have same ZXModulusGF field"];
+ }
+ if (self.zero || other.zero) {
+ return self.field.zero;
+ }
+ int *aCoefficients = self.coefficients;
+ int aLength = self.coefficientsLen;
+ int *bCoefficients = other.coefficients;
+ int bLength = other.coefficientsLen;
+ int productLen = aLength + bLength - 1;
+ int product[productLen];
+ memset(product, 0, productLen * sizeof(int));
+
+ for (int i = 0; i < aLength; i++) {
+ int aCoeff = aCoefficients[i];
+ for (int j = 0; j < bLength; j++) {
+ product[i + j] = [self.field add:product[i + j]
+ b:[self.field multiply:aCoeff b:bCoefficients[j]]];
+ }
+ }
+ return [[[ZXModulusPoly alloc] initWithField:self.field coefficients:product coefficientsLen:productLen] autorelease];
+}
+
+- (ZXModulusPoly *)negative {
+ int negativeCoefficientsLen = self.coefficientsLen;
+ int negativeCoefficients[negativeCoefficientsLen];
+ for (int i = 0; i < self.coefficientsLen; i++) {
+ negativeCoefficients[i] = [self.field subtract:0 b:self.coefficients[i]];
+ }
+ return [[[ZXModulusPoly alloc] initWithField:self.field coefficients:negativeCoefficients coefficientsLen:negativeCoefficientsLen] autorelease];
+}
+
+- (ZXModulusPoly *)multiplyScalar:(int)scalar {
+ if (scalar == 0) {
+ return self.field.zero;
+ }
+ if (scalar == 1) {
+ return self;
+ }
+ int size = self.coefficientsLen;
+ int product[size];
+ for (int i = 0; i < size; i++) {
+ product[i] = [self.field multiply:self.coefficients[i] b:scalar];
+ }
+ return [[[ZXModulusPoly alloc] initWithField:self.field coefficients:product coefficientsLen:size] autorelease];
+}
+
+- (ZXModulusPoly *)multiplyByMonomial:(int)degree coefficient:(int)coefficient {
+ if (degree < 0) {
+ [NSException raise:NSInvalidArgumentException format:@"Degree must be greater than 0."];
+ }
+ if (coefficient == 0) {
+ return self.field.zero;
+ }
+ int size = self.coefficientsLen;
+ int product[size + degree];
+ for (int i = 0; i < size + degree; i++) {
+ if (i < size) {
+ product[i] = [self.field multiply:self.coefficients[i] b:coefficient];
+ } else {
+ product[i] = 0;
+ }
+ }
+
+ return [[[ZXModulusPoly alloc] initWithField:self.field coefficients:product coefficientsLen:size + degree] autorelease];
+}
+
+- (NSArray *)divide:(ZXModulusPoly *)other {
+ if (![self.field isEqual:other->field]) {
+ [NSException raise:NSInvalidArgumentException format:@"ZXModulusPolys do not have same ZXModulusGF field"];
+ }
+ if (other.zero) {
+ [NSException raise:NSInvalidArgumentException format:@"Divide by 0"];
+ }
+
+ ZXModulusPoly *quotient = self.field.zero;
+ ZXModulusPoly *remainder = self;
+
+ int denominatorLeadingTerm = [other coefficient:other.degree];
+ int inverseDenominatorLeadingTerm = [self.field inverse:denominatorLeadingTerm];
+
+ while ([remainder degree] >= other.degree && !remainder.zero) {
+ int degreeDifference = remainder.degree - other.degree;
+ int scale = [self.field multiply:[remainder coefficient:remainder.degree] b:inverseDenominatorLeadingTerm];
+ ZXModulusPoly *term = [other multiplyByMonomial:degreeDifference coefficient:scale];
+ ZXModulusPoly *iterationQuotient = [field buildMonomial:degreeDifference coefficient:scale];
+ quotient = [quotient add:iterationQuotient];
+ remainder = [remainder subtract:term];
+ }
+
+ return [NSArray arrayWithObjects:quotient, remainder, nil];
+}
+
+- (NSString *)description {
+ NSMutableString *result = [NSMutableString stringWithCapacity:8 * [self degree]];
+ for (int degree = [self degree]; degree >= 0; degree--) {
+ int coefficient = [self coefficient:degree];
+ if (coefficient != 0) {
+ if (coefficient < 0) {
+ [result appendString:@" - "];
+ coefficient = -coefficient;
+ } else {
+ if ([result length] > 0) {
+ [result appendString:@" + "];
+ }
+ }
+ if (degree == 0 || coefficient != 1) {
+ [result appendFormat:@"%d", coefficient];
+ }
+ if (degree != 0) {
+ if (degree == 1) {
+ [result appendString:@"x"];
+ } else {
+ [result appendString:@"x^"];
+ [result appendFormat:@"%d", degree];
+ }
+ }
+ }
+ }
+
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXPDF417ECErrorCorrection.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXPDF417ECErrorCorrection.h
new file mode 100644
index 0000000000000000000000000000000000000000..b052127667ddc05c8724cffb81d0b3e97a1d9e81
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXPDF417ECErrorCorrection.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * PDF417 error correction implementation.
+ *
+ * This example <http://en.wikipedia.org/wiki/Reed%E2%80%93Solomon_error_correction#Example>
+ * is quite useful in understanding the algorithm.
+ */
+
+@interface ZXPDF417ECErrorCorrection : NSObject
+
+- (BOOL)decode:(NSMutableArray *)received numECCodewords:(int)numECCodewords erasures:(NSArray *)erasures;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXPDF417ECErrorCorrection.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXPDF417ECErrorCorrection.m
new file mode 100644
index 0000000000000000000000000000000000000000..70cf4d55d762cc4269c5923702c7bcab54812a68
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/decoder/ec/ZXPDF417ECErrorCorrection.m
@@ -0,0 +1,202 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXModulusGF.h"
+#import "ZXModulusPoly.h"
+#import "ZXPDF417ECErrorCorrection.h"
+
+@interface ZXPDF417ECErrorCorrection ()
+
+@property (nonatomic, retain) ZXModulusGF *field;
+
+- (NSArray *)runEuclideanAlgorithm:(ZXModulusPoly *)a b:(ZXModulusPoly *)b R:(int)R;
+- (NSArray *)findErrorLocations:(ZXModulusPoly *)errorLocator;
+- (NSArray *)findErrorMagnitudes:(ZXModulusPoly *)errorEvaluator errorLocator:(ZXModulusPoly *)errorLocator errorLocations:(NSArray *)errorLocations;
+
+@end
+
+@implementation ZXPDF417ECErrorCorrection
+
+@synthesize field;
+
+- (id)init {
+ if (self = [super init]) {
+ self.field = [ZXModulusGF PDF417_GF];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [field release];
+
+ [super dealloc];
+}
+
+- (BOOL)decode:(NSMutableArray *)received numECCodewords:(int)numECCodewords erasures:(NSArray *)erasures {
+ int coefficients[received.count];
+ for (int i = 0; i < received.count; i++) {
+ coefficients[i] = [[received objectAtIndex:i] intValue];
+ }
+ ZXModulusPoly *poly = [[[ZXModulusPoly alloc] initWithField:self.field coefficients:coefficients coefficientsLen:received.count] autorelease];
+
+ int S[numECCodewords];
+ for (int i = 0; i < numECCodewords; i++) {
+ S[i] = 0;
+ }
+
+ BOOL error = NO;
+ for (int i = numECCodewords; i > 0; i--) {
+ int eval = [poly evaluateAt:[self.field exp:i]];
+ S[numECCodewords - i] = eval;
+ if (eval != 0) {
+ error = YES;
+ }
+ }
+
+ if (error) {
+
+ ZXModulusPoly *knownErrors = self.field.one;
+ for (NSNumber *erasure in erasures) {
+ int b = [self.field exp:received.count - 1 - [erasure intValue]];
+ // Add (1 - bx) term:
+ int termCoefficients[2] = { [self.field subtract:0 b:b], 1 };
+ ZXModulusPoly *term = [[[ZXModulusPoly alloc] initWithField:field coefficients:termCoefficients coefficientsLen:2] autorelease];
+ knownErrors = [knownErrors multiply:term];
+ }
+
+ ZXModulusPoly *syndrome = [[[ZXModulusPoly alloc] initWithField:self.field coefficients:S coefficientsLen:numECCodewords] autorelease];
+ //[syndrome multiply:knownErrors];
+
+ NSArray *sigmaOmega = [self runEuclideanAlgorithm:[self.field buildMonomial:numECCodewords coefficient:1] b:syndrome R:numECCodewords];
+ if (!sigmaOmega) {
+ return NO;
+ }
+
+ ZXModulusPoly *sigma = [sigmaOmega objectAtIndex:0];
+ ZXModulusPoly *omega = [sigmaOmega objectAtIndex:1];
+
+ //sigma = [sigma multiply:knownErrors];
+
+ NSArray *errorLocations = [self findErrorLocations:sigma];
+ if (!errorLocations) return NO;
+ NSArray *errorMagnitudes = [self findErrorMagnitudes:omega errorLocator:sigma errorLocations:errorLocations];
+
+ for (int i = 0; i < errorLocations.count; i++) {
+ int position = received.count - 1 - [self.field log:[[errorLocations objectAtIndex:i] intValue]];
+ if (position < 0) {
+ return NO;
+ }
+ [received replaceObjectAtIndex:position
+ withObject:[NSNumber numberWithInt:[self.field subtract:[[received objectAtIndex:position] intValue]
+ b:[[errorMagnitudes objectAtIndex:i] intValue]]]];
+ }
+ }
+
+ return YES;
+}
+
+- (NSArray *)runEuclideanAlgorithm:(ZXModulusPoly *)a b:(ZXModulusPoly *)b R:(int)R {
+ // Assume a's degree is >= b's
+ if (a.degree < b.degree) {
+ ZXModulusPoly *temp = a;
+ a = b;
+ b = temp;
+ }
+
+ ZXModulusPoly *rLast = a;
+ ZXModulusPoly *r = b;
+ ZXModulusPoly *tLast = self.field.zero;
+ ZXModulusPoly *t = self.field.one;
+
+ // Run Euclidean algorithm until r's degree is less than R/2
+ while (r.degree >= R / 2) {
+ ZXModulusPoly *rLastLast = rLast;
+ ZXModulusPoly *tLastLast = tLast;
+ rLast = r;
+ tLast = t;
+
+ // Divide rLastLast by rLast, with quotient in q and remainder in r
+ if (rLast.zero) {
+ // Oops, Euclidean algorithm already terminated?
+ return nil;
+ }
+ r = rLastLast;
+ ZXModulusPoly *q = self.field.zero;
+ int denominatorLeadingTerm = [rLast coefficient:rLast.degree];
+ int dltInverse = [self.field inverse:denominatorLeadingTerm];
+ while (r.degree >= rLast.degree && !r.zero) {
+ int degreeDiff = r.degree - rLast.degree;
+ int scale = [self.field multiply:[r coefficient:r.degree] b:dltInverse];
+ q = [q add:[field buildMonomial:degreeDiff coefficient:scale]];
+ r = [r subtract:[rLast multiplyByMonomial:degreeDiff coefficient:scale]];
+ }
+
+ t = [[[q multiply:tLast] subtract:tLastLast] negative];
+ }
+
+ int sigmaTildeAtZero = [t coefficient:0];
+ if (sigmaTildeAtZero == 0) {
+ return nil;
+ }
+
+ int inverse = [self.field inverse:sigmaTildeAtZero];
+ ZXModulusPoly *sigma = [t multiplyScalar:inverse];
+ ZXModulusPoly *omega = [r multiplyScalar:inverse];
+ return [NSArray arrayWithObjects:sigma, omega, nil];
+}
+
+- (NSArray *)findErrorLocations:(ZXModulusPoly *)errorLocator {
+ // This is a direct application of Chien's search
+ int numErrors = errorLocator.degree;
+ NSMutableArray *result = [NSMutableArray arrayWithCapacity:numErrors];
+ for (int i = 1; i < self.field.size && result.count < numErrors; i++) {
+ if ([errorLocator evaluateAt:i] == 0) {
+ [result addObject:[NSNumber numberWithInt:[field inverse:i]]];
+ }
+ }
+ if (result.count != numErrors) {
+ return nil;
+ }
+ return result;
+}
+
+- (NSArray *)findErrorMagnitudes:(ZXModulusPoly *)errorEvaluator errorLocator:(ZXModulusPoly *)errorLocator errorLocations:(NSArray *)errorLocations {
+ int errorLocatorDegree = errorLocator.degree;
+ int formalDerivativeCoefficients[errorLocatorDegree];
+ for (int i = 0; i < errorLocatorDegree; i++) {
+ formalDerivativeCoefficients[i] = 0;
+ }
+
+ for (int i = 1; i <= errorLocatorDegree; i++) {
+ formalDerivativeCoefficients[errorLocatorDegree - i] =
+ [self.field multiply:i b:[errorLocator coefficient:i]];
+ }
+ ZXModulusPoly *formalDerivative = [[[ZXModulusPoly alloc] initWithField:self.field coefficients:formalDerivativeCoefficients coefficientsLen:errorLocatorDegree] autorelease];
+
+ // This is directly applying Forney's Formula
+ int s = errorLocations.count;
+ NSMutableArray *result = [NSMutableArray arrayWithCapacity:s];
+ for (int i = 0; i < s; i++) {
+ int xiInverse = [self.field inverse:[[errorLocations objectAtIndex:i] intValue]];
+ int numerator = [self.field subtract:0 b:[errorEvaluator evaluateAt:xiInverse]];
+ int denominator = [self.field inverse:[formalDerivative evaluateAt:xiInverse]];
+ [result addObject:[NSNumber numberWithInt:[self.field multiply:numerator b:denominator]]];
+ }
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/detector/ZXPDF417Detector.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/detector/ZXPDF417Detector.h
new file mode 100644
index 0000000000000000000000000000000000000000..c14b7310359bea0bc1300495cbcc0b2bcb407e90
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/detector/ZXPDF417Detector.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates logic that can detect a PDF417 Code in an image, even if the
+ * PDF417 Code is rotated or skewed, or partially obscured.
+ */
+
+@class ZXBinaryBitmap, ZXDecodeHints, ZXDetectorResult;
+
+@interface ZXPDF417Detector : NSObject
+
+- (id)initWithImage:(ZXBinaryBitmap *)image;
+- (ZXDetectorResult *)detectWithError:(NSError **)error;
+- (ZXDetectorResult *)detect:(ZXDecodeHints *)hints error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/detector/ZXPDF417Detector.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/detector/ZXPDF417Detector.m
new file mode 100644
index 0000000000000000000000000000000000000000..4597f862f4367b612955ac417afa7f63fc69849f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/detector/ZXPDF417Detector.m
@@ -0,0 +1,568 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXBinaryBitmap.h"
+#import "ZXDecodeHints.h"
+#import "ZXDetectorResult.h"
+#import "ZXErrors.h"
+#import "ZXGridSampler.h"
+#import "ZXMathUtils.h"
+#import "ZXPDF417Detector.h"
+#import "ZXResultPoint.h"
+
+int const PDF417_INTEGER_MATH_SHIFT = 8;
+int const PDF417_PATTERN_MATCH_RESULT_SCALE_FACTOR = 1 << PDF417_INTEGER_MATH_SHIFT;
+int const MAX_AVG_VARIANCE = (int) (PDF417_PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.42f);
+int const MAX_INDIVIDUAL_VARIANCE = (int) (PDF417_PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.8f);
+int const SKEW_THRESHOLD = 3;
+
+// B S B S B S B S Bar/Space pattern
+// 11111111 0 1 0 1 0 1 000
+int const PDF417_START_PATTERN_LEN = 8;
+int const PDF417_START_PATTERN[PDF417_START_PATTERN_LEN] = {8, 1, 1, 1, 1, 1, 1, 3};
+
+// 11111111 0 1 0 1 0 1 000
+int const START_PATTERN_REVERSE_LEN = 8;
+int const START_PATTERN_REVERSE[START_PATTERN_REVERSE_LEN] = {3, 1, 1, 1, 1, 1, 1, 8};
+
+// 1111111 0 1 000 1 0 1 00 1
+int const STOP_PATTERN_LEN = 9;
+int const STOP_PATTERN[STOP_PATTERN_LEN] = {7, 1, 1, 3, 1, 1, 1, 2, 1};
+
+// B S B S B S B S B Bar/Space pattern
+// 1111111 0 1 000 1 0 1 00 1
+int const STOP_PATTERN_REVERSE_LEN = 9;
+int const STOP_PATTERN_REVERSE[STOP_PATTERN_REVERSE_LEN] = {1, 2, 1, 1, 1, 3, 1, 1, 7};
+
+@interface ZXPDF417Detector ()
+
+@property (nonatomic, retain) ZXBinaryBitmap *image;
+
+- (NSMutableArray *)findVertices:(ZXBitMatrix *)matrix tryHarder:(BOOL)tryHarder;
+- (NSMutableArray *)findVertices180:(ZXBitMatrix *)matrix tryHarder:(BOOL)tryHarder;
+- (void)correctCodeWordVertices:(NSMutableArray *)vertices upsideDown:(BOOL)upsideDown;
+- (float)computeModuleWidth:(NSArray *)vertices;
+- (int)computeDimension:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight bottomLeft:(ZXResultPoint *)bottomLeft bottomRight:(ZXResultPoint *)bottomRight moduleWidth:(float)moduleWidth;
+- (int)computeYDimension:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight bottomLeft:(ZXResultPoint *)bottomLeft bottomRight:(ZXResultPoint *)bottomRight moduleWidth:(float)moduleWidth;
+- (NSRange)findGuardPattern:(ZXBitMatrix *)matrix column:(int)column row:(int)row width:(int)width whiteFirst:(BOOL)whiteFirst pattern:(int *)pattern patternLen:(int)patternLen counters:(int *)counters;
+- (int)patternMatchVariance:(int *)counters countersSize:(int)countersSize pattern:(int *)pattern maxIndividualVariance:(int)maxIndividualVariance;
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)matrix
+ topLeft:(ZXResultPoint *)topLeft
+ bottomLeft:(ZXResultPoint *)bottomLeft
+ topRight:(ZXResultPoint *)topRight
+ bottomRight:(ZXResultPoint *)bottomRight
+ xdimension:(int)xdimension
+ ydimension:(int)ydimension
+ error:(NSError **)error;
+
+@end
+
+
+@implementation ZXPDF417Detector
+
+@synthesize image;
+
+- (id)initWithImage:(ZXBinaryBitmap *)anImage {
+ if (self = [super init]) {
+ self.image = anImage;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [image release];
+
+ [super dealloc];
+}
+
+/**
+ * Detects a PDF417 Code in an image, simply.
+ */
+- (ZXDetectorResult *)detectWithError:(NSError **)error {
+ return [self detect:nil error:error];
+}
+
+
+/**
+ * Detects a PDF417 Code in an image. Only checks 0 and 180 degree rotations.
+ */
+- (ZXDetectorResult *)detect:(ZXDecodeHints *)hints error:(NSError **)error {
+ // Fetch the 1 bit matrix once up front.
+ ZXBitMatrix *matrix = [self.image blackMatrixWithError:error];
+ if (!matrix) {
+ return nil;
+ }
+
+ BOOL tryHarder = hints != nil && hints.tryHarder;
+
+ // Try to find the vertices assuming the image is upright.
+ NSMutableArray *vertices = [self findVertices:matrix tryHarder:tryHarder];
+ if (vertices == nil) {
+ // Maybe the image is rotated 180 degrees?
+ vertices = [self findVertices180:matrix tryHarder:tryHarder];
+ if (vertices != nil) {
+ [self correctCodeWordVertices:vertices upsideDown:YES];
+ }
+ } else {
+ [self correctCodeWordVertices:vertices upsideDown:NO];
+ }
+
+ if (vertices == nil) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ float moduleWidth = [self computeModuleWidth:vertices];
+ if (moduleWidth < 1.0f) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ int dimension = [self computeDimension:[vertices objectAtIndex:4]
+ topRight:[vertices objectAtIndex:6]
+ bottomLeft:[vertices objectAtIndex:5]
+ bottomRight:[vertices objectAtIndex:7]
+ moduleWidth:moduleWidth];
+ if (dimension < 1) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ int ydimension = [self computeYDimension:[vertices objectAtIndex:4]
+ topRight:[vertices objectAtIndex:6]
+ bottomLeft:[vertices objectAtIndex:5]
+ bottomRight:[vertices objectAtIndex:7]
+ moduleWidth:moduleWidth];
+ ydimension = ydimension > dimension ? ydimension : dimension;
+
+ // Deskew and sample image.
+ ZXBitMatrix *bits = [self sampleGrid:matrix
+ topLeft:[vertices objectAtIndex:4]
+ bottomLeft:[vertices objectAtIndex:5]
+ topRight:[vertices objectAtIndex:6]
+ bottomRight:[vertices objectAtIndex:7]
+ xdimension:dimension
+ ydimension:ydimension
+ error:error];
+ if (!bits) {
+ return nil;
+ }
+ return [[[ZXDetectorResult alloc] initWithBits:bits
+ points:[NSArray arrayWithObjects:[vertices objectAtIndex:5],
+ [vertices objectAtIndex:4], [vertices objectAtIndex:6],
+ [vertices objectAtIndex:7], nil]] autorelease];
+}
+
+
+/**
+ * Locate the vertices and the codewords area of a black blob using the Start
+ * and Stop patterns as locators.
+ *
+ * Returns an array containing the vertices:
+ * vertices[0] x, y top left barcode
+ * vertices[1] x, y bottom left barcode
+ * vertices[2] x, y top right barcode
+ * vertices[3] x, y bottom right barcode
+ * vertices[4] x, y top left codeword area
+ * vertices[5] x, y bottom left codeword area
+ * vertices[6] x, y top right codeword area
+ * vertices[7] x, y bottom right codeword area
+ */
+- (NSMutableArray *)findVertices:(ZXBitMatrix *)matrix tryHarder:(BOOL)tryHarder {
+ int height = matrix.height;
+ int width = matrix.width;
+
+ NSMutableArray *result = [NSMutableArray arrayWithCapacity:8];
+ for (int i = 0; i < 8; i++) {
+ [result addObject:[NSNull null]];
+ }
+ BOOL found = NO;
+
+ int counters[START_PATTERN_REVERSE_LEN];
+ memset(counters, 0, START_PATTERN_REVERSE_LEN * sizeof(int));
+
+ int rowStep = MAX(1, height >> (tryHarder ? 9 : 7));
+
+ // Top Left
+ for (int i = 0; i < height; i += rowStep) {
+ NSRange loc = [self findGuardPattern:matrix column:0 row:i width:width whiteFirst:NO pattern:(int *)PDF417_START_PATTERN patternLen:PDF417_START_PATTERN_LEN counters:counters];
+ if (loc.location != NSNotFound) {
+ [result replaceObjectAtIndex:0 withObject:[[[ZXResultPoint alloc] initWithX:loc.location y:i] autorelease]];
+ [result replaceObjectAtIndex:4 withObject:[[[ZXResultPoint alloc] initWithX:NSMaxRange(loc) y:i] autorelease]];
+ found = YES;
+ break;
+ }
+ }
+ // Bottom left
+ if (found) { // Found the Top Left vertex
+ found = NO;
+ for (int i = height - 1; i > 0; i -= rowStep) {
+ NSRange loc = [self findGuardPattern:matrix column:0 row:i width:width whiteFirst:NO pattern:(int *)PDF417_START_PATTERN patternLen:PDF417_START_PATTERN_LEN counters:counters];
+ if (loc.location != NSNotFound) {
+ [result replaceObjectAtIndex:1 withObject:[[[ZXResultPoint alloc] initWithX:loc.location y:i] autorelease]];
+ [result replaceObjectAtIndex:5 withObject:[[[ZXResultPoint alloc] initWithX:NSMaxRange(loc) y:i] autorelease]];
+ found = YES;
+ break;
+ }
+ }
+ }
+
+ int counters2[STOP_PATTERN_REVERSE_LEN];
+ memset(counters2, 0, STOP_PATTERN_REVERSE_LEN * sizeof(int));
+
+ // Top right
+ if (found) { // Found the Bottom Left vertex
+ found = NO;
+ for (int i = 0; i < height; i += rowStep) {
+ NSRange loc = [self findGuardPattern:matrix column:0 row:i width:width whiteFirst:NO pattern:(int *)STOP_PATTERN patternLen:STOP_PATTERN_LEN counters:counters2];
+ if (loc.location != NSNotFound) {
+ [result replaceObjectAtIndex:2 withObject:[[[ZXResultPoint alloc] initWithX:NSMaxRange(loc) y:i] autorelease]];
+ [result replaceObjectAtIndex:6 withObject:[[[ZXResultPoint alloc] initWithX:loc.location y:i] autorelease]];
+ found = YES;
+ break;
+ }
+ }
+ }
+ // Bottom right
+ if (found) { // Found the Top right vertex
+ found = NO;
+ for (int i = height - 1; i > 0; i -= rowStep) {
+ NSRange loc = [self findGuardPattern:matrix column:0 row:i width:width whiteFirst:NO pattern:(int *)STOP_PATTERN patternLen:STOP_PATTERN_LEN counters:counters2];
+ if (loc.location != NSNotFound) {
+ [result replaceObjectAtIndex:3 withObject:[[[ZXResultPoint alloc] initWithX:NSMaxRange(loc) y:i] autorelease]];
+ [result replaceObjectAtIndex:7 withObject:[[[ZXResultPoint alloc] initWithX:loc.location y:i] autorelease]];
+ found = YES;
+ break;
+ }
+ }
+ }
+ return found ? result : nil;
+}
+
+
+/**
+ * Locate the vertices and the codewords area of a black blob using the Start
+ * and Stop patterns as locators. This assumes that the image is rotated 180
+ * degrees and if it locates the start and stop patterns at it will re-map
+ * the vertices for a 0 degree rotation.
+ * TODO: Change assumption about barcode location.
+ *
+ * Returns an array containing the vertices:
+ * vertices[0] x, y top left barcode
+ * vertices[1] x, y bottom left barcode
+ * vertices[2] x, y top right barcode
+ * vertices[3] x, y bottom right barcode
+ * vertices[4] x, y top left codeword area
+ * vertices[5] x, y bottom left codeword area
+ * vertices[6] x, y top right codeword area
+ * vertices[7] x, y bottom right codeword area
+ */
+- (NSMutableArray *)findVertices180:(ZXBitMatrix *)matrix tryHarder:(BOOL)tryHarder {
+ int height = matrix.height;
+ int width = matrix.width;
+ int halfWidth = width >> 1;
+
+ NSMutableArray *result = [NSMutableArray arrayWithCapacity:8];
+ for (int i = 0; i < 8; i++) {
+ [result addObject:[NSNull null]];
+ }
+ BOOL found = NO;
+
+ int counters[PDF417_START_PATTERN_LEN];
+ memset(counters, 0, PDF417_START_PATTERN_LEN * sizeof(int));
+
+ int rowStep = MAX(1, height >> (tryHarder ? 9 : 7));
+
+ // Top Left
+ for (int i = height - 1; i > 0; i -= rowStep) {
+ NSRange loc = [self findGuardPattern:matrix column:halfWidth row:i width:halfWidth whiteFirst:YES pattern:(int *)START_PATTERN_REVERSE patternLen:START_PATTERN_REVERSE_LEN counters:counters];
+ if (loc.location != NSNotFound) {
+ [result replaceObjectAtIndex:0 withObject:[[[ZXResultPoint alloc] initWithX:NSMaxRange(loc) y:i] autorelease]];
+ [result replaceObjectAtIndex:4 withObject:[[[ZXResultPoint alloc] initWithX:loc.location y:i] autorelease]];
+ found = YES;
+ break;
+ }
+ }
+ // Bottom Left
+ if (found) { // Found the Top Left vertex
+ found = NO;
+ for (int i = 0; i < height; i += rowStep) {
+ NSRange loc = [self findGuardPattern:matrix column:halfWidth row:i width:halfWidth whiteFirst:YES pattern:(int *)START_PATTERN_REVERSE patternLen:START_PATTERN_REVERSE_LEN counters:counters];
+ if (loc.location != NSNotFound) {
+ [result replaceObjectAtIndex:1 withObject:[[[ZXResultPoint alloc] initWithX:NSMaxRange(loc) y:i] autorelease]];
+ [result replaceObjectAtIndex:5 withObject:[[[ZXResultPoint alloc] initWithX:loc.location y:i] autorelease]];
+ found = YES;
+ break;
+ }
+ }
+ }
+
+ int counters2[STOP_PATTERN_LEN];
+ memset(counters2, 0, STOP_PATTERN_LEN * sizeof(int));
+
+ // Top Right
+ if (found) { // Found the Bottom Left vertex
+ found = NO;
+ for (int i = height - 1; i > 0; i -= rowStep) {
+ NSRange loc = [self findGuardPattern:matrix column:0 row:i width:halfWidth whiteFirst:NO pattern:(int *)STOP_PATTERN_REVERSE patternLen:STOP_PATTERN_REVERSE_LEN counters:counters2];
+ if (loc.location != NSNotFound) {
+ [result replaceObjectAtIndex:2 withObject:[[[ZXResultPoint alloc] initWithX:loc.location y:i] autorelease]];
+ [result replaceObjectAtIndex:6 withObject:[[[ZXResultPoint alloc] initWithX:NSMaxRange(loc) y:i] autorelease]];
+ found = YES;
+ break;
+ }
+ }
+ }
+ // Bottom Right
+ if (found) { // Found the Top Right vertex
+ found = NO;
+ for (int i = 0; i < height; i += rowStep) {
+ NSRange loc = [self findGuardPattern:matrix column:0 row:i width:halfWidth whiteFirst:NO pattern:(int *)STOP_PATTERN_REVERSE patternLen:STOP_PATTERN_REVERSE_LEN counters:counters2];
+ if (loc.location != NSNotFound) {
+ [result replaceObjectAtIndex:3 withObject:[[[ZXResultPoint alloc] initWithX:loc.location y:i] autorelease]];
+ [result replaceObjectAtIndex:7 withObject:[[[ZXResultPoint alloc] initWithX:NSMaxRange(loc) y:i] autorelease]];
+ found = YES;
+ break;
+ }
+ }
+ }
+ return found ? result : nil;
+}
+
+
+/**
+ * Because we scan horizontally to detect the start and stop patterns, the vertical component of
+ * the codeword coordinates will be slightly wrong if there is any skew or rotation in the image.
+ * This method moves those points back onto the edges of the theoretically perfect bounding
+ * quadrilateral if needed.
+ */
+- (void)correctCodeWordVertices:(NSMutableArray *)vertices upsideDown:(BOOL)upsideDown {
+ float v0x = [(ZXResultPoint *)[vertices objectAtIndex:0] x];
+ float v0y = [(ZXResultPoint *)[vertices objectAtIndex:0] y];
+ float v2x = [(ZXResultPoint *)[vertices objectAtIndex:2] x];
+ float v2y = [(ZXResultPoint *)[vertices objectAtIndex:2] y];
+ float v4x = [(ZXResultPoint *)[vertices objectAtIndex:4] x];
+ float v4y = [(ZXResultPoint *)[vertices objectAtIndex:4] y];
+ float v6x = [(ZXResultPoint *)[vertices objectAtIndex:6] x];
+ float v6y = [(ZXResultPoint *)[vertices objectAtIndex:6] y];
+
+ float skew = v4y - v6y;
+ if (upsideDown) {
+ skew = -skew;
+ }
+ if (skew > SKEW_THRESHOLD) {
+ // Fix v4
+ float deltax = v6x - v0x;
+ float deltay = v6y - v0y;
+ float delta2 = deltax * deltax + deltay * deltay;
+ float correction = (v4x - v0x) * deltax / delta2;
+ [vertices replaceObjectAtIndex:4
+ withObject:[[[ZXResultPoint alloc] initWithX:v0x + correction * deltax
+ y:v0y + correction * deltay] autorelease]];
+ } else if (-skew > SKEW_THRESHOLD) {
+ // Fix v6
+ float deltax = v2x - v4x;
+ float deltay = v2y - v4y;
+ float delta2 = deltax * deltax + deltay * deltay;
+ float correction = (v2x - v6x) * deltax / delta2;
+ [vertices replaceObjectAtIndex:6
+ withObject:[[[ZXResultPoint alloc] initWithX:v2x - correction * deltax
+ y:v2y - correction * deltay] autorelease]];
+ }
+
+ float v1x = [(ZXResultPoint *)[vertices objectAtIndex:1] x];
+ float v1y = [(ZXResultPoint *)[vertices objectAtIndex:1] y];
+ float v3x = [(ZXResultPoint *)[vertices objectAtIndex:3] x];
+ float v3y = [(ZXResultPoint *)[vertices objectAtIndex:3] y];
+ float v5x = [(ZXResultPoint *)[vertices objectAtIndex:5] x];
+ float v5y = [(ZXResultPoint *)[vertices objectAtIndex:5] y];
+ float v7x = [(ZXResultPoint *)[vertices objectAtIndex:7] x];
+ float v7y = [(ZXResultPoint *)[vertices objectAtIndex:7] y];
+
+ skew = v7y - v5y;
+ if (upsideDown) {
+ skew = -skew;
+ }
+ if (skew > SKEW_THRESHOLD) {
+ // Fix v5
+ float deltax = v7x - v1x;
+ float deltay = v7y - v1y;
+ float delta2 = deltax * deltax + deltay * deltay;
+ float correction = (v5x - v1x) * deltax / delta2;
+ [vertices replaceObjectAtIndex:5
+ withObject:[[[ZXResultPoint alloc] initWithX:v1x + correction * deltax
+ y:v1y + correction * deltay] autorelease]];
+ } else if (-skew > SKEW_THRESHOLD) {
+ // Fix v7
+ float deltax = v3x - v5x;
+ float deltay = v3y - v5y;
+ float delta2 = deltax * deltax + deltay * deltay;
+ float correction = (v3x - v7x) * deltax / delta2;
+ [vertices replaceObjectAtIndex:7
+ withObject:[[[ZXResultPoint alloc] initWithX:v3x - correction * deltax
+ y:v3y - correction * deltay] autorelease]];
+ }
+}
+
+
+/**
+ * Estimates module size (pixels in a module) based on the Start and End
+ * finder patterns.
+ *
+ * Vertices is an array of vertices:
+ * vertices[0] x, y top left barcode
+ * vertices[1] x, y bottom left barcode
+ * vertices[2] x, y top right barcode
+ * vertices[3] x, y bottom right barcode
+ * vertices[4] x, y top left codeword area
+ * vertices[5] x, y bottom left codeword area
+ * vertices[6] x, y top right codeword area
+ * vertices[7] x, y bottom right codeword area
+ */
+- (float)computeModuleWidth:(NSArray *)vertices {
+ float pixels1 = [ZXResultPoint distance:[vertices objectAtIndex:0] pattern2:[vertices objectAtIndex:4]];
+ float pixels2 = [ZXResultPoint distance:[vertices objectAtIndex:1] pattern2:[vertices objectAtIndex:5]];
+ float moduleWidth1 = (pixels1 + pixels2) / (17 * 2.0f);
+ float pixels3 = [ZXResultPoint distance:[vertices objectAtIndex:6] pattern2:[vertices objectAtIndex:2]];
+ float pixels4 = [ZXResultPoint distance:[vertices objectAtIndex:7] pattern2:[vertices objectAtIndex:3]];
+ float moduleWidth2 = (pixels3 + pixels4) / (18 * 2.0f);
+ return (moduleWidth1 + moduleWidth2) / 2.0f;
+}
+
+
+/**
+ * Computes the dimension (number of modules in a row) of the PDF417 Code
+ * based on vertices of the codeword area and estimated module size.
+ */
+- (int)computeDimension:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight bottomLeft:(ZXResultPoint *)bottomLeft bottomRight:(ZXResultPoint *)bottomRight moduleWidth:(float)moduleWidth {
+ int topRowDimension = [ZXMathUtils round:[ZXResultPoint distance:topLeft pattern2:topRight] / moduleWidth];
+ int bottomRowDimension = [ZXMathUtils round:[ZXResultPoint distance:bottomLeft pattern2:bottomRight] / moduleWidth];
+ return ((((topRowDimension + bottomRowDimension) >> 1) + 8) / 17) * 17;
+}
+
+/**
+ * Computes the y dimension (number of modules in a column) of the PDF417 Code
+ * based on vertices of the codeword area and estimated module size.
+ */
+- (int)computeYDimension:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight bottomLeft:(ZXResultPoint *)bottomLeft bottomRight:(ZXResultPoint *)bottomRight moduleWidth:(float)moduleWidth {
+ int leftColumnDimension = [ZXMathUtils round:[ZXResultPoint distance:topLeft pattern2:bottomLeft] / moduleWidth];
+ int rightColumnDimension = [ZXMathUtils round:[ZXResultPoint distance:topRight pattern2:bottomRight] / moduleWidth];
+ return (leftColumnDimension + rightColumnDimension) >> 1;
+}
+
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)matrix
+ topLeft:(ZXResultPoint *)topLeft
+ bottomLeft:(ZXResultPoint *)bottomLeft
+ topRight:(ZXResultPoint *)topRight
+ bottomRight:(ZXResultPoint *)bottomRight
+ xdimension:(int)xdimension
+ ydimension:(int)ydimension
+ error:(NSError **)error {
+ ZXGridSampler *sampler = [ZXGridSampler instance];
+ return [sampler sampleGrid:matrix
+ dimensionX:xdimension
+ dimensionY:ydimension
+ p1ToX:0.0f
+ p1ToY:0.0f
+ p2ToX:xdimension
+ p2ToY:0.0f
+ p3ToX:xdimension
+ p3ToY:ydimension
+ p4ToX:0.0f
+ p4ToY:ydimension
+ p1FromX:[topLeft x]
+ p1FromY:[topLeft y]
+ p2FromX:[topRight x]
+ p2FromY:[topRight y]
+ p3FromX:[bottomRight x]
+ p3FromY:[bottomRight y]
+ p4FromX:[bottomLeft x]
+ p4FromY:[bottomLeft y]
+ error:error];
+}
+
+- (NSRange)findGuardPattern:(ZXBitMatrix *)matrix column:(int)column row:(int)row width:(int)width whiteFirst:(BOOL)whiteFirst pattern:(int *)pattern patternLen:(int)patternLen counters:(int *)counters {
+ int patternLength = patternLen;
+ memset(counters, 0, patternLength * sizeof(int));
+ BOOL isWhite = whiteFirst;
+
+ int counterPosition = 0;
+ int patternStart = column;
+ for (int x = column; x < column + width; x++) {
+ BOOL pixel = [matrix getX:x y:row];
+ if (pixel ^ isWhite) {
+ counters[counterPosition] = counters[counterPosition] + 1;
+ } else {
+ if (counterPosition == patternLength - 1) {
+ if ([self patternMatchVariance:counters countersSize:patternLength pattern:pattern maxIndividualVariance:MAX_INDIVIDUAL_VARIANCE] < MAX_AVG_VARIANCE) {
+ return NSMakeRange(patternStart, x - patternStart);
+ }
+ patternStart += counters[0] + counters[1];
+ for (int y = 2; y < patternLength; y++) {
+ counters[y - 2] = counters[y];
+ }
+ counters[patternLength - 2] = 0;
+ counters[patternLength - 1] = 0;
+ counterPosition--;
+ } else {
+ counterPosition++;
+ }
+ counters[counterPosition] = 1;
+ isWhite = !isWhite;
+ }
+ }
+ return NSMakeRange(NSNotFound, 0);
+}
+
+
+/**
+ * Determines how closely a set of observed counts of runs of black/white
+ * values matches a given target pattern. This is reported as the ratio of
+ * the total variance from the expected pattern proportions across all
+ * pattern elements, to the length of the pattern.
+ */
+- (int)patternMatchVariance:(int *)counters countersSize:(int)countersSize pattern:(int *)pattern maxIndividualVariance:(int)maxIndividualVariance {
+ int numCounters = countersSize;
+ int total = 0;
+ int patternLength = 0;
+ for (int i = 0; i < numCounters; i++) {
+ total += counters[i];
+ patternLength += pattern[i];
+ }
+
+ if (total < patternLength) {
+ return NSIntegerMax;
+ }
+ int unitBarWidth = (total << PDF417_INTEGER_MATH_SHIFT) / patternLength;
+ maxIndividualVariance = (maxIndividualVariance * unitBarWidth) >> 8;
+
+ int totalVariance = 0;
+ for (int x = 0; x < numCounters; x++) {
+ int counter = counters[x] << PDF417_INTEGER_MATH_SHIFT;
+ int scaledPattern = pattern[x] * unitBarWidth;
+ int variance = counter > scaledPattern ? counter - scaledPattern : scaledPattern - counter;
+ if (variance > maxIndividualVariance) {
+ return NSIntegerMax;
+ }
+ totalVariance += variance;
+ }
+
+ return totalVariance / total;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXBarcodeMatrix.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXBarcodeMatrix.h
new file mode 100644
index 0000000000000000000000000000000000000000..a69494e3254d63626a6ce4a69a2723f89e5b2b7c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXBarcodeMatrix.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXBarcodeRow;
+
+/**
+ * Holds all of the information for a barcode in a format where it can be easily accessable
+ */
+@interface ZXBarcodeMatrix : NSObject
+
+@property (nonatomic, assign, readonly) int height;
+@property (nonatomic, assign, readonly) int width;
+
+- (id)initWithHeight:(int)height width:(int)width;
+- (void)setX:(int)x y:(int)y value:(unsigned char)value;
+- (void)setMatrixX:(int)x y:(int)y black:(BOOL)black;
+- (void)startRow;
+- (ZXBarcodeRow *)currentRow;
+- (unsigned char **)matrixWithHeight:(int *)height width:(int *)width;
+- (unsigned char **)scaledMatrixWithHeight:(int *)height width:(int *)width scale:(int)scale;
+- (unsigned char **)scaledMatrixWithHeight:(int *)height width:(int *)width xScale:(int)xScale yScale:(int)yScale;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXBarcodeMatrix.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXBarcodeMatrix.m
new file mode 100644
index 0000000000000000000000000000000000000000..ea38d8845484c956b500ef947d23f0100218086b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXBarcodeMatrix.m
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeMatrix.h"
+#import "ZXBarcodeRow.h"
+
+@interface ZXBarcodeMatrix ()
+
+@property (nonatomic, assign) int currentRowIndex;
+@property (nonatomic, assign) int height;
+@property (nonatomic, retain) NSArray *rowMatrix;
+@property (nonatomic, assign) int width;
+
+@end
+
+@implementation ZXBarcodeMatrix
+
+@synthesize currentRowIndex;
+@synthesize height;
+@synthesize rowMatrix;
+@synthesize width;
+
+- (id)initWithHeight:(int)aHeight width:(int)aWidth {
+ if (self = [super init]) {
+ NSMutableArray *_matrix = [NSMutableArray array];
+ for (int i = 0, matrixLength = aHeight + 2; i < matrixLength; i++) {
+ [_matrix addObject:[ZXBarcodeRow barcodeRowWithWidth:(aWidth + 4) * 17 + 1]];
+ }
+ self.rowMatrix = _matrix;
+ self.width = aWidth * 17;
+ self.height = aHeight + 2;
+ self.currentRowIndex = 0;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [rowMatrix release];
+
+ [super dealloc];
+}
+
+- (void)setX:(int)x y:(int)y value:(unsigned char)value {
+ [[self.rowMatrix objectAtIndex:y] setX:x value:value];
+}
+
+- (void)setMatrixX:(int)x y:(int)y black:(BOOL)black {
+ [self setX:x y:y value:(unsigned char)(black ? 1 : 0)];
+}
+
+- (void)startRow {
+ ++self.currentRowIndex;
+}
+
+- (ZXBarcodeRow *)currentRow {
+ return [self.rowMatrix objectAtIndex:self.currentRowIndex];
+}
+
+- (unsigned char **)matrixWithHeight:(int *)pHeight width:(int *)pWidth {
+ return [self scaledMatrixWithHeight:pHeight width:pWidth xScale:1 yScale:1];
+}
+
+- (unsigned char **)scaledMatrixWithHeight:(int *)pHeight width:(int *)pWidth scale:(int)scale {
+ return [self scaledMatrixWithHeight:pHeight width:pWidth xScale:scale yScale:scale];
+}
+
+- (unsigned char **)scaledMatrixWithHeight:(int *)pHeight width:(int *)pWidth xScale:(int)xScale yScale:(int)yScale {
+ int matrixHeight = self.height * yScale;
+
+ if (pHeight) *pHeight = matrixHeight;
+ if (pWidth) *pWidth = (self.width + 69) * xScale;
+
+ unsigned char **matrixOut = (unsigned char **)malloc(matrixHeight * sizeof(unsigned char *));
+ int yMax = self.height * yScale;
+ for (int ii = 0; ii < yMax; ii++) {
+ matrixOut[yMax - ii - 1] = [[self.rowMatrix objectAtIndex:ii / yScale] scaledRow:xScale];
+ }
+ return matrixOut;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXBarcodeRow.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXBarcodeRow.h
new file mode 100644
index 0000000000000000000000000000000000000000..81c616383b331a687dddc2dfb2bc3f1c1802cc4d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXBarcodeRow.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@interface ZXBarcodeRow : NSObject
+
+@property (nonatomic, assign, readonly) unsigned char *row;
+@property (nonatomic, assign, readonly) int rowLength;
+
++ (ZXBarcodeRow *)barcodeRowWithWidth:(int)width;
+- (id)initWithWidth:(int)width;
+- (void)setX:(int)x value:(unsigned char)value;
+- (void)setX:(int)x black:(BOOL)black;
+- (void)addBar:(BOOL)black width:(int)width;
+- (unsigned char *)scaledRow:(int)scale;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXBarcodeRow.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXBarcodeRow.m
new file mode 100644
index 0000000000000000000000000000000000000000..036fa2e7e16ec499b5954c0451265405828ca63e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXBarcodeRow.m
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeRow.h"
+
+@interface ZXBarcodeRow ()
+
+@property (nonatomic, assign) int currentLocation;
+@property (nonatomic, assign) unsigned char *row;
+@property (nonatomic, assign) int rowLength;
+
+@end
+
+@implementation ZXBarcodeRow
+
+@synthesize currentLocation;
+@synthesize row;
+@synthesize rowLength;
+
++ (ZXBarcodeRow *)barcodeRowWithWidth:(int)width {
+ return [[[ZXBarcodeRow alloc] initWithWidth:width] autorelease];
+}
+
+- (id)initWithWidth:(int)width {
+ if (self = [super init]) {
+ self.rowLength = width;
+ self.row = (unsigned char *)malloc(self.rowLength * sizeof(unsigned char));
+ memset(self.row, 0, self.rowLength * sizeof(unsigned char));
+ self.currentLocation = 0;
+ }
+ return self;
+}
+
+- (void)dealloc {
+ if (self.row != NULL) {
+ free(self.row);
+ self.row = NULL;
+ }
+
+ [super dealloc];
+}
+
+- (void)setX:(int)x value:(unsigned char)value {
+ self.row[x] = value;
+}
+
+- (void)setX:(int)x black:(BOOL)black {
+ self.row[x] = (unsigned char)(black ? 1 : 0);
+}
+
+- (void)addBar:(BOOL)black width:(int)width {
+ for (int ii = 0; ii < width; ii++) {
+ [self setX:self.currentLocation++ black:black];
+ }
+}
+
+- (unsigned char *)scaledRow:(int)scale {
+ unsigned char *output = (unsigned char *)malloc(self.rowLength * scale);
+ for (int i = 0; i < self.rowLength * scale; i++) {
+ output[i] = row[i / scale];
+ }
+ return output;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXCompaction.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXCompaction.h
new file mode 100644
index 0000000000000000000000000000000000000000..60705b077f9befcecf9077070ca55d40576ed11d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXCompaction.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+typedef enum {
+ ZX_COMPACTION_AUTO,
+ ZX_COMPACTION_TEXT,
+ ZX_COMPACTION_BYTE,
+ ZX_COMPACTION_NUMERIC
+} ZXCompaction;
\ No newline at end of file
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXDimensions.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXDimensions.h
new file mode 100644
index 0000000000000000000000000000000000000000..81b25a9c72613e1da6efe6832227093490e4443d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXDimensions.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Data object to specify the minimum and maximum number of rows and columns for a PDF417 barcode.
+ */
+@interface ZXDimensions : NSObject
+
+@property (nonatomic, assign) int minCols;
+@property (nonatomic, assign) int maxCols;
+@property (nonatomic, assign) int minRows;
+@property (nonatomic, assign) int maxRows;
+
+- (id)initWithMinCols:(int)minCols maxCols:(int)maxCols minRows:(int)minRows maxRows:(int)maxRows;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXDimensions.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXDimensions.m
new file mode 100644
index 0000000000000000000000000000000000000000..2f331365f2bc26e765e7cc6a467f253d4496ec83
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXDimensions.m
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXDimensions.h"
+
+@implementation ZXDimensions
+
+@synthesize minCols;
+@synthesize maxCols;
+@synthesize minRows;
+@synthesize maxRows;
+
+- (id)initWithMinCols:(int)aMinCols maxCols:(int)aMaxCols minRows:(int)aMinRows maxRows:(int)aMaxRows {
+ if (self = [super init]) {
+ self.minCols = aMinCols;
+ self.maxCols = aMaxCols;
+ self.minRows = aMinRows;
+ self.maxRows = aMaxRows;
+ }
+
+ return self;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d15e32a085ce994ebd6f0e5f32172e7a15d1f8e
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2006 Jeremias Maerki in part, and ZXing Authors in part
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXCompaction.h"
+
+@class ZXBarcodeMatrix;
+
+/*
+ * This file has been modified from its original form in Barcode4J.
+ */
+@interface ZXPDF417 : NSObject
+
+@property (nonatomic, retain, readonly) ZXBarcodeMatrix *barcodeMatrix;
+@property (nonatomic, assign) BOOL compact;
+@property (nonatomic, assign) ZXCompaction compaction;
+
+- (id)initWithCompact:(BOOL)compact;
+- (BOOL)generateBarcodeLogic:(NSString *)msg errorCorrectionLevel:(int)errorCorrectionLevel error:(NSError **)error;
+- (BOOL)determineDimensions:(int *)dimension sourceCodeWords:(int)sourceCodeWords errorCorrectionCodeWords:(int)errorCorrectionCodeWords error:(NSError **)error;
+- (void)setDimensionsWithMaxCols:(int)maxCols minCols:(int)minCols maxRows:(int)maxRows minRows:(int)minRows;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417.m
new file mode 100644
index 0000000000000000000000000000000000000000..b15f0519027006b8b49329adb2fd49e81a908715
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417.m
@@ -0,0 +1,750 @@
+/*
+ * Copyright 2006 Jeremias Maerki in part, and ZXing Authors in part
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeMatrix.h"
+#import "ZXBarcodeRow.h"
+#import "ZXErrors.h"
+#import "ZXPDF417.h"
+#import "ZXPDF417ErrorCorrection.h"
+#import "ZXPDF417HighLevelEncoder.h"
+
+/**
+ * The start pattern (17 bits)
+ */
+const int START_PATTERN_INT = 0x1fea8;
+/**
+ * The stop pattern (18 bits)
+ */
+const int STOP_PATTERN_INT = 0x3fa29;
+
+/**
+ * The codeword table from the Annex A of ISO/IEC 15438:2001(E).
+ */
+#define CODEWORD_TABLE_LEN 3
+#define CODEWORD_TABLE_SUB_LEN 929
+const int PDF_CODEWORD_TABLE[CODEWORD_TABLE_LEN][CODEWORD_TABLE_SUB_LEN] = {
+ {0x1d5c0, 0x1eaf0, 0x1f57c, 0x1d4e0, 0x1ea78, 0x1f53e,
+ 0x1a8c0, 0x1d470, 0x1a860, 0x15040, 0x1a830, 0x15020,
+ 0x1adc0, 0x1d6f0, 0x1eb7c, 0x1ace0, 0x1d678, 0x1eb3e,
+ 0x158c0, 0x1ac70, 0x15860, 0x15dc0, 0x1aef0, 0x1d77c,
+ 0x15ce0, 0x1ae78, 0x1d73e, 0x15c70, 0x1ae3c, 0x15ef0,
+ 0x1af7c, 0x15e78, 0x1af3e, 0x15f7c, 0x1f5fa, 0x1d2e0,
+ 0x1e978, 0x1f4be, 0x1a4c0, 0x1d270, 0x1e93c, 0x1a460,
+ 0x1d238, 0x14840, 0x1a430, 0x1d21c, 0x14820, 0x1a418,
+ 0x14810, 0x1a6e0, 0x1d378, 0x1e9be, 0x14cc0, 0x1a670,
+ 0x1d33c, 0x14c60, 0x1a638, 0x1d31e, 0x14c30, 0x1a61c,
+ 0x14ee0, 0x1a778, 0x1d3be, 0x14e70, 0x1a73c, 0x14e38,
+ 0x1a71e, 0x14f78, 0x1a7be, 0x14f3c, 0x14f1e, 0x1a2c0,
+ 0x1d170, 0x1e8bc, 0x1a260, 0x1d138, 0x1e89e, 0x14440,
+ 0x1a230, 0x1d11c, 0x14420, 0x1a218, 0x14410, 0x14408,
+ 0x146c0, 0x1a370, 0x1d1bc, 0x14660, 0x1a338, 0x1d19e,
+ 0x14630, 0x1a31c, 0x14618, 0x1460c, 0x14770, 0x1a3bc,
+ 0x14738, 0x1a39e, 0x1471c, 0x147bc, 0x1a160, 0x1d0b8,
+ 0x1e85e, 0x14240, 0x1a130, 0x1d09c, 0x14220, 0x1a118,
+ 0x1d08e, 0x14210, 0x1a10c, 0x14208, 0x1a106, 0x14360,
+ 0x1a1b8, 0x1d0de, 0x14330, 0x1a19c, 0x14318, 0x1a18e,
+ 0x1430c, 0x14306, 0x1a1de, 0x1438e, 0x14140, 0x1a0b0,
+ 0x1d05c, 0x14120, 0x1a098, 0x1d04e, 0x14110, 0x1a08c,
+ 0x14108, 0x1a086, 0x14104, 0x141b0, 0x14198, 0x1418c,
+ 0x140a0, 0x1d02e, 0x1a04c, 0x1a046, 0x14082, 0x1cae0,
+ 0x1e578, 0x1f2be, 0x194c0, 0x1ca70, 0x1e53c, 0x19460,
+ 0x1ca38, 0x1e51e, 0x12840, 0x19430, 0x12820, 0x196e0,
+ 0x1cb78, 0x1e5be, 0x12cc0, 0x19670, 0x1cb3c, 0x12c60,
+ 0x19638, 0x12c30, 0x12c18, 0x12ee0, 0x19778, 0x1cbbe,
+ 0x12e70, 0x1973c, 0x12e38, 0x12e1c, 0x12f78, 0x197be,
+ 0x12f3c, 0x12fbe, 0x1dac0, 0x1ed70, 0x1f6bc, 0x1da60,
+ 0x1ed38, 0x1f69e, 0x1b440, 0x1da30, 0x1ed1c, 0x1b420,
+ 0x1da18, 0x1ed0e, 0x1b410, 0x1da0c, 0x192c0, 0x1c970,
+ 0x1e4bc, 0x1b6c0, 0x19260, 0x1c938, 0x1e49e, 0x1b660,
+ 0x1db38, 0x1ed9e, 0x16c40, 0x12420, 0x19218, 0x1c90e,
+ 0x16c20, 0x1b618, 0x16c10, 0x126c0, 0x19370, 0x1c9bc,
+ 0x16ec0, 0x12660, 0x19338, 0x1c99e, 0x16e60, 0x1b738,
+ 0x1db9e, 0x16e30, 0x12618, 0x16e18, 0x12770, 0x193bc,
+ 0x16f70, 0x12738, 0x1939e, 0x16f38, 0x1b79e, 0x16f1c,
+ 0x127bc, 0x16fbc, 0x1279e, 0x16f9e, 0x1d960, 0x1ecb8,
+ 0x1f65e, 0x1b240, 0x1d930, 0x1ec9c, 0x1b220, 0x1d918,
+ 0x1ec8e, 0x1b210, 0x1d90c, 0x1b208, 0x1b204, 0x19160,
+ 0x1c8b8, 0x1e45e, 0x1b360, 0x19130, 0x1c89c, 0x16640,
+ 0x12220, 0x1d99c, 0x1c88e, 0x16620, 0x12210, 0x1910c,
+ 0x16610, 0x1b30c, 0x19106, 0x12204, 0x12360, 0x191b8,
+ 0x1c8de, 0x16760, 0x12330, 0x1919c, 0x16730, 0x1b39c,
+ 0x1918e, 0x16718, 0x1230c, 0x12306, 0x123b8, 0x191de,
+ 0x167b8, 0x1239c, 0x1679c, 0x1238e, 0x1678e, 0x167de,
+ 0x1b140, 0x1d8b0, 0x1ec5c, 0x1b120, 0x1d898, 0x1ec4e,
+ 0x1b110, 0x1d88c, 0x1b108, 0x1d886, 0x1b104, 0x1b102,
+ 0x12140, 0x190b0, 0x1c85c, 0x16340, 0x12120, 0x19098,
+ 0x1c84e, 0x16320, 0x1b198, 0x1d8ce, 0x16310, 0x12108,
+ 0x19086, 0x16308, 0x1b186, 0x16304, 0x121b0, 0x190dc,
+ 0x163b0, 0x12198, 0x190ce, 0x16398, 0x1b1ce, 0x1638c,
+ 0x12186, 0x16386, 0x163dc, 0x163ce, 0x1b0a0, 0x1d858,
+ 0x1ec2e, 0x1b090, 0x1d84c, 0x1b088, 0x1d846, 0x1b084,
+ 0x1b082, 0x120a0, 0x19058, 0x1c82e, 0x161a0, 0x12090,
+ 0x1904c, 0x16190, 0x1b0cc, 0x19046, 0x16188, 0x12084,
+ 0x16184, 0x12082, 0x120d8, 0x161d8, 0x161cc, 0x161c6,
+ 0x1d82c, 0x1d826, 0x1b042, 0x1902c, 0x12048, 0x160c8,
+ 0x160c4, 0x160c2, 0x18ac0, 0x1c570, 0x1e2bc, 0x18a60,
+ 0x1c538, 0x11440, 0x18a30, 0x1c51c, 0x11420, 0x18a18,
+ 0x11410, 0x11408, 0x116c0, 0x18b70, 0x1c5bc, 0x11660,
+ 0x18b38, 0x1c59e, 0x11630, 0x18b1c, 0x11618, 0x1160c,
+ 0x11770, 0x18bbc, 0x11738, 0x18b9e, 0x1171c, 0x117bc,
+ 0x1179e, 0x1cd60, 0x1e6b8, 0x1f35e, 0x19a40, 0x1cd30,
+ 0x1e69c, 0x19a20, 0x1cd18, 0x1e68e, 0x19a10, 0x1cd0c,
+ 0x19a08, 0x1cd06, 0x18960, 0x1c4b8, 0x1e25e, 0x19b60,
+ 0x18930, 0x1c49c, 0x13640, 0x11220, 0x1cd9c, 0x1c48e,
+ 0x13620, 0x19b18, 0x1890c, 0x13610, 0x11208, 0x13608,
+ 0x11360, 0x189b8, 0x1c4de, 0x13760, 0x11330, 0x1cdde,
+ 0x13730, 0x19b9c, 0x1898e, 0x13718, 0x1130c, 0x1370c,
+ 0x113b8, 0x189de, 0x137b8, 0x1139c, 0x1379c, 0x1138e,
+ 0x113de, 0x137de, 0x1dd40, 0x1eeb0, 0x1f75c, 0x1dd20,
+ 0x1ee98, 0x1f74e, 0x1dd10, 0x1ee8c, 0x1dd08, 0x1ee86,
+ 0x1dd04, 0x19940, 0x1ccb0, 0x1e65c, 0x1bb40, 0x19920,
+ 0x1eedc, 0x1e64e, 0x1bb20, 0x1dd98, 0x1eece, 0x1bb10,
+ 0x19908, 0x1cc86, 0x1bb08, 0x1dd86, 0x19902, 0x11140,
+ 0x188b0, 0x1c45c, 0x13340, 0x11120, 0x18898, 0x1c44e,
+ 0x17740, 0x13320, 0x19998, 0x1ccce, 0x17720, 0x1bb98,
+ 0x1ddce, 0x18886, 0x17710, 0x13308, 0x19986, 0x17708,
+ 0x11102, 0x111b0, 0x188dc, 0x133b0, 0x11198, 0x188ce,
+ 0x177b0, 0x13398, 0x199ce, 0x17798, 0x1bbce, 0x11186,
+ 0x13386, 0x111dc, 0x133dc, 0x111ce, 0x177dc, 0x133ce,
+ 0x1dca0, 0x1ee58, 0x1f72e, 0x1dc90, 0x1ee4c, 0x1dc88,
+ 0x1ee46, 0x1dc84, 0x1dc82, 0x198a0, 0x1cc58, 0x1e62e,
+ 0x1b9a0, 0x19890, 0x1ee6e, 0x1b990, 0x1dccc, 0x1cc46,
+ 0x1b988, 0x19884, 0x1b984, 0x19882, 0x1b982, 0x110a0,
+ 0x18858, 0x1c42e, 0x131a0, 0x11090, 0x1884c, 0x173a0,
+ 0x13190, 0x198cc, 0x18846, 0x17390, 0x1b9cc, 0x11084,
+ 0x17388, 0x13184, 0x11082, 0x13182, 0x110d8, 0x1886e,
+ 0x131d8, 0x110cc, 0x173d8, 0x131cc, 0x110c6, 0x173cc,
+ 0x131c6, 0x110ee, 0x173ee, 0x1dc50, 0x1ee2c, 0x1dc48,
+ 0x1ee26, 0x1dc44, 0x1dc42, 0x19850, 0x1cc2c, 0x1b8d0,
+ 0x19848, 0x1cc26, 0x1b8c8, 0x1dc66, 0x1b8c4, 0x19842,
+ 0x1b8c2, 0x11050, 0x1882c, 0x130d0, 0x11048, 0x18826,
+ 0x171d0, 0x130c8, 0x19866, 0x171c8, 0x1b8e6, 0x11042,
+ 0x171c4, 0x130c2, 0x171c2, 0x130ec, 0x171ec, 0x171e6,
+ 0x1ee16, 0x1dc22, 0x1cc16, 0x19824, 0x19822, 0x11028,
+ 0x13068, 0x170e8, 0x11022, 0x13062, 0x18560, 0x10a40,
+ 0x18530, 0x10a20, 0x18518, 0x1c28e, 0x10a10, 0x1850c,
+ 0x10a08, 0x18506, 0x10b60, 0x185b8, 0x1c2de, 0x10b30,
+ 0x1859c, 0x10b18, 0x1858e, 0x10b0c, 0x10b06, 0x10bb8,
+ 0x185de, 0x10b9c, 0x10b8e, 0x10bde, 0x18d40, 0x1c6b0,
+ 0x1e35c, 0x18d20, 0x1c698, 0x18d10, 0x1c68c, 0x18d08,
+ 0x1c686, 0x18d04, 0x10940, 0x184b0, 0x1c25c, 0x11b40,
+ 0x10920, 0x1c6dc, 0x1c24e, 0x11b20, 0x18d98, 0x1c6ce,
+ 0x11b10, 0x10908, 0x18486, 0x11b08, 0x18d86, 0x10902,
+ 0x109b0, 0x184dc, 0x11bb0, 0x10998, 0x184ce, 0x11b98,
+ 0x18dce, 0x11b8c, 0x10986, 0x109dc, 0x11bdc, 0x109ce,
+ 0x11bce, 0x1cea0, 0x1e758, 0x1f3ae, 0x1ce90, 0x1e74c,
+ 0x1ce88, 0x1e746, 0x1ce84, 0x1ce82, 0x18ca0, 0x1c658,
+ 0x19da0, 0x18c90, 0x1c64c, 0x19d90, 0x1cecc, 0x1c646,
+ 0x19d88, 0x18c84, 0x19d84, 0x18c82, 0x19d82, 0x108a0,
+ 0x18458, 0x119a0, 0x10890, 0x1c66e, 0x13ba0, 0x11990,
+ 0x18ccc, 0x18446, 0x13b90, 0x19dcc, 0x10884, 0x13b88,
+ 0x11984, 0x10882, 0x11982, 0x108d8, 0x1846e, 0x119d8,
+ 0x108cc, 0x13bd8, 0x119cc, 0x108c6, 0x13bcc, 0x119c6,
+ 0x108ee, 0x119ee, 0x13bee, 0x1ef50, 0x1f7ac, 0x1ef48,
+ 0x1f7a6, 0x1ef44, 0x1ef42, 0x1ce50, 0x1e72c, 0x1ded0,
+ 0x1ef6c, 0x1e726, 0x1dec8, 0x1ef66, 0x1dec4, 0x1ce42,
+ 0x1dec2, 0x18c50, 0x1c62c, 0x19cd0, 0x18c48, 0x1c626,
+ 0x1bdd0, 0x19cc8, 0x1ce66, 0x1bdc8, 0x1dee6, 0x18c42,
+ 0x1bdc4, 0x19cc2, 0x1bdc2, 0x10850, 0x1842c, 0x118d0,
+ 0x10848, 0x18426, 0x139d0, 0x118c8, 0x18c66, 0x17bd0,
+ 0x139c8, 0x19ce6, 0x10842, 0x17bc8, 0x1bde6, 0x118c2,
+ 0x17bc4, 0x1086c, 0x118ec, 0x10866, 0x139ec, 0x118e6,
+ 0x17bec, 0x139e6, 0x17be6, 0x1ef28, 0x1f796, 0x1ef24,
+ 0x1ef22, 0x1ce28, 0x1e716, 0x1de68, 0x1ef36, 0x1de64,
+ 0x1ce22, 0x1de62, 0x18c28, 0x1c616, 0x19c68, 0x18c24,
+ 0x1bce8, 0x19c64, 0x18c22, 0x1bce4, 0x19c62, 0x1bce2,
+ 0x10828, 0x18416, 0x11868, 0x18c36, 0x138e8, 0x11864,
+ 0x10822, 0x179e8, 0x138e4, 0x11862, 0x179e4, 0x138e2,
+ 0x179e2, 0x11876, 0x179f6, 0x1ef12, 0x1de34, 0x1de32,
+ 0x19c34, 0x1bc74, 0x1bc72, 0x11834, 0x13874, 0x178f4,
+ 0x178f2, 0x10540, 0x10520, 0x18298, 0x10510, 0x10508,
+ 0x10504, 0x105b0, 0x10598, 0x1058c, 0x10586, 0x105dc,
+ 0x105ce, 0x186a0, 0x18690, 0x1c34c, 0x18688, 0x1c346,
+ 0x18684, 0x18682, 0x104a0, 0x18258, 0x10da0, 0x186d8,
+ 0x1824c, 0x10d90, 0x186cc, 0x10d88, 0x186c6, 0x10d84,
+ 0x10482, 0x10d82, 0x104d8, 0x1826e, 0x10dd8, 0x186ee,
+ 0x10dcc, 0x104c6, 0x10dc6, 0x104ee, 0x10dee, 0x1c750,
+ 0x1c748, 0x1c744, 0x1c742, 0x18650, 0x18ed0, 0x1c76c,
+ 0x1c326, 0x18ec8, 0x1c766, 0x18ec4, 0x18642, 0x18ec2,
+ 0x10450, 0x10cd0, 0x10448, 0x18226, 0x11dd0, 0x10cc8,
+ 0x10444, 0x11dc8, 0x10cc4, 0x10442, 0x11dc4, 0x10cc2,
+ 0x1046c, 0x10cec, 0x10466, 0x11dec, 0x10ce6, 0x11de6,
+ 0x1e7a8, 0x1e7a4, 0x1e7a2, 0x1c728, 0x1cf68, 0x1e7b6,
+ 0x1cf64, 0x1c722, 0x1cf62, 0x18628, 0x1c316, 0x18e68,
+ 0x1c736, 0x19ee8, 0x18e64, 0x18622, 0x19ee4, 0x18e62,
+ 0x19ee2, 0x10428, 0x18216, 0x10c68, 0x18636, 0x11ce8,
+ 0x10c64, 0x10422, 0x13de8, 0x11ce4, 0x10c62, 0x13de4,
+ 0x11ce2, 0x10436, 0x10c76, 0x11cf6, 0x13df6, 0x1f7d4,
+ 0x1f7d2, 0x1e794, 0x1efb4, 0x1e792, 0x1efb2, 0x1c714,
+ 0x1cf34, 0x1c712, 0x1df74, 0x1cf32, 0x1df72, 0x18614,
+ 0x18e34, 0x18612, 0x19e74, 0x18e32, 0x1bef4},
+ {0x1f560, 0x1fab8, 0x1ea40, 0x1f530, 0x1fa9c, 0x1ea20,
+ 0x1f518, 0x1fa8e, 0x1ea10, 0x1f50c, 0x1ea08, 0x1f506,
+ 0x1ea04, 0x1eb60, 0x1f5b8, 0x1fade, 0x1d640, 0x1eb30,
+ 0x1f59c, 0x1d620, 0x1eb18, 0x1f58e, 0x1d610, 0x1eb0c,
+ 0x1d608, 0x1eb06, 0x1d604, 0x1d760, 0x1ebb8, 0x1f5de,
+ 0x1ae40, 0x1d730, 0x1eb9c, 0x1ae20, 0x1d718, 0x1eb8e,
+ 0x1ae10, 0x1d70c, 0x1ae08, 0x1d706, 0x1ae04, 0x1af60,
+ 0x1d7b8, 0x1ebde, 0x15e40, 0x1af30, 0x1d79c, 0x15e20,
+ 0x1af18, 0x1d78e, 0x15e10, 0x1af0c, 0x15e08, 0x1af06,
+ 0x15f60, 0x1afb8, 0x1d7de, 0x15f30, 0x1af9c, 0x15f18,
+ 0x1af8e, 0x15f0c, 0x15fb8, 0x1afde, 0x15f9c, 0x15f8e,
+ 0x1e940, 0x1f4b0, 0x1fa5c, 0x1e920, 0x1f498, 0x1fa4e,
+ 0x1e910, 0x1f48c, 0x1e908, 0x1f486, 0x1e904, 0x1e902,
+ 0x1d340, 0x1e9b0, 0x1f4dc, 0x1d320, 0x1e998, 0x1f4ce,
+ 0x1d310, 0x1e98c, 0x1d308, 0x1e986, 0x1d304, 0x1d302,
+ 0x1a740, 0x1d3b0, 0x1e9dc, 0x1a720, 0x1d398, 0x1e9ce,
+ 0x1a710, 0x1d38c, 0x1a708, 0x1d386, 0x1a704, 0x1a702,
+ 0x14f40, 0x1a7b0, 0x1d3dc, 0x14f20, 0x1a798, 0x1d3ce,
+ 0x14f10, 0x1a78c, 0x14f08, 0x1a786, 0x14f04, 0x14fb0,
+ 0x1a7dc, 0x14f98, 0x1a7ce, 0x14f8c, 0x14f86, 0x14fdc,
+ 0x14fce, 0x1e8a0, 0x1f458, 0x1fa2e, 0x1e890, 0x1f44c,
+ 0x1e888, 0x1f446, 0x1e884, 0x1e882, 0x1d1a0, 0x1e8d8,
+ 0x1f46e, 0x1d190, 0x1e8cc, 0x1d188, 0x1e8c6, 0x1d184,
+ 0x1d182, 0x1a3a0, 0x1d1d8, 0x1e8ee, 0x1a390, 0x1d1cc,
+ 0x1a388, 0x1d1c6, 0x1a384, 0x1a382, 0x147a0, 0x1a3d8,
+ 0x1d1ee, 0x14790, 0x1a3cc, 0x14788, 0x1a3c6, 0x14784,
+ 0x14782, 0x147d8, 0x1a3ee, 0x147cc, 0x147c6, 0x147ee,
+ 0x1e850, 0x1f42c, 0x1e848, 0x1f426, 0x1e844, 0x1e842,
+ 0x1d0d0, 0x1e86c, 0x1d0c8, 0x1e866, 0x1d0c4, 0x1d0c2,
+ 0x1a1d0, 0x1d0ec, 0x1a1c8, 0x1d0e6, 0x1a1c4, 0x1a1c2,
+ 0x143d0, 0x1a1ec, 0x143c8, 0x1a1e6, 0x143c4, 0x143c2,
+ 0x143ec, 0x143e6, 0x1e828, 0x1f416, 0x1e824, 0x1e822,
+ 0x1d068, 0x1e836, 0x1d064, 0x1d062, 0x1a0e8, 0x1d076,
+ 0x1a0e4, 0x1a0e2, 0x141e8, 0x1a0f6, 0x141e4, 0x141e2,
+ 0x1e814, 0x1e812, 0x1d034, 0x1d032, 0x1a074, 0x1a072,
+ 0x1e540, 0x1f2b0, 0x1f95c, 0x1e520, 0x1f298, 0x1f94e,
+ 0x1e510, 0x1f28c, 0x1e508, 0x1f286, 0x1e504, 0x1e502,
+ 0x1cb40, 0x1e5b0, 0x1f2dc, 0x1cb20, 0x1e598, 0x1f2ce,
+ 0x1cb10, 0x1e58c, 0x1cb08, 0x1e586, 0x1cb04, 0x1cb02,
+ 0x19740, 0x1cbb0, 0x1e5dc, 0x19720, 0x1cb98, 0x1e5ce,
+ 0x19710, 0x1cb8c, 0x19708, 0x1cb86, 0x19704, 0x19702,
+ 0x12f40, 0x197b0, 0x1cbdc, 0x12f20, 0x19798, 0x1cbce,
+ 0x12f10, 0x1978c, 0x12f08, 0x19786, 0x12f04, 0x12fb0,
+ 0x197dc, 0x12f98, 0x197ce, 0x12f8c, 0x12f86, 0x12fdc,
+ 0x12fce, 0x1f6a0, 0x1fb58, 0x16bf0, 0x1f690, 0x1fb4c,
+ 0x169f8, 0x1f688, 0x1fb46, 0x168fc, 0x1f684, 0x1f682,
+ 0x1e4a0, 0x1f258, 0x1f92e, 0x1eda0, 0x1e490, 0x1fb6e,
+ 0x1ed90, 0x1f6cc, 0x1f246, 0x1ed88, 0x1e484, 0x1ed84,
+ 0x1e482, 0x1ed82, 0x1c9a0, 0x1e4d8, 0x1f26e, 0x1dba0,
+ 0x1c990, 0x1e4cc, 0x1db90, 0x1edcc, 0x1e4c6, 0x1db88,
+ 0x1c984, 0x1db84, 0x1c982, 0x1db82, 0x193a0, 0x1c9d8,
+ 0x1e4ee, 0x1b7a0, 0x19390, 0x1c9cc, 0x1b790, 0x1dbcc,
+ 0x1c9c6, 0x1b788, 0x19384, 0x1b784, 0x19382, 0x1b782,
+ 0x127a0, 0x193d8, 0x1c9ee, 0x16fa0, 0x12790, 0x193cc,
+ 0x16f90, 0x1b7cc, 0x193c6, 0x16f88, 0x12784, 0x16f84,
+ 0x12782, 0x127d8, 0x193ee, 0x16fd8, 0x127cc, 0x16fcc,
+ 0x127c6, 0x16fc6, 0x127ee, 0x1f650, 0x1fb2c, 0x165f8,
+ 0x1f648, 0x1fb26, 0x164fc, 0x1f644, 0x1647e, 0x1f642,
+ 0x1e450, 0x1f22c, 0x1ecd0, 0x1e448, 0x1f226, 0x1ecc8,
+ 0x1f666, 0x1ecc4, 0x1e442, 0x1ecc2, 0x1c8d0, 0x1e46c,
+ 0x1d9d0, 0x1c8c8, 0x1e466, 0x1d9c8, 0x1ece6, 0x1d9c4,
+ 0x1c8c2, 0x1d9c2, 0x191d0, 0x1c8ec, 0x1b3d0, 0x191c8,
+ 0x1c8e6, 0x1b3c8, 0x1d9e6, 0x1b3c4, 0x191c2, 0x1b3c2,
+ 0x123d0, 0x191ec, 0x167d0, 0x123c8, 0x191e6, 0x167c8,
+ 0x1b3e6, 0x167c4, 0x123c2, 0x167c2, 0x123ec, 0x167ec,
+ 0x123e6, 0x167e6, 0x1f628, 0x1fb16, 0x162fc, 0x1f624,
+ 0x1627e, 0x1f622, 0x1e428, 0x1f216, 0x1ec68, 0x1f636,
+ 0x1ec64, 0x1e422, 0x1ec62, 0x1c868, 0x1e436, 0x1d8e8,
+ 0x1c864, 0x1d8e4, 0x1c862, 0x1d8e2, 0x190e8, 0x1c876,
+ 0x1b1e8, 0x1d8f6, 0x1b1e4, 0x190e2, 0x1b1e2, 0x121e8,
+ 0x190f6, 0x163e8, 0x121e4, 0x163e4, 0x121e2, 0x163e2,
+ 0x121f6, 0x163f6, 0x1f614, 0x1617e, 0x1f612, 0x1e414,
+ 0x1ec34, 0x1e412, 0x1ec32, 0x1c834, 0x1d874, 0x1c832,
+ 0x1d872, 0x19074, 0x1b0f4, 0x19072, 0x1b0f2, 0x120f4,
+ 0x161f4, 0x120f2, 0x161f2, 0x1f60a, 0x1e40a, 0x1ec1a,
+ 0x1c81a, 0x1d83a, 0x1903a, 0x1b07a, 0x1e2a0, 0x1f158,
+ 0x1f8ae, 0x1e290, 0x1f14c, 0x1e288, 0x1f146, 0x1e284,
+ 0x1e282, 0x1c5a0, 0x1e2d8, 0x1f16e, 0x1c590, 0x1e2cc,
+ 0x1c588, 0x1e2c6, 0x1c584, 0x1c582, 0x18ba0, 0x1c5d8,
+ 0x1e2ee, 0x18b90, 0x1c5cc, 0x18b88, 0x1c5c6, 0x18b84,
+ 0x18b82, 0x117a0, 0x18bd8, 0x1c5ee, 0x11790, 0x18bcc,
+ 0x11788, 0x18bc6, 0x11784, 0x11782, 0x117d8, 0x18bee,
+ 0x117cc, 0x117c6, 0x117ee, 0x1f350, 0x1f9ac, 0x135f8,
+ 0x1f348, 0x1f9a6, 0x134fc, 0x1f344, 0x1347e, 0x1f342,
+ 0x1e250, 0x1f12c, 0x1e6d0, 0x1e248, 0x1f126, 0x1e6c8,
+ 0x1f366, 0x1e6c4, 0x1e242, 0x1e6c2, 0x1c4d0, 0x1e26c,
+ 0x1cdd0, 0x1c4c8, 0x1e266, 0x1cdc8, 0x1e6e6, 0x1cdc4,
+ 0x1c4c2, 0x1cdc2, 0x189d0, 0x1c4ec, 0x19bd0, 0x189c8,
+ 0x1c4e6, 0x19bc8, 0x1cde6, 0x19bc4, 0x189c2, 0x19bc2,
+ 0x113d0, 0x189ec, 0x137d0, 0x113c8, 0x189e6, 0x137c8,
+ 0x19be6, 0x137c4, 0x113c2, 0x137c2, 0x113ec, 0x137ec,
+ 0x113e6, 0x137e6, 0x1fba8, 0x175f0, 0x1bafc, 0x1fba4,
+ 0x174f8, 0x1ba7e, 0x1fba2, 0x1747c, 0x1743e, 0x1f328,
+ 0x1f996, 0x132fc, 0x1f768, 0x1fbb6, 0x176fc, 0x1327e,
+ 0x1f764, 0x1f322, 0x1767e, 0x1f762, 0x1e228, 0x1f116,
+ 0x1e668, 0x1e224, 0x1eee8, 0x1f776, 0x1e222, 0x1eee4,
+ 0x1e662, 0x1eee2, 0x1c468, 0x1e236, 0x1cce8, 0x1c464,
+ 0x1dde8, 0x1cce4, 0x1c462, 0x1dde4, 0x1cce2, 0x1dde2,
+ 0x188e8, 0x1c476, 0x199e8, 0x188e4, 0x1bbe8, 0x199e4,
+ 0x188e2, 0x1bbe4, 0x199e2, 0x1bbe2, 0x111e8, 0x188f6,
+ 0x133e8, 0x111e4, 0x177e8, 0x133e4, 0x111e2, 0x177e4,
+ 0x133e2, 0x177e2, 0x111f6, 0x133f6, 0x1fb94, 0x172f8,
+ 0x1b97e, 0x1fb92, 0x1727c, 0x1723e, 0x1f314, 0x1317e,
+ 0x1f734, 0x1f312, 0x1737e, 0x1f732, 0x1e214, 0x1e634,
+ 0x1e212, 0x1ee74, 0x1e632, 0x1ee72, 0x1c434, 0x1cc74,
+ 0x1c432, 0x1dcf4, 0x1cc72, 0x1dcf2, 0x18874, 0x198f4,
+ 0x18872, 0x1b9f4, 0x198f2, 0x1b9f2, 0x110f4, 0x131f4,
+ 0x110f2, 0x173f4, 0x131f2, 0x173f2, 0x1fb8a, 0x1717c,
+ 0x1713e, 0x1f30a, 0x1f71a, 0x1e20a, 0x1e61a, 0x1ee3a,
+ 0x1c41a, 0x1cc3a, 0x1dc7a, 0x1883a, 0x1987a, 0x1b8fa,
+ 0x1107a, 0x130fa, 0x171fa, 0x170be, 0x1e150, 0x1f0ac,
+ 0x1e148, 0x1f0a6, 0x1e144, 0x1e142, 0x1c2d0, 0x1e16c,
+ 0x1c2c8, 0x1e166, 0x1c2c4, 0x1c2c2, 0x185d0, 0x1c2ec,
+ 0x185c8, 0x1c2e6, 0x185c4, 0x185c2, 0x10bd0, 0x185ec,
+ 0x10bc8, 0x185e6, 0x10bc4, 0x10bc2, 0x10bec, 0x10be6,
+ 0x1f1a8, 0x1f8d6, 0x11afc, 0x1f1a4, 0x11a7e, 0x1f1a2,
+ 0x1e128, 0x1f096, 0x1e368, 0x1e124, 0x1e364, 0x1e122,
+ 0x1e362, 0x1c268, 0x1e136, 0x1c6e8, 0x1c264, 0x1c6e4,
+ 0x1c262, 0x1c6e2, 0x184e8, 0x1c276, 0x18de8, 0x184e4,
+ 0x18de4, 0x184e2, 0x18de2, 0x109e8, 0x184f6, 0x11be8,
+ 0x109e4, 0x11be4, 0x109e2, 0x11be2, 0x109f6, 0x11bf6,
+ 0x1f9d4, 0x13af8, 0x19d7e, 0x1f9d2, 0x13a7c, 0x13a3e,
+ 0x1f194, 0x1197e, 0x1f3b4, 0x1f192, 0x13b7e, 0x1f3b2,
+ 0x1e114, 0x1e334, 0x1e112, 0x1e774, 0x1e332, 0x1e772,
+ 0x1c234, 0x1c674, 0x1c232, 0x1cef4, 0x1c672, 0x1cef2,
+ 0x18474, 0x18cf4, 0x18472, 0x19df4, 0x18cf2, 0x19df2,
+ 0x108f4, 0x119f4, 0x108f2, 0x13bf4, 0x119f2, 0x13bf2,
+ 0x17af0, 0x1bd7c, 0x17a78, 0x1bd3e, 0x17a3c, 0x17a1e,
+ 0x1f9ca, 0x1397c, 0x1fbda, 0x17b7c, 0x1393e, 0x17b3e,
+ 0x1f18a, 0x1f39a, 0x1f7ba, 0x1e10a, 0x1e31a, 0x1e73a,
+ 0x1ef7a, 0x1c21a, 0x1c63a, 0x1ce7a, 0x1defa, 0x1843a,
+ 0x18c7a, 0x19cfa, 0x1bdfa, 0x1087a, 0x118fa, 0x139fa,
+ 0x17978, 0x1bcbe, 0x1793c, 0x1791e, 0x138be, 0x179be,
+ 0x178bc, 0x1789e, 0x1785e, 0x1e0a8, 0x1e0a4, 0x1e0a2,
+ 0x1c168, 0x1e0b6, 0x1c164, 0x1c162, 0x182e8, 0x1c176,
+ 0x182e4, 0x182e2, 0x105e8, 0x182f6, 0x105e4, 0x105e2,
+ 0x105f6, 0x1f0d4, 0x10d7e, 0x1f0d2, 0x1e094, 0x1e1b4,
+ 0x1e092, 0x1e1b2, 0x1c134, 0x1c374, 0x1c132, 0x1c372,
+ 0x18274, 0x186f4, 0x18272, 0x186f2, 0x104f4, 0x10df4,
+ 0x104f2, 0x10df2, 0x1f8ea, 0x11d7c, 0x11d3e, 0x1f0ca,
+ 0x1f1da, 0x1e08a, 0x1e19a, 0x1e3ba, 0x1c11a, 0x1c33a,
+ 0x1c77a, 0x1823a, 0x1867a, 0x18efa, 0x1047a, 0x10cfa,
+ 0x11dfa, 0x13d78, 0x19ebe, 0x13d3c, 0x13d1e, 0x11cbe,
+ 0x13dbe, 0x17d70, 0x1bebc, 0x17d38, 0x1be9e, 0x17d1c,
+ 0x17d0e, 0x13cbc, 0x17dbc, 0x13c9e, 0x17d9e, 0x17cb8,
+ 0x1be5e, 0x17c9c, 0x17c8e, 0x13c5e, 0x17cde, 0x17c5c,
+ 0x17c4e, 0x17c2e, 0x1c0b4, 0x1c0b2, 0x18174, 0x18172,
+ 0x102f4, 0x102f2, 0x1e0da, 0x1c09a, 0x1c1ba, 0x1813a,
+ 0x1837a, 0x1027a, 0x106fa, 0x10ebe, 0x11ebc, 0x11e9e,
+ 0x13eb8, 0x19f5e, 0x13e9c, 0x13e8e, 0x11e5e, 0x13ede,
+ 0x17eb0, 0x1bf5c, 0x17e98, 0x1bf4e, 0x17e8c, 0x17e86,
+ 0x13e5c, 0x17edc, 0x13e4e, 0x17ece, 0x17e58, 0x1bf2e,
+ 0x17e4c, 0x17e46, 0x13e2e, 0x17e6e, 0x17e2c, 0x17e26,
+ 0x10f5e, 0x11f5c, 0x11f4e, 0x13f58, 0x19fae, 0x13f4c,
+ 0x13f46, 0x11f2e, 0x13f6e, 0x13f2c, 0x13f26},
+ {0x1abe0, 0x1d5f8, 0x153c0, 0x1a9f0, 0x1d4fc, 0x151e0,
+ 0x1a8f8, 0x1d47e, 0x150f0, 0x1a87c, 0x15078, 0x1fad0,
+ 0x15be0, 0x1adf8, 0x1fac8, 0x159f0, 0x1acfc, 0x1fac4,
+ 0x158f8, 0x1ac7e, 0x1fac2, 0x1587c, 0x1f5d0, 0x1faec,
+ 0x15df8, 0x1f5c8, 0x1fae6, 0x15cfc, 0x1f5c4, 0x15c7e,
+ 0x1f5c2, 0x1ebd0, 0x1f5ec, 0x1ebc8, 0x1f5e6, 0x1ebc4,
+ 0x1ebc2, 0x1d7d0, 0x1ebec, 0x1d7c8, 0x1ebe6, 0x1d7c4,
+ 0x1d7c2, 0x1afd0, 0x1d7ec, 0x1afc8, 0x1d7e6, 0x1afc4,
+ 0x14bc0, 0x1a5f0, 0x1d2fc, 0x149e0, 0x1a4f8, 0x1d27e,
+ 0x148f0, 0x1a47c, 0x14878, 0x1a43e, 0x1483c, 0x1fa68,
+ 0x14df0, 0x1a6fc, 0x1fa64, 0x14cf8, 0x1a67e, 0x1fa62,
+ 0x14c7c, 0x14c3e, 0x1f4e8, 0x1fa76, 0x14efc, 0x1f4e4,
+ 0x14e7e, 0x1f4e2, 0x1e9e8, 0x1f4f6, 0x1e9e4, 0x1e9e2,
+ 0x1d3e8, 0x1e9f6, 0x1d3e4, 0x1d3e2, 0x1a7e8, 0x1d3f6,
+ 0x1a7e4, 0x1a7e2, 0x145e0, 0x1a2f8, 0x1d17e, 0x144f0,
+ 0x1a27c, 0x14478, 0x1a23e, 0x1443c, 0x1441e, 0x1fa34,
+ 0x146f8, 0x1a37e, 0x1fa32, 0x1467c, 0x1463e, 0x1f474,
+ 0x1477e, 0x1f472, 0x1e8f4, 0x1e8f2, 0x1d1f4, 0x1d1f2,
+ 0x1a3f4, 0x1a3f2, 0x142f0, 0x1a17c, 0x14278, 0x1a13e,
+ 0x1423c, 0x1421e, 0x1fa1a, 0x1437c, 0x1433e, 0x1f43a,
+ 0x1e87a, 0x1d0fa, 0x14178, 0x1a0be, 0x1413c, 0x1411e,
+ 0x141be, 0x140bc, 0x1409e, 0x12bc0, 0x195f0, 0x1cafc,
+ 0x129e0, 0x194f8, 0x1ca7e, 0x128f0, 0x1947c, 0x12878,
+ 0x1943e, 0x1283c, 0x1f968, 0x12df0, 0x196fc, 0x1f964,
+ 0x12cf8, 0x1967e, 0x1f962, 0x12c7c, 0x12c3e, 0x1f2e8,
+ 0x1f976, 0x12efc, 0x1f2e4, 0x12e7e, 0x1f2e2, 0x1e5e8,
+ 0x1f2f6, 0x1e5e4, 0x1e5e2, 0x1cbe8, 0x1e5f6, 0x1cbe4,
+ 0x1cbe2, 0x197e8, 0x1cbf6, 0x197e4, 0x197e2, 0x1b5e0,
+ 0x1daf8, 0x1ed7e, 0x169c0, 0x1b4f0, 0x1da7c, 0x168e0,
+ 0x1b478, 0x1da3e, 0x16870, 0x1b43c, 0x16838, 0x1b41e,
+ 0x1681c, 0x125e0, 0x192f8, 0x1c97e, 0x16de0, 0x124f0,
+ 0x1927c, 0x16cf0, 0x1b67c, 0x1923e, 0x16c78, 0x1243c,
+ 0x16c3c, 0x1241e, 0x16c1e, 0x1f934, 0x126f8, 0x1937e,
+ 0x1fb74, 0x1f932, 0x16ef8, 0x1267c, 0x1fb72, 0x16e7c,
+ 0x1263e, 0x16e3e, 0x1f274, 0x1277e, 0x1f6f4, 0x1f272,
+ 0x16f7e, 0x1f6f2, 0x1e4f4, 0x1edf4, 0x1e4f2, 0x1edf2,
+ 0x1c9f4, 0x1dbf4, 0x1c9f2, 0x1dbf2, 0x193f4, 0x193f2,
+ 0x165c0, 0x1b2f0, 0x1d97c, 0x164e0, 0x1b278, 0x1d93e,
+ 0x16470, 0x1b23c, 0x16438, 0x1b21e, 0x1641c, 0x1640e,
+ 0x122f0, 0x1917c, 0x166f0, 0x12278, 0x1913e, 0x16678,
+ 0x1b33e, 0x1663c, 0x1221e, 0x1661e, 0x1f91a, 0x1237c,
+ 0x1fb3a, 0x1677c, 0x1233e, 0x1673e, 0x1f23a, 0x1f67a,
+ 0x1e47a, 0x1ecfa, 0x1c8fa, 0x1d9fa, 0x191fa, 0x162e0,
+ 0x1b178, 0x1d8be, 0x16270, 0x1b13c, 0x16238, 0x1b11e,
+ 0x1621c, 0x1620e, 0x12178, 0x190be, 0x16378, 0x1213c,
+ 0x1633c, 0x1211e, 0x1631e, 0x121be, 0x163be, 0x16170,
+ 0x1b0bc, 0x16138, 0x1b09e, 0x1611c, 0x1610e, 0x120bc,
+ 0x161bc, 0x1209e, 0x1619e, 0x160b8, 0x1b05e, 0x1609c,
+ 0x1608e, 0x1205e, 0x160de, 0x1605c, 0x1604e, 0x115e0,
+ 0x18af8, 0x1c57e, 0x114f0, 0x18a7c, 0x11478, 0x18a3e,
+ 0x1143c, 0x1141e, 0x1f8b4, 0x116f8, 0x18b7e, 0x1f8b2,
+ 0x1167c, 0x1163e, 0x1f174, 0x1177e, 0x1f172, 0x1e2f4,
+ 0x1e2f2, 0x1c5f4, 0x1c5f2, 0x18bf4, 0x18bf2, 0x135c0,
+ 0x19af0, 0x1cd7c, 0x134e0, 0x19a78, 0x1cd3e, 0x13470,
+ 0x19a3c, 0x13438, 0x19a1e, 0x1341c, 0x1340e, 0x112f0,
+ 0x1897c, 0x136f0, 0x11278, 0x1893e, 0x13678, 0x19b3e,
+ 0x1363c, 0x1121e, 0x1361e, 0x1f89a, 0x1137c, 0x1f9ba,
+ 0x1377c, 0x1133e, 0x1373e, 0x1f13a, 0x1f37a, 0x1e27a,
+ 0x1e6fa, 0x1c4fa, 0x1cdfa, 0x189fa, 0x1bae0, 0x1dd78,
+ 0x1eebe, 0x174c0, 0x1ba70, 0x1dd3c, 0x17460, 0x1ba38,
+ 0x1dd1e, 0x17430, 0x1ba1c, 0x17418, 0x1ba0e, 0x1740c,
+ 0x132e0, 0x19978, 0x1ccbe, 0x176e0, 0x13270, 0x1993c,
+ 0x17670, 0x1bb3c, 0x1991e, 0x17638, 0x1321c, 0x1761c,
+ 0x1320e, 0x1760e, 0x11178, 0x188be, 0x13378, 0x1113c,
+ 0x17778, 0x1333c, 0x1111e, 0x1773c, 0x1331e, 0x1771e,
+ 0x111be, 0x133be, 0x177be, 0x172c0, 0x1b970, 0x1dcbc,
+ 0x17260, 0x1b938, 0x1dc9e, 0x17230, 0x1b91c, 0x17218,
+ 0x1b90e, 0x1720c, 0x17206, 0x13170, 0x198bc, 0x17370,
+ 0x13138, 0x1989e, 0x17338, 0x1b99e, 0x1731c, 0x1310e,
+ 0x1730e, 0x110bc, 0x131bc, 0x1109e, 0x173bc, 0x1319e,
+ 0x1739e, 0x17160, 0x1b8b8, 0x1dc5e, 0x17130, 0x1b89c,
+ 0x17118, 0x1b88e, 0x1710c, 0x17106, 0x130b8, 0x1985e,
+ 0x171b8, 0x1309c, 0x1719c, 0x1308e, 0x1718e, 0x1105e,
+ 0x130de, 0x171de, 0x170b0, 0x1b85c, 0x17098, 0x1b84e,
+ 0x1708c, 0x17086, 0x1305c, 0x170dc, 0x1304e, 0x170ce,
+ 0x17058, 0x1b82e, 0x1704c, 0x17046, 0x1302e, 0x1706e,
+ 0x1702c, 0x17026, 0x10af0, 0x1857c, 0x10a78, 0x1853e,
+ 0x10a3c, 0x10a1e, 0x10b7c, 0x10b3e, 0x1f0ba, 0x1e17a,
+ 0x1c2fa, 0x185fa, 0x11ae0, 0x18d78, 0x1c6be, 0x11a70,
+ 0x18d3c, 0x11a38, 0x18d1e, 0x11a1c, 0x11a0e, 0x10978,
+ 0x184be, 0x11b78, 0x1093c, 0x11b3c, 0x1091e, 0x11b1e,
+ 0x109be, 0x11bbe, 0x13ac0, 0x19d70, 0x1cebc, 0x13a60,
+ 0x19d38, 0x1ce9e, 0x13a30, 0x19d1c, 0x13a18, 0x19d0e,
+ 0x13a0c, 0x13a06, 0x11970, 0x18cbc, 0x13b70, 0x11938,
+ 0x18c9e, 0x13b38, 0x1191c, 0x13b1c, 0x1190e, 0x13b0e,
+ 0x108bc, 0x119bc, 0x1089e, 0x13bbc, 0x1199e, 0x13b9e,
+ 0x1bd60, 0x1deb8, 0x1ef5e, 0x17a40, 0x1bd30, 0x1de9c,
+ 0x17a20, 0x1bd18, 0x1de8e, 0x17a10, 0x1bd0c, 0x17a08,
+ 0x1bd06, 0x17a04, 0x13960, 0x19cb8, 0x1ce5e, 0x17b60,
+ 0x13930, 0x19c9c, 0x17b30, 0x1bd9c, 0x19c8e, 0x17b18,
+ 0x1390c, 0x17b0c, 0x13906, 0x17b06, 0x118b8, 0x18c5e,
+ 0x139b8, 0x1189c, 0x17bb8, 0x1399c, 0x1188e, 0x17b9c,
+ 0x1398e, 0x17b8e, 0x1085e, 0x118de, 0x139de, 0x17bde,
+ 0x17940, 0x1bcb0, 0x1de5c, 0x17920, 0x1bc98, 0x1de4e,
+ 0x17910, 0x1bc8c, 0x17908, 0x1bc86, 0x17904, 0x17902,
+ 0x138b0, 0x19c5c, 0x179b0, 0x13898, 0x19c4e, 0x17998,
+ 0x1bcce, 0x1798c, 0x13886, 0x17986, 0x1185c, 0x138dc,
+ 0x1184e, 0x179dc, 0x138ce, 0x179ce, 0x178a0, 0x1bc58,
+ 0x1de2e, 0x17890, 0x1bc4c, 0x17888, 0x1bc46, 0x17884,
+ 0x17882, 0x13858, 0x19c2e, 0x178d8, 0x1384c, 0x178cc,
+ 0x13846, 0x178c6, 0x1182e, 0x1386e, 0x178ee, 0x17850,
+ 0x1bc2c, 0x17848, 0x1bc26, 0x17844, 0x17842, 0x1382c,
+ 0x1786c, 0x13826, 0x17866, 0x17828, 0x1bc16, 0x17824,
+ 0x17822, 0x13816, 0x17836, 0x10578, 0x182be, 0x1053c,
+ 0x1051e, 0x105be, 0x10d70, 0x186bc, 0x10d38, 0x1869e,
+ 0x10d1c, 0x10d0e, 0x104bc, 0x10dbc, 0x1049e, 0x10d9e,
+ 0x11d60, 0x18eb8, 0x1c75e, 0x11d30, 0x18e9c, 0x11d18,
+ 0x18e8e, 0x11d0c, 0x11d06, 0x10cb8, 0x1865e, 0x11db8,
+ 0x10c9c, 0x11d9c, 0x10c8e, 0x11d8e, 0x1045e, 0x10cde,
+ 0x11dde, 0x13d40, 0x19eb0, 0x1cf5c, 0x13d20, 0x19e98,
+ 0x1cf4e, 0x13d10, 0x19e8c, 0x13d08, 0x19e86, 0x13d04,
+ 0x13d02, 0x11cb0, 0x18e5c, 0x13db0, 0x11c98, 0x18e4e,
+ 0x13d98, 0x19ece, 0x13d8c, 0x11c86, 0x13d86, 0x10c5c,
+ 0x11cdc, 0x10c4e, 0x13ddc, 0x11cce, 0x13dce, 0x1bea0,
+ 0x1df58, 0x1efae, 0x1be90, 0x1df4c, 0x1be88, 0x1df46,
+ 0x1be84, 0x1be82, 0x13ca0, 0x19e58, 0x1cf2e, 0x17da0,
+ 0x13c90, 0x19e4c, 0x17d90, 0x1becc, 0x19e46, 0x17d88,
+ 0x13c84, 0x17d84, 0x13c82, 0x17d82, 0x11c58, 0x18e2e,
+ 0x13cd8, 0x11c4c, 0x17dd8, 0x13ccc, 0x11c46, 0x17dcc,
+ 0x13cc6, 0x17dc6, 0x10c2e, 0x11c6e, 0x13cee, 0x17dee,
+ 0x1be50, 0x1df2c, 0x1be48, 0x1df26, 0x1be44, 0x1be42,
+ 0x13c50, 0x19e2c, 0x17cd0, 0x13c48, 0x19e26, 0x17cc8,
+ 0x1be66, 0x17cc4, 0x13c42, 0x17cc2, 0x11c2c, 0x13c6c,
+ 0x11c26, 0x17cec, 0x13c66, 0x17ce6, 0x1be28, 0x1df16,
+ 0x1be24, 0x1be22, 0x13c28, 0x19e16, 0x17c68, 0x13c24,
+ 0x17c64, 0x13c22, 0x17c62, 0x11c16, 0x13c36, 0x17c76,
+ 0x1be14, 0x1be12, 0x13c14, 0x17c34, 0x13c12, 0x17c32,
+ 0x102bc, 0x1029e, 0x106b8, 0x1835e, 0x1069c, 0x1068e,
+ 0x1025e, 0x106de, 0x10eb0, 0x1875c, 0x10e98, 0x1874e,
+ 0x10e8c, 0x10e86, 0x1065c, 0x10edc, 0x1064e, 0x10ece,
+ 0x11ea0, 0x18f58, 0x1c7ae, 0x11e90, 0x18f4c, 0x11e88,
+ 0x18f46, 0x11e84, 0x11e82, 0x10e58, 0x1872e, 0x11ed8,
+ 0x18f6e, 0x11ecc, 0x10e46, 0x11ec6, 0x1062e, 0x10e6e,
+ 0x11eee, 0x19f50, 0x1cfac, 0x19f48, 0x1cfa6, 0x19f44,
+ 0x19f42, 0x11e50, 0x18f2c, 0x13ed0, 0x19f6c, 0x18f26,
+ 0x13ec8, 0x11e44, 0x13ec4, 0x11e42, 0x13ec2, 0x10e2c,
+ 0x11e6c, 0x10e26, 0x13eec, 0x11e66, 0x13ee6, 0x1dfa8,
+ 0x1efd6, 0x1dfa4, 0x1dfa2, 0x19f28, 0x1cf96, 0x1bf68,
+ 0x19f24, 0x1bf64, 0x19f22, 0x1bf62, 0x11e28, 0x18f16,
+ 0x13e68, 0x11e24, 0x17ee8, 0x13e64, 0x11e22, 0x17ee4,
+ 0x13e62, 0x17ee2, 0x10e16, 0x11e36, 0x13e76, 0x17ef6,
+ 0x1df94, 0x1df92, 0x19f14, 0x1bf34, 0x19f12, 0x1bf32,
+ 0x11e14, 0x13e34, 0x11e12, 0x17e74, 0x13e32, 0x17e72,
+ 0x1df8a, 0x19f0a, 0x1bf1a, 0x11e0a, 0x13e1a, 0x17e3a,
+ 0x1035c, 0x1034e, 0x10758, 0x183ae, 0x1074c, 0x10746,
+ 0x1032e, 0x1076e, 0x10f50, 0x187ac, 0x10f48, 0x187a6,
+ 0x10f44, 0x10f42, 0x1072c, 0x10f6c, 0x10726, 0x10f66,
+ 0x18fa8, 0x1c7d6, 0x18fa4, 0x18fa2, 0x10f28, 0x18796,
+ 0x11f68, 0x18fb6, 0x11f64, 0x10f22, 0x11f62, 0x10716,
+ 0x10f36, 0x11f76, 0x1cfd4, 0x1cfd2, 0x18f94, 0x19fb4,
+ 0x18f92, 0x19fb2, 0x10f14, 0x11f34, 0x10f12, 0x13f74,
+ 0x11f32, 0x13f72, 0x1cfca, 0x18f8a, 0x19f9a, 0x10f0a,
+ 0x11f1a, 0x13f3a, 0x103ac, 0x103a6, 0x107a8, 0x183d6,
+ 0x107a4, 0x107a2, 0x10396, 0x107b6, 0x187d4, 0x187d2,
+ 0x10794, 0x10fb4, 0x10792, 0x10fb2, 0x1c7ea}};
+
+static float PREFERRED_RATIO = 3.0f;
+static float DEFAULT_MODULE_WIDTH = 0.357f; //1px in mm
+static float HEIGHT = 2.0f; //mm
+
+@interface ZXPDF417 ()
+
+@property (nonatomic, retain) ZXBarcodeMatrix *barcodeMatrix;
+@property (nonatomic, assign) int minCols;
+@property (nonatomic, assign) int maxCols;
+@property (nonatomic, assign) int minRows;
+@property (nonatomic, assign) int maxRows;
+
+- (int)calculateNumberOfRowsM:(int)m k:(int)k c:(int)c;
+- (int)numberOfPadCodewordsM:(int)m k:(int)k c:(int)c r:(int)r;
+- (void)encodeCharPattern:(int)pattern len:(int)len logic:(ZXBarcodeRow *)logic;
+- (void)encodeLowLevel:(NSString *)fullCodewords c:(int)c r:(int)r errorCorrectionLevel:(int)aErrorCorrectionLevel logic:(ZXBarcodeMatrix *)logic;
+
+@end
+
+@implementation ZXPDF417
+
+@synthesize barcodeMatrix;
+@synthesize compact;
+@synthesize compaction;
+@synthesize minCols;
+@synthesize maxCols;
+@synthesize minRows;
+@synthesize maxRows;
+
+- (id)init {
+ return [self initWithCompact:NO];
+}
+
+- (id)initWithCompact:(BOOL)aCompact {
+ if (self = [super init]) {
+ self.compact = aCompact;
+ self.compaction = ZX_COMPACTION_AUTO;
+ self.minCols = 2;
+ self.maxCols = 30;
+ self.maxRows = 30;
+ self.minRows = 2;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [barcodeMatrix release];
+
+ [super dealloc];
+}
+
+/**
+ * Calculates the necessary number of rows as described in annex Q of ISO/IEC 15438:2001(E).
+ */
+- (int)calculateNumberOfRowsM:(int)m k:(int)k c:(int)c {
+ int r = ((m + 1 + k) / c) + 1;
+ if (c * r >= (m + 1 + k + c)) {
+ r--;
+ }
+ return r;
+}
+
+/**
+ * Calculates the number of pad codewords as described in 4.9.2 of ISO/IEC 15438:2001(E).
+ */
+- (int)numberOfPadCodewordsM:(int)m k:(int)k c:(int)c r:(int)r {
+ int n = c * r - k;
+ return n > m + 1 ? n - m - 1 : 0;
+}
+
+- (void)encodeCharPattern:(int)pattern len:(int)len logic:(ZXBarcodeRow *)logic {
+ int map = 1 << len - 1;
+ BOOL last = (pattern & map) != 0; //Initialize to inverse of first bit
+ int width = 0;
+ for (int i = 0; i < len; i++) {
+ BOOL black = (pattern & map) != 0;
+ if (last == black) {
+ width++;
+ } else {
+ [logic addBar:last width:width];
+
+ last = black;
+ width = 1;
+ }
+ map >>= 1;
+ }
+ [logic addBar:last width:width];
+}
+
+- (void)encodeLowLevel:(NSString *)fullCodewords c:(int)c r:(int)r errorCorrectionLevel:(int)errorCorrectionLevel logic:(ZXBarcodeMatrix *)logic {
+ int idx = 0;
+ for (int y = 0; y < r; y++) {
+ int cluster = y % 3;
+ [logic startRow];
+ [self encodeCharPattern:START_PATTERN_INT len:17 logic:logic.currentRow];
+
+ int left;
+ int right;
+ if (cluster == 0) {
+ left = (30 * (y / 3)) + ((r - 1) / 3);
+ right = (30 * (y / 3)) + (c - 1);
+ } else if (cluster == 1) {
+ left = (30 * (y / 3)) + (errorCorrectionLevel * 3) + ((r - 1) % 3);
+ right = (30 * (y / 3)) + ((r - 1) / 3);
+ } else {
+ left = (30 * (y / 3)) + (c - 1);
+ right = (30 * (y / 3)) + (errorCorrectionLevel * 3) + ((r - 1) % 3);
+ }
+
+ int pattern = PDF_CODEWORD_TABLE[cluster][left];
+ [self encodeCharPattern:pattern len:17 logic:logic.currentRow];
+
+ for (int x = 0; x < c; x++) {
+ pattern = PDF_CODEWORD_TABLE[cluster][[fullCodewords characterAtIndex:idx]];
+ [self encodeCharPattern:pattern len:17 logic:logic.currentRow];
+ idx++;
+ }
+
+ if (self.compact) {
+ [self encodeCharPattern:STOP_PATTERN_INT len:1 logic:logic.currentRow];
+ } else {
+ pattern = PDF_CODEWORD_TABLE[cluster][right];
+ [self encodeCharPattern:pattern len:17 logic:logic.currentRow];
+
+ [self encodeCharPattern:STOP_PATTERN_INT len:18 logic:logic.currentRow];
+ }
+ }
+}
+
+/**
+ * Generates the barcode logic.
+ */
+- (BOOL)generateBarcodeLogic:(NSString *)msg errorCorrectionLevel:(int)anErrorCorrectionLevel error:(NSError **)error {
+
+ //1. step: High-level encoding
+ int errorCorrectionCodeWords = [ZXPDF417ErrorCorrection errorCorrectionCodewordCount:anErrorCorrectionLevel];
+ NSString *highLevel = [ZXPDF417HighLevelEncoder encodeHighLevel:msg compaction:self.compaction error:error];
+ if (!highLevel) {
+ return NO;
+ }
+ int sourceCodeWords = highLevel.length;
+
+ int dimension[2] = {0};
+ if (![self determineDimensions:dimension sourceCodeWords:sourceCodeWords errorCorrectionCodeWords:errorCorrectionCodeWords error:error]) {
+ return NO;
+ }
+
+ int cols = dimension[0];
+ int rows = dimension[1];
+
+ int pad = [self numberOfPadCodewordsM:sourceCodeWords k:errorCorrectionCodeWords c:cols r:rows];
+
+ //2. step: construct data codewords
+ if (sourceCodeWords + errorCorrectionCodeWords + 1 > 929) { // +1 for symbol length CW
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSString stringWithFormat:@"Encoded message contains to many code words, message to big (%d bytes)", msg.length]
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return NO;
+ }
+
+ int n = sourceCodeWords + pad + 1;
+ NSMutableString *sb = [NSMutableString stringWithCapacity:n];
+ [sb appendFormat:@"%C", (unichar)n];
+ [sb appendFormat:@"%@", highLevel];
+ for (int i = 0; i < pad; i++) {
+ [sb appendFormat:@"%C", (unichar) 900]; //PAD characters
+ }
+ NSString *dataCodewords = sb;
+
+ //3. step: Error correction
+ NSString *ec = [ZXPDF417ErrorCorrection generateErrorCorrection:dataCodewords errorCorrectionLevel:anErrorCorrectionLevel];
+ NSString *fullCodewords = [dataCodewords stringByAppendingString:ec];
+
+ //4. step: low-level encoding
+ self.barcodeMatrix = [[[ZXBarcodeMatrix alloc] initWithHeight:rows width:cols] autorelease];
+ [self encodeLowLevel:fullCodewords c:cols r:rows errorCorrectionLevel:anErrorCorrectionLevel logic:self.barcodeMatrix];
+
+ return YES;
+}
+
+/**
+ * Determine optimal nr of columns and rows for the specified number of
+ * codewords.
+ */
+- (BOOL)determineDimensions:(int *)dimension sourceCodeWords:(int)sourceCodeWords errorCorrectionCodeWords:(int)errorCorrectionCodeWords error:(NSError **)error{
+ float ratio = 0.0f;
+ BOOL result = NO;
+
+ for (int cols = self.minCols; cols <= self.maxCols; cols++) {
+
+ int rows = [self calculateNumberOfRowsM:sourceCodeWords k:errorCorrectionCodeWords c:cols];
+
+ if (rows < self.minRows) {
+ break;
+ }
+
+ if (rows > self.maxRows) {
+ continue;
+ }
+
+ float newRatio = ((17 * cols + 69) * DEFAULT_MODULE_WIDTH) / (rows * HEIGHT);
+
+ // ignore if previous ratio is closer to preferred ratio
+ if (result && fabsf(newRatio - PREFERRED_RATIO) > fabsf(ratio - PREFERRED_RATIO)) {
+ continue;
+ }
+
+ ratio = newRatio;
+ dimension[0] = cols;
+ dimension[1] = rows;
+ result = YES;
+ }
+
+ // Handle case when min values were larger than necessary
+ if (!result) {
+ int rows = [self calculateNumberOfRowsM:sourceCodeWords k:errorCorrectionCodeWords c:minCols];
+ if (rows < minRows) {
+ dimension[0] = minCols;
+ dimension[1] = minRows;
+ }
+ }
+
+ if (!result) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"Unable to fit message in columns"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return NO;
+ }
+
+ return result;
+}
+
+/**
+ * Sets max/min row/col values
+ */
+- (void)setDimensionsWithMaxCols:(int)_maxCols minCols:(int)_minCols maxRows:(int)_maxRows minRows:(int)_minRows {
+ self.maxCols = _maxCols;
+ self.minCols = _minCols;
+ self.maxRows = _maxRows;
+ self.minRows = _minRows;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417ErrorCorrection.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417ErrorCorrection.h
new file mode 100644
index 0000000000000000000000000000000000000000..e17585415d4cfed54381dae2f92b2e3de39eb190
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417ErrorCorrection.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2006 Jeremias Maerki in part, and ZXing Authors in part
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * PDF417 error correction code following the algorithm described in ISO/IEC 15438:2001(E) in
+ * chapter 4.10.
+ */
+@interface ZXPDF417ErrorCorrection : NSObject
+
++ (int)errorCorrectionCodewordCount:(int)errorCorrectionLevel;
++ (int)recommendedMinimumErrorCorrectionLevel:(int)n error:(NSError **)error;
++ (NSString *)generateErrorCorrection:(NSString *)dataCodewords errorCorrectionLevel:(int)errorCorrectionLevel;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417ErrorCorrection.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417ErrorCorrection.m
new file mode 100644
index 0000000000000000000000000000000000000000..5eb581712f65d8496b78a6acbc65e8990474369f
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417ErrorCorrection.m
@@ -0,0 +1,190 @@
+/*
+ * Copyright 2006 Jeremias Maerki in part, and ZXing Authors in part
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXErrors.h"
+#import "ZXPDF417ErrorCorrection.h"
+
+/**
+ * Tables of coefficients for calculating error correction words
+ * (see annex F, ISO/IEC 15438:2001(E))
+ */
+const int EC_COEFFICIENTS[9][512] = {
+ {27, 917},
+ {522, 568, 723, 809},
+ {237, 308, 436, 284, 646, 653, 428, 379},
+ {274, 562, 232, 755, 599, 524, 801, 132, 295, 116, 442, 428, 295,
+ 42, 176, 65},
+ {361, 575, 922, 525, 176, 586, 640, 321, 536, 742, 677, 742, 687,
+ 284, 193, 517, 273, 494, 263, 147, 593, 800, 571, 320, 803,
+ 133, 231, 390, 685, 330, 63, 410},
+ {539, 422, 6, 93, 862, 771, 453, 106, 610, 287, 107, 505, 733,
+ 877, 381, 612, 723, 476, 462, 172, 430, 609, 858, 822, 543,
+ 376, 511, 400, 672, 762, 283, 184, 440, 35, 519, 31, 460,
+ 594, 225, 535, 517, 352, 605, 158, 651, 201, 488, 502, 648,
+ 733, 717, 83, 404, 97, 280, 771, 840, 629, 4, 381, 843,
+ 623, 264, 543},
+ {521, 310, 864, 547, 858, 580, 296, 379, 53, 779, 897, 444, 400,
+ 925, 749, 415, 822, 93, 217, 208, 928, 244, 583, 620, 246,
+ 148, 447, 631, 292, 908, 490, 704, 516, 258, 457, 907, 594,
+ 723, 674, 292, 272, 96, 684, 432, 686, 606, 860, 569, 193,
+ 219, 129, 186, 236, 287, 192, 775, 278, 173, 40, 379, 712,
+ 463, 646, 776, 171, 491, 297, 763, 156, 732, 95, 270, 447,
+ 90, 507, 48, 228, 821, 808, 898, 784, 663, 627, 378, 382,
+ 262, 380, 602, 754, 336, 89, 614, 87, 432, 670, 616, 157,
+ 374, 242, 726, 600, 269, 375, 898, 845, 454, 354, 130, 814,
+ 587, 804, 34, 211, 330, 539, 297, 827, 865, 37, 517, 834,
+ 315, 550, 86, 801, 4, 108, 539},
+ {524, 894, 75, 766, 882, 857, 74, 204, 82, 586, 708, 250, 905,
+ 786, 138, 720, 858, 194, 311, 913, 275, 190, 375, 850, 438,
+ 733, 194, 280, 201, 280, 828, 757, 710, 814, 919, 89, 68,
+ 569, 11, 204, 796, 605, 540, 913, 801, 700, 799, 137, 439,
+ 418, 592, 668, 353, 859, 370, 694, 325, 240, 216, 257, 284,
+ 549, 209, 884, 315, 70, 329, 793, 490, 274, 877, 162, 749,
+ 812, 684, 461, 334, 376, 849, 521, 307, 291, 803, 712, 19,
+ 358, 399, 908, 103, 511, 51, 8, 517, 225, 289, 470, 637,
+ 731, 66, 255, 917, 269, 463, 830, 730, 433, 848, 585, 136,
+ 538, 906, 90, 2, 290, 743, 199, 655, 903, 329, 49, 802,
+ 580, 355, 588, 188, 462, 10, 134, 628, 320, 479, 130, 739,
+ 71, 263, 318, 374, 601, 192, 605, 142, 673, 687, 234, 722,
+ 384, 177, 752, 607, 640, 455, 193, 689, 707, 805, 641, 48,
+ 60, 732, 621, 895, 544, 261, 852, 655, 309, 697, 755, 756,
+ 60, 231, 773, 434, 421, 726, 528, 503, 118, 49, 795, 32,
+ 144, 500, 238, 836, 394, 280, 566, 319, 9, 647, 550, 73,
+ 914, 342, 126, 32, 681, 331, 792, 620, 60, 609, 441, 180,
+ 791, 893, 754, 605, 383, 228, 749, 760, 213, 54, 297, 134,
+ 54, 834, 299, 922, 191, 910, 532, 609, 829, 189, 20, 167,
+ 29, 872, 449, 83, 402, 41, 656, 505, 579, 481, 173, 404,
+ 251, 688, 95, 497, 555, 642, 543, 307, 159, 924, 558, 648,
+ 55, 497, 10},
+ {352, 77, 373, 504, 35, 599, 428, 207, 409, 574, 118, 498, 285,
+ 380, 350, 492, 197, 265, 920, 155, 914, 299, 229, 643, 294,
+ 871, 306, 88, 87, 193, 352, 781, 846, 75, 327, 520, 435,
+ 543, 203, 666, 249, 346, 781, 621, 640, 268, 794, 534, 539,
+ 781, 408, 390, 644, 102, 476, 499, 290, 632, 545, 37, 858,
+ 916, 552, 41, 542, 289, 122, 272, 383, 800, 485, 98, 752,
+ 472, 761, 107, 784, 860, 658, 741, 290, 204, 681, 407, 855,
+ 85, 99, 62, 482, 180, 20, 297, 451, 593, 913, 142, 808,
+ 684, 287, 536, 561, 76, 653, 899, 729, 567, 744, 390, 513,
+ 192, 516, 258, 240, 518, 794, 395, 768, 848, 51, 610, 384,
+ 168, 190, 826, 328, 596, 786, 303, 570, 381, 415, 641, 156,
+ 237, 151, 429, 531, 207, 676, 710, 89, 168, 304, 402, 40,
+ 708, 575, 162, 864, 229, 65, 861, 841, 512, 164, 477, 221,
+ 92, 358, 785, 288, 357, 850, 836, 827, 736, 707, 94, 8,
+ 494, 114, 521, 2, 499, 851, 543, 152, 729, 771, 95, 248,
+ 361, 578, 323, 856, 797, 289, 51, 684, 466, 533, 820, 669,
+ 45, 902, 452, 167, 342, 244, 173, 35, 463, 651, 51, 699,
+ 591, 452, 578, 37, 124, 298, 332, 552, 43, 427, 119, 662,
+ 777, 475, 850, 764, 364, 578, 911, 283, 711, 472, 420, 245,
+ 288, 594, 394, 511, 327, 589, 777, 699, 688, 43, 408, 842,
+ 383, 721, 521, 560, 644, 714, 559, 62, 145, 873, 663, 713,
+ 159, 672, 729, 624, 59, 193, 417, 158, 209, 563, 564, 343,
+ 693, 109, 608, 563, 365, 181, 772, 677, 310, 248, 353, 708,
+ 410, 579, 870, 617, 841, 632, 860, 289, 536, 35, 777, 618,
+ 586, 424, 833, 77, 597, 346, 269, 757, 632, 695, 751, 331,
+ 247, 184, 45, 787, 680, 18, 66, 407, 369, 54, 492, 228,
+ 613, 830, 922, 437, 519, 644, 905, 789, 420, 305, 441, 207,
+ 300, 892, 827, 141, 537, 381, 662, 513, 56, 252, 341, 242,
+ 797, 838, 837, 720, 224, 307, 631, 61, 87, 560, 310, 756,
+ 665, 397, 808, 851, 309, 473, 795, 378, 31, 647, 915, 459,
+ 806, 590, 731, 425, 216, 548, 249, 321, 881, 699, 535, 673,
+ 782, 210, 815, 905, 303, 843, 922, 281, 73, 469, 791, 660,
+ 162, 498, 308, 155, 422, 907, 817, 187, 62, 16, 425, 535,
+ 336, 286, 437, 375, 273, 610, 296, 183, 923, 116, 667, 751,
+ 353, 62, 366, 691, 379, 687, 842, 37, 357, 720, 742, 330,
+ 5, 39, 923, 311, 424, 242, 749, 321, 54, 669, 316, 342,
+ 299, 534, 105, 667, 488, 640, 672, 576, 540, 316, 486, 721,
+ 610, 46, 656, 447, 171, 616, 464, 190, 531, 297, 321, 762,
+ 752, 533, 175, 134, 14, 381, 433, 717, 45, 111, 20, 596,
+ 284, 736, 138, 646, 411, 877, 669, 141, 919, 45, 780, 407,
+ 164, 332, 899, 165, 726, 600, 325, 498, 655, 357, 752, 768,
+ 223, 849, 647, 63, 310, 863, 251, 366, 304, 282, 738, 675,
+ 410, 389, 244, 31, 121, 303, 263}};
+
+@implementation ZXPDF417ErrorCorrection
+
+/**
+ * Determines the number of error correction codewords for a specified error correction
+ * level.
+ */
++ (int)errorCorrectionCodewordCount:(int)errorCorrectionLevel {
+ if (errorCorrectionLevel < 0 || errorCorrectionLevel > 8) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"Error correction level must be between 0 and 8!"];
+ }
+ return 1 << (errorCorrectionLevel + 1);
+}
+
+/**
+ * Returns the recommended minimum error correction level as described in annex E of
+ * ISO/IEC 15438:2001(E).
+ */
++ (int)recommendedMinimumErrorCorrectionLevel:(int)n error:(NSError **)error {
+ if (n <= 0) {
+ [NSException raise:NSInvalidArgumentException
+ format:@"n must be > 0"];
+ }
+ if (n <= 40) {
+ return 2;
+ }
+ if (n <= 160) {
+ return 3;
+ }
+ if (n <= 320) {
+ return 4;
+ }
+ if (n <= 863) {
+ return 5;
+ }
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"No recommendation possible"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return -1;
+}
+
+/**
+ * Generates the error correction codewords according to 4.10 in ISO/IEC 15438:2001(E).
+ */
++ (NSString *)generateErrorCorrection:(NSString *)dataCodewords errorCorrectionLevel:(int)errorCorrectionLevel {
+ int k = [self errorCorrectionCodewordCount:errorCorrectionLevel];
+ unichar e[k];
+ memset(e, 0, k * sizeof(unichar));
+
+ int sld = dataCodewords.length;
+ for (int i = 0; i < sld; i++) {
+ int t1 = ([dataCodewords characterAtIndex:i] + e[k - 1]) % 929;
+ int t2;
+ int t3;
+ for (int j = k - 1; j >= 1; j--) {
+ t2 = (t1 * EC_COEFFICIENTS[errorCorrectionLevel][j]) % 929;
+ t3 = 929 - t2;
+ e[j] = (unichar) ((e[j - 1] + t3) % 929);
+ }
+ t2 = (t1 * EC_COEFFICIENTS[errorCorrectionLevel][0]) % 929;
+ t3 = 929 - t2;
+ e[0] = (unichar) (t3 % 929);
+ }
+ NSMutableString *sb = [NSMutableString stringWithCapacity:k];
+ for (int j = k - 1; j >= 0; j--) {
+ if (e[j] != 0) {
+ e[j] = (unichar) (929 - e[j]);
+ }
+ [sb appendFormat:@"%C", e[j]];
+ }
+ return sb;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417HighLevelEncoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417HighLevelEncoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..b87a128c9bd99bcbc3cc6380f23049ed5c6d93e3
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417HighLevelEncoder.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2006 Jeremias Maerki in part, and ZXing Authors in part
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * This file has been modified from its original form in Barcode4J.
+ */
+
+#import "ZXCompaction.h"
+
+/**
+ * PDF417 high-level encoder following the algorithm described in ISO/IEC 15438:2001(E) in
+ * annex P.
+ */
+
+@interface ZXPDF417HighLevelEncoder : NSObject
+
++ (NSString *)encodeHighLevel:(NSString *)msg compaction:(ZXCompaction)compaction error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417HighLevelEncoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417HighLevelEncoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..6d03cf5edf2eb00a6eb1e2549bf475d51eece9cb
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417HighLevelEncoder.m
@@ -0,0 +1,537 @@
+/*
+ * Copyright 2006 Jeremias Maerki in part, and ZXing Authors in part
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXErrors.h"
+#import "ZXPDF417HighLevelEncoder.h"
+
+/**
+ * code for Text compaction
+ */
+const int TEXT_COMPACTION = 0;
+
+/**
+ * code for Byte compaction
+ */
+const int BYTE_COMPACTION = 1;
+
+/**
+ * code for Numeric compaction
+ */
+const int NUMERIC_COMPACTION = 2;
+
+/**
+ * Text compaction submode Alpha
+ */
+const int SUBMODE_ALPHA = 0;
+
+/**
+ * Text compaction submode Lower
+ */
+const int SUBMODE_LOWER = 1;
+
+/**
+ * Text compaction submode Mixed
+ */
+const int SUBMODE_MIXED = 2;
+
+/**
+ * Text compaction submode Punctuation
+ */
+const int SUBMODE_PUNCTUATION = 3;
+
+/**
+ * mode latch to Text Compaction mode
+ */
+const int LATCH_TO_TEXT = 900;
+
+/**
+ * mode latch to Byte Compaction mode (number of characters NOT a multiple of 6)
+ */
+const int LATCH_TO_BYTE_PADDED = 901;
+
+/**
+ * mode latch to Numeric Compaction mode
+ */
+const int LATCH_TO_NUMERIC = 902;
+
+/**
+ * mode shift to Byte Compaction mode
+ */
+const int SHIFT_TO_BYTE = 913;
+
+/**
+ * mode latch to Byte Compaction mode (number of characters a multiple of 6)
+ */
+const int LATCH_TO_BYTE = 924;
+
+/**
+ * Raw code table for text compaction Mixed sub-mode
+ */
+const int TEXT_MIXED_RAW_LEN = 30;
+const unsigned char TEXT_MIXED_RAW[TEXT_MIXED_RAW_LEN] = {
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 38, 13, 9, 44, 58,
+ 35, 45, 46, 36, 47, 43, 37, 42, 61, 94, 0, 32, 0, 0, 0};
+
+/**
+ * Raw code table for text compaction: Punctuation sub-mode
+ */
+const int TEXT_PUNCTUATION_RAW_LEN = 30;
+const unsigned char TEXT_PUNCTUATION_RAW[TEXT_PUNCTUATION_RAW_LEN] = {
+ 59, 60, 62, 64, 91, 92, 93, 95, 96, 126, 33, 13, 9, 44, 58,
+ 10, 45, 46, 36, 47, 34, 124, 42, 40, 41, 63, 123, 125, 39, 0};
+
+const int MIXED_TABLE_LEN = 128;
+unichar MIXED_TABLE[MIXED_TABLE_LEN];
+
+const int PUNCTUATION_LEN = 128;
+unichar PUNCTUATION[PUNCTUATION_LEN];
+
+@interface ZXPDF417HighLevelEncoder ()
+
++ (unsigned char *)bytesForMessage:(NSString *)msg;
++ (int)encodeText:(NSString *)msg startpos:(int)startpos count:(int)count buffer:(NSMutableString *)sb initialSubmode:(int)initialSubmode;
++ (void)encodeBinary:(unsigned char *)bytes startpos:(int)startpos count:(int)count startmode:(int)startmode buffer:(NSMutableString *)sb;
++ (void)encodeNumeric:(NSString *)msg startpos:(int)startpos count:(int)count buffer:(NSMutableString *)sb;
++ (BOOL)isDigit:(char)ch;
++ (BOOL)isAlphaUpper:(char)ch;
++ (BOOL)isAlphaLower:(char)ch;
++ (BOOL)isMixed:(char)ch;
++ (BOOL)isPunctuation:(char)ch;
++ (BOOL)isText:(char)ch;
++ (int)determineConsecutiveDigitCount:(NSString *)msg startpos:(int)startpos;
++ (int)determineConsecutiveTextCount:(NSString *)msg startpos:(int)startpos;
++ (int)determineConsecutiveBinaryCount:(NSString *)msg bytes:(unsigned char *)bytes startpos:(int)startpos error:(NSError **)error;
+
+@end
+
+@implementation ZXPDF417HighLevelEncoder
+
++ (void)initialize {
+ //Construct inverse lookups
+ for (int i = 0; i < MIXED_TABLE_LEN; i++) {
+ MIXED_TABLE[i] = 0xFF;
+ }
+ for (unsigned char i = 0; i < TEXT_MIXED_RAW_LEN; i++) {
+ unsigned char b = TEXT_MIXED_RAW[i];
+ if (b > 0) {
+ MIXED_TABLE[b] = i;
+ }
+ }
+ for (int i = 0; i < PUNCTUATION_LEN; i++) {
+ PUNCTUATION[i] = 0xFF;
+ }
+ for (unsigned char i = 0; i < TEXT_PUNCTUATION_RAW_LEN; i++) {
+ unsigned char b = TEXT_PUNCTUATION_RAW[i];
+ if (b > 0) {
+ PUNCTUATION[b] = i;
+ }
+ }
+}
+
+/**
+ * Converts the message to a byte array using the default encoding (cp437) as defined by the
+ * specification
+ */
++ (unsigned char *)bytesForMessage:(NSString *)msg {
+ return (unsigned char *)[[msg dataUsingEncoding:(NSStringEncoding) 0x80000400] bytes];
+}
+
+/**
+ * Performs high-level encoding of a PDF417 message using the algorithm described in annex P
+ * of ISO/IEC 15438:2001(E). If byte compaction has been selected, then only byte compaction
+ * is used.
+ */
++ (NSString *)encodeHighLevel:(NSString *)msg compaction:(ZXCompaction)compaction error:(NSError **)error {
+ unsigned char *bytes = NULL; //Fill later and only if needed
+
+ //the codewords 0..928 are encoded as Unicode characters
+ NSMutableString *sb = [NSMutableString stringWithCapacity:msg.length];
+
+ int len = msg.length;
+ int p = 0;
+ int textSubMode = SUBMODE_ALPHA;
+
+ // User selected encoding mode
+ if (compaction == ZX_COMPACTION_TEXT) {
+ [self encodeText:msg startpos:p count:len buffer:sb initialSubmode:textSubMode];
+ } else if (compaction == ZX_COMPACTION_BYTE) {
+ bytes = [self bytesForMessage:msg];
+ [self encodeBinary:bytes startpos:p count:msg.length startmode:BYTE_COMPACTION buffer:sb];
+ } else if (compaction == ZX_COMPACTION_NUMERIC) {
+ [sb appendFormat:@"%C", (unichar) LATCH_TO_NUMERIC];
+ [self encodeNumeric:msg startpos:p count:len buffer:sb];
+ } else {
+ int encodingMode = TEXT_COMPACTION; //Default mode, see 4.4.2.1
+ while (p < len) {
+ int n = [self determineConsecutiveDigitCount:msg startpos:p];
+ if (n >= 13) {
+ [sb appendFormat:@"%C", (unichar) LATCH_TO_NUMERIC];
+ encodingMode = NUMERIC_COMPACTION;
+ textSubMode = SUBMODE_ALPHA; //Reset after latch
+ [self encodeNumeric:msg startpos:p count:n buffer:sb];
+ p += n;
+ } else {
+ int t = [self determineConsecutiveTextCount:msg startpos:p];
+ if (t >= 5 || n == len) {
+ if (encodingMode != TEXT_COMPACTION) {
+ [sb appendFormat:@"%C", (unichar) LATCH_TO_TEXT];
+ encodingMode = TEXT_COMPACTION;
+ textSubMode = SUBMODE_ALPHA; //start with submode alpha after latch
+ }
+ textSubMode = [self encodeText:msg startpos:p count:t buffer:sb initialSubmode:textSubMode];
+ p += t;
+ } else {
+ if (bytes == NULL) {
+ bytes = [self bytesForMessage:msg];
+ }
+ int b = [self determineConsecutiveBinaryCount:msg bytes:bytes startpos:p error:error];
+ if (b == -1) {
+ return nil;
+ } else if (b == 0) {
+ b = 1;
+ }
+ if (b == 1 && encodingMode == TEXT_COMPACTION) {
+ //Switch for one byte (instead of latch)
+ [self encodeBinary:bytes startpos:p count:1 startmode:TEXT_COMPACTION buffer:sb];
+ } else {
+ //Mode latch performed by encodeBinary
+ [self encodeBinary:bytes startpos:p count:b startmode:encodingMode buffer:sb];
+ encodingMode = BYTE_COMPACTION;
+ textSubMode = SUBMODE_ALPHA; //Reset after latch
+ }
+ p += b;
+ }
+ }
+ }
+ }
+
+ return sb;
+}
+
+/**
+ * Encode parts of the message using Text Compaction as described in ISO/IEC 15438:2001(E),
+ * chapter 4.4.2.
+ */
++ (int)encodeText:(NSString *)msg startpos:(int)startpos count:(int)count buffer:(NSMutableString *)sb initialSubmode:(int)initialSubmode {
+ NSMutableString *tmp = [NSMutableString stringWithCapacity:count];
+ int submode = initialSubmode;
+ int idx = 0;
+ while (true) {
+ unichar ch = [msg characterAtIndex:startpos + idx];
+ switch (submode) {
+ case SUBMODE_ALPHA:
+ if ([self isAlphaUpper:ch]) {
+ if (ch == ' ') {
+ [tmp appendFormat:@"%C", (unichar) 26]; //space
+ } else {
+ [tmp appendFormat:@"%C", (unichar) (ch - 65)];
+ }
+ } else {
+ if ([self isAlphaLower:ch]) {
+ submode = SUBMODE_LOWER;
+ [tmp appendFormat:@"%C", (unichar) 27]; //ll
+ continue;
+ } else if ([self isMixed:ch]) {
+ submode = SUBMODE_MIXED;
+ [tmp appendFormat:@"%C", (unichar) 28]; //ml
+ continue;
+ } else {
+ [tmp appendFormat:@"%C", (unichar) 29]; //ps
+ [tmp appendFormat:@"%C", PUNCTUATION[ch]];
+ break;
+ }
+ }
+ break;
+ case SUBMODE_LOWER:
+ if ([self isAlphaLower:ch]) {
+ if (ch == ' ') {
+ [tmp appendFormat:@"%C", (unichar) 26]; //space
+ } else {
+ [tmp appendFormat:@"%C", (unichar) (ch - 97)];
+ }
+ } else {
+ if ([self isAlphaUpper:ch]) {
+ [tmp appendFormat:@"%C", (unichar) 27]; //as
+ [tmp appendFormat:@"%C", (unichar) (ch - 65)];
+ //space cannot happen here, it is also in "Lower"
+ break;
+ } else if ([self isMixed:ch]) {
+ submode = SUBMODE_MIXED;
+ [tmp appendFormat:@"%C", (unichar) 28]; //ml
+ continue;
+ } else {
+ [tmp appendFormat:@"%C", (unichar) 29]; //ps
+ [tmp appendFormat:@"%C", PUNCTUATION[ch]];
+ break;
+ }
+ }
+ break;
+ case SUBMODE_MIXED:
+ if ([self isMixed:ch]) {
+ [tmp appendFormat:@"%C", MIXED_TABLE[ch]]; //as
+ } else {
+ if ([self isAlphaUpper:ch]) {
+ submode = SUBMODE_ALPHA;
+ [tmp appendFormat:@"%C", (unichar) 28]; //al
+ continue;
+ } else if ([self isAlphaLower:ch]) {
+ submode = SUBMODE_LOWER;
+ [tmp appendFormat:@"%C", (unichar) 27]; //ll
+ continue;
+ } else {
+ if (startpos + idx + 1 < count) {
+ char next = [msg characterAtIndex:startpos + idx + 1];
+ if ([self isPunctuation:next]) {
+ submode = SUBMODE_PUNCTUATION;
+ [tmp appendFormat:@"%C", (unichar) 25]; //pl
+ continue;
+ }
+ }
+ [tmp appendFormat:@"%C", (unichar) 29]; //ps
+ [tmp appendFormat:@"%C", PUNCTUATION[ch]];
+ }
+ }
+ break;
+ default: //SUBMODE_PUNCTUATION
+ if ([self isPunctuation:ch]) {
+ [tmp appendFormat:@"%C", PUNCTUATION[ch]];
+ } else {
+ submode = SUBMODE_ALPHA;
+ [tmp appendFormat:@"%C", (unichar) 29]; //al
+ continue;
+ }
+ }
+ idx++;
+ if (idx >= count) {
+ break;
+ }
+ }
+ unichar h = 0;
+ int len = tmp.length;
+ for (int i = 0; i < len; i++) {
+ BOOL odd = (i % 2) != 0;
+ if (odd) {
+ h = (unichar) ((h * 30) + [tmp characterAtIndex:i]);
+ [sb appendFormat:@"%C", h];
+ } else {
+ h = [tmp characterAtIndex:i];
+ }
+ }
+ if ((len % 2) != 0) {
+ [sb appendFormat:@"%C", (unichar) ((h * 30) + 29)]; //ps
+ }
+ return submode;
+}
+
+/**
+ * Encode parts of the message using Byte Compaction as described in ISO/IEC 15438:2001(E),
+ * chapter 4.4.3. The Unicode characters will be converted to binary using the cp437
+ * codepage.
+ */
++ (void)encodeBinary:(unsigned char *)bytes startpos:(int)startpos count:(int)count startmode:(int)startmode buffer:(NSMutableString *)sb {
+ if (count == 1 && startmode == TEXT_COMPACTION) {
+ [sb appendFormat:@"%C", (unichar) SHIFT_TO_BYTE];
+ }
+
+ int idx = startpos;
+ // Encode sixpacks
+ if (count >= 6) {
+ [sb appendFormat:@"%C", (unichar) LATCH_TO_BYTE];
+ const int charsLen = 5;
+ unichar chars[charsLen];
+ memset(chars, 0, charsLen * sizeof(unichar));
+ while ((startpos + count - idx) >= 6) {
+ long t = 0;
+ for (int i = 0; i < 6; i++) {
+ t <<= 8;
+ t += bytes[idx + i] & 0xff;
+ }
+ for (int i = 0; i < 5; i++) {
+ chars[i] = (unichar) (t % 900);
+ t /= 900;
+ }
+ for (int i = charsLen - 1; i >= 0; i--) {
+ [sb appendFormat:@"%C", chars[i]];
+ }
+ idx += 6;
+ }
+ }
+ //Encode rest (remaining n<5 bytes if any)
+ if (idx < startpos + count) {
+ [sb appendFormat:@"%C", (unichar) LATCH_TO_BYTE_PADDED];
+ }
+ for (int i = idx; i < startpos + count; i++) {
+ int ch = bytes[i] & 0xff;
+ [sb appendFormat:@"%C", (unichar)ch];
+ }
+}
+
++ (void)encodeNumeric:(NSString *)msg startpos:(int)startpos count:(int)count buffer:(NSMutableString *)sb {
+ int idx = 0;
+ NSMutableString *tmp = [NSMutableString stringWithCapacity:count / 3 + 1];
+ while (idx < count - 1) {
+ [tmp setString:@""];
+ int len = MIN(44, count - idx);
+ NSString *part = [@"1" stringByAppendingString:[msg substringWithRange:NSMakeRange(startpos + idx, len)]];
+ long long bigint = [part longLongValue];
+ do {
+ long c = bigint % 900;
+ [tmp appendFormat:@"%C", (unichar) c];
+ bigint /= 900;
+ } while (bigint != 0);
+
+ //Reverse temporary string
+ for (int i = tmp.length - 1; i >= 0; i--) {
+ [tmp appendFormat:@"%C", [tmp characterAtIndex:i]];
+ }
+ idx += len;
+ }
+}
+
++ (BOOL)isDigit:(char)ch {
+ return ch >= '0' && ch <= '9';
+}
+
++ (BOOL)isAlphaUpper:(char)ch {
+ return ch == ' ' || (ch >= 'A' && ch <= 'Z');
+}
+
++ (BOOL)isAlphaLower:(char)ch {
+ return ch == ' ' || (ch >= 'a' && ch <= 'z');
+}
+
++ (BOOL)isMixed:(char)ch {
+ return MIXED_TABLE[ch] != 0xFF;
+}
+
++ (BOOL)isPunctuation:(char)ch {
+ return PUNCTUATION[ch] != 0xFF;
+}
+
++ (BOOL)isText:(char)ch {
+ return ch == '\t' || ch == '\n' || ch == '\r' || (ch >= 32 && ch <= 126);
+}
+
+/**
+ * Determines the number of consecutive characters that are encodable using numeric compaction.
+ */
++ (int)determineConsecutiveDigitCount:(NSString *)msg startpos:(int)startpos {
+ int count = 0;
+ int len = msg.length;
+ int idx = startpos;
+ if (idx < len) {
+ char ch = [msg characterAtIndex:idx];
+ while ([self isDigit:ch] && idx < len) {
+ count++;
+ idx++;
+ if (idx < len) {
+ ch = [msg characterAtIndex:idx];
+ }
+ }
+ }
+ return count;
+}
+
+/**
+ * Determines the number of consecutive characters that are encodable using text compaction.
+ *
+ * @param msg the message
+ * @param startpos the start position within the message
+ * @return the requested character count
+ */
++ (int)determineConsecutiveTextCount:(NSString *)msg startpos:(int)startpos {
+ int len = msg.length;
+ int idx = startpos;
+ while (idx < len) {
+ char ch = [msg characterAtIndex:idx];
+ int numericCount = 0;
+ while (numericCount < 13 && [self isDigit:ch] && idx < len) {
+ numericCount++;
+ idx++;
+ if (idx < len) {
+ ch = [msg characterAtIndex:idx];
+ }
+ }
+ if (numericCount >= 13) {
+ return idx - startpos - numericCount;
+ }
+ if (numericCount > 0) {
+ //Heuristic: All text-encodable chars or digits are binary encodable
+ continue;
+ }
+ ch = [msg characterAtIndex:idx];
+
+ //Check if character is encodable
+ if (![self isText:ch]) {
+ break;
+ }
+ idx++;
+ }
+ return idx - startpos;
+}
+
+/**
+ * Determines the number of consecutive characters that are encodable using binary compaction.
+ */
++ (int)determineConsecutiveBinaryCount:(NSString *)msg bytes:(unsigned char *)bytes startpos:(int)startpos error:(NSError **)error {
+ int len = msg.length;
+ int idx = startpos;
+ while (idx < len) {
+ char ch = [msg characterAtIndex:idx];
+ int numericCount = 0;
+
+ while (numericCount < 13 && [self isDigit:ch]) {
+ numericCount++;
+ //textCount++;
+ int i = idx + numericCount;
+ if (i >= len) {
+ break;
+ }
+ ch = [msg characterAtIndex:i];
+ }
+ if (numericCount >= 13) {
+ return idx - startpos;
+ }
+ int textCount = 0;
+ while (textCount < 5 && [self isText:ch]) {
+ textCount++;
+ int i = idx + textCount;
+ if (i >= len) {
+ break;
+ }
+ ch = [msg characterAtIndex:i];
+ }
+ if (textCount >= 5) {
+ return idx - startpos;
+ }
+ ch = [msg characterAtIndex:idx];
+
+ //Check if character is encodable
+ //Sun returns a ASCII 63 (?) for a character that cannot be mapped. Let's hope all
+ //other VMs do the same
+ if (bytes[idx] == 63 && ch != '?') {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSString stringWithFormat:@"Non-encodable character detected: %c (Unicode: %C)", ch, (unichar)ch]
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return -1;
+ }
+ idx++;
+ }
+ return idx - startpos;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417Writer.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417Writer.h
new file mode 100644
index 0000000000000000000000000000000000000000..669f33015aab5f07ffdd0185c0dcf6de23c912ef
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417Writer.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXCompaction.h"
+#import "ZXWriter.h"
+
+@interface ZXPDF417Writer : NSObject <ZXWriter>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417Writer.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417Writer.m
new file mode 100644
index 0000000000000000000000000000000000000000..084c008a16119ae188cb13f732108bd6f8a2d057
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/pdf417/encoder/ZXPDF417Writer.m
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeMatrix.h"
+#import "ZXBitMatrix.h"
+#import "ZXEncodeHints.h"
+#import "ZXPDF417.h"
+#import "ZXPDF417Writer.h"
+
+@interface ZXPDF417Writer ()
+
+- (ZXBitMatrix *)bitMatrixFromEncoder:(ZXPDF417 *)encoder contents:(NSString *)contents width:(int)width height:(int)height error:(NSError **)error;
+- (ZXBitMatrix *)bitMatrixFrombitArray:(unsigned char **)input height:(int)height width:(int)width;
+- (unsigned char **)rotateArray:(unsigned char **)bitarray height:(int)height width:(int)width;
+
+@end
+
+@implementation ZXPDF417Writer
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height
+ hints:(ZXEncodeHints *)hints error:(NSError **)error {
+ if (format != kBarcodeFormatPDF417) {
+ [NSException raise:NSInvalidArgumentException format:@"Can only encode PDF_417, but got %d", format];
+ }
+
+ ZXPDF417 *encoder = [[[ZXPDF417 alloc] init] autorelease];
+
+ if (hints != nil) {
+ encoder.compact = hints.pdf417Compact;
+ encoder.compaction = hints.pdf417Compaction;
+ if (hints.pdf417Dimensions != nil) {
+ ZXDimensions *dimensions = hints.pdf417Dimensions;
+ [encoder setDimensionsWithMaxCols:dimensions.maxCols
+ minCols:dimensions.minCols
+ maxRows:dimensions.maxRows
+ minRows:dimensions.minRows];
+ }
+ }
+
+ return [self bitMatrixFromEncoder:encoder contents:contents width:width height:height error:error];
+}
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height error:(NSError **)error {
+ return [self encode:contents format:format width:width height:height hints:nil error:error];
+}
+
+/**
+ * Takes encoder, accounts for width/height, and retrieves bit matrix
+ */
+- (ZXBitMatrix *)bitMatrixFromEncoder:(ZXPDF417 *)encoder contents:(NSString *)contents width:(int)width height:(int)height error:(NSError **)error {
+ int errorCorrectionLevel = 2;
+ if (![encoder generateBarcodeLogic:contents errorCorrectionLevel:errorCorrectionLevel error:error]) {
+ return nil;
+ }
+
+ int lineThickness = 2;
+ int aspectRatio = 4;
+
+ int scaleHeight;
+ int scaleWidth;
+ unsigned char **originalScale = [[encoder barcodeMatrix] scaledMatrixWithHeight:&scaleHeight width:&scaleWidth xScale:lineThickness yScale:aspectRatio * lineThickness];
+ BOOL rotated = NO;
+ if ((height > width) ^ (scaleWidth < scaleHeight)) {
+ unsigned char **oldOriginalScale = originalScale;
+ originalScale = [self rotateArray:oldOriginalScale height:scaleHeight width:scaleWidth];
+ free(oldOriginalScale);
+ rotated = YES;
+ }
+
+ int scaleX = width / scaleWidth;
+ int scaleY = height / scaleHeight;
+
+ int scale;
+ if (scaleX < scaleY) {
+ scale = scaleX;
+ } else {
+ scale = scaleY;
+ }
+
+ ZXBitMatrix *result = nil;
+ if (scale > 1) {
+ unsigned char **scaledMatrix =
+ [[encoder barcodeMatrix] scaledMatrixWithHeight:&scaleHeight width:&scaleWidth xScale:scale * lineThickness yScale:scale * aspectRatio * lineThickness];
+ if (rotated) {
+ unsigned char **oldScaledMatrix = scaledMatrix;
+ scaledMatrix = [self rotateArray:scaledMatrix height:scaleHeight width:scaleWidth];
+ free(oldScaledMatrix);
+ }
+ result = [self bitMatrixFrombitArray:scaledMatrix height:scaleHeight width:scaleWidth];
+ free(scaledMatrix);
+ } else {
+ result = [self bitMatrixFrombitArray:originalScale height:scaleHeight width:scaleWidth];
+ }
+ free(originalScale);
+ return result;
+}
+
+/**
+ * This takes an array holding the values of the PDF 417
+ */
+- (ZXBitMatrix *)bitMatrixFrombitArray:(unsigned char **)input height:(int)height width:(int)width {
+ // Creates a small whitespace boarder around the barcode
+ int whiteSpace = 30;
+
+ // Creates the bitmatrix with extra space for whtespace
+ ZXBitMatrix *output = [[[ZXBitMatrix alloc] initWithWidth:width + 2 * whiteSpace height:height + 2 * whiteSpace] autorelease];
+ [output clear];
+ for (int y = 0, yOutput = output.height - whiteSpace; y < height; y++, yOutput--) {
+ for (int x = 0; x < width; x++) {
+ // Zero is white in the bytematrix
+ if (input[y][x] == 1) {
+ [output setX:x + whiteSpace y:yOutput];
+ }
+ }
+ }
+ return output;
+}
+
+/**
+ * Takes and rotates the it 90 degrees
+ */
+- (unsigned char **)rotateArray:(unsigned char **)bitarray height:(int)height width:(int)width {
+ unsigned char **temp = (unsigned char **)malloc(width * sizeof(unsigned char *));
+ for (int ii = 0; ii < height; ii++) {
+ // This makes the direction consistent on screen when rotating the
+ // screen;
+ int inverseii = height - ii - 1;
+ for (int jj = 0; jj < width; jj++) {
+ temp[jj][inverseii] = bitarray[ii][jj];
+ }
+ }
+ return temp;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/ZXQRCodeReader.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/ZXQRCodeReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..dc88a8d428a20542c779bf2bebbd80c13873b1a4
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/ZXQRCodeReader.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXReader.h"
+
+/**
+ * This implementation can detect and decode QR Codes in an image.
+ */
+
+@class ZXBinaryBitmap, ZXQRCodeDecoder, ZXResult;
+
+@interface ZXQRCodeReader : NSObject <ZXReader>
+
+@property (nonatomic, retain, readonly) ZXQRCodeDecoder *decoder;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/ZXQRCodeReader.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/ZXQRCodeReader.m
new file mode 100644
index 0000000000000000000000000000000000000000..5a8e7727e91cac0bb240c2ad885c02eee9915281
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/ZXQRCodeReader.m
@@ -0,0 +1,191 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBarcodeFormat.h"
+#import "ZXBinaryBitmap.h"
+#import "ZXBitMatrix.h"
+#import "ZXDecodeHints.h"
+#import "ZXDecoderResult.h"
+#import "ZXDetectorResult.h"
+#import "ZXErrors.h"
+#import "ZXQRCodeDecoder.h"
+#import "ZXQRCodeDetector.h"
+#import "ZXQRCodeReader.h"
+#import "ZXResult.h"
+
+@interface ZXQRCodeReader ()
+
+@property (nonatomic, retain) ZXQRCodeDecoder *decoder;
+
+- (ZXBitMatrix *)extractPureBits:(ZXBitMatrix *)image;
+- (float)moduleSize:(NSArray *)leftTopBlack image:(ZXBitMatrix *)image;
+
+@end
+
+@implementation ZXQRCodeReader
+
+@synthesize decoder;
+
+- (id)init {
+ if (self = [super init]) {
+ self.decoder = [[[ZXQRCodeDecoder alloc] init] autorelease];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [decoder release];
+
+ [super dealloc];
+}
+
+/**
+ * Locates and decodes a QR code in an image.
+ */
+- (ZXResult *)decode:(ZXBinaryBitmap *)image error:(NSError **)error {
+ return [self decode:image hints:nil error:error];
+}
+
+- (ZXResult *)decode:(ZXBinaryBitmap *)image hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ ZXDecoderResult *decoderResult;
+ NSArray *points;
+ ZXBitMatrix *matrix = [image blackMatrixWithError:error];
+ if (!matrix) {
+ return nil;
+ }
+ if (hints != nil && hints.pureBarcode) {
+ ZXBitMatrix *bits = [self extractPureBits:matrix];
+ if (!bits) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ decoderResult = [decoder decodeMatrix:bits hints:hints error:error];
+ if (!decoderResult) {
+ return nil;
+ }
+ points = [NSArray array];
+ } else {
+ ZXDetectorResult *detectorResult = [[[[ZXQRCodeDetector alloc] initWithImage:matrix] autorelease] detect:hints error:error];
+ if (!detectorResult) {
+ return nil;
+ }
+ decoderResult = [decoder decodeMatrix:[detectorResult bits] hints:hints error:error];
+ if (!decoderResult) {
+ return nil;
+ }
+ points = [detectorResult points];
+ }
+
+ ZXResult *result = [ZXResult resultWithText:decoderResult.text
+ rawBytes:decoderResult.rawBytes
+ length:decoderResult.length
+ resultPoints:points
+ format:kBarcodeFormatQRCode];
+ NSMutableArray *byteSegments = decoderResult.byteSegments;
+ if (byteSegments != nil) {
+ [result putMetadata:kResultMetadataTypeByteSegments value:byteSegments];
+ }
+ NSString *ecLevel = decoderResult.ecLevel;
+ if (ecLevel != nil) {
+ [result putMetadata:kResultMetadataTypeErrorCorrectionLevel value:ecLevel];
+ }
+ return result;
+}
+
+- (void)reset {
+ // do nothing
+}
+
+
+/**
+ * This method detects a code in a "pure" image -- that is, pure monochrome image
+ * which contains only an unrotated, unskewed, image of a code, with some white border
+ * around it. This is a specialized method that works exceptionally fast in this special
+ * case.
+ */
+- (ZXBitMatrix *)extractPureBits:(ZXBitMatrix *)image {
+ NSArray *leftTopBlack = image.topLeftOnBit;
+ NSArray *rightBottomBlack = image.bottomRightOnBit;
+ if (leftTopBlack == nil || rightBottomBlack == nil) {
+ return nil;
+ }
+
+ float moduleSize = [self moduleSize:leftTopBlack image:image];
+ if (moduleSize == -1) {
+ return nil;
+ }
+
+ int top = [[leftTopBlack objectAtIndex:1] intValue];
+ int bottom = [[rightBottomBlack objectAtIndex:1] intValue];
+ int left = [[leftTopBlack objectAtIndex:0] intValue];
+ int right = [[rightBottomBlack objectAtIndex:0] intValue];
+
+ if (bottom - top != right - left) {
+ // Special case, where bottom-right module wasn't black so we found something else in the last row
+ // Assume it's a square, so use height as the width
+ right = left + (bottom - top);
+ }
+
+ int matrixWidth = round((right - left + 1) / moduleSize);
+ int matrixHeight = round((bottom - top + 1) / moduleSize);
+ if (matrixWidth <= 0 || matrixHeight <= 0) {
+ return nil;
+ }
+ if (matrixHeight != matrixWidth) {
+ return nil;
+ }
+
+ int nudge = (int) (moduleSize / 2.0f);
+ top += nudge;
+ left += nudge;
+
+ ZXBitMatrix *bits = [[[ZXBitMatrix alloc] initWithWidth:matrixWidth height:matrixHeight] autorelease];
+ for (int y = 0; y < matrixHeight; y++) {
+ int iOffset = top + (int) (y * moduleSize);
+ for (int x = 0; x < matrixWidth; x++) {
+ if ([image getX:left + (int) (x * moduleSize) y:iOffset]) {
+ [bits setX:x y:y];
+ }
+ }
+ }
+ return bits;
+}
+
+- (float)moduleSize:(NSArray *)leftTopBlack image:(ZXBitMatrix *)image {
+ int height = image.height;
+ int width = image.width;
+ int x = [[leftTopBlack objectAtIndex:0] intValue];
+ int y = [[leftTopBlack objectAtIndex:1] intValue];
+ BOOL inBlack = YES;
+ int transitions = 0;
+ while (x < width && y < height) {
+ if (inBlack != [image getX:x y:y]) {
+ if (++transitions == 5) {
+ break;
+ }
+ }
+ x++;
+ y++;
+ }
+ if (x == width || y == height) {
+ return -1;
+ }
+
+ return (x - [[leftTopBlack objectAtIndex:0] intValue]) / 7.0f;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/ZXQRCodeWriter.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/ZXQRCodeWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..e114ee3050d168007958af11f5198ac7bf3852a2
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/ZXQRCodeWriter.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXWriter.h"
+
+/**
+ * This object renders a QR Code as a BitMatrix 2D array of greyscale values.
+ */
+
+@interface ZXQRCodeWriter : NSObject <ZXWriter>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/ZXQRCodeWriter.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/ZXQRCodeWriter.m
new file mode 100644
index 0000000000000000000000000000000000000000..61d8791116b03f205d6f6399d6c4eb9ec7ce5caf
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/ZXQRCodeWriter.m
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXByteMatrix.h"
+#import "ZXEncodeHints.h"
+#import "ZXEncoder.h"
+#import "ZXErrorCorrectionLevel.h"
+#import "ZXQRCode.h"
+#import "ZXQRCodeWriter.h"
+
+int const QUIET_ZONE_SIZE = 4;
+
+@interface ZXQRCodeWriter ()
+
+- (ZXBitMatrix *)renderResult:(ZXQRCode *)code width:(int)width height:(int)height quietZone:(int)quietZone;
+
+@end
+
+@implementation ZXQRCodeWriter
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height error:(NSError **)error {
+ return [self encode:contents format:format width:width height:height hints:nil error:error];
+}
+
+- (ZXBitMatrix *)encode:(NSString *)contents format:(ZXBarcodeFormat)format width:(int)width height:(int)height hints:(ZXEncodeHints *)hints error:(NSError **)error {
+ if ([contents length] == 0) {
+ [NSException raise:NSInvalidArgumentException format:@"Found empty contents"];
+ }
+
+ if (format != kBarcodeFormatQRCode) {
+ [NSException raise:NSInvalidArgumentException format:@"Can only encode QR_CODE"];
+ }
+
+ if (width < 0 || height < 0) {
+ [NSException raise:NSInvalidArgumentException format:@"Requested dimensions are too small: %dx%d", width, height];
+ }
+
+ ZXErrorCorrectionLevel *errorCorrectionLevel = [ZXErrorCorrectionLevel errorCorrectionLevelL];
+ int quietZone = QUIET_ZONE_SIZE;
+ if (hints != nil) {
+ if (hints.errorCorrectionLevel) {
+ errorCorrectionLevel = hints.errorCorrectionLevel;
+ }
+ if (hints.margin) {
+ quietZone = [hints.margin intValue];
+ }
+ }
+
+ ZXQRCode *code = [ZXEncoder encode:contents ecLevel:errorCorrectionLevel hints:hints error:error];
+ return [self renderResult:code width:width height:height quietZone:quietZone];
+}
+
+- (ZXBitMatrix *)renderResult:(ZXQRCode *)code width:(int)width height:(int)height quietZone:(int)quietZone {
+ ZXByteMatrix *input = code.matrix;
+ if (input == nil) {
+ return nil;
+ }
+ int inputWidth = input.width;
+ int inputHeight = input.height;
+ int qrWidth = inputWidth + (quietZone << 1);
+ int qrHeight = inputHeight + (quietZone << 1);
+ int outputWidth = MAX(width, qrWidth);
+ int outputHeight = MAX(height, qrHeight);
+
+ int multiple = MIN(outputWidth / qrWidth, outputHeight / qrHeight);
+ // Padding includes both the quiet zone and the extra white pixels to accommodate the requested
+ // dimensions. For example, if input is 25x25 the QR will be 33x33 including the quiet zone.
+ // If the requested size is 200x160, the multiple will be 4, for a QR of 132x132. These will
+ // handle all the padding from 100x100 (the actual QR) up to 200x160.
+ int leftPadding = (outputWidth - (inputWidth * multiple)) / 2;
+ int topPadding = (outputHeight - (inputHeight * multiple)) / 2;
+
+ ZXBitMatrix *output = [[[ZXBitMatrix alloc] initWithWidth:outputWidth height:outputHeight] autorelease];
+
+ for (int inputY = 0, outputY = topPadding; inputY < inputHeight; inputY++, outputY += multiple) {
+ for (int inputX = 0, outputX = leftPadding; inputX < inputWidth; inputX++, outputX += multiple) {
+ if ([input getX:inputX y:inputY] == 1) {
+ [output setRegionAtLeft:outputX top:outputY width:multiple height:multiple];
+ }
+ }
+ }
+
+ return output;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXDataMask.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXDataMask.h
new file mode 100644
index 0000000000000000000000000000000000000000..325abe4110b9e3871b3377d153ce2021668db023
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXDataMask.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates data masks for the data bits in a QR code, per ISO 18004:2006 6.8. Implementations
+ * of this class can un-mask a raw BitMatrix. For simplicity, they will unmask the entire BitMatrix,
+ * including areas used for finder patterns, timing patterns, etc. These areas should be unused
+ * after the point they are unmasked anyway.
+ *
+ * Note that the diagram in section 6.8.1 is misleading since it indicates that i is column position
+ * and j is row position. In fact, as the text says, i is row position and j is column position.
+ */
+
+@class ZXBitMatrix;
+
+@interface ZXDataMask : NSObject
+
+- (void)unmaskBitMatrix:(ZXBitMatrix *)bits dimension:(int)dimension;
+- (BOOL)isMasked:(int)i j:(int)j;
++ (ZXDataMask *)forReference:(int)reference;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXDataMask.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXDataMask.m
new file mode 100644
index 0000000000000000000000000000000000000000..c0e6aaf6abec1166d73842516d17ef78f3fdecd9
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXDataMask.m
@@ -0,0 +1,205 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXDataMask.h"
+
+/**
+ * 000: mask bits for which (x + y) mod 2 == 0
+ */
+
+@interface ZXDataMask000 : ZXDataMask
+
+@end
+
+@implementation ZXDataMask000
+
+- (BOOL)isMasked:(int)i j:(int)j {
+ return ((i + j) & 0x01) == 0;
+}
+
+@end
+
+
+/**
+ * 001: mask bits for which x mod 2 == 0
+ */
+
+@interface ZXDataMask001 : ZXDataMask
+
+@end
+
+@implementation ZXDataMask001
+
+- (BOOL)isMasked:(int)i j:(int)j {
+ return (i & 0x01) == 0;
+}
+
+@end
+
+
+/**
+ * 010: mask bits for which y mod 3 == 0
+ */
+
+@interface ZXDataMask010 : ZXDataMask
+
+@end
+
+@implementation ZXDataMask010
+
+- (BOOL)isMasked:(int)i j:(int)j {
+ return j % 3 == 0;
+}
+
+@end
+
+
+/**
+ * 011: mask bits for which (x + y) mod 3 == 0
+ */
+
+@interface ZXDataMask011 : ZXDataMask
+
+@end
+
+@implementation ZXDataMask011
+
+- (BOOL)isMasked:(int)i j:(int)j {
+ return (i + j) % 3 == 0;
+}
+
+@end
+
+
+/**
+ * 100: mask bits for which (x/2 + y/3) mod 2 == 0
+ */
+
+@interface ZXDataMask100 : ZXDataMask
+
+@end
+
+@implementation ZXDataMask100
+
+- (BOOL)isMasked:(int)i j:(int)j {
+ return (((int)((unsigned int)i >> 1) + (j / 3)) & 0x01) == 0;
+}
+
+@end
+
+
+/**
+ * 101: mask bits for which xy mod 2 + xy mod 3 == 0
+ */
+
+@interface ZXDataMask101 : ZXDataMask
+
+@end
+
+@implementation ZXDataMask101
+
+- (BOOL)isMasked:(int)i j:(int)j {
+ int temp = i * j;
+ return (temp & 0x01) + (temp % 3) == 0;
+}
+
+@end
+
+
+/**
+ * 110: mask bits for which (xy mod 2 + xy mod 3) mod 2 == 0
+ */
+
+@interface ZXDataMask110 : ZXDataMask
+
+@end
+
+@implementation ZXDataMask110
+
+- (BOOL)isMasked:(int)i j:(int)j {
+ int temp = i * j;
+ return (((temp & 0x01) + (temp % 3)) & 0x01) == 0;
+}
+
+@end
+
+
+/**
+ * 111: mask bits for which ((x+y)mod 2 + xy mod 3) mod 2 == 0
+ */
+
+@interface ZXDataMask111 : ZXDataMask
+
+@end
+
+@implementation ZXDataMask111
+
+- (BOOL)isMasked:(int)i j:(int)j {
+ return ((((i + j) & 0x01) + ((i * j) % 3)) & 0x01) == 0;
+}
+
+@end
+
+
+@implementation ZXDataMask
+
+static NSArray *DATA_MASKS = nil;
+
+/**
+ * Implementations of this method reverse the data masking process applied to a QR Code and
+ * make its bits ready to read.
+ */
+- (void)unmaskBitMatrix:(ZXBitMatrix *)bits dimension:(int)dimension {
+ for (int i = 0; i < dimension; i++) {
+ for (int j = 0; j < dimension; j++) {
+ if ([self isMasked:i j:j]) {
+ [bits flipX:j y:i];
+ }
+ }
+ }
+}
+
+- (BOOL)isMasked:(int)i j:(int)j {
+ @throw [NSException exceptionWithName:NSInternalInconsistencyException
+ reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
+ userInfo:nil];
+}
+
+
++ (ZXDataMask *)forReference:(int)reference {
+ if (!DATA_MASKS) {
+ /**
+ * See ISO 18004:2006 6.8.1
+ */
+ DATA_MASKS = [[NSArray alloc] initWithObjects:
+ [[[ZXDataMask000 alloc] init] autorelease],
+ [[[ZXDataMask001 alloc] init] autorelease],
+ [[[ZXDataMask010 alloc] init] autorelease],
+ [[[ZXDataMask011 alloc] init] autorelease],
+ [[[ZXDataMask100 alloc] init] autorelease],
+ [[[ZXDataMask101 alloc] init] autorelease],
+ [[[ZXDataMask110 alloc] init] autorelease],
+ [[[ZXDataMask111 alloc] init] autorelease], nil];
+ }
+
+ if (reference < 0 || reference > 7) {
+ [NSException raise:NSInvalidArgumentException format:@"Invalid reference value"];
+ }
+ return [DATA_MASKS objectAtIndex:reference];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXErrorCorrectionLevel.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXErrorCorrectionLevel.h
new file mode 100644
index 0000000000000000000000000000000000000000..b632d226ef428ffea1a39417fe9588b4fd68101c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXErrorCorrectionLevel.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * See ISO 18004:2006, 6.5.1. This enum encapsulates the four error correction levels
+ * defined by the QR code standard.
+ */
+
+@interface ZXErrorCorrectionLevel : NSObject
+
+@property (nonatomic, assign, readonly) int bits;
+@property (nonatomic, copy, readonly) NSString *name;
+@property (nonatomic, assign, readonly) int ordinal;
+
+- (id)initWithOrdinal:(int)anOrdinal bits:(int)theBits name:(NSString *)aName;
++ (ZXErrorCorrectionLevel *)forBits:(int)bits;
+
+/**
+ * L = ~7% correction
+ */
++ (ZXErrorCorrectionLevel *)errorCorrectionLevelL;
+
+/**
+ * M = ~15% correction
+ */
++ (ZXErrorCorrectionLevel *)errorCorrectionLevelM;
+
+/**
+ * Q = ~25% correction
+ */
++ (ZXErrorCorrectionLevel *)errorCorrectionLevelQ;
+
+/**
+ * H = ~30% correction
+ */
++ (ZXErrorCorrectionLevel *)errorCorrectionLevelH;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXErrorCorrectionLevel.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXErrorCorrectionLevel.m
new file mode 100644
index 0000000000000000000000000000000000000000..2aa466dbc83d2c45804b23b6a517c83cb6ad8b5b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXErrorCorrectionLevel.m
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXErrorCorrectionLevel.h"
+
+@interface ZXErrorCorrectionLevel ()
+
+@property (nonatomic, assign) int bits;
+@property (nonatomic, copy) NSString *name;
+@property (nonatomic, assign) int ordinal;
+
+@end
+
+@implementation ZXErrorCorrectionLevel
+
+static NSArray *FOR_BITS = nil;
+
+@synthesize bits;
+@synthesize name;
+@synthesize ordinal;
+
+- (id)initWithOrdinal:(int)anOrdinal bits:(int)theBits name:(NSString *)aName {
+ if (self = [super init]) {
+ self.ordinal = anOrdinal;
+ self.bits = theBits;
+ self.name = aName;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [name release];
+
+ [super dealloc];
+}
+
+- (NSString *)description {
+ return self.name;
+}
+
+
++ (ZXErrorCorrectionLevel *)forBits:(int)bits {
+ if (!FOR_BITS) {
+ FOR_BITS = [[NSArray alloc] initWithObjects:[ZXErrorCorrectionLevel errorCorrectionLevelM],
+ [ZXErrorCorrectionLevel errorCorrectionLevelL], [ZXErrorCorrectionLevel errorCorrectionLevelH],
+ [ZXErrorCorrectionLevel errorCorrectionLevelQ], nil];
+ }
+
+ if (bits < 0 || bits >= [FOR_BITS count]) {
+ @throw [NSException exceptionWithName:NSInvalidArgumentException
+ reason:@"Invalid bits"
+ userInfo:nil];
+ }
+ return [FOR_BITS objectAtIndex:bits];
+}
+
+/**
+ * L = ~7% correction
+ */
++ (ZXErrorCorrectionLevel *)errorCorrectionLevelL {
+ static ZXErrorCorrectionLevel *thisLevel = nil;
+ if (!thisLevel) {
+ thisLevel = [[ZXErrorCorrectionLevel alloc] initWithOrdinal:0 bits:0x01 name:@"L"];
+ }
+ return thisLevel;
+}
+
+/**
+ * M = ~15% correction
+ */
++ (ZXErrorCorrectionLevel *)errorCorrectionLevelM {
+ static ZXErrorCorrectionLevel *thisLevel = nil;
+ if (!thisLevel) {
+ thisLevel = [[ZXErrorCorrectionLevel alloc] initWithOrdinal:1 bits:0x00 name:@"M"];
+ }
+ return thisLevel;
+}
+
+/**
+ * Q = ~25% correction
+ */
++ (ZXErrorCorrectionLevel *)errorCorrectionLevelQ {
+ static ZXErrorCorrectionLevel *thisLevel = nil;
+ if (!thisLevel) {
+ thisLevel = [[ZXErrorCorrectionLevel alloc] initWithOrdinal:2 bits:0x03 name:@"Q"];
+ }
+ return thisLevel;
+}
+
+/**
+ * H = ~30% correction
+ */
++ (ZXErrorCorrectionLevel *)errorCorrectionLevelH {
+ static ZXErrorCorrectionLevel *thisLevel = nil;
+ if (!thisLevel) {
+ thisLevel = [[ZXErrorCorrectionLevel alloc] initWithOrdinal:3 bits:0x02 name:@"H"];
+ }
+ return thisLevel;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXFormatInformation.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXFormatInformation.h
new file mode 100644
index 0000000000000000000000000000000000000000..f9780ef8633d8cff9f90bebe57abc9671a485dcc
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXFormatInformation.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates a QR Code's format information, including the data mask used and
+ * error correction level.
+ */
+
+@class ZXErrorCorrectionLevel;
+
+@interface ZXFormatInformation : NSObject
+
+@property (nonatomic, retain, readonly) ZXErrorCorrectionLevel *errorCorrectionLevel;
+@property (nonatomic, assign, readonly) char dataMask;
+
++ (int)numBitsDiffering:(int)a b:(int)b;
++ (ZXFormatInformation *)decodeFormatInformation:(int)maskedFormatInfo1 maskedFormatInfo2:(int)maskedFormatInfo2;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXFormatInformation.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXFormatInformation.m
new file mode 100644
index 0000000000000000000000000000000000000000..d0fcfcd6f15a23d70113047c8fe7aa75198328d2
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXFormatInformation.m
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXErrorCorrectionLevel.h"
+#import "ZXFormatInformation.h"
+
+int const FORMAT_INFO_MASK_QR = 0x5412;
+
+/**
+ * See ISO 18004:2006, Annex C, Table C.1
+ */
+int const FORMAT_INFO_DECODE_LOOKUP_LEN = 32;
+int const FORMAT_INFO_DECODE_LOOKUP[FORMAT_INFO_DECODE_LOOKUP_LEN][2] = {
+ {0x5412, 0x00},
+ {0x5125, 0x01},
+ {0x5E7C, 0x02},
+ {0x5B4B, 0x03},
+ {0x45F9, 0x04},
+ {0x40CE, 0x05},
+ {0x4F97, 0x06},
+ {0x4AA0, 0x07},
+ {0x77C4, 0x08},
+ {0x72F3, 0x09},
+ {0x7DAA, 0x0A},
+ {0x789D, 0x0B},
+ {0x662F, 0x0C},
+ {0x6318, 0x0D},
+ {0x6C41, 0x0E},
+ {0x6976, 0x0F},
+ {0x1689, 0x10},
+ {0x13BE, 0x11},
+ {0x1CE7, 0x12},
+ {0x19D0, 0x13},
+ {0x0762, 0x14},
+ {0x0255, 0x15},
+ {0x0D0C, 0x16},
+ {0x083B, 0x17},
+ {0x355F, 0x18},
+ {0x3068, 0x19},
+ {0x3F31, 0x1A},
+ {0x3A06, 0x1B},
+ {0x24B4, 0x1C},
+ {0x2183, 0x1D},
+ {0x2EDA, 0x1E},
+ {0x2BED, 0x1F},
+};
+
+/**
+ * Offset i holds the number of 1 bits in the binary representation of i
+ */
+int const BITS_SET_IN_HALF_BYTE[16] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
+
+@interface ZXFormatInformation ()
+
+@property (nonatomic, retain) ZXErrorCorrectionLevel *errorCorrectionLevel;
+@property (nonatomic, assign) char dataMask;
+
++ (ZXFormatInformation *)doDecodeFormatInformation:(int)maskedFormatInfo1 maskedFormatInfo2:(int)maskedFormatInfo2;
+
+@end
+
+@implementation ZXFormatInformation
+
+@synthesize dataMask;
+@synthesize errorCorrectionLevel;
+
+- (id)initWithFormatInfo:(int)formatInfo {
+ if (self = [super init]) {
+ self.errorCorrectionLevel = [ZXErrorCorrectionLevel forBits:(formatInfo >> 3) & 0x03];
+ self.dataMask = (char)(formatInfo & 0x07);
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [errorCorrectionLevel release];
+
+ [super dealloc];
+}
+
++ (int)numBitsDiffering:(int)a b:(int)b {
+ a ^= b;
+ return BITS_SET_IN_HALF_BYTE[a & 0x0F] +
+ BITS_SET_IN_HALF_BYTE[((int)((unsigned int)a) >> 4 & 0x0F)] +
+ BITS_SET_IN_HALF_BYTE[((int)((unsigned int)a) >> 8 & 0x0F)] +
+ BITS_SET_IN_HALF_BYTE[((int)((unsigned int)a) >> 12 & 0x0F)] +
+ BITS_SET_IN_HALF_BYTE[((int)((unsigned int)a) >> 16 & 0x0F)] +
+ BITS_SET_IN_HALF_BYTE[((int)((unsigned int)a) >> 20 & 0x0F)] +
+ BITS_SET_IN_HALF_BYTE[((int)((unsigned int)a) >> 24 & 0x0F)] +
+ BITS_SET_IN_HALF_BYTE[((int)((unsigned int)a) >> 28 & 0x0F)];
+}
+
++ (ZXFormatInformation *)decodeFormatInformation:(int)maskedFormatInfo1 maskedFormatInfo2:(int)maskedFormatInfo2 {
+ ZXFormatInformation *formatInfo = [self doDecodeFormatInformation:maskedFormatInfo1 maskedFormatInfo2:maskedFormatInfo2];
+ if (formatInfo != nil) {
+ return formatInfo;
+ }
+ return [self doDecodeFormatInformation:maskedFormatInfo1 ^ FORMAT_INFO_MASK_QR maskedFormatInfo2:maskedFormatInfo2 ^ FORMAT_INFO_MASK_QR];
+}
+
++ (ZXFormatInformation *)doDecodeFormatInformation:(int)maskedFormatInfo1 maskedFormatInfo2:(int)maskedFormatInfo2 {
+ int bestDifference = NSIntegerMax;
+ int bestFormatInfo = 0;
+
+ for (int i = 0; i < FORMAT_INFO_DECODE_LOOKUP_LEN; i++) {
+ int targetInfo = FORMAT_INFO_DECODE_LOOKUP[i][0];
+ if (targetInfo == maskedFormatInfo1 || targetInfo == maskedFormatInfo2) {
+ return [[[ZXFormatInformation alloc] initWithFormatInfo:FORMAT_INFO_DECODE_LOOKUP[i][1]] autorelease];
+ }
+ int bitsDifference = [self numBitsDiffering:maskedFormatInfo1 b:targetInfo];
+ if (bitsDifference < bestDifference) {
+ bestFormatInfo = FORMAT_INFO_DECODE_LOOKUP[i][1];
+ bestDifference = bitsDifference;
+ }
+ if (maskedFormatInfo1 != maskedFormatInfo2) {
+ bitsDifference = [self numBitsDiffering:maskedFormatInfo2 b:targetInfo];
+ if (bitsDifference < bestDifference) {
+ bestFormatInfo = FORMAT_INFO_DECODE_LOOKUP[i][1];
+ bestDifference = bitsDifference;
+ }
+ }
+ }
+
+ if (bestDifference <= 3) {
+ return [[[ZXFormatInformation alloc] initWithFormatInfo:bestFormatInfo] autorelease];
+ }
+ return nil;
+}
+
+- (NSUInteger)hash {
+ return (self.errorCorrectionLevel.ordinal << 3) | (int)self.dataMask;
+}
+
+- (BOOL)isEqual:(id)o {
+ if (![o isKindOfClass:[ZXFormatInformation class]]) {
+ return NO;
+ }
+ ZXFormatInformation *other = (ZXFormatInformation *)o;
+ return self.errorCorrectionLevel == other.errorCorrectionLevel && self.dataMask == other.dataMask;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXMode.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXMode.h
new file mode 100644
index 0000000000000000000000000000000000000000..7ab27e173e2bddb4ae09245145f63934042170c9
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXMode.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * See ISO 18004:2006, 6.4.1, Tables 2 and 3. This enum encapsulates the various modes in which
+ * data can be encoded to bits in the QR code standard.
+ */
+
+@class ZXQRCodeVersion;
+
+@interface ZXMode : NSObject
+
+@property (nonatomic, assign, readonly) int bits;
+@property (nonatomic, copy, readonly) NSString *name;
+
+- (id)initWithCharacterCountBitsForVersions:(NSArray *)characterCountBitsForVersions
+ bits:(int)bits
+ name:(NSString *)name;
++ (ZXMode *)forBits:(int)bits;
+- (int)characterCountBits:(ZXQRCodeVersion *)version;
+
++ (ZXMode *)terminatorMode; // Not really a mode...
++ (ZXMode *)numericMode;
++ (ZXMode *)alphanumericMode;
++ (ZXMode *)structuredAppendMode; // Not supported
++ (ZXMode *)byteMode;
++ (ZXMode *)eciMode; // character counts don't apply
++ (ZXMode *)kanjiMode;
++ (ZXMode *)fnc1FirstPositionMode;
++ (ZXMode *)fnc1SecondPositionMode;
+
+/** See GBT 18284-2000; "Hanzi" is a transliteration of this mode name. */
++ (ZXMode *)hanziMode;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXMode.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXMode.m
new file mode 100644
index 0000000000000000000000000000000000000000..7705f69042a594a324e30de78c589e8565148872
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXMode.m
@@ -0,0 +1,230 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXMode.h"
+#import "ZXQRCodeVersion.h"
+
+@interface ZXMode ()
+
+@property (nonatomic, assign) int bits;
+@property (nonatomic, retain) NSArray *characterCountBitsForVersions;
+@property (nonatomic, copy) NSString *name;
+
+@end
+
+@implementation ZXMode
+
+@synthesize bits;
+@synthesize characterCountBitsForVersions;
+@synthesize name;
+
+- (id)initWithCharacterCountBitsForVersions:(NSArray *)aCharacterCountBitsForVersions
+ bits:(int)aBits
+ name:(NSString *)aName {
+ if (self = [super init]) {
+ self.characterCountBitsForVersions = aCharacterCountBitsForVersions;
+ self.bits = aBits;
+ self.name = aName;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [characterCountBitsForVersions release];
+ [name release];
+
+ [super dealloc];
+}
+
++ (ZXMode *)forBits:(int)bits {
+ switch (bits) {
+ case 0x0:
+ return [ZXMode terminatorMode];
+ case 0x1:
+ return [ZXMode numericMode];
+ case 0x2:
+ return [ZXMode alphanumericMode];
+ case 0x3:
+ return [ZXMode structuredAppendMode];
+ case 0x4:
+ return [ZXMode byteMode];
+ case 0x5:
+ return [ZXMode fnc1FirstPositionMode];
+ case 0x7:
+ return [ZXMode eciMode];
+ case 0x8:
+ return [ZXMode kanjiMode];
+ case 0x9:
+ return [ZXMode fnc1SecondPositionMode];
+ case 0xD:
+ return [ZXMode hanziMode];
+ default:
+ return nil;
+ }
+}
+
+- (int)characterCountBits:(ZXQRCodeVersion *)version {
+ int number = version.versionNumber;
+ int offset;
+ if (number <= 9) {
+ offset = 0;
+ } else if (number <= 26) {
+ offset = 1;
+ } else {
+ offset = 2;
+ }
+ return [[self.characterCountBitsForVersions objectAtIndex:offset] intValue];
+}
+
+- (NSString *)description {
+ return self.name;
+}
+
++ (ZXMode *)terminatorMode {
+ static ZXMode *thisMode = nil;
+ if (!thisMode) {
+ thisMode = [[ZXMode alloc] initWithCharacterCountBitsForVersions:[NSArray arrayWithObjects:
+ [NSNumber numberWithInt:0],
+ [NSNumber numberWithInt:0],
+ [NSNumber numberWithInt:0], nil]
+ bits:0x00
+ name:@"TERMINATOR"];
+ }
+ return thisMode;
+}
+
++ (ZXMode *)numericMode {
+ static ZXMode *thisMode = nil;
+ if (!thisMode) {
+ thisMode = [[ZXMode alloc] initWithCharacterCountBitsForVersions:[NSArray arrayWithObjects:
+ [NSNumber numberWithInt:10],
+ [NSNumber numberWithInt:12],
+ [NSNumber numberWithInt:14], nil]
+ bits:0x01
+ name:@"NUMERIC"];
+ }
+ return thisMode;
+}
+
++ (ZXMode *)alphanumericMode {
+ static ZXMode *thisMode = nil;
+ if (!thisMode) {
+ thisMode = [[ZXMode alloc] initWithCharacterCountBitsForVersions:[NSArray arrayWithObjects:
+ [NSNumber numberWithInt:9],
+ [NSNumber numberWithInt:11],
+ [NSNumber numberWithInt:13], nil]
+ bits:0x02
+ name:@"ALPHANUMERIC"];
+ }
+ return thisMode;
+}
+
++ (ZXMode *)structuredAppendMode {
+ static ZXMode *thisMode = nil;
+ if (!thisMode) {
+ thisMode = [[ZXMode alloc] initWithCharacterCountBitsForVersions:[NSArray arrayWithObjects:
+ [NSNumber numberWithInt:0],
+ [NSNumber numberWithInt:0],
+ [NSNumber numberWithInt:0], nil]
+ bits:0x03
+ name:@"STRUCTURED_APPEND"];
+ }
+ return thisMode;
+}
+
++ (ZXMode *)byteMode {
+ static ZXMode *thisMode = nil;
+ if (!thisMode) {
+ thisMode = [[ZXMode alloc] initWithCharacterCountBitsForVersions:[NSArray arrayWithObjects:
+ [NSNumber numberWithInt:8],
+ [NSNumber numberWithInt:16],
+ [NSNumber numberWithInt:16], nil]
+ bits:0x04
+ name:@"BYTE"];
+ }
+ return thisMode;
+}
+
++ (ZXMode *)eciMode {
+ static ZXMode *thisMode = nil;
+ if (!thisMode) {
+ thisMode = [[ZXMode alloc] initWithCharacterCountBitsForVersions:[NSArray arrayWithObjects:
+ [NSNumber numberWithInt:0],
+ [NSNumber numberWithInt:0],
+ [NSNumber numberWithInt:0], nil]
+ bits:0x07
+ name:@"ECI"];
+ }
+ return thisMode;
+}
+
++ (ZXMode *)kanjiMode {
+ static ZXMode *thisMode = nil;
+ if (!thisMode) {
+ thisMode = [[ZXMode alloc] initWithCharacterCountBitsForVersions:[NSArray arrayWithObjects:
+ [NSNumber numberWithInt:8],
+ [NSNumber numberWithInt:10],
+ [NSNumber numberWithInt:12], nil]
+ bits:0x08
+ name:@"KANJI"];
+ }
+ return thisMode;
+}
+
++ (ZXMode *)fnc1FirstPositionMode {
+ static ZXMode *thisMode = nil;
+ if (!thisMode) {
+ thisMode = [[ZXMode alloc] initWithCharacterCountBitsForVersions:[NSArray arrayWithObjects:
+ [NSNumber numberWithInt:0],
+ [NSNumber numberWithInt:0],
+ [NSNumber numberWithInt:0], nil]
+ bits:0x05
+ name:@"FNC1_FIRST_POSITION"];
+ }
+ return thisMode;
+}
+
++ (ZXMode *)fnc1SecondPositionMode {
+ static ZXMode *thisMode = nil;
+ if (!thisMode) {
+ thisMode = [[ZXMode alloc] initWithCharacterCountBitsForVersions:[NSArray arrayWithObjects:
+ [NSNumber numberWithInt:0],
+ [NSNumber numberWithInt:0],
+ [NSNumber numberWithInt:0], nil]
+ bits:0x09
+ name:@"FNC1_SECOND_POSITION"];
+ }
+ return thisMode;
+}
+
+/**
+ * See GBT 18284-2000; "Hanzi" is a transliteration of this mode name.
+ */
++ (ZXMode *)hanziMode {
+ static ZXMode *thisMode = nil;
+ if (!thisMode) {
+ thisMode = [[ZXMode alloc] initWithCharacterCountBitsForVersions:[NSArray arrayWithObjects:
+ [NSNumber numberWithInt:8],
+ [NSNumber numberWithInt:10],
+ [NSNumber numberWithInt:12], nil]
+ bits:0x0D
+ name:@"HANZI"];
+ }
+ return thisMode;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeBitMatrixParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeBitMatrixParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..9382d702970831c33f26e03f2f229518e2afda71
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeBitMatrixParser.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXBitMatrix, ZXFormatInformation, ZXQRCodeVersion;
+
+@interface ZXQRCodeBitMatrixParser : NSObject
+
+- (id)initWithBitMatrix:(ZXBitMatrix *)bitMatrix error:(NSError **)error;
+- (ZXFormatInformation *)readFormatInformationWithError:(NSError **)error;
+- (ZXQRCodeVersion *)readVersionWithError:(NSError **)error;
+- (NSArray *)readCodewordsWithError:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeBitMatrixParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeBitMatrixParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..2e5059643e15fb5352caf8a8deb66254a4319d70
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeBitMatrixParser.m
@@ -0,0 +1,216 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXDataMask.h"
+#import "ZXErrors.h"
+#import "ZXFormatInformation.h"
+#import "ZXQRCodeBitMatrixParser.h"
+#import "ZXQRCodeVersion.h"
+
+@interface ZXQRCodeBitMatrixParser ()
+
+@property (nonatomic, retain) ZXBitMatrix *bitMatrix;
+@property (nonatomic, retain) ZXFormatInformation *parsedFormatInfo;
+@property (nonatomic, retain) ZXQRCodeVersion *parsedVersion;
+
+- (int)copyBit:(int)i j:(int)j versionBits:(int)versionBits;
+
+@end
+
+@implementation ZXQRCodeBitMatrixParser
+
+@synthesize bitMatrix;
+@synthesize parsedFormatInfo;
+@synthesize parsedVersion;
+
+- (id)initWithBitMatrix:(ZXBitMatrix *)aBitMatrix error:(NSError **)error {
+ int dimension = aBitMatrix.height;
+ if (dimension < 21 || (dimension & 0x03) != 1) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+
+ if (self = [super init]) {
+ self.bitMatrix = aBitMatrix;
+ self.parsedFormatInfo = nil;
+ self.parsedVersion = nil;
+ }
+ return self;
+}
+
+- (void)dealloc {
+ [bitMatrix release];
+ [parsedVersion release];
+ [parsedFormatInfo release];
+
+ [super dealloc];
+}
+
+/**
+ * Reads format information from one of its two locations within the QR Code.
+ */
+- (ZXFormatInformation *)readFormatInformationWithError:(NSError **)error {
+ if (self.parsedFormatInfo != nil) {
+ return self.parsedFormatInfo;
+ }
+ int formatInfoBits1 = 0;
+
+ for (int i = 0; i < 6; i++) {
+ formatInfoBits1 = [self copyBit:i j:8 versionBits:formatInfoBits1];
+ }
+
+ formatInfoBits1 = [self copyBit:7 j:8 versionBits:formatInfoBits1];
+ formatInfoBits1 = [self copyBit:8 j:8 versionBits:formatInfoBits1];
+ formatInfoBits1 = [self copyBit:8 j:7 versionBits:formatInfoBits1];
+
+ for (int j = 5; j >= 0; j--) {
+ formatInfoBits1 = [self copyBit:8 j:j versionBits:formatInfoBits1];
+ }
+
+ int dimension = self.bitMatrix.height;
+ int formatInfoBits2 = 0;
+ int jMin = dimension - 7;
+
+ for (int j = dimension - 1; j >= jMin; j--) {
+ formatInfoBits2 = [self copyBit:8 j:j versionBits:formatInfoBits2];
+ }
+
+ for (int i = dimension - 8; i < dimension; i++) {
+ formatInfoBits2 = [self copyBit:i j:8 versionBits:formatInfoBits2];
+ }
+
+ self.parsedFormatInfo = [ZXFormatInformation decodeFormatInformation:formatInfoBits1 maskedFormatInfo2:formatInfoBits2];
+ if (self.parsedFormatInfo != nil) {
+ return self.parsedFormatInfo;
+ }
+ if (error) *error = FormatErrorInstance();
+ return nil;
+}
+
+
+/**
+ * Reads version information from one of its two locations within the QR Code.
+ */
+- (ZXQRCodeVersion *)readVersionWithError:(NSError **)error {
+ if (self.parsedVersion != nil) {
+ return self.parsedVersion;
+ }
+ int dimension = self.bitMatrix.height;
+ int provisionalVersion = (dimension - 17) >> 2;
+ if (provisionalVersion <= 6) {
+ return [ZXQRCodeVersion versionForNumber:provisionalVersion];
+ }
+ int versionBits = 0;
+ int ijMin = dimension - 11;
+
+ for (int j = 5; j >= 0; j--) {
+
+ for (int i = dimension - 9; i >= ijMin; i--) {
+ versionBits = [self copyBit:i j:j versionBits:versionBits];
+ }
+
+ }
+
+ ZXQRCodeVersion *theParsedVersion = [ZXQRCodeVersion decodeVersionInformation:versionBits];
+ if (theParsedVersion != nil && theParsedVersion.dimensionForVersion == dimension) {
+ self.parsedVersion = theParsedVersion;
+ return self.parsedVersion;
+ }
+ versionBits = 0;
+
+ for (int i = 5; i >= 0; i--) {
+ for (int j = dimension - 9; j >= ijMin; j--) {
+ versionBits = [self copyBit:i j:j versionBits:versionBits];
+ }
+ }
+
+ theParsedVersion = [ZXQRCodeVersion decodeVersionInformation:versionBits];
+ if (theParsedVersion != nil && theParsedVersion.dimensionForVersion == dimension) {
+ self.parsedVersion = theParsedVersion;
+ return self.parsedVersion;
+ }
+ if (error) *error = FormatErrorInstance();
+ return nil;
+}
+
+- (int)copyBit:(int)i j:(int)j versionBits:(int)versionBits {
+ return [self.bitMatrix getX:i y:j] ? (versionBits << 1) | 0x1 : versionBits << 1;
+}
+
+
+/**
+ * Reads the bits in the {@link BitMatrix} representing the finder pattern in the
+ * correct order in order to reconstitute the codewords bytes contained within the
+ * QR Code.
+ */
+- (NSArray *)readCodewordsWithError:(NSError **)error {
+ ZXFormatInformation *formatInfo = [self readFormatInformationWithError:error];
+ if (!formatInfo) {
+ return nil;
+ }
+
+ ZXQRCodeVersion *version = [self readVersionWithError:error];
+ if (!version) {
+ return nil;
+ }
+
+ ZXDataMask *dataMask = [ZXDataMask forReference:(int)[formatInfo dataMask]];
+ int dimension = self.bitMatrix.height;
+ [dataMask unmaskBitMatrix:bitMatrix dimension:dimension];
+ ZXBitMatrix *functionPattern = [version buildFunctionPattern];
+ BOOL readingUp = YES;
+ NSMutableArray *result = [NSMutableArray array];
+ int resultOffset = 0;
+ int currentByte = 0;
+ int bitsRead = 0;
+
+ for (int j = dimension - 1; j > 0; j -= 2) {
+ if (j == 6) {
+ j--;
+ }
+
+ for (int count = 0; count < dimension; count++) {
+ int i = readingUp ? dimension - 1 - count : count;
+
+ for (int col = 0; col < 2; col++) {
+ if (![functionPattern getX:j - col y:i]) {
+ bitsRead++;
+ currentByte <<= 1;
+ if ([self.bitMatrix getX:j - col y:i]) {
+ currentByte |= 1;
+ }
+ if (bitsRead == 8) {
+ [result addObject:[NSNumber numberWithChar:(char)currentByte]];
+ resultOffset++;
+ bitsRead = 0;
+ currentByte = 0;
+ }
+ }
+ }
+ }
+
+ readingUp ^= YES;
+ }
+
+ if (resultOffset != [version totalCodewords]) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDataBlock.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDataBlock.h
new file mode 100644
index 0000000000000000000000000000000000000000..62fdd3115c62c2dea8035d4a6e534ad2bec4e92a
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDataBlock.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates a block of data within a QR Code. QR Codes may split their data into
+ * multiple blocks, each of which is a unit of data and error-correction codewords. Each
+ * is represented by an instance of this class.
+ */
+
+@class ZXErrorCorrectionLevel, ZXQRCodeVersion;
+
+@interface ZXQRCodeDataBlock : NSObject
+
+@property (nonatomic, retain, readonly) NSMutableArray *codewords;
+@property (nonatomic, assign, readonly) int numDataCodewords;
+
+- (id)initWithNumDataCodewords:(int)numDataCodewords codewords:(NSMutableArray *)codewords;
++ (NSArray *)dataBlocks:(NSArray *)rawCodewords version:(ZXQRCodeVersion *)version ecLevel:(ZXErrorCorrectionLevel *)ecLevel;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDataBlock.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDataBlock.m
new file mode 100644
index 0000000000000000000000000000000000000000..415d6b59ecd1d048edb2e017af5c9f1484a09a46
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDataBlock.m
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXErrorCorrectionLevel.h"
+#import "ZXQRCodeDataBlock.h"
+#import "ZXQRCodeVersion.h"
+
+@interface ZXQRCodeDataBlock ()
+
+@property (nonatomic, retain) NSMutableArray *codewords;
+@property (nonatomic, assign) int numDataCodewords;
+
+@end
+
+@implementation ZXQRCodeDataBlock
+
+@synthesize codewords;
+@synthesize numDataCodewords;
+
+- (id)initWithNumDataCodewords:(int)theNumDataCodewords codewords:(NSMutableArray *)theCodewords {
+ if (self = [super init]) {
+ self.numDataCodewords = theNumDataCodewords;
+ self.codewords = theCodewords;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [codewords release];
+
+ [super dealloc];
+}
+
+
+/**
+ * When QR Codes use multiple data blocks, they are actually interleaved.
+ * That is, the first byte of data block 1 to n is written, then the second bytes, and so on. This
+ * method will separate the data into original blocks.
+ */
++ (NSArray *)dataBlocks:(NSArray *)rawCodewords version:(ZXQRCodeVersion *)version ecLevel:(ZXErrorCorrectionLevel *)ecLevel {
+ if (rawCodewords.count != version.totalCodewords) {
+ [NSException raise:NSInvalidArgumentException format:@"Invalid codewords count"];
+ }
+
+ ZXQRCodeECBlocks *ecBlocks = [version ecBlocksForLevel:ecLevel];
+
+ int totalBlocks = 0;
+ NSArray *ecBlockArray = ecBlocks.ecBlocks;
+ for (ZXQRCodeECB *ecBlock in ecBlockArray) {
+ totalBlocks += ecBlock.count;
+ }
+
+ NSMutableArray *result = [NSMutableArray arrayWithCapacity:totalBlocks];
+ for (ZXQRCodeECB *ecBlock in ecBlockArray) {
+ for (int i = 0; i < ecBlock.count; i++) {
+ int numDataCodewords = ecBlock.dataCodewords;
+ int numBlockCodewords = ecBlocks.ecCodewordsPerBlock + numDataCodewords;
+ NSMutableArray *newCodewords = [NSMutableArray arrayWithCapacity:numBlockCodewords];
+ for (int j = 0; j < numBlockCodewords; j++) {
+ [newCodewords addObject:[NSNull null]];
+ }
+
+ [result addObject:[[[ZXQRCodeDataBlock alloc] initWithNumDataCodewords:numDataCodewords codewords:newCodewords] autorelease]];
+ }
+ }
+
+ int shorterBlocksTotalCodewords = [[[result objectAtIndex:0] codewords] count];
+ int longerBlocksStartAt = [result count] - 1;
+
+ while (longerBlocksStartAt >= 0) {
+ int numCodewords = [[[result objectAtIndex:longerBlocksStartAt] codewords] count];
+ if (numCodewords == shorterBlocksTotalCodewords) {
+ break;
+ }
+ longerBlocksStartAt--;
+ }
+
+ longerBlocksStartAt++;
+ int shorterBlocksNumDataCodewords = shorterBlocksTotalCodewords - ecBlocks.ecCodewordsPerBlock;
+ int rawCodewordsOffset = 0;
+ int numResultBlocks = [result count];
+
+ for (int i = 0; i < shorterBlocksNumDataCodewords; i++) {
+ for (int j = 0; j < numResultBlocks; j++) {
+ [[[result objectAtIndex:j] codewords] replaceObjectAtIndex:i withObject:[rawCodewords objectAtIndex:rawCodewordsOffset++]];
+ }
+ }
+
+ for (int j = longerBlocksStartAt; j < numResultBlocks; j++) {
+ [[[result objectAtIndex:j] codewords] replaceObjectAtIndex:shorterBlocksNumDataCodewords withObject:[rawCodewords objectAtIndex:rawCodewordsOffset++]];
+ }
+
+ int max = [[[result objectAtIndex:0] codewords] count];
+ for (int i = shorterBlocksNumDataCodewords; i < max; i++) {
+ for (int j = 0; j < numResultBlocks; j++) {
+ int iOffset = j < longerBlocksStartAt ? i : i + 1;
+ [[[result objectAtIndex:j] codewords] replaceObjectAtIndex:iOffset withObject:[rawCodewords objectAtIndex:rawCodewordsOffset++]];
+ }
+ }
+
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDecodedBitStreamParser.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDecodedBitStreamParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..e015f2cbe03381974fd71088d71f91a93856e952
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDecodedBitStreamParser.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * QR Codes can encode text as bits in one of several modes, and can use multiple modes
+ * in one QR Code. This class decodes the bits back into text.
+ *
+ * See ISO 18004:2006, 6.4.3 - 6.4.7
+ */
+
+@class ZXDecodeHints, ZXDecoderResult, ZXErrorCorrectionLevel, ZXQRCodeVersion;
+
+@interface ZXQRCodeDecodedBitStreamParser : NSObject
+
++ (ZXDecoderResult *)decode:(unsigned char *)bytes length:(unsigned int)length version:(ZXQRCodeVersion *)version
+ ecLevel:(ZXErrorCorrectionLevel *)ecLevel hints:(ZXDecodeHints *)hints error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDecodedBitStreamParser.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDecodedBitStreamParser.m
new file mode 100644
index 0000000000000000000000000000000000000000..71f067b1110b3aeda0858206036a5e6fa596e750
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDecodedBitStreamParser.m
@@ -0,0 +1,345 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitSource.h"
+#import "ZXCharacterSetECI.h"
+#import "ZXDecoderResult.h"
+#import "ZXErrors.h"
+#import "ZXErrorCorrectionLevel.h"
+#import "ZXMode.h"
+#import "ZXQRCodeDecodedBitStreamParser.h"
+#import "ZXQRCodeVersion.h"
+#import "ZXStringUtils.h"
+
+
+/**
+ * See ISO 18004:2006, 6.4.4 Table 5
+ */
+char const ALPHANUMERIC_CHARS[45] = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
+ 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
+ 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+ ' ', '$', '%', '*', '+', '-', '.', '/', ':'
+};
+
+int const GB2312_SUBSET = 1;
+
+@interface ZXQRCodeDecodedBitStreamParser ()
+
++ (BOOL)decodeHanziSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count;
++ (BOOL)decodeKanjiSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count;
++ (BOOL)decodeByteSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count currentCharacterSetECI:(ZXCharacterSetECI *)currentCharacterSetECI byteSegments:(NSMutableArray *)byteSegments hints:(ZXDecodeHints *)hints;
++ (BOOL)decodeAlphanumericSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count fc1InEffect:(BOOL)fc1InEffect;
++ (BOOL)decodeNumericSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count;
++ (int)parseECIValue:(ZXBitSource *)bits;
+
+@end
+
+@implementation ZXQRCodeDecodedBitStreamParser
+
++ (ZXDecoderResult *)decode:(unsigned char *)bytes length:(unsigned int)length version:(ZXQRCodeVersion *)version
+ ecLevel:(ZXErrorCorrectionLevel *)ecLevel hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ ZXBitSource *bits = [[[ZXBitSource alloc] initWithBytes:bytes length:length] autorelease];
+ NSMutableString *result = [NSMutableString stringWithCapacity:50];
+ ZXCharacterSetECI *currentCharacterSetECI = nil;
+ BOOL fc1InEffect = NO;
+ NSMutableArray *byteSegments = [NSMutableArray arrayWithCapacity:1];
+ ZXMode *mode;
+
+ do {
+ if ([bits available] < 4) {
+ mode = [ZXMode terminatorMode];
+ } else {
+ mode = [ZXMode forBits:[bits readBits:4]];
+ if (!mode) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ }
+ if (![mode isEqual:[ZXMode terminatorMode]]) {
+ if ([mode isEqual:[ZXMode fnc1FirstPositionMode]] || [mode isEqual:[ZXMode fnc1SecondPositionMode]]) {
+ fc1InEffect = YES;
+ } else if ([mode isEqual:[ZXMode structuredAppendMode]]) {
+ if (bits.available < 16) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ [bits readBits:16];
+ } else if ([mode isEqual:[ZXMode eciMode]]) {
+ int value = [self parseECIValue:bits];
+ currentCharacterSetECI = [ZXCharacterSetECI characterSetECIByValue:value];
+ if (currentCharacterSetECI == nil) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ } else {
+ if ([mode isEqual:[ZXMode hanziMode]]) {
+ int subset = [bits readBits:4];
+ int countHanzi = [bits readBits:[mode characterCountBits:version]];
+ if (subset == GB2312_SUBSET) {
+ if (![self decodeHanziSegment:bits result:result count:countHanzi]) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ }
+ } else {
+ int count = [bits readBits:[mode characterCountBits:version]];
+ if ([mode isEqual:[ZXMode numericMode]]) {
+ if (![self decodeNumericSegment:bits result:result count:count]) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ } else if ([mode isEqual:[ZXMode alphanumericMode]]) {
+ if (![self decodeAlphanumericSegment:bits result:result count:count fc1InEffect:fc1InEffect]) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ } else if ([mode isEqual:[ZXMode byteMode]]) {
+ if (![self decodeByteSegment:bits result:result count:count currentCharacterSetECI:currentCharacterSetECI byteSegments:byteSegments hints:hints]) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ } else if ([mode isEqual:[ZXMode kanjiMode]]) {
+ if (![self decodeKanjiSegment:bits result:result count:count]) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ } else {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ }
+ }
+ }
+ } while (![mode isEqual:[ZXMode terminatorMode]]);
+ return [[[ZXDecoderResult alloc] initWithRawBytes:bytes
+ length:length
+ text:result.description
+ byteSegments:byteSegments.count == 0 ? nil : byteSegments
+ ecLevel:ecLevel == nil ? nil : ecLevel.description] autorelease];
+}
+
+
+/**
+ * See specification GBT 18284-2000
+ */
++ (BOOL)decodeHanziSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count {
+ if (count * 13 > bits.available) {
+ return NO;
+ }
+
+ NSMutableData *buffer = [NSMutableData dataWithCapacity:2 * count];
+ while (count > 0) {
+ int twoBytes = [bits readBits:13];
+ int assembledTwoBytes = ((twoBytes / 0x060) << 8) | (twoBytes % 0x060);
+ if (assembledTwoBytes < 0x003BF) {
+ assembledTwoBytes += 0x0A1A1;
+ } else {
+ assembledTwoBytes += 0x0A6A1;
+ }
+ char bytes[2];
+ bytes[0] = (char)((assembledTwoBytes >> 8) & 0xFF);
+ bytes[1] = (char)(assembledTwoBytes & 0xFF);
+
+ [buffer appendBytes:bytes length:2];
+
+ count--;
+ }
+
+ NSString *string = [[[NSString alloc] initWithData:buffer encoding:CFStringConvertEncodingToNSStringEncoding(kCFStringEncodingGB_18030_2000)] autorelease];
+ if (string) {
+ [result appendString:string];
+ }
+ return YES;
+}
+
++ (BOOL)decodeKanjiSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count {
+ if (count * 13 > bits.available) {
+ return NO;
+ }
+
+ NSMutableData *buffer = [NSMutableData dataWithCapacity:2 * count];
+ while (count > 0) {
+ int twoBytes = [bits readBits:13];
+ int assembledTwoBytes = ((twoBytes / 0x0C0) << 8) | (twoBytes % 0x0C0);
+ if (assembledTwoBytes < 0x01F00) {
+ assembledTwoBytes += 0x08140;
+ } else {
+ assembledTwoBytes += 0x0C140;
+ }
+ char bytes[2];
+ bytes[0] = (char)(assembledTwoBytes >> 8);
+ bytes[1] = (char)assembledTwoBytes;
+
+ [buffer appendBytes:bytes length:2];
+
+ count--;
+ }
+
+ NSString *string = [[[NSString alloc] initWithData:buffer encoding:NSShiftJISStringEncoding] autorelease];
+ if (string) {
+ [result appendString:string];
+ }
+ return YES;
+}
+
++ (BOOL)decodeByteSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count currentCharacterSetECI:(ZXCharacterSetECI *)currentCharacterSetECI byteSegments:(NSMutableArray *)byteSegments hints:(ZXDecodeHints *)hints {
+ if (count << 3 > bits.available) {
+ return NO;
+ }
+ unsigned char readBytes[count];
+ NSMutableArray *readBytesArray = [NSMutableArray arrayWithCapacity:count];
+
+ for (int i = 0; i < count; i++) {
+ readBytes[i] = (char)[bits readBits:8];
+ [readBytesArray addObject:[NSNumber numberWithChar:readBytes[i]]];
+ }
+
+ NSStringEncoding encoding;
+ if (currentCharacterSetECI == nil) {
+ encoding = [ZXStringUtils guessEncoding:readBytes length:count hints:hints];
+ } else {
+ encoding = [currentCharacterSetECI encoding];
+ }
+
+ NSString *string = [[[NSString alloc] initWithBytes:readBytes length:count encoding:encoding] autorelease];
+ if (string) {
+ [result appendString:string];
+ }
+
+ [byteSegments addObject:readBytesArray];
+ return YES;
+}
+
++ (unichar)toAlphaNumericChar:(int)value {
+ if (value >= 45) {
+ return -1;
+ }
+ return ALPHANUMERIC_CHARS[value];
+}
+
++ (BOOL)decodeAlphanumericSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count fc1InEffect:(BOOL)fc1InEffect {
+ int start = result.length;
+
+ while (count > 1) {
+ if ([bits available] < 11) {
+ return NO;
+ }
+ int nextTwoCharsBits = [bits readBits:11];
+ unichar next1 = [self toAlphaNumericChar:nextTwoCharsBits / 45];
+ unichar next2 = [self toAlphaNumericChar:nextTwoCharsBits % 45];
+ if (next1 == -1 || next2 == -1) {
+ return NO;
+ }
+
+ [result appendFormat:@"%C%C", next1, next2];
+ count -= 2;
+ }
+
+ if (count == 1) {
+ if ([bits available] < 6) {
+ return NO;
+ }
+ unichar next1 = [self toAlphaNumericChar:[bits readBits:6]];
+ if (next1 == -1) {
+ return NO;
+ }
+ [result appendFormat:@"%C", next1];
+ }
+ if (fc1InEffect) {
+ for (int i = start; i < [result length]; i++) {
+ if ([result characterAtIndex:i] == '%') {
+ if (i < [result length] - 1 && [result characterAtIndex:i + 1] == '%') {
+ [result deleteCharactersInRange:NSMakeRange(i + 1, 1)];
+ } else {
+ [result insertString:[NSString stringWithFormat:@"%C", (unichar)0x1D]
+ atIndex:i];
+ }
+ }
+ }
+ }
+ return YES;
+}
+
++ (BOOL)decodeNumericSegment:(ZXBitSource *)bits result:(NSMutableString *)result count:(int)count {
+ // Read three digits at a time
+ while (count >= 3) {
+ // Each 10 bits encodes three digits
+ if (bits.available < 10) {
+ return NO;
+ }
+ int threeDigitsBits = [bits readBits:10];
+ if (threeDigitsBits >= 1000) {
+ return NO;
+ }
+ unichar next1 = [self toAlphaNumericChar:threeDigitsBits / 100];
+ unichar next2 = [self toAlphaNumericChar:(threeDigitsBits / 10) % 10];
+ unichar next3 = [self toAlphaNumericChar:threeDigitsBits % 10];
+ if (next1 == -1 || next2 == -1 || next3 == -1) {
+ return NO;
+ }
+
+ [result appendFormat:@"%C%C%C", next1, next2, next3];
+ count -= 3;
+ }
+
+ if (count == 2) {
+ // Two digits left over to read, encoded in 7 bits
+ if (bits.available < 7) {
+ return NO;
+ }
+ int twoDigitsBits = [bits readBits:7];
+ if (twoDigitsBits >= 100) {
+ return NO;
+ }
+ unichar next1 = [self toAlphaNumericChar:twoDigitsBits / 10];
+ unichar next2 = [self toAlphaNumericChar:twoDigitsBits % 10];
+ [result appendFormat:@"%C%C", next1, next2];
+ } else if (count == 1) {
+ // One digit left over to read
+ if (bits.available < 4) {
+ return NO;
+ }
+ int digitBits = [bits readBits:4];
+ if (digitBits >= 10) {
+ return NO;
+ }
+ unichar next1 = [self toAlphaNumericChar:digitBits];
+ if (next1 == -1) {
+ return NO;
+ }
+ [result appendFormat:@"%C", next1];
+ }
+ return YES;
+}
+
++ (int)parseECIValue:(ZXBitSource *)bits {
+ int firstByte = [bits readBits:8];
+ if ((firstByte & 0x80) == 0) {
+ return firstByte & 0x7F;
+ }
+ if ((firstByte & 0xC0) == 0x80) {
+ int secondByte = [bits readBits:8];
+ return ((firstByte & 0x3F) << 8) | secondByte;
+ }
+ if ((firstByte & 0xE0) == 0xC0) {
+ int secondThirdBytes = [bits readBits:16];
+ return ((firstByte & 0x1F) << 16) | secondThirdBytes;
+ }
+ return -1;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDecoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDecoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..894c620cf3b68e3f011574a880209ee1e6473700
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDecoder.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The main class which implements QR Code decoding -- as opposed to locating and extracting
+ * the QR Code from an image.
+ */
+
+@class ZXBitMatrix, ZXDecodeHints, ZXDecodeHints, ZXDecoderResult;
+
+@interface ZXQRCodeDecoder : NSObject
+
+- (ZXDecoderResult *) decode:(BOOL **)image length:(unsigned int)length error:(NSError **)error;
+- (ZXDecoderResult *) decode:(BOOL **)image length:(unsigned int)length hints:(ZXDecodeHints *)hints error:(NSError **)error;
+- (ZXDecoderResult *) decodeMatrix:(ZXBitMatrix *)bits error:(NSError **)error;
+- (ZXDecoderResult *) decodeMatrix:(ZXBitMatrix *)bits hints:(ZXDecodeHints *)hints error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDecoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDecoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..c8e994934708277b86aad210ed535177a88ae57a
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeDecoder.m
@@ -0,0 +1,165 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXDecoderResult.h"
+#import "ZXErrorCorrectionLevel.h"
+#import "ZXErrors.h"
+#import "ZXFormatInformation.h"
+#import "ZXGenericGF.h"
+#import "ZXQRCodeBitMatrixParser.h"
+#import "ZXQRCodeDataBlock.h"
+#import "ZXQRCodeDecodedBitStreamParser.h"
+#import "ZXQRCodeDecoder.h"
+#import "ZXQRCodeVersion.h"
+#import "ZXReedSolomonDecoder.h"
+
+@interface ZXQRCodeDecoder ()
+
+@property (nonatomic, retain) ZXReedSolomonDecoder *rsDecoder;
+
+- (BOOL)correctErrors:(NSMutableArray *)codewordBytes numDataCodewords:(int)numDataCodewords error:(NSError **)error;
+
+@end
+
+@implementation ZXQRCodeDecoder
+
+@synthesize rsDecoder;
+
+- (id)init {
+ if (self = [super init]) {
+ self.rsDecoder = [[[ZXReedSolomonDecoder alloc] initWithField:[ZXGenericGF QrCodeField256]] autorelease];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [rsDecoder release];
+
+ [super dealloc];
+}
+
+- (ZXDecoderResult *)decode:(BOOL **)image length:(unsigned int)length error:(NSError **)error {
+ return [self decode:image length:length hints:nil error:error];
+}
+
+
+/**
+ * Convenience method that can decode a QR Code represented as a 2D array of booleans.
+ * "true" is taken to mean a black module.
+ */
+- (ZXDecoderResult *)decode:(BOOL **)image length:(unsigned int)length hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ int dimension = length;
+ ZXBitMatrix *bits = [[[ZXBitMatrix alloc] initWithDimension:dimension] autorelease];
+ for (int i = 0; i < dimension; i++) {
+ for (int j = 0; j < dimension; j++) {
+ if (image[i][j]) {
+ [bits setX:j y:i];
+ }
+ }
+ }
+
+ return [self decodeMatrix:bits hints:hints error:error];
+}
+
+- (ZXDecoderResult *)decodeMatrix:(ZXBitMatrix *)bits error:(NSError **)error {
+ return [self decodeMatrix:bits hints:nil error:error];
+}
+
+
+/**
+ * Decodes a QR Code represented as a {@link BitMatrix}. A 1 or "true" is taken to mean a black module.
+ */
+- (ZXDecoderResult *)decodeMatrix:(ZXBitMatrix *)bits hints:(ZXDecodeHints *)hints error:(NSError **)error {
+ ZXQRCodeBitMatrixParser *parser = [[[ZXQRCodeBitMatrixParser alloc] initWithBitMatrix:bits error:error] autorelease];
+ if (!parser) {
+ return nil;
+ }
+ ZXQRCodeVersion *version = [parser readVersionWithError:error];
+ if (!version) {
+ return nil;
+ }
+ ZXFormatInformation *formatInfo = [parser readFormatInformationWithError:error];
+ if (!formatInfo) {
+ return nil;
+ }
+ ZXErrorCorrectionLevel *ecLevel = formatInfo.errorCorrectionLevel;
+
+ NSArray *codewords = [parser readCodewordsWithError:error];
+ if (!codewords) {
+ return nil;
+ }
+ NSArray *dataBlocks = [ZXQRCodeDataBlock dataBlocks:codewords version:version ecLevel:ecLevel];
+
+ int totalBytes = 0;
+ for (ZXQRCodeDataBlock *dataBlock in dataBlocks) {
+ totalBytes += dataBlock.numDataCodewords;
+ }
+
+ if (totalBytes == 0) {
+ return nil;
+ }
+
+ unsigned char resultBytes[totalBytes];
+ int resultOffset = 0;
+
+ for (ZXQRCodeDataBlock *dataBlock in dataBlocks) {
+ NSMutableArray *codewordBytes = [dataBlock codewords];
+ int numDataCodewords = [dataBlock numDataCodewords];
+ if (![self correctErrors:codewordBytes numDataCodewords:numDataCodewords error:error]) {
+ return nil;
+ }
+ for (int i = 0; i < numDataCodewords; i++) {
+ resultBytes[resultOffset++] = [[codewordBytes objectAtIndex:i] charValue];
+ }
+ }
+
+ return [ZXQRCodeDecodedBitStreamParser decode:resultBytes length:totalBytes version:version ecLevel:ecLevel hints:hints error:error];
+}
+
+
+/**
+ * Given data and error-correction codewords received, possibly corrupted by errors, attempts to
+ * correct the errors in-place using Reed-Solomon error correction.
+ */
+- (BOOL)correctErrors:(NSMutableArray *)codewordBytes numDataCodewords:(int)numDataCodewords error:(NSError **)error {
+ int numCodewords = [codewordBytes count];
+ int codewordsInts[numCodewords];
+
+ for (int i = 0; i < numCodewords; i++) {
+ codewordsInts[i] = [[codewordBytes objectAtIndex:i] charValue] & 0xFF;
+ }
+
+ int numECCodewords = [codewordBytes count] - numDataCodewords;
+ NSError *decodeError = nil;
+ if (![rsDecoder decode:codewordsInts receivedLen:numCodewords twoS:numECCodewords error:&decodeError]) {
+ if (decodeError.code == ZXReedSolomonError) {
+ if (error) *error = ChecksumErrorInstance();
+ return NO;
+ } else {
+ if (error) *error = decodeError;
+ return NO;
+ }
+ }
+
+ for (int i = 0; i < numDataCodewords; i++) {
+ [codewordBytes replaceObjectAtIndex:i withObject:[NSNumber numberWithChar:codewordsInts[i]]];
+ }
+ return YES;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeVersion.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeVersion.h
new file mode 100644
index 0000000000000000000000000000000000000000..8bec128c2b45a99c4c90491c36ee7712fa6c1dac
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeVersion.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates a set of error-correction blocks in one symbol version. Most versions will
+ * use blocks of differing sizes within one version, so, this encapsulates the parameters for
+ * each set of blocks. It also holds the number of error-correction codewords per block since it
+ * will be the same across all blocks within one version.
+ */
+
+@class ZXQRCodeECB;
+
+@interface ZXQRCodeECBlocks : NSObject
+
+@property (nonatomic, assign, readonly) int ecCodewordsPerBlock;
+@property (nonatomic, assign, readonly) int numBlocks;
+@property (nonatomic, assign, readonly) int totalECCodewords;
+@property (nonatomic, retain, readonly) NSArray *ecBlocks;
+
+- (id)initWithEcCodewordsPerBlock:(int)ecCodewordsPerBlock ecBlocks:(ZXQRCodeECB *)ecBlocks;
+- (id)initWithEcCodewordsPerBlock:(int)ecCodewordsPerBlock ecBlocks1:(ZXQRCodeECB *)ecBlocks1 ecBlocks2:(ZXQRCodeECB *)ecBlocks2;
++ (ZXQRCodeECBlocks *)ecBlocksWithEcCodewordsPerBlock:(int)ecCodewordsPerBlock ecBlocks:(ZXQRCodeECB *)ecBlocks;
++ (ZXQRCodeECBlocks *)ecBlocksWithEcCodewordsPerBlock:(int)ecCodewordsPerBlock ecBlocks1:(ZXQRCodeECB *)ecBlocks1 ecBlocks2:(ZXQRCodeECB *)ecBlocks2;
+
+@end
+
+/**
+ * Encapsualtes the parameters for one error-correction block in one symbol version.
+ * This includes the number of data codewords, and the number of times a block with these
+ * parameters is used consecutively in the QR code version's format.
+ */
+
+@interface ZXQRCodeECB : NSObject
+
+@property (nonatomic, assign, readonly) int count;
+@property (nonatomic, assign, readonly) int dataCodewords;
+
+- (id)initWithCount:(int)count dataCodewords:(int)dataCodewords;
++ (ZXQRCodeECB *)ecbWithCount:(int)count dataCodewords:(int)dataCodewords;
+
+@end
+
+/**
+ * See ISO 18004:2006 Annex D
+ */
+
+@class ZXErrorCorrectionLevel, ZXBitMatrix;
+
+@interface ZXQRCodeVersion : NSObject
+
+@property (nonatomic, assign, readonly) int versionNumber;
+@property (nonatomic, retain, readonly) NSArray *alignmentPatternCenters;
+@property (nonatomic, retain, readonly) NSArray *ecBlocks;
+@property (nonatomic, assign, readonly) int totalCodewords;
+@property (nonatomic, assign, readonly) int dimensionForVersion;
+
+- (ZXQRCodeECBlocks *)ecBlocksForLevel:(ZXErrorCorrectionLevel *)ecLevel;
++ (ZXQRCodeVersion *)provisionalVersionForDimension:(int)dimension;
++ (ZXQRCodeVersion *)versionForNumber:(int)versionNumber;
++ (ZXQRCodeVersion *)decodeVersionInformation:(int)versionBits;
+- (ZXBitMatrix *)buildFunctionPattern;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeVersion.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeVersion.m
new file mode 100644
index 0000000000000000000000000000000000000000..37f42a9ff26e517ba7cf4318978ff52e78c2db88
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/decoder/ZXQRCodeVersion.m
@@ -0,0 +1,551 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXErrorCorrectionLevel.h"
+#import "ZXFormatInformation.h"
+#import "ZXQRCodeVersion.h"
+
+@interface ZXQRCodeECBlocks ()
+
+@property (nonatomic, assign) int ecCodewordsPerBlock;
+@property (nonatomic, assign) int numBlocks;
+@property (nonatomic, assign) int totalECCodewords;
+@property (nonatomic, retain) NSArray *ecBlocks;
+
+@end
+
+@implementation ZXQRCodeECBlocks
+
+@synthesize ecCodewordsPerBlock;
+@synthesize numBlocks;
+@synthesize totalECCodewords;
+@synthesize ecBlocks;
+
+- (id)initWithEcCodewordsPerBlock:(int)anEcCodewordsPerBlock ecBlocks:(ZXQRCodeECB *)theEcBlocks {
+ if (self = [super init]) {
+ self.ecCodewordsPerBlock = anEcCodewordsPerBlock;
+ self.ecBlocks = [NSArray arrayWithObject:theEcBlocks];
+ }
+
+ return self;
+}
+
+- (id)initWithEcCodewordsPerBlock:(int)anEcCodewordsPerBlock ecBlocks1:(ZXQRCodeECB *)ecBlocks1 ecBlocks2:(ZXQRCodeECB *)ecBlocks2 {
+ if (self = [super init]) {
+ self.ecCodewordsPerBlock = anEcCodewordsPerBlock;
+ self.ecBlocks = [NSArray arrayWithObjects:ecBlocks1, ecBlocks2, nil];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [ecBlocks release];
+
+ [super dealloc];
+}
+
++ (ZXQRCodeECBlocks *)ecBlocksWithEcCodewordsPerBlock:(int)ecCodewordsPerBlock ecBlocks:(ZXQRCodeECB *)ecBlocks {
+ return [[[ZXQRCodeECBlocks alloc] initWithEcCodewordsPerBlock:ecCodewordsPerBlock ecBlocks:ecBlocks] autorelease];
+}
+
++ (ZXQRCodeECBlocks *)ecBlocksWithEcCodewordsPerBlock:(int)ecCodewordsPerBlock ecBlocks1:(ZXQRCodeECB *)ecBlocks1 ecBlocks2:(ZXQRCodeECB *)ecBlocks2 {
+ return [[[ZXQRCodeECBlocks alloc] initWithEcCodewordsPerBlock:ecCodewordsPerBlock ecBlocks1:ecBlocks1 ecBlocks2:ecBlocks2] autorelease];
+}
+
+- (int)numBlocks {
+ int total = 0;
+
+ for (ZXQRCodeECB *ecb in self.ecBlocks) {
+ total += [ecb count];
+ }
+
+ return total;
+}
+
+- (int)totalECCodewords {
+ return self.ecCodewordsPerBlock * [self numBlocks];
+}
+
+@end
+
+@interface ZXQRCodeECB ()
+
+@property (nonatomic, assign) int count;
+@property (nonatomic, assign) int dataCodewords;
+
+@end
+
+@implementation ZXQRCodeECB
+
+@synthesize count;
+@synthesize dataCodewords;
+
+- (id)initWithCount:(int)aCount dataCodewords:(int)aDataCodewords {
+ if (self = [super init]) {
+ self.count = aCount;
+ self.dataCodewords = aDataCodewords;
+ }
+
+ return self;
+}
+
++ (ZXQRCodeECB *)ecbWithCount:(int)count dataCodewords:(int)dataCodewords {
+ return [[[ZXQRCodeECB alloc] initWithCount:count dataCodewords:dataCodewords] autorelease];
+}
+
+@end
+
+
+/**
+ * See ISO 18004:2006 Annex D.
+ * Element i represents the raw version bits that specify version i + 7
+ */
+
+int const VERSION_DECODE_INFO_LEN = 34;
+int const VERSION_DECODE_INFO[VERSION_DECODE_INFO_LEN] = {
+ 0x07C94, 0x085BC, 0x09A99, 0x0A4D3, 0x0BBF6,
+ 0x0C762, 0x0D847, 0x0E60D, 0x0F928, 0x10B78,
+ 0x1145D, 0x12A17, 0x13532, 0x149A6, 0x15683,
+ 0x168C9, 0x177EC, 0x18EC4, 0x191E1, 0x1AFAB,
+ 0x1B08E, 0x1CC1A, 0x1D33F, 0x1ED75, 0x1F250,
+ 0x209D5, 0x216F0, 0x228BA, 0x2379F, 0x24B0B,
+ 0x2542E, 0x26A64, 0x27541, 0x28C69
+};
+
+static NSArray *VERSIONS = nil;
+
+@interface ZXQRCodeVersion ()
+
+@property (nonatomic, assign) int versionNumber;
+@property (nonatomic, retain) NSArray *alignmentPatternCenters;
+@property (nonatomic, retain) NSArray *ecBlocks;
+@property (nonatomic, assign) int totalCodewords;
+
+@end
+
+@implementation ZXQRCodeVersion
+
+@synthesize versionNumber;
+@synthesize alignmentPatternCenters;
+@synthesize ecBlocks;
+@synthesize totalCodewords;
+
+- (id)initWithVersionNumber:(int)aVersionNumber alignmentPatternCenters:(NSArray *)anAlignmentPatternCenters ecBlocks1:(ZXQRCodeECBlocks *)ecBlocks1 ecBlocks2:(ZXQRCodeECBlocks *)ecBlocks2 ecBlocks3:(ZXQRCodeECBlocks *)ecBlocks3 ecBlocks4:(ZXQRCodeECBlocks *)ecBlocks4 {
+ if (self = [super init]) {
+ self.versionNumber = aVersionNumber;
+ self.alignmentPatternCenters = anAlignmentPatternCenters;
+ self.ecBlocks = [NSArray arrayWithObjects:ecBlocks1, ecBlocks2, ecBlocks3, ecBlocks4, nil];
+ int total = 0;
+ int ecCodewords = ecBlocks1.ecCodewordsPerBlock;
+
+ for (ZXQRCodeECB *ecBlock in ecBlocks1.ecBlocks) {
+ total += ecBlock.count * (ecBlock.dataCodewords + ecCodewords);
+ }
+
+ self.totalCodewords = total;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [alignmentPatternCenters release];
+ [ecBlocks release];
+
+ [super dealloc];
+}
+
++ (ZXQRCodeVersion *)ZXQRCodeVersionWithVersionNumber:(int)aVersionNumber alignmentPatternCenters:(NSArray *)anAlignmentPatternCenters ecBlocks1:(ZXQRCodeECBlocks *)ecBlocks1 ecBlocks2:(ZXQRCodeECBlocks *)ecBlocks2 ecBlocks3:(ZXQRCodeECBlocks *)ecBlocks3 ecBlocks4:(ZXQRCodeECBlocks *)ecBlocks4 {
+ return [[[ZXQRCodeVersion alloc] initWithVersionNumber:aVersionNumber alignmentPatternCenters:anAlignmentPatternCenters ecBlocks1:ecBlocks1 ecBlocks2:ecBlocks2 ecBlocks3:ecBlocks3 ecBlocks4:ecBlocks4] autorelease];
+}
+
+- (int)dimensionForVersion {
+ return 17 + 4 * versionNumber;
+}
+
+- (ZXQRCodeECBlocks *)ecBlocksForLevel:(ZXErrorCorrectionLevel *)ecLevel {
+ return [self.ecBlocks objectAtIndex:[ecLevel ordinal]];
+}
+
+
+/**
+ * Deduces version information purely from QR Code dimensions.
+ */
++ (ZXQRCodeVersion *)provisionalVersionForDimension:(int)dimension {
+ if (dimension % 4 != 1) {
+ return nil;
+ }
+
+ return [self versionForNumber:(dimension - 17) >> 2];
+}
+
++ (ZXQRCodeVersion *)versionForNumber:(int)versionNumber {
+ if (versionNumber < 1 || versionNumber > 40) {
+ return nil;
+ }
+ return [VERSIONS objectAtIndex:versionNumber - 1];
+}
+
++ (ZXQRCodeVersion *)decodeVersionInformation:(int)versionBits {
+ int bestDifference = NSIntegerMax;
+ int bestVersion = 0;
+
+ for (int i = 0; i < VERSION_DECODE_INFO_LEN; i++) {
+ int targetVersion = VERSION_DECODE_INFO[i];
+ if (targetVersion == versionBits) {
+ return [self versionForNumber:i + 7];
+ }
+ int bitsDifference = [ZXFormatInformation numBitsDiffering:versionBits b:targetVersion];
+ if (bitsDifference < bestDifference) {
+ bestVersion = i + 7;
+ bestDifference = bitsDifference;
+ }
+ }
+
+ if (bestDifference <= 3) {
+ return [self versionForNumber:bestVersion];
+ }
+ return nil;
+}
+
+
+/**
+ * See ISO 18004:2006 Annex E
+ */
+- (ZXBitMatrix *)buildFunctionPattern {
+ int dimension = [self dimensionForVersion];
+ ZXBitMatrix *bitMatrix = [[[ZXBitMatrix alloc] initWithDimension:dimension] autorelease];
+ [bitMatrix setRegionAtLeft:0 top:0 width:9 height:9];
+ [bitMatrix setRegionAtLeft:dimension - 8 top:0 width:8 height:9];
+ [bitMatrix setRegionAtLeft:0 top:dimension - 8 width:9 height:8];
+ int max = self.alignmentPatternCenters.count;
+
+ for (int x = 0; x < max; x++) {
+ int i = [[self.alignmentPatternCenters objectAtIndex:x] intValue] - 2;
+
+ for (int y = 0; y < max; y++) {
+ if ((x == 0 && (y == 0 || y == max - 1)) || (x == max - 1 && y == 0)) {
+ continue;
+ }
+ [bitMatrix setRegionAtLeft:[[self.alignmentPatternCenters objectAtIndex:y] intValue] - 2 top:i width:5 height:5];
+ }
+ }
+
+ [bitMatrix setRegionAtLeft:6 top:9 width:1 height:dimension - 17];
+ [bitMatrix setRegionAtLeft:9 top:6 width:dimension - 17 height:1];
+ if (self.versionNumber > 6) {
+ [bitMatrix setRegionAtLeft:dimension - 11 top:0 width:3 height:6];
+ [bitMatrix setRegionAtLeft:0 top:dimension - 11 width:6 height:3];
+ }
+ return bitMatrix;
+}
+
+- (NSString *)description {
+ return [[NSNumber numberWithInt:self.versionNumber] stringValue];
+}
+
+
+/**
+ * See ISO 18004:2006 6.5.1 Table 9
+ */
++ (void)initialize {
+ VERSIONS = [[NSArray alloc] initWithObjects:
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:1
+ alignmentPatternCenters:[NSArray array]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:7 ecBlocks:[ZXQRCodeECB ecbWithCount:1 dataCodewords:19]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:10 ecBlocks:[ZXQRCodeECB ecbWithCount:1 dataCodewords:16]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:13 ecBlocks:[ZXQRCodeECB ecbWithCount:1 dataCodewords:13]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:17 ecBlocks:[ZXQRCodeECB ecbWithCount:1 dataCodewords:9]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:2
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:18], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:10 ecBlocks:[ZXQRCodeECB ecbWithCount:1 dataCodewords:34]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:16 ecBlocks:[ZXQRCodeECB ecbWithCount:1 dataCodewords:28]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:22 ecBlocks:[ZXQRCodeECB ecbWithCount:1 dataCodewords:22]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks:[ZXQRCodeECB ecbWithCount:1 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:3
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:22], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:15 ecBlocks:[ZXQRCodeECB ecbWithCount:1 dataCodewords:55]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks:[ZXQRCodeECB ecbWithCount:1 dataCodewords:44]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:18 ecBlocks:[ZXQRCodeECB ecbWithCount:2 dataCodewords:17]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:22 ecBlocks:[ZXQRCodeECB ecbWithCount:2 dataCodewords:13]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:4
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:26], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:20 ecBlocks:[ZXQRCodeECB ecbWithCount:1 dataCodewords:80]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:18 ecBlocks:[ZXQRCodeECB ecbWithCount:2 dataCodewords:32]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks:[ZXQRCodeECB ecbWithCount:2 dataCodewords:24]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:16 ecBlocks:[ZXQRCodeECB ecbWithCount:4 dataCodewords:9]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:5
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:30], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks:[ZXQRCodeECB ecbWithCount:1 dataCodewords:108]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks:[ZXQRCodeECB ecbWithCount:2 dataCodewords:43]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:18 ecBlocks1:[ZXQRCodeECB ecbWithCount:2 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:16]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:22 ecBlocks1:[ZXQRCodeECB ecbWithCount:2 dataCodewords:11] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:12]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:6
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:34], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:18 ecBlocks:[ZXQRCodeECB ecbWithCount:2 dataCodewords:68]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:16 ecBlocks:[ZXQRCodeECB ecbWithCount:4 dataCodewords:27]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks:[ZXQRCodeECB ecbWithCount:4 dataCodewords:19]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks:[ZXQRCodeECB ecbWithCount:4 dataCodewords:15]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:7
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:22], [NSNumber numberWithInt:38], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:20 ecBlocks:[ZXQRCodeECB ecbWithCount:2 dataCodewords:78]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:18 ecBlocks:[ZXQRCodeECB ecbWithCount:4 dataCodewords:31]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:18 ecBlocks1:[ZXQRCodeECB ecbWithCount:2 dataCodewords:14] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:15]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:13] ecBlocks2:[ZXQRCodeECB ecbWithCount:1 dataCodewords:14]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:8
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:24], [NSNumber numberWithInt:42], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks:[ZXQRCodeECB ecbWithCount:2 dataCodewords:97]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:22 ecBlocks1:[ZXQRCodeECB ecbWithCount:2 dataCodewords:38] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:39]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:22 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:18] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:19]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:14] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:15]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:9
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:26], [NSNumber numberWithInt:46], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks:[ZXQRCodeECB ecbWithCount:2 dataCodewords:116]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:22 ecBlocks1:[ZXQRCodeECB ecbWithCount:3 dataCodewords:36] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:37]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:20 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:16] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:17]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:12] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:13]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:10
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:28], [NSNumber numberWithInt:50], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:18 ecBlocks1:[ZXQRCodeECB ecbWithCount:2 dataCodewords:68] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:69]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:43] ecBlocks2:[ZXQRCodeECB ecbWithCount:1 dataCodewords:44]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks1:[ZXQRCodeECB ecbWithCount:6 dataCodewords:19] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:20]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:6 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:11
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:30], [NSNumber numberWithInt:54], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:20 ecBlocks:[ZXQRCodeECB ecbWithCount:4 dataCodewords:81]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:1 dataCodewords:50] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:51]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:22] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:23]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks1:[ZXQRCodeECB ecbWithCount:3 dataCodewords:12] ecBlocks2:[ZXQRCodeECB ecbWithCount:8 dataCodewords:13]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:12
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:32], [NSNumber numberWithInt:58], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks1:[ZXQRCodeECB ecbWithCount:2 dataCodewords:92] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:93]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:22 ecBlocks1:[ZXQRCodeECB ecbWithCount:6 dataCodewords:36] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:37]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:20] ecBlocks2:[ZXQRCodeECB ecbWithCount:6 dataCodewords:21]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:7 dataCodewords:14] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:15]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:13
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:34], [NSNumber numberWithInt:62], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks:[ZXQRCodeECB ecbWithCount:4 dataCodewords:107]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:22 ecBlocks1:[ZXQRCodeECB ecbWithCount:8 dataCodewords:37] ecBlocks2:[ZXQRCodeECB ecbWithCount:1 dataCodewords:38]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks1:[ZXQRCodeECB ecbWithCount:8 dataCodewords:20] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:21]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:22 ecBlocks1:[ZXQRCodeECB ecbWithCount:12 dataCodewords:11] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:12]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:14
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:26], [NSNumber numberWithInt:46], [NSNumber numberWithInt:66], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:3 dataCodewords:115] ecBlocks2:[ZXQRCodeECB ecbWithCount:1 dataCodewords:116]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:40] ecBlocks2:[ZXQRCodeECB ecbWithCount:5 dataCodewords:41]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:20 ecBlocks1:[ZXQRCodeECB ecbWithCount:11 dataCodewords:16] ecBlocks2:[ZXQRCodeECB ecbWithCount:5 dataCodewords:17]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks1:[ZXQRCodeECB ecbWithCount:11 dataCodewords:12] ecBlocks2:[ZXQRCodeECB ecbWithCount:5 dataCodewords:13]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:15
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:26], [NSNumber numberWithInt:48], [NSNumber numberWithInt:70], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:22 ecBlocks1:[ZXQRCodeECB ecbWithCount:5 dataCodewords:87] ecBlocks2:[ZXQRCodeECB ecbWithCount:1 dataCodewords:88]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks1:[ZXQRCodeECB ecbWithCount:5 dataCodewords:41] ecBlocks2:[ZXQRCodeECB ecbWithCount:5 dataCodewords:42]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:5 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:7 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks1:[ZXQRCodeECB ecbWithCount:11 dataCodewords:12] ecBlocks2:[ZXQRCodeECB ecbWithCount:7 dataCodewords:13]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:16
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:26], [NSNumber numberWithInt:50], [NSNumber numberWithInt:74], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks1:[ZXQRCodeECB ecbWithCount:5 dataCodewords:98] ecBlocks2:[ZXQRCodeECB ecbWithCount:1 dataCodewords:99]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:7 dataCodewords:45] ecBlocks2:[ZXQRCodeECB ecbWithCount:3 dataCodewords:46]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks1:[ZXQRCodeECB ecbWithCount:15 dataCodewords:19] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:20]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:3 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:13 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:17
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:30], [NSNumber numberWithInt:54], [NSNumber numberWithInt:78], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:1 dataCodewords:107] ecBlocks2:[ZXQRCodeECB ecbWithCount:5 dataCodewords:108]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:10 dataCodewords:46] ecBlocks2:[ZXQRCodeECB ecbWithCount:1 dataCodewords:47]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:1 dataCodewords:22] ecBlocks2:[ZXQRCodeECB ecbWithCount:15 dataCodewords:23]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:2 dataCodewords:14] ecBlocks2:[ZXQRCodeECB ecbWithCount:17 dataCodewords:15]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:18
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:30], [NSNumber numberWithInt:56], [NSNumber numberWithInt:82], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:5 dataCodewords:120] ecBlocks2:[ZXQRCodeECB ecbWithCount:1 dataCodewords:121]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks1:[ZXQRCodeECB ecbWithCount:9 dataCodewords:43] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:44]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:17 dataCodewords:22] ecBlocks2:[ZXQRCodeECB ecbWithCount:1 dataCodewords:23]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:2 dataCodewords:14] ecBlocks2:[ZXQRCodeECB ecbWithCount:19 dataCodewords:15]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:19
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:30], [NSNumber numberWithInt:58], [NSNumber numberWithInt:86], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:3 dataCodewords:113] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:114]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks1:[ZXQRCodeECB ecbWithCount:3 dataCodewords:44] ecBlocks2:[ZXQRCodeECB ecbWithCount:11 dataCodewords:45]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks1:[ZXQRCodeECB ecbWithCount:17 dataCodewords:21] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:22]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks1:[ZXQRCodeECB ecbWithCount:9 dataCodewords:13] ecBlocks2:[ZXQRCodeECB ecbWithCount:16 dataCodewords:14]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:20
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:34], [NSNumber numberWithInt:62], [NSNumber numberWithInt:90], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:3 dataCodewords:107] ecBlocks2:[ZXQRCodeECB ecbWithCount:5 dataCodewords:108]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks1:[ZXQRCodeECB ecbWithCount:3 dataCodewords:41] ecBlocks2:[ZXQRCodeECB ecbWithCount:13 dataCodewords:42]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:15 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:5 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:15 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:10 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:21
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:28], [NSNumber numberWithInt:50], [NSNumber numberWithInt:72], [NSNumber numberWithInt:94], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:116] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:117]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks:[ZXQRCodeECB ecbWithCount:17 dataCodewords:42]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:17 dataCodewords:22] ecBlocks2:[ZXQRCodeECB ecbWithCount:6 dataCodewords:23]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:19 dataCodewords:16] ecBlocks2:[ZXQRCodeECB ecbWithCount:6 dataCodewords:17]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:22
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:26], [NSNumber numberWithInt:50], [NSNumber numberWithInt:74], [NSNumber numberWithInt:98], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:2 dataCodewords:111] ecBlocks2:[ZXQRCodeECB ecbWithCount:7 dataCodewords:112]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks:[ZXQRCodeECB ecbWithCount:17 dataCodewords:46]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:7 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:16 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:24 ecBlocks:[ZXQRCodeECB ecbWithCount:34 dataCodewords:13]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:23
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:30], [NSNumber numberWithInt:54], [NSNumber numberWithInt:78], [NSNumber numberWithInt:102], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:121] ecBlocks2:[ZXQRCodeECB ecbWithCount:5 dataCodewords:122]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:47] ecBlocks2:[ZXQRCodeECB ecbWithCount:14 dataCodewords:48]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:11 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:14 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:16 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:14 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:24
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:28], [NSNumber numberWithInt:54], [NSNumber numberWithInt:80], [NSNumber numberWithInt:106], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:6 dataCodewords:117] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:118]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:6 dataCodewords:45] ecBlocks2:[ZXQRCodeECB ecbWithCount:14 dataCodewords:46]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:11 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:16 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:30 dataCodewords:16] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:17]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:25
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:32], [NSNumber numberWithInt:58], [NSNumber numberWithInt:84], [NSNumber numberWithInt:110], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:26 ecBlocks1:[ZXQRCodeECB ecbWithCount:8 dataCodewords:106] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:107]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:8 dataCodewords:47] ecBlocks2:[ZXQRCodeECB ecbWithCount:13 dataCodewords:48]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:7 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:22 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:22 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:13 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:26
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:30], [NSNumber numberWithInt:58], [NSNumber numberWithInt:86], [NSNumber numberWithInt:114], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:10 dataCodewords:114] ecBlocks2:[ZXQRCodeECB ecbWithCount:2 dataCodewords:115]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:19 dataCodewords:46] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:47]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:28 dataCodewords:22] ecBlocks2:[ZXQRCodeECB ecbWithCount:6 dataCodewords:23]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:33 dataCodewords:16] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:17]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:27
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:34], [NSNumber numberWithInt:62], [NSNumber numberWithInt:90], [NSNumber numberWithInt:118], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:8 dataCodewords:122] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:123]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:22 dataCodewords:45] ecBlocks2:[ZXQRCodeECB ecbWithCount:3 dataCodewords:46]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:8 dataCodewords:23] ecBlocks2:[ZXQRCodeECB ecbWithCount:26 dataCodewords:24]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:12 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:28 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:28
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:26], [NSNumber numberWithInt:50], [NSNumber numberWithInt:74], [NSNumber numberWithInt:98], [NSNumber numberWithInt:122], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:3 dataCodewords:117] ecBlocks2:[ZXQRCodeECB ecbWithCount:10 dataCodewords:118]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:3 dataCodewords:45] ecBlocks2:[ZXQRCodeECB ecbWithCount:23 dataCodewords:46]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:31 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:11 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:31 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:29
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:30], [NSNumber numberWithInt:54], [NSNumber numberWithInt:78], [NSNumber numberWithInt:102], [NSNumber numberWithInt:126], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:7 dataCodewords:116] ecBlocks2:[ZXQRCodeECB ecbWithCount:7 dataCodewords:117]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:21 dataCodewords:45] ecBlocks2:[ZXQRCodeECB ecbWithCount:7 dataCodewords:46]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:1 dataCodewords:23] ecBlocks2:[ZXQRCodeECB ecbWithCount:37 dataCodewords:24]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:19 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:26 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:30
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:26], [NSNumber numberWithInt:52], [NSNumber numberWithInt:78], [NSNumber numberWithInt:104], [NSNumber numberWithInt:130], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:5 dataCodewords:115] ecBlocks2:[ZXQRCodeECB ecbWithCount:10 dataCodewords:116]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:19 dataCodewords:47] ecBlocks2:[ZXQRCodeECB ecbWithCount:10 dataCodewords:48]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:15 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:25 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:23 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:25 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:31
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:30], [NSNumber numberWithInt:56], [NSNumber numberWithInt:82], [NSNumber numberWithInt:108], [NSNumber numberWithInt:134], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:13 dataCodewords:115] ecBlocks2:[ZXQRCodeECB ecbWithCount:3 dataCodewords:116]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:2 dataCodewords:46] ecBlocks2:[ZXQRCodeECB ecbWithCount:29 dataCodewords:47]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:42 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:1 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:23 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:28 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:32
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:34], [NSNumber numberWithInt:60], [NSNumber numberWithInt:86], [NSNumber numberWithInt:112], [NSNumber numberWithInt:138], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks:[ZXQRCodeECB ecbWithCount:17 dataCodewords:115]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:10 dataCodewords:46] ecBlocks2:[ZXQRCodeECB ecbWithCount:23 dataCodewords:47]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:10 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:35 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:19 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:35 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:33
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:30], [NSNumber numberWithInt:58], [NSNumber numberWithInt:86], [NSNumber numberWithInt:114], [NSNumber numberWithInt:142], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:17 dataCodewords:115] ecBlocks2:[ZXQRCodeECB ecbWithCount:1 dataCodewords:116]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:14 dataCodewords:46] ecBlocks2:[ZXQRCodeECB ecbWithCount:21 dataCodewords:47]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:29 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:19 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:11 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:46 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:34
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:34], [NSNumber numberWithInt:62], [NSNumber numberWithInt:90], [NSNumber numberWithInt:118], [NSNumber numberWithInt:146], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:13 dataCodewords:115] ecBlocks2:[ZXQRCodeECB ecbWithCount:6 dataCodewords:116]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:14 dataCodewords:46] ecBlocks2:[ZXQRCodeECB ecbWithCount:23 dataCodewords:47]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:44 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:7 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:59 dataCodewords:16] ecBlocks2:[ZXQRCodeECB ecbWithCount:1 dataCodewords:17]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:35
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:30], [NSNumber numberWithInt:54], [NSNumber numberWithInt:78], [NSNumber numberWithInt:102], [NSNumber numberWithInt:126], [NSNumber numberWithInt:150], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:12 dataCodewords:121] ecBlocks2:[ZXQRCodeECB ecbWithCount:7 dataCodewords:122]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:12 dataCodewords:47] ecBlocks2:[ZXQRCodeECB ecbWithCount:26 dataCodewords:48]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:39 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:14 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:22 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:41 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:36
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:24], [NSNumber numberWithInt:50], [NSNumber numberWithInt:76], [NSNumber numberWithInt:102], [NSNumber numberWithInt:128], [NSNumber numberWithInt:154], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:6 dataCodewords:121] ecBlocks2:[ZXQRCodeECB ecbWithCount:14 dataCodewords:122]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:6 dataCodewords:47] ecBlocks2:[ZXQRCodeECB ecbWithCount:34 dataCodewords:48]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:46 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:10 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:2 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:64 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:37
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:28], [NSNumber numberWithInt:54], [NSNumber numberWithInt:80], [NSNumber numberWithInt:106], [NSNumber numberWithInt:132], [NSNumber numberWithInt:158], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:17 dataCodewords:122] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:123]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:29 dataCodewords:46] ecBlocks2:[ZXQRCodeECB ecbWithCount:14 dataCodewords:47]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:49 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:10 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:24 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:46 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:38
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:32], [NSNumber numberWithInt:58], [NSNumber numberWithInt:84], [NSNumber numberWithInt:110], [NSNumber numberWithInt:136], [NSNumber numberWithInt:162], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:4 dataCodewords:122] ecBlocks2:[ZXQRCodeECB ecbWithCount:18 dataCodewords:123]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:13 dataCodewords:46] ecBlocks2:[ZXQRCodeECB ecbWithCount:32 dataCodewords:47]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:48 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:14 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:42 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:32 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:39
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:26], [NSNumber numberWithInt:54], [NSNumber numberWithInt:82], [NSNumber numberWithInt:110], [NSNumber numberWithInt:138], [NSNumber numberWithInt:166], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:20 dataCodewords:117] ecBlocks2:[ZXQRCodeECB ecbWithCount:4 dataCodewords:118]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:40 dataCodewords:47] ecBlocks2:[ZXQRCodeECB ecbWithCount:7 dataCodewords:48]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:43 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:22 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:10 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:67 dataCodewords:16]]],
+
+ [ZXQRCodeVersion ZXQRCodeVersionWithVersionNumber:40
+ alignmentPatternCenters:[NSArray arrayWithObjects:[NSNumber numberWithInt:6], [NSNumber numberWithInt:30], [NSNumber numberWithInt:58], [NSNumber numberWithInt:86], [NSNumber numberWithInt:114], [NSNumber numberWithInt:142], [NSNumber numberWithInt:170], nil]
+ ecBlocks1:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:19 dataCodewords:118] ecBlocks2:[ZXQRCodeECB ecbWithCount:6 dataCodewords:119]]
+ ecBlocks2:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:28 ecBlocks1:[ZXQRCodeECB ecbWithCount:18 dataCodewords:47] ecBlocks2:[ZXQRCodeECB ecbWithCount:31 dataCodewords:48]]
+ ecBlocks3:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:34 dataCodewords:24] ecBlocks2:[ZXQRCodeECB ecbWithCount:34 dataCodewords:25]]
+ ecBlocks4:[ZXQRCodeECBlocks ecBlocksWithEcCodewordsPerBlock:30 ecBlocks1:[ZXQRCodeECB ecbWithCount:20 dataCodewords:15] ecBlocks2:[ZXQRCodeECB ecbWithCount:61 dataCodewords:16]]],
+
+ nil];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXAlignmentPattern.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXAlignmentPattern.h
new file mode 100644
index 0000000000000000000000000000000000000000..25aa26c09a882013b7adf9b0554e7515458ef979
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXAlignmentPattern.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultPoint.h"
+
+/**
+ * Encapsulates an alignment pattern, which are the smaller square patterns found in
+ * all but the simplest QR Codes.
+ */
+
+@interface ZXAlignmentPattern : ZXResultPoint
+
+- (id)initWithPosX:(float)posX posY:(float)posY estimatedModuleSize:(float)estimatedModuleSize;
+- (BOOL)aboutEquals:(float)moduleSize i:(float)i j:(float)j;
+- (ZXAlignmentPattern *)combineEstimateI:(float)i j:(float)j newModuleSize:(float)newModuleSize;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXAlignmentPattern.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXAlignmentPattern.m
new file mode 100644
index 0000000000000000000000000000000000000000..af5b28a787eebbc68191b4aabf7b869ec8e76c76
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXAlignmentPattern.m
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAlignmentPattern.h"
+
+@interface ZXAlignmentPattern ()
+
+@property (nonatomic, assign) float estimatedModuleSize;
+
+@end
+
+@implementation ZXAlignmentPattern
+
+@synthesize estimatedModuleSize;
+
+- (id)initWithPosX:(float)posX posY:(float)posY estimatedModuleSize:(float)anEstimatedModuleSize {
+ if (self = [super initWithX:posX y:posY]) {
+ self.estimatedModuleSize = anEstimatedModuleSize;
+ }
+
+ return self;
+}
+
+/**
+ * Determines if this alignment pattern "about equals" an alignment pattern at the stated
+ * position and size -- meaning, it is at nearly the same center with nearly the same size.
+ */
+- (BOOL)aboutEquals:(float)moduleSize i:(float)i j:(float)j {
+ if (fabsf(i - self.y) <= moduleSize && fabsf(j - self.x) <= moduleSize) {
+ float moduleSizeDiff = fabsf(moduleSize - self.estimatedModuleSize);
+ return moduleSizeDiff <= 1.0f || moduleSizeDiff <= estimatedModuleSize;
+ }
+
+ return NO;
+}
+
+/**
+ * Combines this object's current estimate of a finder pattern position and module size
+ * with a new estimate. It returns a new FinderPattern containing an average of the two.
+ */
+- (ZXAlignmentPattern *)combineEstimateI:(float)i j:(float)j newModuleSize:(float)newModuleSize {
+ float combinedX = (self.x + j) / 2.0f;
+ float combinedY = (self.y + i) / 2.0f;
+ float combinedModuleSize = (self.estimatedModuleSize + newModuleSize) / 2.0f;
+ return [[[ZXAlignmentPattern alloc] initWithPosX:combinedX posY:combinedY estimatedModuleSize:combinedModuleSize] autorelease];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXAlignmentPatternFinder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXAlignmentPatternFinder.h
new file mode 100644
index 0000000000000000000000000000000000000000..5014ee1d0aff7d99f23b61741f2c41a8075a1b4d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXAlignmentPatternFinder.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This class attempts to find alignment patterns in a QR Code. Alignment patterns look like finder
+ * patterns but are smaller and appear at regular intervals throughout the image.
+ *
+ * At the moment this only looks for the bottom-right alignment pattern.
+ *
+ * This is mostly a simplified copy of {@link FinderPatternFinder}. It is copied,
+ * pasted and stripped down here for maximum performance but does unfortunately duplicate
+ * some code.
+ *
+ * This class is thread-safe but not reentrant. Each thread must allocate its own object.
+ */
+
+@class ZXAlignmentPattern, ZXBitMatrix;
+@protocol ZXResultPointCallback;
+
+@interface ZXAlignmentPatternFinder : NSObject
+
+- (id)initWithImage:(ZXBitMatrix *)image startX:(int)startX startY:(int)startY width:(int)width height:(int)height moduleSize:(float)moduleSize resultPointCallback:(id <ZXResultPointCallback>)resultPointCallback;
+- (ZXAlignmentPattern *)findWithError:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXAlignmentPatternFinder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXAlignmentPatternFinder.m
new file mode 100644
index 0000000000000000000000000000000000000000..ebcf101e200b0e71e31d9f283b51bae43849483a
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXAlignmentPatternFinder.m
@@ -0,0 +1,259 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAlignmentPattern.h"
+#import "ZXAlignmentPatternFinder.h"
+#import "ZXBitMatrix.h"
+#import "ZXErrors.h"
+#import "ZXResultPointCallback.h"
+
+@interface ZXAlignmentPatternFinder ()
+
+@property (nonatomic, retain) ZXBitMatrix *image;
+@property (nonatomic, retain) NSMutableArray *possibleCenters;
+@property (nonatomic, assign) int startX;
+@property (nonatomic, assign) int startY;
+@property (nonatomic, assign) int width;
+@property (nonatomic, assign) int height;
+@property (nonatomic, assign) float moduleSize;
+@property (nonatomic, assign) int *crossCheckStateCount;
+@property (nonatomic, assign) id <ZXResultPointCallback> resultPointCallback;
+
+- (float)centerFromEnd:(int *)stateCount end:(int)end;
+- (BOOL)foundPatternCross:(int *)stateCount;
+- (ZXAlignmentPattern *)handlePossibleCenter:(int *)stateCount i:(int)i j:(int)j;
+
+@end
+
+@implementation ZXAlignmentPatternFinder
+
+@synthesize image;
+@synthesize possibleCenters;
+@synthesize startX;
+@synthesize startY;
+@synthesize width;
+@synthesize height;
+@synthesize moduleSize;
+@synthesize crossCheckStateCount;
+@synthesize resultPointCallback;
+
+/**
+ * Creates a finder that will look in a portion of the whole image.
+ */
+- (id)initWithImage:(ZXBitMatrix *)anImage startX:(int)aStartX startY:(int)aStartY width:(int)aWidth height:(int)aHeight moduleSize:(float)aModuleSize resultPointCallback:(id <ZXResultPointCallback>)aResultPointCallback {
+ if (self = [super init]) {
+ self.image = anImage;
+ self.possibleCenters = [NSMutableArray arrayWithCapacity:5];
+ self.startX = aStartX;
+ self.startY = aStartY;
+ self.width = aWidth;
+ self.height = aHeight;
+ self.moduleSize = aModuleSize;
+ self.crossCheckStateCount = (int *)malloc(3 * sizeof(int));
+ memset(self.crossCheckStateCount, 0, 3 * sizeof(int));
+ self.resultPointCallback = aResultPointCallback;
+ }
+
+ return self;
+}
+
+- (void) dealloc {
+ if (self.crossCheckStateCount != NULL) {
+ free(self.crossCheckStateCount);
+ self.crossCheckStateCount = NULL;
+ }
+
+ [image release];
+ [possibleCenters release];
+
+ [super dealloc];
+}
+
+
+/**
+ * This method attempts to find the bottom-right alignment pattern in the image. It is a bit messy since
+ * it's pretty performance-critical and so is written to be fast foremost.
+ */
+- (ZXAlignmentPattern *)findWithError:(NSError **)error {
+ int maxJ = self.startX + self.width;
+ int middleI = self.startY + (self.height >> 1);
+ int stateCount[3];
+
+ for (int iGen = 0; iGen < height; iGen++) {
+ int i = middleI + ((iGen & 0x01) == 0 ? (iGen + 1) >> 1 : -((iGen + 1) >> 1));
+ stateCount[0] = 0;
+ stateCount[1] = 0;
+ stateCount[2] = 0;
+ int j = startX;
+
+ while (j < maxJ && ![self.image getX:j y:i]) {
+ j++;
+ }
+
+ int currentState = 0;
+
+ while (j < maxJ) {
+ if ([self.image getX:j y:i]) {
+ if (currentState == 1) {
+ stateCount[currentState]++;
+ } else {
+ if (currentState == 2) {
+ if ([self foundPatternCross:stateCount]) {
+ ZXAlignmentPattern *confirmed = [self handlePossibleCenter:stateCount i:i j:j];
+ if (confirmed != nil) {
+ return confirmed;
+ }
+ }
+ stateCount[0] = stateCount[2];
+ stateCount[1] = 1;
+ stateCount[2] = 0;
+ currentState = 1;
+ } else {
+ stateCount[++currentState]++;
+ }
+ }
+ } else {
+ if (currentState == 1) {
+ currentState++;
+ }
+ stateCount[currentState]++;
+ }
+ j++;
+ }
+
+ if ([self foundPatternCross:stateCount]) {
+ ZXAlignmentPattern *confirmed = [self handlePossibleCenter:stateCount i:i j:maxJ];
+ if (confirmed != nil) {
+ return confirmed;
+ }
+ }
+ }
+
+ if ([self.possibleCenters count] > 0) {
+ return [self.possibleCenters objectAtIndex:0];
+ }
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+}
+
+
+/**
+ * Given a count of black/white/black pixels just seen and an end position,
+ * figures the location of the center of this black/white/black run.
+ */
+- (float)centerFromEnd:(int *)stateCount end:(int)end {
+ return (float)(end - stateCount[2]) - stateCount[1] / 2.0f;
+}
+
+- (BOOL)foundPatternCross:(int *)stateCount {
+ float maxVariance = self.moduleSize / 2.0f;
+
+ for (int i = 0; i < 3; i++) {
+ if (fabsf(self.moduleSize - stateCount[i]) >= maxVariance) {
+ return NO;
+ }
+ }
+
+ return YES;
+}
+
+
+/**
+ * After a horizontal scan finds a potential alignment pattern, this method
+ * "cross-checks" by scanning down vertically through the center of the possible
+ * alignment pattern to see if the same proportion is detected.
+ */
+- (float)crossCheckVertical:(int)startI centerJ:(int)centerJ maxCount:(int)maxCount originalStateCountTotal:(int)originalStateCountTotal {
+ int maxI = self.image.height;
+ int stateCount[3] = {0, 0, 0};
+ int i = startI;
+
+ while (i >= 0 && [self.image getX:centerJ y:i] && stateCount[1] <= maxCount) {
+ stateCount[1]++;
+ i--;
+ }
+
+ if (i < 0 || stateCount[1] > maxCount) {
+ return NAN;
+ }
+
+ while (i >= 0 && ![self.image getX:centerJ y:i] && stateCount[0] <= maxCount) {
+ stateCount[0]++;
+ i--;
+ }
+
+ if (stateCount[0] > maxCount) {
+ return NAN;
+ }
+ i = startI + 1;
+
+ while (i < maxI && [self.image getX:centerJ y:i] && stateCount[1] <= maxCount) {
+ stateCount[1]++;
+ i++;
+ }
+
+ if (i == maxI || stateCount[1] > maxCount) {
+ return NAN;
+ }
+
+ while (i < maxI && ![self.image getX:centerJ y:i] && stateCount[2] <= maxCount) {
+ stateCount[2]++;
+ i++;
+ }
+
+ if (stateCount[2] > maxCount) {
+ return NAN;
+ }
+ int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2];
+ if (5 * abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) {
+ return NAN;
+ }
+ return [self foundPatternCross:stateCount] ? [self centerFromEnd:stateCount end:i] : NAN;
+}
+
+
+/**
+ * This is called when a horizontal scan finds a possible alignment pattern. It will
+ * cross check with a vertical scan, and if successful, will see if this pattern had been
+ * found on a previous horizontal scan. If so, we consider it confirmed and conclude we have
+ * found the alignment pattern.
+ */
+- (ZXAlignmentPattern *)handlePossibleCenter:(int *)stateCount i:(int)i j:(int)j {
+ int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2];
+ float centerJ = [self centerFromEnd:stateCount end:j];
+ float centerI = [self crossCheckVertical:i centerJ:(int)centerJ maxCount:2 * stateCount[1] originalStateCountTotal:stateCountTotal];
+ if (!isnan(centerI)) {
+ float estimatedModuleSize = (float)(stateCount[0] + stateCount[1] + stateCount[2]) / 3.0f;
+ int max = self.possibleCenters.count;
+
+ for (int index = 0; index < max; index++) {
+ ZXAlignmentPattern *center = [self.possibleCenters objectAtIndex:index];
+ // Look for about the same center and module size:
+ if ([center aboutEquals:estimatedModuleSize i:centerI j:centerJ]) {
+ return [center combineEstimateI:centerI j:centerJ newModuleSize:estimatedModuleSize];
+ }
+ }
+ // Hadn't found this before; save it
+ ZXResultPoint *point = [[[ZXAlignmentPattern alloc] initWithPosX:centerJ posY:centerI estimatedModuleSize:estimatedModuleSize] autorelease];
+ [self.possibleCenters addObject:point];
+ if (self.resultPointCallback != nil) {
+ [self.resultPointCallback foundPossibleResultPoint:point];
+ }
+ }
+ return nil;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXFinderPatternFinder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXFinderPatternFinder.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f5cabe7c317484bc69334b1ab8f138bb669d573
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXFinderPatternFinder.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This class attempts to find finder patterns in a QR Code. Finder patterns are the square
+ * markers at three corners of a QR Code.
+ *
+ * This class is thread-safe but not reentrant. Each thread must allocate its own object.
+ */
+
+extern int const FINDER_PATTERN_MIN_SKIP;
+extern int const FINDER_PATTERN_MAX_MODULES;
+
+@class ZXBitMatrix, ZXDecodeHints, ZXFinderPatternInfo;
+@protocol ZXResultPointCallback;
+
+@interface ZXFinderPatternFinder : NSObject
+
+@property (nonatomic, retain, readonly) ZXBitMatrix *image;
+@property (nonatomic, retain, readonly) NSMutableArray *possibleCenters;
+
+- (id)initWithImage:(ZXBitMatrix *)image;
+- (id)initWithImage:(ZXBitMatrix *)image resultPointCallback:(id <ZXResultPointCallback>)resultPointCallback;
+- (ZXFinderPatternInfo *)find:(ZXDecodeHints *)hints error:(NSError **)error;
++ (BOOL)foundPatternCross:(int[])stateCount;
+- (BOOL)handlePossibleCenter:(int[])stateCount i:(int)i j:(int)j;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXFinderPatternFinder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXFinderPatternFinder.m
new file mode 100644
index 0000000000000000000000000000000000000000..ff2694b1b9edcdf20828864ef43354aad88c629b
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXFinderPatternFinder.m
@@ -0,0 +1,504 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitMatrix.h"
+#import "ZXDecodeHints.h"
+#import "ZXErrors.h"
+#import "ZXFinderPatternFinder.h"
+#import "ZXFinderPatternInfo.h"
+#import "ZXOneDReader.h"
+#import "ZXQRCodeFinderPattern.h"
+#import "ZXResultPoint.h"
+#import "ZXResultPointCallback.h"
+
+int const CENTER_QUORUM = 2;
+int const FINDER_PATTERN_MIN_SKIP = 3;
+int const FINDER_PATTERN_MAX_MODULES = 57;
+
+@interface ZXFinderPatternFinder ()
+
+NSInteger centerCompare(id center1, id center2, void *context);
+NSInteger furthestFromAverageCompare(id center1, id center2, void *context);
+
+@property (nonatomic, retain) ZXBitMatrix *image;
+@property (nonatomic, retain) NSMutableArray *possibleCenters;
+@property (nonatomic, assign) BOOL hasSkipped;
+@property (nonatomic, assign) id <ZXResultPointCallback> resultPointCallback;
+
+- (float)centerFromEnd:(int *)stateCount end:(int)end;
+- (int)findRowSkip;
+- (BOOL)haveMultiplyConfirmedCenters;
+- (NSMutableArray *)selectBestPatterns;
+
+@end
+
+@implementation ZXFinderPatternFinder
+
+@synthesize image;
+@synthesize possibleCenters;
+@synthesize hasSkipped;
+@synthesize resultPointCallback;
+
+/**
+ * Creates a finder that will search the image for three finder patterns.
+ */
+- (id)initWithImage:(ZXBitMatrix *)anImage {
+ return [self initWithImage:anImage resultPointCallback:nil];
+}
+
+- (id)initWithImage:(ZXBitMatrix *)anImage resultPointCallback:(id <ZXResultPointCallback>)aResultPointCallback {
+ if (self = [super init]) {
+ self.image = anImage;
+ self.possibleCenters = [NSMutableArray array];
+ self.resultPointCallback = aResultPointCallback;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [image release];
+ [possibleCenters release];
+
+ [super dealloc];
+}
+
+- (ZXFinderPatternInfo *)find:(ZXDecodeHints *)hints error:(NSError **)error {
+ BOOL tryHarder = hints != nil && hints.tryHarder;
+ int maxI = self.image.height;
+ int maxJ = self.image.width;
+ int iSkip = (3 * maxI) / (4 * FINDER_PATTERN_MAX_MODULES);
+ if (iSkip < FINDER_PATTERN_MIN_SKIP || tryHarder) {
+ iSkip = FINDER_PATTERN_MIN_SKIP;
+ }
+
+ BOOL done = NO;
+ int stateCount[5];
+ for (int i = iSkip - 1; i < maxI && !done; i += iSkip) {
+ stateCount[0] = 0;
+ stateCount[1] = 0;
+ stateCount[2] = 0;
+ stateCount[3] = 0;
+ stateCount[4] = 0;
+ int currentState = 0;
+
+ for (int j = 0; j < maxJ; j++) {
+ if ([image getX:j y:i]) {
+ if ((currentState & 1) == 1) {
+ currentState++;
+ }
+ stateCount[currentState]++;
+ } else {
+ if ((currentState & 1) == 0) {
+ if (currentState == 4) {
+ if ([ZXFinderPatternFinder foundPatternCross:stateCount]) {
+ BOOL confirmed = [self handlePossibleCenter:stateCount i:i j:j];
+ if (confirmed) {
+ iSkip = 2;
+ if (hasSkipped) {
+ done = [self haveMultiplyConfirmedCenters];
+ } else {
+ int rowSkip = [self findRowSkip];
+ if (rowSkip > stateCount[2]) {
+ i += rowSkip - stateCount[2] - iSkip;
+ j = maxJ - 1;
+ }
+ }
+ } else {
+ stateCount[0] = stateCount[2];
+ stateCount[1] = stateCount[3];
+ stateCount[2] = stateCount[4];
+ stateCount[3] = 1;
+ stateCount[4] = 0;
+ currentState = 3;
+ continue;
+ }
+ currentState = 0;
+ stateCount[0] = 0;
+ stateCount[1] = 0;
+ stateCount[2] = 0;
+ stateCount[3] = 0;
+ stateCount[4] = 0;
+ } else {
+ stateCount[0] = stateCount[2];
+ stateCount[1] = stateCount[3];
+ stateCount[2] = stateCount[4];
+ stateCount[3] = 1;
+ stateCount[4] = 0;
+ currentState = 3;
+ }
+ } else {
+ stateCount[++currentState]++;
+ }
+ } else {
+ stateCount[currentState]++;
+ }
+ }
+ }
+
+ if ([ZXFinderPatternFinder foundPatternCross:stateCount]) {
+ BOOL confirmed = [self handlePossibleCenter:stateCount i:i j:maxJ];
+ if (confirmed) {
+ iSkip = stateCount[0];
+ if (self.hasSkipped) {
+ done = [self haveMultiplyConfirmedCenters];
+ }
+ }
+ }
+ }
+
+ NSMutableArray *patternInfo = [self selectBestPatterns];
+ if (!patternInfo) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ [ZXResultPoint orderBestPatterns:patternInfo];
+ return [[[ZXFinderPatternInfo alloc] initWithPatternCenters:patternInfo] autorelease];
+}
+
+/**
+ * Given a count of black/white/black/white/black pixels just seen and an end position,
+ * figures the location of the center of this run.
+ */
+- (float)centerFromEnd:(int *)stateCount end:(int)end {
+ return (float)(end - stateCount[4] - stateCount[3]) - stateCount[2] / 2.0f;
+}
+
++ (BOOL)foundPatternCross:(int[])stateCount {
+ int totalModuleSize = 0;
+
+ for (int i = 0; i < 5; i++) {
+ int count = stateCount[i];
+ if (count == 0) {
+ return NO;
+ }
+ totalModuleSize += count;
+ }
+
+ if (totalModuleSize < 7) {
+ return NO;
+ }
+ int moduleSize = (totalModuleSize << INTEGER_MATH_SHIFT) / 7;
+ int maxVariance = moduleSize / 2;
+ return abs(moduleSize - (stateCount[0] << INTEGER_MATH_SHIFT)) < maxVariance &&
+ abs(moduleSize - (stateCount[1] << INTEGER_MATH_SHIFT)) < maxVariance &&
+ abs(3 * moduleSize - (stateCount[2] << INTEGER_MATH_SHIFT)) < 3 * maxVariance &&
+ abs(moduleSize - (stateCount[3] << INTEGER_MATH_SHIFT)) < maxVariance &&
+ abs(moduleSize - (stateCount[4] << INTEGER_MATH_SHIFT)) < maxVariance;
+}
+
+/**
+ * After a horizontal scan finds a potential finder pattern, this method
+ * "cross-checks" by scanning down vertically through the center of the possible
+ * finder pattern to see if the same proportion is detected.
+ */
+- (float)crossCheckVertical:(int)startI centerJ:(int)centerJ maxCount:(int)maxCount originalStateCountTotal:(int)originalStateCountTotal {
+ int maxI = self.image.height;
+ int stateCount[5] = {0, 0, 0, 0, 0};
+
+ int i = startI;
+ while (i >= 0 && [self.image getX:centerJ y:i]) {
+ stateCount[2]++;
+ i--;
+ }
+ if (i < 0) {
+ return NAN;
+ }
+ while (i >= 0 && ![self.image getX:centerJ y:i] && stateCount[1] <= maxCount) {
+ stateCount[1]++;
+ i--;
+ }
+ if (i < 0 || stateCount[1] > maxCount) {
+ return NAN;
+ }
+ while (i >= 0 && [self.image getX:centerJ y:i] && stateCount[0] <= maxCount) {
+ stateCount[0]++;
+ i--;
+ }
+ if (stateCount[0] > maxCount) {
+ return NAN;
+ }
+
+ i = startI + 1;
+ while (i < maxI && [self.image getX:centerJ y:i]) {
+ stateCount[2]++;
+ i++;
+ }
+ if (i == maxI) {
+ return NAN;
+ }
+ while (i < maxI && ![self.image getX:centerJ y:i] && stateCount[3] < maxCount) {
+ stateCount[3]++;
+ i++;
+ }
+ if (i == maxI || stateCount[3] >= maxCount) {
+ return NAN;
+ }
+ while (i < maxI && [self.image getX:centerJ y:i] && stateCount[4] < maxCount) {
+ stateCount[4]++;
+ i++;
+ }
+ if (stateCount[4] >= maxCount) {
+ return NAN;
+ }
+
+ int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4];
+ if (5 * abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) {
+ return NAN;
+ }
+ return [ZXFinderPatternFinder foundPatternCross:stateCount] ? [self centerFromEnd:stateCount end:i] : NAN;
+}
+
+
+/**
+ * Like crossCheckVertical, and in fact is basically identical,
+ * except it reads horizontally instead of vertically. This is used to cross-cross
+ * check a vertical cross check and locate the real center of the alignment pattern.
+ */
+- (float)crossCheckHorizontal:(int)startJ centerI:(int)centerI maxCount:(int)maxCount originalStateCountTotal:(int)originalStateCountTotal {
+ int maxJ = self.image.width;
+ int stateCount[5] = {0, 0, 0, 0, 0};
+
+ int j = startJ;
+ while (j >= 0 && [self.image getX:j y:centerI]) {
+ stateCount[2]++;
+ j--;
+ }
+ if (j < 0) {
+ return NAN;
+ }
+ while (j >= 0 && ![self.image getX:j y:centerI] && stateCount[1] <= maxCount) {
+ stateCount[1]++;
+ j--;
+ }
+ if (j < 0 || stateCount[1] > maxCount) {
+ return NAN;
+ }
+ while (j >= 0 && [self.image getX:j y:centerI] && stateCount[0] <= maxCount) {
+ stateCount[0]++;
+ j--;
+ }
+ if (stateCount[0] > maxCount) {
+ return NAN;
+ }
+
+ j = startJ + 1;
+ while (j < maxJ && [self.image getX:j y:centerI]) {
+ stateCount[2]++;
+ j++;
+ }
+ if (j == maxJ) {
+ return NAN;
+ }
+ while (j < maxJ && ![self.image getX:j y:centerI] && stateCount[3] < maxCount) {
+ stateCount[3]++;
+ j++;
+ }
+ if (j == maxJ || stateCount[3] >= maxCount) {
+ return NAN;
+ }
+ while (j < maxJ && [self.image getX:j y:centerI] && stateCount[4] < maxCount) {
+ stateCount[4]++;
+ j++;
+ }
+ if (stateCount[4] >= maxCount) {
+ return NAN;
+ }
+
+ int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4];
+ if (5 * abs(stateCountTotal - originalStateCountTotal) >= originalStateCountTotal) {
+ return NAN;
+ }
+
+ return [ZXFinderPatternFinder foundPatternCross:stateCount] ? [self centerFromEnd:stateCount end:j] : NAN;
+}
+
+
+/**
+ * This is called when a horizontal scan finds a possible alignment pattern. It will
+ * cross check with a vertical scan, and if successful, will, ah, cross-cross-check
+ * with another horizontal scan. This is needed primarily to locate the real horizontal
+ * center of the pattern in cases of extreme skew.
+ *
+ * If that succeeds the finder pattern location is added to a list that tracks
+ * the number of times each location has been nearly-matched as a finder pattern.
+ * Each additional find is more evidence that the location is in fact a finder
+ * pattern center
+ */
+- (BOOL)handlePossibleCenter:(int *)stateCount i:(int)i j:(int)j {
+ int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4];
+ float centerJ = [self centerFromEnd:stateCount end:j];
+ float centerI = [self crossCheckVertical:i centerJ:(int)centerJ maxCount:stateCount[2] originalStateCountTotal:stateCountTotal];
+ if (!isnan(centerI)) {
+ centerJ = [self crossCheckHorizontal:(int)centerJ centerI:(int)centerI maxCount:stateCount[2] originalStateCountTotal:stateCountTotal];
+ if (!isnan(centerJ)) {
+ float estimatedModuleSize = (float)stateCountTotal / 7.0f;
+ BOOL found = NO;
+ int max = [self.possibleCenters count];
+ for (int index = 0; index < max; index++) {
+ ZXQRCodeFinderPattern *center = [self.possibleCenters objectAtIndex:index];
+ if ([center aboutEquals:estimatedModuleSize i:centerI j:centerJ]) {
+ [possibleCenters replaceObjectAtIndex:index
+ withObject:[center combineEstimateI:centerI j:centerJ newModuleSize:estimatedModuleSize]];
+ found = YES;
+ break;
+ }
+ }
+
+ if (!found) {
+ ZXResultPoint *point = [[[ZXQRCodeFinderPattern alloc] initWithPosX:centerJ posY:centerI estimatedModuleSize:estimatedModuleSize] autorelease];
+ [self.possibleCenters addObject:point];
+ if (self.resultPointCallback != nil) {
+ [self.resultPointCallback foundPossibleResultPoint:point];
+ }
+ }
+ return YES;
+ }
+ }
+ return NO;
+}
+
+
+/**
+ * @return number of rows we could safely skip during scanning, based on the first
+ * two finder patterns that have been located. In some cases their position will
+ * allow us to infer that the third pattern must lie below a certain point farther
+ * down in the image.
+ */
+- (int) findRowSkip {
+ int max = [self.possibleCenters count];
+ if (max <= 1) {
+ return 0;
+ }
+ ZXQRCodeFinderPattern *firstConfirmedCenter = nil;
+ for (int i = 0; i < max; i++) {
+ ZXQRCodeFinderPattern *center = [self.possibleCenters objectAtIndex:i];
+ if ([center count] >= CENTER_QUORUM) {
+ if (firstConfirmedCenter == nil) {
+ firstConfirmedCenter = center;
+ } else {
+ hasSkipped = YES;
+ return (int)(fabsf([firstConfirmedCenter x] - [center x]) - fabsf([firstConfirmedCenter y] - [center y])) / 2;
+ }
+ }
+ }
+ return 0;
+}
+
+
+- (BOOL)haveMultiplyConfirmedCenters {
+ int confirmedCount = 0;
+ float totalModuleSize = 0.0f;
+ int max = [self.possibleCenters count];
+ for (int i = 0; i < max; i++) {
+ ZXQRCodeFinderPattern *pattern = [self.possibleCenters objectAtIndex:i];
+ if ([pattern count] >= CENTER_QUORUM) {
+ confirmedCount++;
+ totalModuleSize += [pattern estimatedModuleSize];
+ }
+ }
+ if (confirmedCount < 3) {
+ return NO;
+ }
+
+ float average = totalModuleSize / (float)max;
+ float totalDeviation = 0.0f;
+ for (int i = 0; i < max; i++) {
+ ZXQRCodeFinderPattern *pattern = [self.possibleCenters objectAtIndex:i];
+ totalDeviation += fabsf([pattern estimatedModuleSize] - average);
+ }
+ return totalDeviation <= 0.05f * totalModuleSize;
+}
+
+/**
+ * Orders by ZXFinderPattern count, descending.
+ */
+NSInteger centerCompare(id center1, id center2, void *context) {
+ float average = [(NSNumber *)context floatValue];
+
+ if ([((ZXQRCodeFinderPattern *)center2) count] == [((ZXQRCodeFinderPattern *)center1) count]) {
+ float dA = fabsf([((ZXQRCodeFinderPattern *)center2) estimatedModuleSize] - average);
+ float dB = fabsf([((ZXQRCodeFinderPattern *)center1) estimatedModuleSize] - average);
+ return dA < dB ? 1 : dA == dB ? 0 : -1;
+ } else {
+ return [((ZXQRCodeFinderPattern *)center2) count] - [((ZXQRCodeFinderPattern *)center1) count];
+ }
+}
+
+/**
+ * Orders by furthest from average
+ */
+NSInteger furthestFromAverageCompare(id center1, id center2, void *context) {
+ float average = [(NSNumber *)context floatValue];
+
+ float dA = fabsf([((ZXQRCodeFinderPattern *)center2) estimatedModuleSize] - average);
+ float dB = fabsf([((ZXQRCodeFinderPattern *)center1) estimatedModuleSize] - average);
+ return dA < dB ? -1 : dA == dB ? 0 : 1;
+}
+
+
+/**
+ * Returns the 3 best ZXFinderPatterns from our list of candidates. The "best" are
+ * those that have been detected at least CENTER_QUORUM times, and whose module
+ * size differs from the average among those patterns the least
+ */
+- (NSMutableArray *)selectBestPatterns {
+ int startSize = [self.possibleCenters count];
+ if (startSize < 3) {
+ return nil;
+ }
+
+ if (startSize > 3) {
+ float totalModuleSize = 0.0f;
+ float square = 0.0f;
+ for (int i = 0; i < startSize; i++) {
+ float size = [[self.possibleCenters objectAtIndex:i] estimatedModuleSize];
+ totalModuleSize += size;
+ square += size * size;
+ }
+ float average = totalModuleSize / (float)startSize;
+ float stdDev = (float)sqrt(square / startSize - average * average);
+
+ [self.possibleCenters sortUsingFunction:furthestFromAverageCompare context:[NSNumber numberWithFloat:average]];
+
+ float limit = MAX(0.2f * average, stdDev);
+
+ for (int i = 0; i < [self.possibleCenters count] && [self.possibleCenters count] > 3; i++) {
+ ZXQRCodeFinderPattern *pattern = [self.possibleCenters objectAtIndex:i];
+ if (fabsf([pattern estimatedModuleSize] - average) > limit) {
+ [self.possibleCenters removeObjectAtIndex:i];
+ i--;
+ }
+ }
+ }
+
+ if ([self.possibleCenters count] > 3) {
+ float totalModuleSize = 0.0f;
+ for (int i = 0; i < [self.possibleCenters count]; i++) {
+ totalModuleSize += [[self.possibleCenters objectAtIndex:i] estimatedModuleSize];
+ }
+
+ float average = totalModuleSize / (float)[self.possibleCenters count];
+
+ [self.possibleCenters sortUsingFunction:centerCompare context:[NSNumber numberWithFloat:average]];
+
+ self.possibleCenters = [[[NSMutableArray alloc] initWithArray:[possibleCenters subarrayWithRange:NSMakeRange(0, 3)]] autorelease];
+ }
+
+ return [NSMutableArray arrayWithObjects:[self.possibleCenters objectAtIndex:0], [self.possibleCenters objectAtIndex:1], [self.possibleCenters objectAtIndex:2], nil];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXFinderPatternInfo.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXFinderPatternInfo.h
new file mode 100644
index 0000000000000000000000000000000000000000..dbea40a372b2f9afb7f44e6e0ad51afd0197c5a0
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXFinderPatternInfo.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates information about finder patterns in an image, including the location of
+ * the three finder patterns, and their estimated module size.
+ */
+
+@class ZXQRCodeFinderPattern;
+
+@interface ZXFinderPatternInfo : NSObject
+
+@property (nonatomic, retain, readonly) ZXQRCodeFinderPattern *bottomLeft;
+@property (nonatomic, retain, readonly) ZXQRCodeFinderPattern *topLeft;
+@property (nonatomic, retain, readonly) ZXQRCodeFinderPattern *topRight;
+
+- (id)initWithPatternCenters:(NSArray *)patternCenters;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXFinderPatternInfo.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXFinderPatternInfo.m
new file mode 100644
index 0000000000000000000000000000000000000000..68246fd943bfe653e9b721ef8e366176d27b1d61
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXFinderPatternInfo.m
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXFinderPatternInfo.h"
+#import "ZXQRCodeFinderPattern.h"
+
+@interface ZXFinderPatternInfo ()
+
+@property (nonatomic, retain) ZXQRCodeFinderPattern *bottomLeft;
+@property (nonatomic, retain) ZXQRCodeFinderPattern *topLeft;
+@property (nonatomic, retain) ZXQRCodeFinderPattern *topRight;
+
+@end
+
+@implementation ZXFinderPatternInfo
+
+@synthesize bottomLeft;
+@synthesize topLeft;
+@synthesize topRight;
+
+- (id)initWithPatternCenters:(NSArray *)patternCenters {
+ if (self = [super init]) {
+ self.bottomLeft = [patternCenters objectAtIndex:0];
+ self.topLeft = [patternCenters objectAtIndex:1];
+ self.topRight = [patternCenters objectAtIndex:2];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [bottomLeft release];
+ [topLeft release];
+ [topRight release];
+
+ [super dealloc];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXQRCodeDetector.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXQRCodeDetector.h
new file mode 100644
index 0000000000000000000000000000000000000000..f8e8574c6477cd4aee07925733a8ccda5bd2ae96
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXQRCodeDetector.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Encapsulates logic that can detect a QR Code in an image, even if the QR Code
+ * is rotated or skewed, or partially obscured.
+ */
+
+@class ZXAlignmentPattern, ZXBitMatrix, ZXDecodeHints, ZXDetectorResult, ZXFinderPatternInfo, ZXPerspectiveTransform, ZXResultPoint;
+@protocol ZXResultPointCallback;
+
+@interface ZXQRCodeDetector : NSObject
+
+@property (nonatomic, retain, readonly) ZXBitMatrix *image;
+@property (nonatomic, assign, readonly) id <ZXResultPointCallback> resultPointCallback;
+
+- (id)initWithImage:(ZXBitMatrix *)image;
+- (ZXDetectorResult *)detectWithError:(NSError **)error;
+- (ZXDetectorResult *)detect:(ZXDecodeHints *)hints error:(NSError **)error;
+- (ZXDetectorResult *)processFinderPatternInfo:(ZXFinderPatternInfo *)info error:(NSError **)error;
++ (int)computeDimension:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight bottomLeft:(ZXResultPoint *)bottomLeft moduleSize:(float)moduleSize error:(NSError **)error;
+- (float)calculateModuleSize:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight bottomLeft:(ZXResultPoint *)bottomLeft;
+- (ZXAlignmentPattern *)findAlignmentInRegion:(float)overallEstModuleSize estAlignmentX:(int)estAlignmentX estAlignmentY:(int)estAlignmentY allowanceFactor:(float)allowanceFactor error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXQRCodeDetector.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXQRCodeDetector.m
new file mode 100644
index 0000000000000000000000000000000000000000..88799eb68b791198e8949a3a47496aa956600634
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXQRCodeDetector.m
@@ -0,0 +1,353 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAlignmentPattern.h"
+#import "ZXAlignmentPatternFinder.h"
+#import "ZXBitMatrix.h"
+#import "ZXDecodeHints.h"
+#import "ZXDetectorResult.h"
+#import "ZXErrors.h"
+#import "ZXFinderPatternFinder.h"
+#import "ZXFinderPatternInfo.h"
+#import "ZXGridSampler.h"
+#import "ZXMathUtils.h"
+#import "ZXPerspectiveTransform.h"
+#import "ZXQRCodeDetector.h"
+#import "ZXQRCodeFinderPattern.h"
+#import "ZXQRCodeVersion.h"
+#import "ZXResultPoint.h"
+#import "ZXResultPointCallback.h"
+
+@interface ZXQRCodeDetector ()
+
+@property (nonatomic, retain) ZXBitMatrix *image;
+@property (nonatomic, assign) id <ZXResultPointCallback> resultPointCallback;
+
+- (float)calculateModuleSizeOneWay:(ZXResultPoint *)pattern otherPattern:(ZXResultPoint *)otherPattern;
++ (ZXPerspectiveTransform *)createTransform:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight bottomLeft:(ZXResultPoint *)bottomLeft alignmentPattern:(ZXResultPoint *)alignmentPattern dimension:(int)dimension;
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)image transform:(ZXPerspectiveTransform *)transform dimension:(int)dimension error:(NSError **)error;
+- (float)sizeOfBlackWhiteBlackRun:(int)fromX fromY:(int)fromY toX:(int)toX toY:(int)toY;
+- (float)sizeOfBlackWhiteBlackRunBothWays:(int)fromX fromY:(int)fromY toX:(int)toX toY:(int)toY;
+
+@end
+
+@implementation ZXQRCodeDetector
+
+@synthesize image;
+@synthesize resultPointCallback;
+
+- (id)initWithImage:(ZXBitMatrix *)anImage {
+ if (self = [super init]) {
+ self.image = anImage;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [image release];
+
+ [super dealloc];
+}
+
+
+/**
+ * Detects a QR Code in an image, simply.
+ */
+- (ZXDetectorResult *)detectWithError:(NSError **)error {
+ return [self detect:nil error:error];
+}
+
+
+/**
+ * Detects a QR Code in an image, simply.
+ */
+- (ZXDetectorResult *)detect:(ZXDecodeHints *)hints error:(NSError **)error {
+ self.resultPointCallback = hints == nil ? nil : hints.resultPointCallback;
+
+ ZXFinderPatternFinder *finder = [[[ZXFinderPatternFinder alloc] initWithImage:image resultPointCallback:resultPointCallback] autorelease];
+ ZXFinderPatternInfo *info = [finder find:hints error:error];
+ if (!info) {
+ return nil;
+ }
+
+ return [self processFinderPatternInfo:info error:error];
+}
+
+- (ZXDetectorResult *)processFinderPatternInfo:(ZXFinderPatternInfo *)info error:(NSError **)error {
+ ZXQRCodeFinderPattern *topLeft = info.topLeft;
+ ZXQRCodeFinderPattern *topRight = info.topRight;
+ ZXQRCodeFinderPattern *bottomLeft = info.bottomLeft;
+
+ float moduleSize = [self calculateModuleSize:topLeft topRight:topRight bottomLeft:bottomLeft];
+ if (moduleSize < 1.0f) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+ int dimension = [ZXQRCodeDetector computeDimension:topLeft topRight:topRight bottomLeft:bottomLeft moduleSize:moduleSize error:error];
+ if (dimension == -1) {
+ return nil;
+ }
+
+ ZXQRCodeVersion *provisionalVersion = [ZXQRCodeVersion provisionalVersionForDimension:dimension];
+ if (!provisionalVersion) {
+ if (error) *error = FormatErrorInstance();
+ return nil;
+ }
+ int modulesBetweenFPCenters = [provisionalVersion dimensionForVersion] - 7;
+
+ ZXAlignmentPattern *alignmentPattern = nil;
+ if ([[provisionalVersion alignmentPatternCenters] count] > 0) {
+ float bottomRightX = [topRight x] - [topLeft x] + [bottomLeft x];
+ float bottomRightY = [topRight y] - [topLeft y] + [bottomLeft y];
+
+ float correctionToTopLeft = 1.0f - 3.0f / (float)modulesBetweenFPCenters;
+ int estAlignmentX = (int)([topLeft x] + correctionToTopLeft * (bottomRightX - [topLeft x]));
+ int estAlignmentY = (int)([topLeft y] + correctionToTopLeft * (bottomRightY - [topLeft y]));
+
+ for (int i = 4; i <= 16; i <<= 1) {
+ NSError *alignmentError = nil;
+ alignmentPattern = [self findAlignmentInRegion:moduleSize estAlignmentX:estAlignmentX estAlignmentY:estAlignmentY allowanceFactor:(float)i error:&alignmentError];
+ if (alignmentPattern) {
+ break;
+ } else if (alignmentError.code != ZXNotFoundError) {
+ if (error) *error = alignmentError;
+ return nil;
+ }
+ }
+ }
+
+ ZXPerspectiveTransform *transform = [ZXQRCodeDetector createTransform:topLeft topRight:topRight bottomLeft:bottomLeft alignmentPattern:alignmentPattern dimension:dimension];
+ ZXBitMatrix *bits = [self sampleGrid:image transform:transform dimension:dimension error:error];
+ if (!bits) {
+ return nil;
+ }
+ NSArray *points;
+ if (alignmentPattern == nil) {
+ points = [NSArray arrayWithObjects:bottomLeft, topLeft, topRight, nil];
+ } else {
+ points = [NSArray arrayWithObjects:bottomLeft, topLeft, topRight, alignmentPattern, nil];
+ }
+ return [[[ZXDetectorResult alloc] initWithBits:bits points:points] autorelease];
+}
+
++ (ZXPerspectiveTransform *)createTransform:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight bottomLeft:(ZXResultPoint *)bottomLeft alignmentPattern:(ZXResultPoint *)alignmentPattern dimension:(int)dimension {
+ float dimMinusThree = (float)dimension - 3.5f;
+ float bottomRightX;
+ float bottomRightY;
+ float sourceBottomRightX;
+ float sourceBottomRightY;
+ if (alignmentPattern != nil) {
+ bottomRightX = alignmentPattern.x;
+ bottomRightY = alignmentPattern.y;
+ sourceBottomRightX = dimMinusThree - 3.0f;
+ sourceBottomRightY = sourceBottomRightX;
+ } else {
+ bottomRightX = (topRight.x - topLeft.x) + bottomLeft.x;
+ bottomRightY = (topRight.y - topLeft.y) + bottomLeft.y;
+ sourceBottomRightX = dimMinusThree;
+ sourceBottomRightY = dimMinusThree;
+ }
+ return [ZXPerspectiveTransform quadrilateralToQuadrilateral:3.5f y0:3.5f
+ x1:dimMinusThree y1:3.5f
+ x2:sourceBottomRightX y2:sourceBottomRightY
+ x3:3.5f y3:dimMinusThree
+ x0p:topLeft.x y0p:topLeft.y
+ x1p:topRight.x y1p:topRight.y
+ x2p:bottomRightX y2p:bottomRightY
+ x3p:bottomLeft.x y3p:bottomLeft.y];
+}
+
+- (ZXBitMatrix *)sampleGrid:(ZXBitMatrix *)anImage transform:(ZXPerspectiveTransform *)transform dimension:(int)dimension error:(NSError **)error {
+ ZXGridSampler *sampler = [ZXGridSampler instance];
+ return [sampler sampleGrid:anImage dimensionX:dimension dimensionY:dimension transform:transform error:error];
+}
+
+
+/**
+ * Computes the dimension (number of modules on a size) of the QR Code based on the position
+ * of the finder patterns and estimated module size. Returns -1 on an error.
+ */
++ (int)computeDimension:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight bottomLeft:(ZXResultPoint *)bottomLeft moduleSize:(float)moduleSize error:(NSError **)error {
+ int tltrCentersDimension = [ZXMathUtils round:[ZXResultPoint distance:topLeft pattern2:topRight] / moduleSize];
+ int tlblCentersDimension = [ZXMathUtils round:[ZXResultPoint distance:topLeft pattern2:bottomLeft] / moduleSize];
+ int dimension = ((tltrCentersDimension + tlblCentersDimension) >> 1) + 7;
+
+ switch (dimension & 0x03) {
+ case 0:
+ dimension++;
+ break;
+ case 2:
+ dimension--;
+ break;
+ case 3:
+ if (error) *error = NotFoundErrorInstance();
+ return -1;
+ }
+ return dimension;
+}
+
+
+/**
+ * Computes an average estimated module size based on estimated derived from the positions
+ * of the three finder patterns.
+ */
+- (float)calculateModuleSize:(ZXResultPoint *)topLeft topRight:(ZXResultPoint *)topRight bottomLeft:(ZXResultPoint *)bottomLeft {
+ return ([self calculateModuleSizeOneWay:topLeft otherPattern:topRight] + [self calculateModuleSizeOneWay:topLeft otherPattern:bottomLeft]) / 2.0f;
+}
+
+
+- (float)calculateModuleSizeOneWay:(ZXResultPoint *)pattern otherPattern:(ZXResultPoint *)otherPattern {
+ float moduleSizeEst1 = [self sizeOfBlackWhiteBlackRunBothWays:(int)[pattern x] fromY:(int)[pattern y] toX:(int)[otherPattern x] toY:(int)[otherPattern y]];
+ float moduleSizeEst2 = [self sizeOfBlackWhiteBlackRunBothWays:(int)[otherPattern x] fromY:(int)[otherPattern y] toX:(int)[pattern x] toY:(int)[pattern y]];
+ if (isnan(moduleSizeEst1)) {
+ return moduleSizeEst2 / 7.0f;
+ }
+ if (isnan(moduleSizeEst2)) {
+ return moduleSizeEst1 / 7.0f;
+ }
+ return (moduleSizeEst1 + moduleSizeEst2) / 14.0f;
+}
+
+
+- (float)sizeOfBlackWhiteBlackRunBothWays:(int)fromX fromY:(int)fromY toX:(int)toX toY:(int)toY {
+ float result = [self sizeOfBlackWhiteBlackRun:fromX fromY:fromY toX:toX toY:toY];
+
+ // Now count other way -- don't run off image though of course
+ float scale = 1.0f;
+ int otherToX = fromX - (toX - fromX);
+ if (otherToX < 0) {
+ scale = (float)fromX / (float)(fromX - otherToX);
+ otherToX = 0;
+ } else if (otherToX >= self.image.width) {
+ scale = (float)(self.image.width - 1 - fromX) / (float)(otherToX - fromX);
+ otherToX = self.image.width - 1;
+ }
+ int otherToY = (int)(fromY - (toY - fromY) * scale);
+
+ scale = 1.0f;
+ if (otherToY < 0) {
+ scale = (float)fromY / (float)(fromY - otherToY);
+ otherToY = 0;
+ } else if (otherToY >= self.image.height) {
+ scale = (float)(self.image.height - 1 - fromY) / (float)(otherToY - fromY);
+ otherToY = self.image.height - 1;
+ }
+ otherToX = (int)(fromX + (otherToX - fromX) * scale);
+
+ result += [self sizeOfBlackWhiteBlackRun:fromX fromY:fromY toX:otherToX toY:otherToY];
+
+ // Middle pixel is double-counted this way; subtract 1
+ return result - 1.0f;
+}
+
+
+/**
+ * This method traces a line from a point in the image, in the direction towards another point.
+ * It begins in a black region, and keeps going until it finds white, then black, then white again.
+ * It reports the distance from the start to this point.
+ *
+ * This is used when figuring out how wide a finder pattern is, when the finder pattern
+ * may be skewed or rotated.
+ */
+- (float)sizeOfBlackWhiteBlackRun:(int)fromX fromY:(int)fromY toX:(int)toX toY:(int)toY {
+ // Mild variant of Bresenham's algorithm;
+ // see http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
+ BOOL steep = abs(toY - fromY) > abs(toX - fromX);
+ if (steep) {
+ int temp = fromX;
+ fromX = fromY;
+ fromY = temp;
+ temp = toX;
+ toX = toY;
+ toY = temp;
+ }
+
+ int dx = abs(toX - fromX);
+ int dy = abs(toY - fromY);
+ int error = -dx >> 1;
+ int xstep = fromX < toX ? 1 : -1;
+ int ystep = fromY < toY ? 1 : -1;
+
+ // In black pixels, looking for white, first or second time.
+ int state = 0;
+ // Loop up until x == toX, but not beyond
+ int xLimit = toX + xstep;
+ for (int x = fromX, y = fromY; x != xLimit; x += xstep) {
+ int realX = steep ? y : x;
+ int realY = steep ? x : y;
+
+ // Does current pixel mean we have moved white to black or vice versa?
+ // Scanning black in state 0,2 and white in state 1, so if we find the wrong
+ // color, advance to next state or end if we are in state 2 already
+ if ((state == 1) == [image getX:realX y:realY]) {
+ if (state == 2) {
+ return [ZXMathUtils distanceInt:x aY:y bX:fromX bY:fromY];
+ }
+ state++;
+ }
+
+ error += dy;
+ if (error > 0) {
+ if (y == toY) {
+ break;
+ }
+ y += ystep;
+ error -= dx;
+ }
+ }
+ // Found black-white-black; give the benefit of the doubt that the next pixel outside the image
+ // is "white" so this last point at (toX+xStep,toY) is the right ending. This is really a
+ // small approximation; (toX+xStep,toY+yStep) might be really correct. Ignore this.
+ if (state == 2) {
+ return [ZXMathUtils distanceInt:toX + xstep aY:toY bX:fromX bY:fromY];
+ }
+ // else we didn't find even black-white-black; no estimate is really possible
+ return NAN;
+}
+
+
+/**
+ * Attempts to locate an alignment pattern in a limited region of the image, which is
+ * guessed to contain it. This method uses ZXAlignmentPattern.
+ */
+- (ZXAlignmentPattern *)findAlignmentInRegion:(float)overallEstModuleSize estAlignmentX:(int)estAlignmentX estAlignmentY:(int)estAlignmentY allowanceFactor:(float)allowanceFactor error:(NSError **)error {
+ int allowance = (int)(allowanceFactor * overallEstModuleSize);
+ int alignmentAreaLeftX = MAX(0, estAlignmentX - allowance);
+ int alignmentAreaRightX = MIN(self.image.width - 1, estAlignmentX + allowance);
+ if (alignmentAreaRightX - alignmentAreaLeftX < overallEstModuleSize * 3) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ int alignmentAreaTopY = MAX(0, estAlignmentY - allowance);
+ int alignmentAreaBottomY = MIN(self.image.height - 1, estAlignmentY + allowance);
+ if (alignmentAreaBottomY - alignmentAreaTopY < overallEstModuleSize * 3) {
+ if (error) *error = NotFoundErrorInstance();
+ return nil;
+ }
+
+ ZXAlignmentPatternFinder *alignmentFinder = [[[ZXAlignmentPatternFinder alloc] initWithImage:self.image
+ startX:alignmentAreaLeftX
+ startY:alignmentAreaTopY
+ width:alignmentAreaRightX - alignmentAreaLeftX
+ height:alignmentAreaBottomY - alignmentAreaTopY
+ moduleSize:overallEstModuleSize
+ resultPointCallback:self.resultPointCallback] autorelease];
+ return [alignmentFinder findWithError:error];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXQRCodeFinderPattern.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXQRCodeFinderPattern.h
new file mode 100644
index 0000000000000000000000000000000000000000..bfc5ba7190b135b84d42dd4c21569814b28b5b7d
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXQRCodeFinderPattern.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXResultPoint.h"
+
+/**
+ * Encapsulates a finder pattern, which are the three square patterns found in
+ * the corners of QR Codes. It also encapsulates a count of similar finder patterns,
+ * as a convenience to the finder's bookkeeping.
+ */
+
+@interface ZXQRCodeFinderPattern : ZXResultPoint
+
+@property (nonatomic, assign, readonly) int count;
+@property (nonatomic, assign, readonly) float estimatedModuleSize;
+
+- (id)initWithPosX:(float)posX posY:(float)posY estimatedModuleSize:(float)estimatedModuleSize;
+- (id)initWithPosX:(float)posX posY:(float)posY estimatedModuleSize:(float)estimatedModuleSize count:(int)count;
+- (void)incrementCount;
+- (BOOL)aboutEquals:(float)moduleSize i:(float)i j:(float)j;
+- (ZXQRCodeFinderPattern *)combineEstimateI:(float)i j:(float)j newModuleSize:(float)newModuleSize;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXQRCodeFinderPattern.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXQRCodeFinderPattern.m
new file mode 100644
index 0000000000000000000000000000000000000000..079ac5deaa22d38be6170b9bf5389ea5175e9fe1
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/detector/ZXQRCodeFinderPattern.m
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXQRCodeFinderPattern.h"
+
+@interface ZXQRCodeFinderPattern ()
+
+@property (nonatomic, assign) int count;
+@property (nonatomic, assign) float estimatedModuleSize;
+
+@end
+
+@implementation ZXQRCodeFinderPattern
+
+@synthesize count;
+@synthesize estimatedModuleSize;
+
+- (id)initWithPosX:(float)posX posY:(float)posY estimatedModuleSize:(float)anEstimatedModuleSize {
+ return [self initWithPosX:posX posY:posY estimatedModuleSize:anEstimatedModuleSize count:1];
+}
+
+- (id)initWithPosX:(float)posX posY:(float)posY estimatedModuleSize:(float)anEstimatedModuleSize count:(int)aCount {
+ if (self = [super initWithX:posX y:posY]) {
+ self.estimatedModuleSize = anEstimatedModuleSize;
+ self.count = aCount;
+ }
+
+ return self;
+}
+
+- (void)incrementCount {
+ self.count++;
+}
+
+/**
+ * Determines if this finder pattern "about equals" a finder pattern at the stated
+ * position and size -- meaning, it is at nearly the same center with nearly the same size.
+ */
+- (BOOL)aboutEquals:(float)moduleSize i:(float)i j:(float)j {
+ if (fabsf(i - [self y]) <= moduleSize && fabsf(j - [self x]) <= moduleSize) {
+ float moduleSizeDiff = fabsf(moduleSize - self.estimatedModuleSize);
+ return moduleSizeDiff <= 1.0f || moduleSizeDiff <= estimatedModuleSize;
+ }
+ return NO;
+}
+
+/**
+ * Combines this object's current estimate of a finder pattern position and module size
+ * with a new estimate. It returns a new ZXQRCodeFinderPattern containing a weighted average
+ * based on count.
+ */
+- (ZXQRCodeFinderPattern *)combineEstimateI:(float)i j:(float)j newModuleSize:(float)newModuleSize {
+ int combinedCount = self.count + 1;
+ float combinedX = (self.count * self.x + j) / combinedCount;
+ float combinedY = (self.count * self.y + i) / combinedCount;
+ float combinedModuleSize = (self.count * self.estimatedModuleSize + newModuleSize) / combinedCount;
+ return [[[ZXQRCodeFinderPattern alloc] initWithPosX:combinedX
+ posY:combinedY
+ estimatedModuleSize:combinedModuleSize
+ count:combinedCount] autorelease];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXBlockPair.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXBlockPair.h
new file mode 100644
index 0000000000000000000000000000000000000000..3b2703da765dd251f9d4edc7a81e94cadd5ba32c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXBlockPair.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@interface ZXBlockPair : NSObject
+
+@property (nonatomic, assign, readonly) unsigned char *dataBytes;
+@property (nonatomic, assign, readonly) unsigned char *errorCorrectionBytes;
+@property (nonatomic, assign, readonly) int errorCorrectionLength;
+@property (nonatomic, assign, readonly) int length;
+
+- (id)initWithData:(unsigned char *)data length:(unsigned int)length errorCorrection:(unsigned char *)errorCorrection errorCorrectionLength:(unsigned int)errorCorrectionLength;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXBlockPair.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXBlockPair.m
new file mode 100644
index 0000000000000000000000000000000000000000..e4dd141a3d994f4ee21fc7daec695acd2bdb3ad1
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXBlockPair.m
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBlockPair.h"
+
+@interface ZXBlockPair ()
+
+@property (nonatomic, assign) unsigned char *dataBytes;
+@property (nonatomic, assign) unsigned char *errorCorrectionBytes;
+@property (nonatomic, assign) int errorCorrectionLength;
+@property (nonatomic, assign) int length;
+
+@end
+
+@implementation ZXBlockPair
+
+@synthesize dataBytes;
+@synthesize errorCorrectionBytes;
+@synthesize errorCorrectionLength;
+@synthesize length;
+
+- (id)initWithData:(unsigned char *)data length:(unsigned int)aLength errorCorrection:(unsigned char *)errorCorrection errorCorrectionLength:(unsigned int)anErrorCorrectionLength{
+ if (self = [super init]) {
+ self.dataBytes = (unsigned char *)malloc(aLength * sizeof(char));
+ memcpy(self.dataBytes, data, aLength * sizeof(char));
+ self.errorCorrectionBytes = (unsigned char *)malloc(anErrorCorrectionLength * sizeof(char));
+ memcpy(self.errorCorrectionBytes, errorCorrection, anErrorCorrectionLength);
+ self.length = aLength;
+ self.errorCorrectionLength = anErrorCorrectionLength;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ if (self.dataBytes != NULL) {
+ free(self.dataBytes);
+ self.dataBytes = NULL;
+ }
+
+ if (self.errorCorrectionBytes != NULL) {
+ free(self.errorCorrectionBytes);
+ self.errorCorrectionBytes = NULL;
+ }
+
+ [super dealloc];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXByteMatrix.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXByteMatrix.h
new file mode 100644
index 0000000000000000000000000000000000000000..a78d9e13f6e89b9f669a293000d4487537dcc808
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXByteMatrix.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@interface ZXByteMatrix : NSObject
+
+@property (nonatomic, assign, readonly) int height;
+@property (nonatomic, assign, readonly) int width;
+@property (nonatomic, assign, readonly) unsigned char **array;
+
+- (id)initWithWidth:(int)width height:(int)height;
+- (char)getX:(int)x y:(int)y;
+- (void)setX:(int)x y:(int)y charValue:(char)value;
+- (void)setX:(int)x y:(int)y intValue:(int)value;
+- (void)setX:(int)x y:(int)y boolValue:(BOOL)value;
+- (void)clear:(char)value;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXByteMatrix.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXByteMatrix.m
new file mode 100644
index 0000000000000000000000000000000000000000..e04f313a5c6b2cb37bc4093a11340f8834213077
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXByteMatrix.m
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXByteMatrix.h"
+
+@interface ZXByteMatrix ()
+
+@property (nonatomic, assign) int height;
+@property (nonatomic, assign) int width;
+@property (nonatomic, assign) unsigned char **array;
+
+@end
+
+@implementation ZXByteMatrix
+
+@synthesize array;
+@synthesize height;
+@synthesize width;
+
+- (id)initWithWidth:(int)aWidth height:(int)aHeight {
+ if (self = [super init]) {
+ self.width = aWidth;
+ self.height = aHeight;
+
+ self.array = (unsigned char **)malloc(aHeight * sizeof(unsigned char *));
+ for (int i = 0; i < aHeight; i++) {
+ self.array[i] = (unsigned char *)malloc(aWidth * sizeof(unsigned char));
+ }
+ [self clear:0];
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ if (self.array != NULL) {
+ for (int i = 0; i < height; i++) {
+ free(self.array[i]);
+ }
+ free(self.array);
+ self.array = NULL;
+ }
+
+ [super dealloc];
+}
+
+- (char)getX:(int)x y:(int)y {
+ return self.array[y][x];
+}
+
+- (void)setX:(int)x y:(int)y charValue:(char)value {
+ self.array[y][x] = value;
+}
+
+- (void)setX:(int)x y:(int)y intValue:(int)value {
+ self.array[y][x] = (char)value;
+}
+
+- (void)setX:(int)x y:(int)y boolValue:(BOOL)value {
+ self.array[y][x] = (char)value;
+}
+
+- (void)clear:(char)value {
+ for (int y = 0; y < self.height; ++y) {
+ for (int x = 0; x < self.width; ++x) {
+ self.array[y][x] = value;
+ }
+ }
+}
+
+- (NSString *)description {
+ NSMutableString *result = [NSMutableString string];
+
+ for (int y = 0; y < self.height; ++y) {
+ for (int x = 0; x < self.width; ++x) {
+ switch (self.array[y][x]) {
+ case 0:
+ [result appendString:@" 0"];
+ break;
+ case 1:
+ [result appendString:@" 1"];
+ break;
+ default:
+ [result appendString:@" "];
+ break;
+ }
+ }
+
+ [result appendString:@"\n"];
+ }
+
+ return result;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXEncoder.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXEncoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..ff9a76ddabe33be8cad5df93e5d5c4c36e8208c4
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXEncoder.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXBitArray, ZXEncodeHints, ZXErrorCorrectionLevel, ZXMode, ZXQRCode, ZXQRCodeVersion;
+
+extern const NSStringEncoding DEFAULT_BYTE_MODE_ENCODING;
+
+@interface ZXEncoder : NSObject
+
++ (ZXQRCode *)encode:(NSString *)content ecLevel:(ZXErrorCorrectionLevel *)ecLevel error:(NSError **)error;
++ (ZXQRCode *)encode:(NSString *)content ecLevel:(ZXErrorCorrectionLevel *)ecLevel hints:(ZXEncodeHints *)hints error:(NSError **)error;
++ (int)alphanumericCode:(int)code;
++ (ZXMode *)chooseMode:(NSString *)content;
++ (BOOL)terminateBits:(int)numDataBytes bits:(ZXBitArray *)bits error:(NSError **)error;
++ (BOOL)numDataBytesAndNumECBytesForBlockID:(int)numTotalBytes numDataBytes:(int)numDataBytes numRSBlocks:(int)numRSBlocks blockID:(int)blockID numDataBytesInBlock:(int[])numDataBytesInBlock numECBytesInBlock:(int[])numECBytesInBlock error:(NSError **)error;
++ (ZXBitArray *)interleaveWithECBytes:(ZXBitArray *)bits numTotalBytes:(int)numTotalBytes numDataBytes:(int)numDataBytes numRSBlocks:(int)numRSBlocks error:(NSError **)error;
++ (unsigned char *)generateECBytes:(unsigned char *)dataBytes numDataBytes:(int)numDataBytes numEcBytesInBlock:(int)numEcBytesInBlock;
++ (void)appendModeInfo:(ZXMode *)mode bits:(ZXBitArray *)bits;
++ (BOOL)appendLengthInfo:(int)numLetters version:(ZXQRCodeVersion *)version mode:(ZXMode *)mode bits:(ZXBitArray *)bits error:(NSError **)error;
++ (BOOL)appendBytes:(NSString *)content mode:(ZXMode *)mode bits:(ZXBitArray *)bits encoding:(NSStringEncoding)encoding error:(NSError **)error;
++ (void)appendNumericBytes:(NSString *)content bits:(ZXBitArray *)bits;
++ (BOOL)appendAlphanumericBytes:(NSString *)content bits:(ZXBitArray *)bits error:(NSError **)error;
++ (void)append8BitBytes:(NSString *)content bits:(ZXBitArray *)bits encoding:(NSStringEncoding)encoding;
++ (BOOL)appendKanjiBytes:(NSString *)content bits:(ZXBitArray *)bits error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXEncoder.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXEncoder.m
new file mode 100644
index 0000000000000000000000000000000000000000..8d75c0f5ac4d72d7275ce8ea6f7a4a73ad28b397
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXEncoder.m
@@ -0,0 +1,630 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXBlockPair.h"
+#import "ZXByteMatrix.h"
+#import "ZXCharacterSetECI.h"
+#import "ZXECI.h"
+#import "ZXEncoder.h"
+#import "ZXEncodeHints.h"
+#import "ZXErrors.h"
+#import "ZXErrorCorrectionLevel.h"
+#import "ZXGenericGF.h"
+#import "ZXMaskUtil.h"
+#import "ZXMatrixUtil.h"
+#import "ZXMode.h"
+#import "ZXQRCodeVersion.h"
+#import "ZXQRCode.h"
+#import "ZXReedSolomonEncoder.h"
+
+// The original table is defined in the table 5 of JISX0510:2004 (p.19).
+const int ALPHANUMERIC_TABLE[96] = {
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x00-0x0f
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x10-0x1f
+ 36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43, // 0x20-0x2f
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1, // 0x30-0x3f
+ -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 0x40-0x4f
+ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, // 0x50-0x5f
+};
+
+const NSStringEncoding DEFAULT_BYTE_MODE_ENCODING = NSISOLatin1StringEncoding;
+
+@interface ZXEncoder ()
+
++ (void)appendECI:(ZXECI *)eci bits:(ZXBitArray *)bits;
++ (int)chooseMaskPattern:(ZXBitArray *)bits ecLevel:(ZXErrorCorrectionLevel *)ecLevel version:(ZXQRCodeVersion *)version matrix:(ZXByteMatrix *)matrix error:(NSError **)error;
++ (ZXMode *)chooseMode:(NSString *)content encoding:(NSStringEncoding)encoding;
++ (ZXQRCodeVersion *)chooseVersion:(int)numInputBits ecLevel:(ZXErrorCorrectionLevel *)ecLevel error:(NSError **)error;
++ (BOOL)isOnlyDoubleByteKanji:(NSString *)content;
++ (int)totalInputBytes:(int)numInputBits version:(ZXQRCodeVersion *)version mode:(ZXMode *)mode;
+
+@end
+
+@implementation ZXEncoder
+
++ (int)calculateMaskPenalty:(ZXByteMatrix *)matrix {
+ return [ZXMaskUtil applyMaskPenaltyRule1:matrix]
+ + [ZXMaskUtil applyMaskPenaltyRule2:matrix]
+ + [ZXMaskUtil applyMaskPenaltyRule3:matrix]
+ + [ZXMaskUtil applyMaskPenaltyRule4:matrix];
+}
+
+
+/**
+ * Encode "bytes" with the error correction level "ecLevel". The encoding mode will be chosen
+ * internally by chooseMode(). On success, store the result in "qrCode".
+ *
+ * We recommend you to use QRCode.EC_LEVEL_L (the lowest level) for
+ * "getECLevel" since our primary use is to show QR code on desktop screens. We don't need very
+ * strong error correction for this purpose.
+ *
+ * Note that there is no way to encode bytes in MODE_KANJI. We might want to add EncodeWithMode()
+ * with which clients can specify the encoding mode. For now, we don't need the functionality.
+ */
++ (ZXQRCode *)encode:(NSString *)content ecLevel:(ZXErrorCorrectionLevel *)ecLevel error:(NSError **)error {
+ return [self encode:content ecLevel:ecLevel hints:nil error:error];
+}
+
++ (ZXQRCode *)encode:(NSString *)content ecLevel:(ZXErrorCorrectionLevel *)ecLevel hints:(ZXEncodeHints *)hints error:(NSError **)error {
+ // Determine what character encoding has been specified by the caller, if any
+ NSStringEncoding encoding = hints == nil ? 0 : hints.encoding;
+ if (encoding == 0) {
+ encoding = DEFAULT_BYTE_MODE_ENCODING;
+ }
+
+ // Pick an encoding mode appropriate for the content. Note that this will not attempt to use
+ // multiple modes / segments even if that were more efficient. Twould be nice.
+ ZXMode *mode = [self chooseMode:content encoding:encoding];
+
+ // This will store the header information, like mode and
+ // length, as well as "header" segments like an ECI segment.
+ ZXBitArray *headerBits = [[[ZXBitArray alloc] init] autorelease];
+
+ // Append ECI segment if applicable
+ if ([mode isEqual:[ZXMode byteMode]] && DEFAULT_BYTE_MODE_ENCODING != encoding) {
+ ZXCharacterSetECI *eci = [ZXCharacterSetECI characterSetECIByEncoding:encoding];
+ if (eci != nil) {
+ [self appendECI:eci bits:headerBits];
+ }
+ }
+
+ // (With ECI in place,) Write the mode marker
+ [self appendModeInfo:mode bits:headerBits];
+
+ // Collect data within the main segment, separately, to count its size if needed. Don't add it to
+ // main payload yet.
+ ZXBitArray *dataBits = [[[ZXBitArray alloc] init] autorelease];
+ if (![self appendBytes:content mode:mode bits:dataBits encoding:encoding error:error]) {
+ return nil;
+ }
+
+ // Hard part: need to know version to know how many bits length takes. But need to know how many
+ // bits it takes to know version. First we take a guess at version by assuming version will be
+ // the minimum, 1:
+
+ int provisionalBitsNeeded = headerBits.size
+ + [mode characterCountBits:[ZXQRCodeVersion versionForNumber:1]]
+ + dataBits.size;
+ ZXQRCodeVersion *provisionalVersion = [self chooseVersion:provisionalBitsNeeded ecLevel:ecLevel error:error];
+ if (!provisionalVersion) {
+ return nil;
+ }
+
+ // Use that guess to calculate the right version. I am still not sure this works in 100% of cases.
+
+ int bitsNeeded = headerBits.size
+ + [mode characterCountBits:provisionalVersion]
+ + dataBits.size;
+ ZXQRCodeVersion *version = [self chooseVersion:bitsNeeded ecLevel:ecLevel error:error];
+ if (!version) {
+ return nil;
+ }
+
+ ZXBitArray *headerAndDataBits = [[[ZXBitArray alloc] init] autorelease];
+ [headerAndDataBits appendBitArray:headerBits];
+ // Find "length" of main segment and write it
+ int numLetters = [mode isEqual:[ZXMode byteMode]] ? [dataBits sizeInBytes] : [content length];
+ if (![self appendLengthInfo:numLetters version:version mode:mode bits:headerAndDataBits error:error]) {
+ return nil;
+ }
+ // Put data together into the overall payload
+ [headerAndDataBits appendBitArray:dataBits];
+
+ ZXQRCodeECBlocks *ecBlocks = [version ecBlocksForLevel:ecLevel];
+ int numDataBytes = version.totalCodewords - ecBlocks.totalECCodewords;
+
+ // Terminate the bits properly.
+ if (![self terminateBits:numDataBytes bits:headerAndDataBits error:error]) {
+ return nil;
+ }
+
+ // Interleave data bits with error correction code.
+ ZXBitArray *finalBits = [self interleaveWithECBytes:headerAndDataBits numTotalBytes:version.totalCodewords numDataBytes:numDataBytes
+ numRSBlocks:ecBlocks.numBlocks error:error];
+ if (!finalBits) {
+ return nil;
+ }
+
+ ZXQRCode *qrCode = [[[ZXQRCode alloc] init] autorelease];
+
+ qrCode.ecLevel = ecLevel;
+ qrCode.mode = mode;
+ qrCode.version = version;
+
+ // Choose the mask pattern and set to "qrCode".
+ int dimension = version.dimensionForVersion;
+ ZXByteMatrix *matrix = [[[ZXByteMatrix alloc] initWithWidth:dimension height:dimension] autorelease];
+ int maskPattern = [self chooseMaskPattern:finalBits ecLevel:[qrCode ecLevel] version:[qrCode version] matrix:matrix error:error];
+ if (maskPattern == -1) {
+ return nil;
+ }
+ [qrCode setMaskPattern:maskPattern];
+
+ // Build the matrix and set it to "qrCode".
+ if (![ZXMatrixUtil buildMatrix:finalBits ecLevel:ecLevel version:version maskPattern:maskPattern matrix:matrix error:error]) {
+ return nil;
+ }
+ [qrCode setMatrix:matrix];
+
+ return qrCode;
+}
+
+
+/**
+ * Return the code point of the table used in alphanumeric mode or
+ * -1 if there is no corresponding code in the table.
+ */
++ (int)alphanumericCode:(int)code {
+ if (code < sizeof(ALPHANUMERIC_TABLE) / sizeof(int)) {
+ return ALPHANUMERIC_TABLE[code];
+ }
+ return -1;
+}
+
++ (ZXMode *)chooseMode:(NSString *)content {
+ return [self chooseMode:content encoding:-1];
+}
+
+
+/**
+ * Choose the best mode by examining the content. Note that 'encoding' is used as a hint;
+ * if it is Shift_JIS, and the input is only double-byte Kanji, then we return {@link Mode#KANJI}.
+ */
++ (ZXMode *)chooseMode:(NSString *)content encoding:(NSStringEncoding)encoding {
+ if (NSShiftJISStringEncoding == encoding) {
+ return [self isOnlyDoubleByteKanji:content] ? [ZXMode kanjiMode] : [ZXMode byteMode];
+ }
+ BOOL hasNumeric = NO;
+ BOOL hasAlphanumeric = NO;
+ for (int i = 0; i < [content length]; ++i) {
+ unichar c = [content characterAtIndex:i];
+ if (c >= '0' && c <= '9') {
+ hasNumeric = YES;
+ } else if ([self alphanumericCode:c] != -1) {
+ hasAlphanumeric = YES;
+ } else {
+ return [ZXMode byteMode];
+ }
+ }
+ if (hasAlphanumeric) {
+ return [ZXMode alphanumericMode];
+ }
+ if (hasNumeric) {
+ return [ZXMode numericMode];
+ }
+ return [ZXMode byteMode];
+}
+
++ (BOOL)isOnlyDoubleByteKanji:(NSString *)content {
+ NSData *data = [content dataUsingEncoding:NSShiftJISStringEncoding];
+ unsigned char *bytes = (unsigned char *)[data bytes];
+ int length = [data length];
+ if (length % 2 != 0) {
+ return NO;
+ }
+ for (int i = 0; i < length; i += 2) {
+ int byte1 = bytes[i] & 0xFF;
+ if ((byte1 < 0x81 || byte1 > 0x9F) && (byte1 < 0xE0 || byte1 > 0xEB)) {
+ return NO;
+ }
+ }
+ return YES;
+}
+
++ (int)chooseMaskPattern:(ZXBitArray *)bits ecLevel:(ZXErrorCorrectionLevel *)ecLevel version:(ZXQRCodeVersion *)version matrix:(ZXByteMatrix *)matrix error:(NSError **)error {
+ int minPenalty = NSIntegerMax;
+ int bestMaskPattern = -1;
+
+ for (int maskPattern = 0; maskPattern < NUM_MASK_PATTERNS; maskPattern++) {
+ if (![ZXMatrixUtil buildMatrix:bits ecLevel:ecLevel version:version maskPattern:maskPattern matrix:matrix error:error]) {
+ return -1;
+ }
+ int penalty = [self calculateMaskPenalty:matrix];
+ if (penalty < minPenalty) {
+ minPenalty = penalty;
+ bestMaskPattern = maskPattern;
+ }
+ }
+ return bestMaskPattern;
+}
+
+
++ (ZXQRCodeVersion *)chooseVersion:(int)numInputBits ecLevel:(ZXErrorCorrectionLevel *)ecLevel error:(NSError **)error {
+ // In the following comments, we use numbers of Version 7-H.
+ for (int versionNum = 1; versionNum <= 40; versionNum++) {
+ ZXQRCodeVersion *version = [ZXQRCodeVersion versionForNumber:versionNum];
+ // numBytes = 196
+ int numBytes = version.totalCodewords;
+ // getNumECBytes = 130
+ ZXQRCodeECBlocks *ecBlocks = [version ecBlocksForLevel:ecLevel];
+ int numEcBytes = ecBlocks.totalECCodewords;
+ // getNumDataBytes = 196 - 130 = 66
+ int numDataBytes = numBytes - numEcBytes;
+ int totalInputBytes = (numInputBits + 7) / 8;
+ if (numDataBytes >= totalInputBytes) {
+ return version;
+ }
+ }
+
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"Data too big" forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return nil;
+}
+
++ (int)totalInputBytes:(int)numInputBits version:(ZXQRCodeVersion *)version mode:(ZXMode *)mode {
+ int modeInfoBits = 4;
+ int charCountBits = [mode characterCountBits:version];
+ int headerBits = modeInfoBits + charCountBits;
+ int totalBits = numInputBits + headerBits;
+
+ return (totalBits + 7) / 8;
+}
+
+/**
+ * Terminate bits as described in 8.4.8 and 8.4.9 of JISX0510:2004 (p.24).
+ */
++ (BOOL)terminateBits:(int)numDataBytes bits:(ZXBitArray *)bits error:(NSError **)error {
+ int capacity = numDataBytes << 3;
+ if ([bits size] > capacity) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSString stringWithFormat:@"data bits cannot fit in the QR Code %d > %d", [bits size], capacity]
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return NO;
+ }
+ for (int i = 0; i < 4 && [bits size] < capacity; ++i) {
+ [bits appendBit:NO];
+ }
+ int numBitsInLastByte = [bits size] & 0x07;
+ if (numBitsInLastByte > 0) {
+ for (int i = numBitsInLastByte; i < 8; i++) {
+ [bits appendBit:NO];
+ }
+ }
+ int numPaddingBytes = numDataBytes - [bits sizeInBytes];
+ for (int i = 0; i < numPaddingBytes; ++i) {
+ [bits appendBits:(i & 0x01) == 0 ? 0xEC : 0x11 numBits:8];
+ }
+ if ([bits size] != capacity) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"Bits size does not equal capacity"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return NO;
+ }
+ return YES;
+}
+
+
+/**
+ * Get number of data bytes and number of error correction bytes for block id "blockID". Store
+ * the result in "numDataBytesInBlock", and "numECBytesInBlock". See table 12 in 8.5.1 of
+ * JISX0510:2004 (p.30)
+ */
++ (BOOL)numDataBytesAndNumECBytesForBlockID:(int)numTotalBytes numDataBytes:(int)numDataBytes numRSBlocks:(int)numRSBlocks blockID:(int)blockID numDataBytesInBlock:(int[])numDataBytesInBlock numECBytesInBlock:(int[])numECBytesInBlock error:(NSError **)error {
+ if (blockID >= numRSBlocks) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"Block ID too large"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return NO;
+ }
+ int numRsBlocksInGroup2 = numTotalBytes % numRSBlocks;
+ int numRsBlocksInGroup1 = numRSBlocks - numRsBlocksInGroup2;
+ int numTotalBytesInGroup1 = numTotalBytes / numRSBlocks;
+ int numTotalBytesInGroup2 = numTotalBytesInGroup1 + 1;
+ int numDataBytesInGroup1 = numDataBytes / numRSBlocks;
+ int numDataBytesInGroup2 = numDataBytesInGroup1 + 1;
+ int numEcBytesInGroup1 = numTotalBytesInGroup1 - numDataBytesInGroup1;
+ int numEcBytesInGroup2 = numTotalBytesInGroup2 - numDataBytesInGroup2;
+ if (numEcBytesInGroup1 != numEcBytesInGroup2) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"EC bytes mismatch"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return NO;
+ }
+ if (numRSBlocks != numRsBlocksInGroup1 + numRsBlocksInGroup2) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"RS blocks mismatch"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return NO;
+ }
+ if (numTotalBytes != ((numDataBytesInGroup1 + numEcBytesInGroup1) * numRsBlocksInGroup1) + ((numDataBytesInGroup2 + numEcBytesInGroup2) * numRsBlocksInGroup2)) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"Total bytes mismatch"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return NO;
+ }
+ if (blockID < numRsBlocksInGroup1) {
+ numDataBytesInBlock[0] = numDataBytesInGroup1;
+ numECBytesInBlock[0] = numEcBytesInGroup1;
+ } else {
+ numDataBytesInBlock[0] = numDataBytesInGroup2;
+ numECBytesInBlock[0] = numEcBytesInGroup2;
+ }
+ return YES;
+}
+
+
+/**
+ * Interleave "bits" with corresponding error correction bytes. On success, store the result in
+ * "result". The interleave rule is complicated. See 8.6 of JISX0510:2004 (p.37) for details.
+ */
++ (ZXBitArray *)interleaveWithECBytes:(ZXBitArray *)bits numTotalBytes:(int)numTotalBytes numDataBytes:(int)numDataBytes numRSBlocks:(int)numRSBlocks error:(NSError **)error {
+ // "bits" must have "getNumDataBytes" bytes of data.
+ if ([bits sizeInBytes] != numDataBytes) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"Number of bits and data bytes does not match"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return nil;
+ }
+
+ // Step 1. Divide data bytes into blocks and generate error correction bytes for them. We'll
+ // store the divided data bytes blocks and error correction bytes blocks into "blocks".
+ int dataBytesOffset = 0;
+ int maxNumDataBytes = 0;
+ int maxNumEcBytes = 0;
+
+ // Since, we know the number of reedsolmon blocks, we can initialize the vector with the number.
+ NSMutableArray *blocks = [NSMutableArray arrayWithCapacity:numRSBlocks];
+
+ for (int i = 0; i < numRSBlocks; ++i) {
+ int numDataBytesInBlock[1];
+ int numEcBytesInBlock[1];
+ if (![self numDataBytesAndNumECBytesForBlockID:numTotalBytes numDataBytes:numDataBytes numRSBlocks:numRSBlocks
+ blockID:i numDataBytesInBlock:numDataBytesInBlock
+ numECBytesInBlock:numEcBytesInBlock error:error]) {
+ return nil;
+ }
+
+ int size = numDataBytesInBlock[0];
+ unsigned char dataBytes[size];
+ [bits toBytes:8 * dataBytesOffset array:dataBytes offset:0 numBytes:size];
+ unsigned char *ecBytes = [self generateECBytes:dataBytes numDataBytes:size numEcBytesInBlock:numEcBytesInBlock[0]];
+ [blocks addObject:[[[ZXBlockPair alloc] initWithData:dataBytes length:size errorCorrection:ecBytes errorCorrectionLength:numEcBytesInBlock[0]] autorelease]];
+
+ maxNumDataBytes = MAX(maxNumDataBytes, size);
+ maxNumEcBytes = MAX(maxNumEcBytes, numEcBytesInBlock[0]);
+ dataBytesOffset += numDataBytesInBlock[0];
+ free(ecBytes);
+ }
+ if (numDataBytes != dataBytesOffset) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"Data bytes does not match offset"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return nil;
+ }
+
+ ZXBitArray *result = [[[ZXBitArray alloc] init] autorelease];
+
+ // First, place data blocks.
+ for (int i = 0; i < maxNumDataBytes; ++i) {
+ for (ZXBlockPair *block in blocks) {
+ unsigned char *dataBytes = block.dataBytes;
+ int length = block.length;
+ if (i < length) {
+ [result appendBits:dataBytes[i] numBits:8];
+ }
+ }
+ }
+ // Then, place error correction blocks.
+ for (int i = 0; i < maxNumEcBytes; ++i) {
+ for (ZXBlockPair *block in blocks) {
+ unsigned char *ecBytes = block.errorCorrectionBytes;
+ int length = block.errorCorrectionLength;
+ if (i < length) {
+ [result appendBits:ecBytes[i] numBits:8];
+ }
+ }
+ }
+ if (numTotalBytes != [result sizeInBytes]) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSString stringWithFormat:@"Interleaving error: %d and %d differ.", numTotalBytes, [result sizeInBytes]]
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return nil;
+ }
+
+ return result;
+}
+
++ (unsigned char *)generateECBytes:(unsigned char[])dataBytes numDataBytes:(int)numDataBytes numEcBytesInBlock:(int)numEcBytesInBlock {
+ int toEncodeLen = numDataBytes + numEcBytesInBlock;
+ int toEncode[toEncodeLen];
+ for (int i = 0; i < numDataBytes; i++) {
+ toEncode[i] = dataBytes[i] & 0xFF;
+ }
+ for (int i = numDataBytes; i < toEncodeLen; i++) {
+ toEncode[i] = 0;
+ }
+
+ [[[[ZXReedSolomonEncoder alloc] initWithField:[ZXGenericGF QrCodeField256]] autorelease] encode:toEncode toEncodeLen:toEncodeLen ecBytes:numEcBytesInBlock];
+
+ unsigned char *ecBytes = (unsigned char *)malloc(numEcBytesInBlock * sizeof(unsigned char));
+ for (int i = 0; i < numEcBytesInBlock; i++) {
+ ecBytes[i] = (unsigned char)toEncode[numDataBytes + i];
+ }
+
+ return ecBytes;
+}
+
+
+/**
+ * Append mode info. On success, store the result in "bits".
+ */
++ (void)appendModeInfo:(ZXMode *)mode bits:(ZXBitArray *)bits {
+ [bits appendBits:[mode bits] numBits:4];
+}
+
+
+/**
+ * Append length info. On success, store the result in "bits".
+ */
++ (BOOL)appendLengthInfo:(int)numLetters version:(ZXQRCodeVersion *)version mode:(ZXMode *)mode bits:(ZXBitArray *)bits error:(NSError **)error {
+ int numBits = [mode characterCountBits:version];
+ if (numLetters >= (1 << numBits)) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSString stringWithFormat:@"%d is bigger than %d", numLetters, ((1 << numBits) - 1)]
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return NO;
+ }
+ [bits appendBits:numLetters numBits:numBits];
+ return YES;
+}
+
+
+/**
+ * Append "bytes" in "mode" mode (encoding) into "bits". On success, store the result in "bits".
+ */
++ (BOOL)appendBytes:(NSString *)content mode:(ZXMode *)mode bits:(ZXBitArray *)bits encoding:(NSStringEncoding)encoding error:(NSError **)error {
+ if ([mode isEqual:[ZXMode numericMode]]) {
+ [self appendNumericBytes:content bits:bits];
+ } else if ([mode isEqual:[ZXMode alphanumericMode]]) {
+ if (![self appendAlphanumericBytes:content bits:bits error:error]) {
+ return NO;
+ }
+ } else if ([mode isEqual:[ZXMode byteMode]]) {
+ [self append8BitBytes:content bits:bits encoding:encoding];
+ } else if ([mode isEqual:[ZXMode kanjiMode]]) {
+ if (![self appendKanjiBytes:content bits:bits error:error]) {
+ return NO;
+ }
+ } else {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSString stringWithFormat:@"Invalid mode: %@", mode]
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return NO;
+ }
+ return YES;
+}
+
++ (void)appendNumericBytes:(NSString *)content bits:(ZXBitArray *)bits {
+ int length = [content length];
+ int i = 0;
+ while (i < length) {
+ int num1 = [content characterAtIndex:i] - '0';
+ if (i + 2 < length) {
+ int num2 = [content characterAtIndex:i + 1] - '0';
+ int num3 = [content characterAtIndex:i + 2] - '0';
+ [bits appendBits:num1 * 100 + num2 * 10 + num3 numBits:10];
+ i += 3;
+ } else if (i + 1 < length) {
+ int num2 = [content characterAtIndex:i + 1] - '0';
+ [bits appendBits:num1 * 10 + num2 numBits:7];
+ i += 2;
+ } else {
+ [bits appendBits:num1 numBits:4];
+ i++;
+ }
+ }
+}
+
++ (BOOL)appendAlphanumericBytes:(NSString *)content bits:(ZXBitArray *)bits error:(NSError **)error {
+ int length = [content length];
+ int i = 0;
+
+ while (i < length) {
+ int code1 = [self alphanumericCode:[content characterAtIndex:i]];
+ if (code1 == -1) {
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:nil] autorelease];
+ return NO;
+ }
+ if (i + 1 < length) {
+ int code2 = [self alphanumericCode:[content characterAtIndex:i + 1]];
+ if (code2 == -1) {
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:nil] autorelease];
+ return NO;
+ }
+ [bits appendBits:code1 * 45 + code2 numBits:11];
+ i += 2;
+ } else {
+ [bits appendBits:code1 numBits:6];
+ i++;
+ }
+ }
+ return YES;
+}
+
++ (void)append8BitBytes:(NSString *)content bits:(ZXBitArray *)bits encoding:(NSStringEncoding)encoding {
+ NSData *data = [content dataUsingEncoding:encoding];
+ unsigned char *bytes = (unsigned char *)[data bytes];
+
+ for (int i = 0; i < [data length]; ++i) {
+ [bits appendBits:bytes[i] numBits:8];
+ }
+}
+
++ (BOOL)appendKanjiBytes:(NSString *)content bits:(ZXBitArray *)bits error:(NSError **)error {
+ NSData *data = [content dataUsingEncoding:NSShiftJISStringEncoding];
+ unsigned char *bytes = (unsigned char *)[data bytes];
+ for (int i = 0; i < [data length]; i += 2) {
+ int byte1 = bytes[i] & 0xFF;
+ int byte2 = bytes[i + 1] & 0xFF;
+ int code = (byte1 << 8) | byte2;
+ int subtracted = -1;
+ if (code >= 0x8140 && code <= 0x9ffc) {
+ subtracted = code - 0x8140;
+ } else if (code >= 0xe040 && code <= 0xebbf) {
+ subtracted = code - 0xc140;
+ }
+ if (subtracted == -1) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"Invalid byte sequence"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo] autorelease];
+ return NO;
+ }
+ int encoded = ((subtracted >> 8) * 0xc0) + (subtracted & 0xff);
+ [bits appendBits:encoded numBits:13];
+ }
+ return YES;
+}
+
++ (void)appendECI:(ZXECI *)eci bits:(ZXBitArray *)bits {
+ [bits appendBits:[[ZXMode eciMode] bits] numBits:4];
+ [bits appendBits:[eci value] numBits:8];
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXMaskUtil.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXMaskUtil.h
new file mode 100644
index 0000000000000000000000000000000000000000..9d7f146af504acdd708030dfde54522c9a1a38d1
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXMaskUtil.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXByteMatrix;
+
+@interface ZXMaskUtil : NSObject
+
++ (int)applyMaskPenaltyRule1:(ZXByteMatrix *)matrix;
++ (int)applyMaskPenaltyRule2:(ZXByteMatrix *)matrix;
++ (int)applyMaskPenaltyRule3:(ZXByteMatrix *)matrix;
++ (int)applyMaskPenaltyRule4:(ZXByteMatrix *)matrix;
++ (BOOL)dataMaskBit:(int)maskPattern x:(int)x y:(int)y;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXMaskUtil.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXMaskUtil.m
new file mode 100644
index 0000000000000000000000000000000000000000..b59de4d0eccc3f6d77589cb9040d5f4e13130911
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXMaskUtil.m
@@ -0,0 +1,220 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXByteMatrix.h"
+#import "ZXMaskUtil.h"
+#import "ZXQRCode.h"
+
+// Penalty weights from section 6.8.2.1
+const int N1 = 3;
+const int N2 = 3;
+const int N3 = 40;
+const int N4 = 10;
+
+@interface ZXMaskUtil ()
+
++ (int)applyMaskPenaltyRule1Internal:(ZXByteMatrix *)matrix isHorizontal:(BOOL)isHorizontal;
+
+@end
+
+@implementation ZXMaskUtil
+
+/**
+ * Apply mask penalty rule 1 and return the penalty. Find repetitive cells with the same color and
+ * give penalty to them. Example: 00000 or 11111.
+ */
++ (int)applyMaskPenaltyRule1:(ZXByteMatrix *)matrix {
+ return [self applyMaskPenaltyRule1Internal:matrix isHorizontal:YES] + [self applyMaskPenaltyRule1Internal:matrix isHorizontal:NO];
+}
+
+/**
+ * Apply mask penalty rule 2 and return the penalty. Find 2x2 blocks with the same color and give
+ * penalty to them. This is actually equivalent to the spec's rule, which is to find MxN blocks and give a
+ * penalty proportional to (M-1)x(N-1), because this is the number of 2x2 blocks inside such a block.
+ */
++ (int)applyMaskPenaltyRule2:(ZXByteMatrix *)matrix {
+ int penalty = 0;
+ unsigned char **array = matrix.array;
+ int width = matrix.width;
+ int height = matrix.height;
+
+ for (int y = 0; y < height - 1; y++) {
+ for (int x = 0; x < width - 1; x++) {
+ int value = array[y][x];
+ if (value == array[y][x + 1] && value == array[y + 1][x] && value == array[y + 1][x + 1]) {
+ penalty++;
+ }
+ }
+ }
+
+ return N2 * penalty;
+}
+
+/**
+ * Apply mask penalty rule 3 and return the penalty. Find consecutive cells of 00001011101 or
+ * 10111010000, and give penalty to them. If we find patterns like 000010111010000, we give
+ * penalties twice (i.e. 40 * 2).
+ */
++ (int)applyMaskPenaltyRule3:(ZXByteMatrix *)matrix {
+ int penalty = 0;
+ unsigned char **array = matrix.array;
+ int width = matrix.width;
+ int height = matrix.height;
+
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ if (x + 6 < width &&
+ array[y][x] == 1 &&
+ array[y][x + 1] == 0 &&
+ array[y][x + 2] == 1 &&
+ array[y][x + 3] == 1 &&
+ array[y][x + 4] == 1 &&
+ array[y][x + 5] == 0 &&
+ array[y][x + 6] == 1 &&
+ ((x + 10 < width &&
+ array[y][x + 7] == 0 &&
+ array[y][x + 8] == 0 &&
+ array[y][x + 9] == 0 &&
+ array[y][x + 10] == 0) ||
+ (x - 4 >= 0 &&
+ array[y][x - 1] == 0 &&
+ array[y][x - 2] == 0 &&
+ array[y][x - 3] == 0 &&
+ array[y][x - 4] == 0))) {
+ penalty += N3;
+ }
+ if (y + 6 < height &&
+ array[y][x] == 1 &&
+ array[y + 1][x] == 0 &&
+ array[y + 2][x] == 1 &&
+ array[y + 3][x] == 1 &&
+ array[y + 4][x] == 1 &&
+ array[y + 5][x] == 0 &&
+ array[y + 6][x] == 1 &&
+ ((y + 10 < height &&
+ array[y + 7][x] == 0 &&
+ array[y + 8][x] == 0 &&
+ array[y + 9][x] == 0 &&
+ array[y + 10][x] == 0) ||
+ (y - 4 >= 0 &&
+ array[y - 1][x] == 0 &&
+ array[y - 2][x] == 0 &&
+ array[y - 3][x] == 0 &&
+ array[y - 4][x] == 0))) {
+ penalty += N3;
+ }
+ }
+ }
+ return penalty;
+}
+
+/**
+ * Apply mask penalty rule 4 and return the penalty. Calculate the ratio of dark cells and give
+ * penalty if the ratio is far from 50%. It gives 10 penalty for 5% distance.
+ */
++ (int)applyMaskPenaltyRule4:(ZXByteMatrix *)matrix {
+ int numDarkCells = 0;
+ unsigned char **array = matrix.array;
+ int width = matrix.width;
+ int height = matrix.height;
+ for (int y = 0; y < height; y++) {
+ unsigned char *arrayY = array[y];
+ for (int x = 0; x < width; x++) {
+ if (arrayY[x] == 1) {
+ numDarkCells++;
+ }
+ }
+ }
+ int numTotalCells = [matrix height] * [matrix width];
+ double darkRatio = (double) numDarkCells / numTotalCells;
+ int fivePercentVariances = abs((int)(darkRatio * 100 - 50)) / 5; // * 100.0 / 5.0
+ return fivePercentVariances * N4;
+}
+
+/**
+ * Return the mask bit for "getMaskPattern" at "x" and "y". See 8.8 of JISX0510:2004 for mask
+ * pattern conditions.
+ */
++ (BOOL)dataMaskBit:(int)maskPattern x:(int)x y:(int)y {
+ int intermediate;
+ int temp;
+ switch (maskPattern) {
+ case 0:
+ intermediate = (y + x) & 0x1;
+ break;
+ case 1:
+ intermediate = y & 0x1;
+ break;
+ case 2:
+ intermediate = x % 3;
+ break;
+ case 3:
+ intermediate = (y + x) % 3;
+ break;
+ case 4:
+ intermediate = ((int)((unsigned int)y >> 1) + (x / 3)) & 0x1;
+ break;
+ case 5:
+ temp = y * x;
+ intermediate = (temp & 0x1) + (temp % 3);
+ break;
+ case 6:
+ temp = y * x;
+ intermediate = ((temp & 0x1) + (temp % 3)) & 0x1;
+ break;
+ case 7:
+ temp = y * x;
+ intermediate = ((temp % 3) + ((y + x) & 0x1)) & 0x1;
+ break;
+ default:
+ [NSException raise:NSInvalidArgumentException
+ format:@"Invalid mask pattern: %d", maskPattern];
+ }
+ return intermediate == 0;
+}
+
+/**
+ * Helper function for applyMaskPenaltyRule1. We need this for doing this calculation in both
+ * vertical and horizontal orders respectively.
+ */
++ (int)applyMaskPenaltyRule1Internal:(ZXByteMatrix *)matrix isHorizontal:(BOOL)isHorizontal {
+ int penalty = 0;
+ int iLimit = isHorizontal ? matrix.height : matrix.width;
+ int jLimit = isHorizontal ? matrix.width : matrix.height;
+ unsigned char **array = matrix.array;
+ for (int i = 0; i < iLimit; i++) {
+ int numSameBitCells = 0;
+ int prevBit = -1;
+ for (int j = 0; j < jLimit; j++) {
+ int bit = isHorizontal ? array[i][j] : array[j][i];
+ if (bit == prevBit) {
+ numSameBitCells++;
+ } else {
+ if (numSameBitCells >= 5) {
+ penalty += N1 + (numSameBitCells - 5);
+ }
+ numSameBitCells = 1; // Include the cell itself.
+ prevBit = bit;
+ }
+ }
+ if (numSameBitCells > 5) {
+ penalty += N1 + (numSameBitCells - 5);
+ }
+ }
+ return penalty;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXMatrixUtil.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXMatrixUtil.h
new file mode 100644
index 0000000000000000000000000000000000000000..759e07016f43a31fe48bea815cce1c76aa55495a
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXMatrixUtil.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@class ZXBitArray, ZXByteMatrix, ZXErrorCorrectionLevel, ZXQRCodeVersion;
+
+@interface ZXMatrixUtil : NSObject
+
++ (BOOL)buildMatrix:(ZXBitArray *)dataBits ecLevel:(ZXErrorCorrectionLevel *)ecLevel version:(ZXQRCodeVersion *)version maskPattern:(int)maskPattern matrix:(ZXByteMatrix *)matrix error:(NSError **)error;
++ (void)clearMatrix:(ZXByteMatrix *)matrix;
++ (BOOL)embedBasicPatterns:(ZXQRCodeVersion *)version matrix:(ZXByteMatrix *)matrix error:(NSError **)error;
++ (BOOL)embedTypeInfo:(ZXErrorCorrectionLevel *)ecLevel maskPattern:(int)maskPattern matrix:(ZXByteMatrix *)matrix error:(NSError **)error;
++ (BOOL)maybeEmbedVersionInfo:(ZXQRCodeVersion *)version matrix:(ZXByteMatrix *)matrix error:(NSError **)error;
++ (BOOL)embedDataBits:(ZXBitArray *)dataBits maskPattern:(int)maskPattern matrix:(ZXByteMatrix *)matrix error:(NSError **)error;
++ (int)findMSBSet:(int)value;
++ (int)calculateBCHCode:(int)value poly:(int)poly;
++ (BOOL)makeTypeInfoBits:(ZXErrorCorrectionLevel *)ecLevel maskPattern:(int)maskPattern bits:(ZXBitArray *)bits error:(NSError **)error;
++ (BOOL)makeVersionInfoBits:(ZXQRCodeVersion *)version bits:(ZXBitArray *)bits error:(NSError **)error;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXMatrixUtil.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXMatrixUtil.m
new file mode 100644
index 0000000000000000000000000000000000000000..aa61d32e74439c9111d2e8f3153e0a4194c90c74
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXMatrixUtil.m
@@ -0,0 +1,534 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXBitArray.h"
+#import "ZXByteMatrix.h"
+#import "ZXErrors.h"
+#import "ZXErrorCorrectionLevel.h"
+#import "ZXMaskUtil.h"
+#import "ZXMatrixUtil.h"
+#import "ZXQRCode.h"
+#import "ZXQRCodeVersion.h"
+
+int const POSITION_DETECTION_PATTERN[7][7] = {
+ {1, 1, 1, 1, 1, 1, 1},
+ {1, 0, 0, 0, 0, 0, 1},
+ {1, 0, 1, 1, 1, 0, 1},
+ {1, 0, 1, 1, 1, 0, 1},
+ {1, 0, 1, 1, 1, 0, 1},
+ {1, 0, 0, 0, 0, 0, 1},
+ {1, 1, 1, 1, 1, 1, 1},
+};
+
+int const POSITION_ADJUSTMENT_PATTERN[5][5] = {
+ {1, 1, 1, 1, 1},
+ {1, 0, 0, 0, 1},
+ {1, 0, 1, 0, 1},
+ {1, 0, 0, 0, 1},
+ {1, 1, 1, 1, 1},
+};
+
+// From Appendix E. Table 1, JIS0510X:2004 (p 71). The table was double-checked by komatsu.
+int const POSITION_ADJUSTMENT_PATTERN_COORDINATE_TABLE[40][7] = {
+ {-1, -1, -1, -1, -1, -1, -1}, // Version 1
+ { 6, 18, -1, -1, -1, -1, -1}, // Version 2
+ { 6, 22, -1, -1, -1, -1, -1}, // Version 3
+ { 6, 26, -1, -1, -1, -1, -1}, // Version 4
+ { 6, 30, -1, -1, -1, -1, -1}, // Version 5
+ { 6, 34, -1, -1, -1, -1, -1}, // Version 6
+ { 6, 22, 38, -1, -1, -1, -1}, // Version 7
+ { 6, 24, 42, -1, -1, -1, -1}, // Version 8
+ { 6, 26, 46, -1, -1, -1, -1}, // Version 9
+ { 6, 28, 50, -1, -1, -1, -1}, // Version 10
+ { 6, 30, 54, -1, -1, -1, -1}, // Version 11
+ { 6, 32, 58, -1, -1, -1, -1}, // Version 12
+ { 6, 34, 62, -1, -1, -1, -1}, // Version 13
+ { 6, 26, 46, 66, -1, -1, -1}, // Version 14
+ { 6, 26, 48, 70, -1, -1, -1}, // Version 15
+ { 6, 26, 50, 74, -1, -1, -1}, // Version 16
+ { 6, 30, 54, 78, -1, -1, -1}, // Version 17
+ { 6, 30, 56, 82, -1, -1, -1}, // Version 18
+ { 6, 30, 58, 86, -1, -1, -1}, // Version 19
+ { 6, 34, 62, 90, -1, -1, -1}, // Version 20
+ { 6, 28, 50, 72, 94, -1, -1}, // Version 21
+ { 6, 26, 50, 74, 98, -1, -1}, // Version 22
+ { 6, 30, 54, 78, 102, -1, -1}, // Version 23
+ { 6, 28, 54, 80, 106, -1, -1}, // Version 24
+ { 6, 32, 58, 84, 110, -1, -1}, // Version 25
+ { 6, 30, 58, 86, 114, -1, -1}, // Version 26
+ { 6, 34, 62, 90, 118, -1, -1}, // Version 27
+ { 6, 26, 50, 74, 98, 122, -1}, // Version 28
+ { 6, 30, 54, 78, 102, 126, -1}, // Version 29
+ { 6, 26, 52, 78, 104, 130, -1}, // Version 30
+ { 6, 30, 56, 82, 108, 134, -1}, // Version 31
+ { 6, 34, 60, 86, 112, 138, -1}, // Version 32
+ { 6, 30, 58, 86, 114, 142, -1}, // Version 33
+ { 6, 34, 62, 90, 118, 146, -1}, // Version 34
+ { 6, 30, 54, 78, 102, 126, 150}, // Version 35
+ { 6, 24, 50, 76, 102, 128, 154}, // Version 36
+ { 6, 28, 54, 80, 106, 132, 158}, // Version 37
+ { 6, 32, 58, 84, 110, 136, 162}, // Version 38
+ { 6, 26, 54, 82, 110, 138, 166}, // Version 39
+ { 6, 30, 58, 86, 114, 142, 170}, // Version 40
+};
+
+// Type info cells at the left top corner.
+int const TYPE_INFO_COORDINATES[15][2] = {
+ {8, 0},
+ {8, 1},
+ {8, 2},
+ {8, 3},
+ {8, 4},
+ {8, 5},
+ {8, 7},
+ {8, 8},
+ {7, 8},
+ {5, 8},
+ {4, 8},
+ {3, 8},
+ {2, 8},
+ {1, 8},
+ {0, 8},
+};
+
+// From Appendix D in JISX0510:2004 (p. 67)
+int const VERSION_INFO_POLY = 0x1f25; // 1 1111 0010 0101
+
+// From Appendix C in JISX0510:2004 (p.65).
+int const TYPE_INFO_POLY = 0x537;
+int const TYPE_INFO_MASK_PATTERN = 0x5412;
+
+@interface ZXMatrixUtil ()
+
++ (BOOL)isEmpty:(int)value;
++ (void)embedTimingPatterns:(ZXByteMatrix *)matrix;
++ (BOOL)embedDarkDotAtLeftBottomCorner:(ZXByteMatrix *)matrix;
++ (BOOL)embedHorizontalSeparationPattern:(int)xStart yStart:(int)yStart matrix:(ZXByteMatrix *)matrix;
++ (BOOL)embedVerticalSeparationPattern:(int)xStart yStart:(int)yStart matrix:(ZXByteMatrix *)matrix;
++ (void)embedPositionAdjustmentPattern:(int)xStart yStart:(int)yStart matrix:(ZXByteMatrix *)matrix;
++ (void)embedPositionDetectionPattern:(int)xStart yStart:(int)yStart matrix:(ZXByteMatrix *)matrix;
++ (BOOL)embedPositionDetectionPatternsAndSeparators:(ZXByteMatrix *)matrix;
++ (void)maybeEmbedPositionAdjustmentPatterns:(ZXQRCodeVersion *)version matrix:(ZXByteMatrix *)matrix;
+
+@end
+
+@implementation ZXMatrixUtil
+
+// Set all cells to -1. -1 means that the cell is empty (not set yet).
++ (void)clearMatrix:(ZXByteMatrix *)matrix {
+ [matrix clear:(char) -1];
+}
+
+// Build 2D matrix of QR Code from "dataBits" with "ecLevel", "version" and "getMaskPattern". On
+// success, store the result in "matrix" and return true.
++ (BOOL)buildMatrix:(ZXBitArray *)dataBits ecLevel:(ZXErrorCorrectionLevel *)ecLevel version:(ZXQRCodeVersion *)version maskPattern:(int)maskPattern matrix:(ZXByteMatrix *)matrix error:(NSError **)error {
+ [self clearMatrix:matrix];
+ if (![self embedBasicPatterns:version matrix:matrix error:error]) {
+ return NO;
+ }
+ // Type information appear with any version.
+ if (![self embedTypeInfo:ecLevel maskPattern:maskPattern matrix:matrix error:error]) {
+ return NO;
+ }
+ // Version info appear if version >= 7.
+ if (![self maybeEmbedVersionInfo:version matrix:matrix error:error]) {
+ return NO;
+ }
+ // Data should be embedded at end.
+ if (![self embedDataBits:dataBits maskPattern:maskPattern matrix:matrix error:error]) {
+ return NO;
+ }
+ return YES;
+}
+
+// Embed basic patterns. On success, modify the matrix and return true.
+// The basic patterns are:
+// - Position detection patterns
+// - Timing patterns
+// - Dark dot at the left bottom corner
+// - Position adjustment patterns, if need be
++ (BOOL)embedBasicPatterns:(ZXQRCodeVersion *)version matrix:(ZXByteMatrix *)matrix error:(NSError **)error {
+ // Let's get started with embedding big squares at corners.
+ if (![self embedPositionDetectionPatternsAndSeparators:matrix]) {
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXNotFoundError userInfo:nil] autorelease];
+ return NO;
+ }
+ // Then, embed the dark dot at the left bottom corner.
+ if (![self embedDarkDotAtLeftBottomCorner:matrix]) {
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXNotFoundError userInfo:nil] autorelease];
+ return NO;
+ }
+
+ // Position adjustment patterns appear if version >= 2.
+ [self maybeEmbedPositionAdjustmentPatterns:version matrix:matrix];
+ // Timing patterns should be embedded after position adj. patterns.
+ [self embedTimingPatterns:matrix];
+
+ return YES;
+}
+
+// Embed type information. On success, modify the matrix.
++ (BOOL)embedTypeInfo:(ZXErrorCorrectionLevel *)ecLevel maskPattern:(int)maskPattern matrix:(ZXByteMatrix *)matrix error:(NSError **)error {
+ ZXBitArray *typeInfoBits = [[[ZXBitArray alloc] init] autorelease];
+ if (![self makeTypeInfoBits:ecLevel maskPattern:maskPattern bits:typeInfoBits error:error]) {
+ return NO;
+ }
+
+ for (int i = 0; i < [typeInfoBits size]; ++i) {
+ // Place bits in LSB to MSB order. LSB (least significant bit) is the last value in
+ // "typeInfoBits".
+ BOOL bit = [typeInfoBits get:[typeInfoBits size] - 1 - i];
+
+ // Type info bits at the left top corner. See 8.9 of JISX0510:2004 (p.46).
+ int x1 = TYPE_INFO_COORDINATES[i][0];
+ int y1 = TYPE_INFO_COORDINATES[i][1];
+ [matrix setX:x1 y:y1 boolValue:bit];
+
+ if (i < 8) {
+ // Right top corner.
+ int x2 = [matrix width] - i - 1;
+ int y2 = 8;
+ [matrix setX:x2 y:y2 boolValue:bit];
+ } else {
+ // Left bottom corner.
+ int x2 = 8;
+ int y2 = [matrix height] - 7 + (i - 8);
+ [matrix setX:x2 y:y2 boolValue:bit];
+ }
+ }
+
+ return YES;
+}
+
+// Embed version information if need be. On success, modify the matrix and return true.
+// See 8.10 of JISX0510:2004 (p.47) for how to embed version information.
++ (BOOL)maybeEmbedVersionInfo:(ZXQRCodeVersion *)version matrix:(ZXByteMatrix *)matrix error:(NSError **)error {
+ if (version.versionNumber < 7) { // Version info is necessary if version >= 7.
+ return YES; // Don't need version info.
+ }
+ ZXBitArray *versionInfoBits = [[[ZXBitArray alloc] init] autorelease];
+ if (![self makeVersionInfoBits:version bits:versionInfoBits error:error]) {
+ return NO;
+ }
+
+ int bitIndex = 6 * 3 - 1; // It will decrease from 17 to 0.
+ for (int i = 0; i < 6; ++i) {
+ for (int j = 0; j < 3; ++j) {
+ // Place bits in LSB (least significant bit) to MSB order.
+ BOOL bit = [versionInfoBits get:bitIndex];
+ bitIndex--;
+ // Left bottom corner.
+ [matrix setX:i y:[matrix height] - 11 + j boolValue:bit];
+ // Right bottom corner.
+ [matrix setX:[matrix height] - 11 + j y:i boolValue:bit];
+ }
+ }
+
+ return YES;
+}
+
+// Embed "dataBits" using "getMaskPattern". On success, modify the matrix and return true.
+// For debugging purposes, it skips masking process if "getMaskPattern" is -1.
+// See 8.7 of JISX0510:2004 (p.38) for how to embed data bits.
++ (BOOL)embedDataBits:(ZXBitArray *)dataBits maskPattern:(int)maskPattern matrix:(ZXByteMatrix *)matrix error:(NSError **)error {
+ int bitIndex = 0;
+ int direction = -1;
+ // Start from the right bottom cell.
+ int x = [matrix width] - 1;
+ int y = [matrix height] - 1;
+ while (x > 0) {
+ // Skip the vertical timing pattern.
+ if (x == 6) {
+ x -= 1;
+ }
+ while (y >= 0 && y < [matrix height]) {
+ for (int i = 0; i < 2; ++i) {
+ int xx = x - i;
+ // Skip the cell if it's not empty.
+ if (![self isEmpty:[matrix getX:xx y:y]]) {
+ continue;
+ }
+ BOOL bit;
+ if (bitIndex < [dataBits size]) {
+ bit = [dataBits get:bitIndex];
+ ++bitIndex;
+ } else {
+ // Padding bit. If there is no bit left, we'll fill the left cells with 0, as described
+ // in 8.4.9 of JISX0510:2004 (p. 24).
+ bit = NO;
+ }
+
+ // Skip masking if mask_pattern is -1.
+ if (maskPattern != -1 && [ZXMaskUtil dataMaskBit:maskPattern x:xx y:y]) {
+ bit = !bit;
+ }
+ [matrix setX:xx y:y boolValue:bit];
+ }
+ y += direction;
+ }
+ direction = -direction; // Reverse the direction.
+ y += direction;
+ x -= 2; // Move to the left.
+ }
+ // All bits should be consumed.
+ if (bitIndex != [dataBits size]) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSString stringWithFormat:@"Not all bits consumed: %d/%d", bitIndex, [dataBits size]]
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXNotFoundError userInfo:userInfo] autorelease];
+ return NO;
+ }
+
+ return YES;
+}
+
+// Return the position of the most significant bit set (to one) in the "value". The most
+// significant bit is position 32. If there is no bit set, return 0. Examples:
+// - findMSBSet(0) => 0
+// - findMSBSet(1) => 1
+// - findMSBSet(255) => 8
++ (int)findMSBSet:(int)value {
+ int numDigits = 0;
+ while (value != 0) {
+ value = (int)((unsigned int)value >> 1);
+ ++numDigits;
+ }
+ return numDigits;
+}
+
+// Calculate BCH (Bose-Chaudhuri-Hocquenghem) code for "value" using polynomial "poly". The BCH
+// code is used for encoding type information and version information.
+// Example: Calculation of version information of 7.
+// f(x) is created from 7.
+// - 7 = 000111 in 6 bits
+// - f(x) = x^2 + x^1 + x^0
+// g(x) is given by the standard (p. 67)
+// - g(x) = x^12 + x^11 + x^10 + x^9 + x^8 + x^5 + x^2 + 1
+// Multiply f(x) by x^(18 - 6)
+// - f'(x) = f(x) * x^(18 - 6)
+// - f'(x) = x^14 + x^13 + x^12
+// Calculate the remainder of f'(x) / g(x)
+// x^2
+// __________________________________________________
+// g(x) )x^14 + x^13 + x^12
+// x^14 + x^13 + x^12 + x^11 + x^10 + x^7 + x^4 + x^2
+// --------------------------------------------------
+// x^11 + x^10 + x^7 + x^4 + x^2
+//
+// The remainder is x^11 + x^10 + x^7 + x^4 + x^2
+// Encode it in binary: 110010010100
+// The return value is 0xc94 (1100 1001 0100)
+//
+// Since all coefficients in the polynomials are 1 or 0, we can do the calculation by bit
+// operations. We don't care if cofficients are positive or negative.
++ (int)calculateBCHCode:(int)value poly:(int)poly {
+ // If poly is "1 1111 0010 0101" (version info poly), msbSetInPoly is 13. We'll subtract 1
+ // from 13 to make it 12.
+ int msbSetInPoly = [self findMSBSet:poly];
+ value <<= msbSetInPoly - 1;
+ // Do the division business using exclusive-or operations.
+ while ([self findMSBSet:value] >= msbSetInPoly) {
+ value ^= poly << ([self findMSBSet:value] - msbSetInPoly);
+ }
+ // Now the "value" is the remainder (i.e. the BCH code)
+ return value;
+}
+
+// Make bit vector of type information. On success, store the result in "bits" and return true.
+// Encode error correction level and mask pattern. See 8.9 of
+// JISX0510:2004 (p.45) for details.
++ (BOOL)makeTypeInfoBits:(ZXErrorCorrectionLevel *)ecLevel maskPattern:(int)maskPattern bits:(ZXBitArray *)bits error:(NSError **)error {
+ if (![ZXQRCode isValidMaskPattern:maskPattern]) {
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"Invalid mask pattern"
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXNotFoundError userInfo:userInfo] autorelease];
+ return NO;
+ }
+ int typeInfo = ([ecLevel bits] << 3) | maskPattern;
+ [bits appendBits:typeInfo numBits:5];
+
+ int bchCode = [self calculateBCHCode:typeInfo poly:TYPE_INFO_POLY];
+ [bits appendBits:bchCode numBits:10];
+
+ ZXBitArray *maskBits = [[[ZXBitArray alloc] init] autorelease];
+ [maskBits appendBits:TYPE_INFO_MASK_PATTERN numBits:15];
+ [bits xor:maskBits];
+
+ if ([bits size] != 15) { // Just in case.
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSString stringWithFormat:@"should not happen but we got: %d", [bits size]]
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXNotFoundError userInfo:userInfo] autorelease];
+ return NO;
+ }
+
+ return YES;
+}
+
+// Make bit vector of version information. On success, store the result in "bits" and return true.
+// See 8.10 of JISX0510:2004 (p.45) for details.
++ (BOOL)makeVersionInfoBits:(ZXQRCodeVersion *)version bits:(ZXBitArray *)bits error:(NSError **)error {
+ [bits appendBits:version.versionNumber numBits:6];
+ int bchCode = [self calculateBCHCode:version.versionNumber poly:VERSION_INFO_POLY];
+ [bits appendBits:bchCode numBits:12];
+
+ if ([bits size] != 18) { // Just in case.
+ NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSString stringWithFormat:@"should not happen but we got: %d", [bits size]]
+ forKey:NSLocalizedDescriptionKey];
+
+ if (error) *error = [[[NSError alloc] initWithDomain:ZXErrorDomain code:ZXNotFoundError userInfo:userInfo] autorelease];
+ return NO;
+ }
+
+ return YES;
+}
+
+// Check if "value" is empty.
++ (BOOL)isEmpty:(int)value {
+ return value == -1;
+}
+
++ (void)embedTimingPatterns:(ZXByteMatrix *)matrix {
+ // -8 is for skipping position detection patterns (size 7), and two horizontal/vertical
+ // separation patterns (size 1). Thus, 8 = 7 + 1.
+ for (int i = 8; i < [matrix width] - 8; ++i) {
+ int bit = (i + 1) % 2;
+ // Horizontal line.
+ if ([self isEmpty:[matrix getX:i y:6]]) {
+ [matrix setX:i y:6 boolValue:bit];
+ }
+ // Vertical line.
+ if ([self isEmpty:[matrix getX:6 y:i]]) {
+ [matrix setX:6 y:i boolValue:bit];
+ }
+ }
+}
+
+// Embed the lonely dark dot at left bottom corner. JISX0510:2004 (p.46)
++ (BOOL)embedDarkDotAtLeftBottomCorner:(ZXByteMatrix *)matrix {
+ if ([matrix getX:8 y:matrix.height - 8] == 0) {
+ return NO;
+ }
+ [matrix setX:8 y:matrix.height - 8 intValue:1];
+
+ return YES;
+}
+
++ (BOOL)embedHorizontalSeparationPattern:(int)xStart yStart:(int)yStart matrix:(ZXByteMatrix *)matrix {
+ for (int x = 0; x < 8; ++x) {
+ if (![self isEmpty:[matrix getX:xStart + x y:yStart]]) {
+ return NO;
+ }
+ [matrix setX:xStart + x y:yStart intValue:0];
+ }
+
+ return YES;
+}
+
++ (BOOL)embedVerticalSeparationPattern:(int)xStart yStart:(int)yStart matrix:(ZXByteMatrix *)matrix {
+ for (int y = 0; y < 7; ++y) {
+ if (![self isEmpty:[matrix getX:xStart y:yStart + y]]) {
+ return NO;
+ }
+ [matrix setX:xStart y:yStart + y intValue:0];
+ }
+
+ return YES;
+}
+
+// Note that we cannot unify the function with embedPositionDetectionPattern() despite they are
+// almost identical, since we cannot write a function that takes 2D arrays in different sizes in
+// C/C++. We should live with the fact.
++ (void)embedPositionAdjustmentPattern:(int)xStart yStart:(int)yStart matrix:(ZXByteMatrix *)matrix {
+ for (int y = 0; y < 5; ++y) {
+ for (int x = 0; x < 5; ++x) {
+ [matrix setX:xStart + x y:yStart + y intValue:POSITION_ADJUSTMENT_PATTERN[y][x]];
+ }
+ }
+}
+
++ (void)embedPositionDetectionPattern:(int)xStart yStart:(int)yStart matrix:(ZXByteMatrix *)matrix {
+ for (int y = 0; y < 7; ++y) {
+ for (int x = 0; x < 7; ++x) {
+ [matrix setX:xStart + x y:yStart + y intValue:POSITION_DETECTION_PATTERN[y][x]];
+ }
+ }
+}
+
+// Embed position detection patterns and surrounding vertical/horizontal separators.
++ (BOOL)embedPositionDetectionPatternsAndSeparators:(ZXByteMatrix *)matrix {
+ // Embed three big squares at corners.
+ int pdpWidth = sizeof(POSITION_DETECTION_PATTERN[0]) / sizeof(int);
+ // Left top corner.
+ [self embedPositionDetectionPattern:0 yStart:0 matrix:matrix];
+ // Right top corner.
+ [self embedPositionDetectionPattern:[matrix width] - pdpWidth yStart:0 matrix:matrix];
+ // Left bottom corner.
+ [self embedPositionDetectionPattern:0 yStart:[matrix width] - pdpWidth matrix:matrix];
+
+ // Embed horizontal separation patterns around the squares.
+ int hspWidth = 8;
+ // Left top corner.
+ [self embedHorizontalSeparationPattern:0 yStart:hspWidth - 1 matrix:matrix];
+ // Right top corner.
+ [self embedHorizontalSeparationPattern:[matrix width] - hspWidth yStart:hspWidth - 1 matrix:matrix];
+ // Left bottom corner.
+ [self embedHorizontalSeparationPattern:0 yStart:[matrix width] - hspWidth matrix:matrix];
+
+ // Embed vertical separation patterns around the squares.
+ int vspSize = 7;
+ // Left top corner.
+ if (![self embedVerticalSeparationPattern:vspSize yStart:0 matrix:matrix]) {
+ return NO;
+ }
+ // Right top corner.
+ if (![self embedVerticalSeparationPattern:[matrix height] - vspSize - 1 yStart:0 matrix:matrix]) {
+ return NO;
+ }
+ // Left bottom corner.
+ if (![self embedVerticalSeparationPattern:vspSize yStart:[matrix height] - vspSize matrix:matrix]) {
+ return NO;
+ }
+
+ return YES;
+}
+
+// Embed position adjustment patterns if need be.
++ (void)maybeEmbedPositionAdjustmentPatterns:(ZXQRCodeVersion *)version matrix:(ZXByteMatrix *)matrix {
+ if (version.versionNumber < 2) { // The patterns appear if version >= 2
+ return;
+ }
+ int index = version.versionNumber - 1;
+ int numCoordinates = sizeof(POSITION_ADJUSTMENT_PATTERN_COORDINATE_TABLE[index]) / sizeof(int);
+ for (int i = 0; i < numCoordinates; ++i) {
+ for (int j = 0; j < numCoordinates; ++j) {
+ int y = POSITION_ADJUSTMENT_PATTERN_COORDINATE_TABLE[index][i];
+ int x = POSITION_ADJUSTMENT_PATTERN_COORDINATE_TABLE[index][j];
+ if (x == -1 || y == -1) {
+ continue;
+ }
+ // If the cell is unset, we embed the position adjustment pattern here.
+ if ([self isEmpty:[matrix getX:x y:y]]) {
+ // -2 is necessary since the x/y coordinates point to the center of the pattern, not the
+ // left top corner.
+ [self embedPositionAdjustmentPattern:x - 2 yStart:y - 2 matrix:matrix];
+ }
+ }
+ }
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXQRCode.h b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXQRCode.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb97dffd91eaa16c865754042a3ceae9237147d3
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXQRCode.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+extern int const NUM_MASK_PATTERNS;
+
+@class ZXByteMatrix, ZXErrorCorrectionLevel, ZXMode, ZXQRCodeVersion;
+
+@interface ZXQRCode : NSObject
+
+@property (nonatomic, retain) ZXMode *mode;
+@property (nonatomic, retain) ZXErrorCorrectionLevel *ecLevel;
+@property (nonatomic, retain) ZXQRCodeVersion *version;
+@property (nonatomic, assign) int maskPattern;
+@property (nonatomic, retain) ZXByteMatrix *matrix;
+
++ (BOOL)isValidMaskPattern:(int)maskPattern;
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXQRCode.m b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXQRCode.m
new file mode 100644
index 0000000000000000000000000000000000000000..e960f3ab8c71a13e0d49e8c1a6d8e267b5dede95
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/ZXingObjC/qrcode/encoder/ZXQRCode.m
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXByteMatrix.h"
+#import "ZXErrorCorrectionLevel.h"
+#import "ZXMode.h"
+#import "ZXQRCode.h"
+
+int const NUM_MASK_PATTERNS = 8;
+
+@implementation ZXQRCode
+
+@synthesize mode;
+@synthesize ecLevel;
+@synthesize version;
+@synthesize maskPattern;
+@synthesize matrix;
+
+- (id)init {
+ if (self = [super init]) {
+ self.mode = nil;
+ self.ecLevel = nil;
+ self.version = nil;
+ self.maskPattern = -1;
+ self.matrix = nil;
+ }
+
+ return self;
+}
+
+- (void)dealloc {
+ [mode release];
+ [ecLevel release];
+ [matrix release];
+ [version release];
+
+ [super dealloc];
+}
+
+- (NSString *)description {
+ NSMutableString *result = [NSMutableString stringWithCapacity:200];
+ [result appendFormat:@"<<\n mode: %@", self.mode];
+ [result appendFormat:@"\n ecLevel: %@", self.ecLevel];
+ [result appendFormat:@"\n version: %@", self.version];
+ [result appendFormat:@"\n maskPattern: %d", self.maskPattern];
+ if (self.matrix == nil) {
+ [result appendString:@"\n matrix: (null)\n"];
+ } else {
+ [result appendFormat:@"\n matrix:\n%@", [self.matrix description]];
+ }
+ [result appendString:@">>\n"];
+ return [NSString stringWithString:result];
+}
+
+// Check if "mask_pattern" is valid.
++ (BOOL)isValidMaskPattern:(int)maskPattern {
+ return maskPattern >= 0 && maskPattern < NUM_MASK_PATTERNS;
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/project.pbxproj b/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/project.pbxproj
index 94a6e04ba9cdf0ccd03273f0c6ba55ccbef70146..ca6e84ab9c238c9197ac6ba50149f7e1899b63b0 100644
--- a/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/project.pbxproj
+++ b/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/project.pbxproj
@@ -56,6 +56,214 @@
36F71F30161C4F0400C87277 /* CISDOBJsonRpcCall.m in Sources */ = {isa = PBXBuildFile; fileRef = 36F71ED4161C453D00C87277 /* CISDOBJsonRpcCall.m */; };
36F71F32161C4F0400C87277 /* persistent-data-model.xcdatamodeld in Sources */ = {isa = PBXBuildFile; fileRef = 36F71ED6161C453D00C87277 /* persistent-data-model.xcdatamodeld */; };
36F97A2E1628123F005D063E /* CISDOBOpenBisModel.m in Sources */ = {isa = PBXBuildFile; fileRef = 36F97A2D1628123F005D063E /* CISDOBOpenBisModel.m */; };
+ 5D07BF671771C6E100555DE2 /* ZXAztecDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDAB1771C6E100555DE2 /* ZXAztecDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF681771C6E100555DE2 /* ZXAztecDetector.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDAE1771C6E100555DE2 /* ZXAztecDetector.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF691771C6E100555DE2 /* ZXAztecCode.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDB11771C6E100555DE2 /* ZXAztecCode.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF6A1771C6E100555DE2 /* ZXAztecEncoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDB31771C6E100555DE2 /* ZXAztecEncoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF6B1771C6E100555DE2 /* ZXAztecWriter.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDB51771C6E100555DE2 /* ZXAztecWriter.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF6C1771C6E100555DE2 /* ZXAztecDetectorResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDB71771C6E100555DE2 /* ZXAztecDetectorResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF6D1771C6E100555DE2 /* ZXAztecReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDB91771C6E100555DE2 /* ZXAztecReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF6E1771C6E100555DE2 /* ZXAbstractDoCoMoResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDBD1771C6E100555DE2 /* ZXAbstractDoCoMoResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF6F1771C6E100555DE2 /* ZXAddressBookAUResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDBF1771C6E100555DE2 /* ZXAddressBookAUResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF701771C6E100555DE2 /* ZXAddressBookDoCoMoResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDC11771C6E100555DE2 /* ZXAddressBookDoCoMoResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF711771C6E100555DE2 /* ZXAddressBookParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDC31771C6E100555DE2 /* ZXAddressBookParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF721771C6E100555DE2 /* ZXBizcardResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDC51771C6E100555DE2 /* ZXBizcardResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF731771C6E100555DE2 /* ZXBookmarkDoCoMoResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDC71771C6E100555DE2 /* ZXBookmarkDoCoMoResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF741771C6E100555DE2 /* ZXCalendarParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDC91771C6E100555DE2 /* ZXCalendarParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF751771C6E100555DE2 /* ZXEmailAddressParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDCB1771C6E100555DE2 /* ZXEmailAddressParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF761771C6E100555DE2 /* ZXEmailAddressResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDCD1771C6E100555DE2 /* ZXEmailAddressResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF771771C6E100555DE2 /* ZXEmailDoCoMoResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDCF1771C6E100555DE2 /* ZXEmailDoCoMoResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF781771C6E100555DE2 /* ZXExpandedProductParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDD11771C6E100555DE2 /* ZXExpandedProductParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF791771C6E100555DE2 /* ZXExpandedProductResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDD31771C6E100555DE2 /* ZXExpandedProductResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF7A1771C6E100555DE2 /* ZXGeoParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDD51771C6E100555DE2 /* ZXGeoParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF7B1771C6E100555DE2 /* ZXGeoResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDD71771C6E100555DE2 /* ZXGeoResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF7C1771C6E100555DE2 /* ZXISBNParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDD91771C6E100555DE2 /* ZXISBNParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF7D1771C6E100555DE2 /* ZXISBNResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDDB1771C6E100555DE2 /* ZXISBNResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF7E1771C6E100555DE2 /* ZXParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDDD1771C6E100555DE2 /* ZXParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF7F1771C6E100555DE2 /* ZXProductParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDE01771C6E100555DE2 /* ZXProductParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF801771C6E100555DE2 /* ZXProductResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDE21771C6E100555DE2 /* ZXProductResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF811771C6E100555DE2 /* ZXResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDE41771C6E100555DE2 /* ZXResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF821771C6E100555DE2 /* ZXSMSMMSResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDE61771C6E100555DE2 /* ZXSMSMMSResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF831771C6E100555DE2 /* ZXSMSParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDE81771C6E100555DE2 /* ZXSMSParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF841771C6E100555DE2 /* ZXSMSTOMMSTOResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDEA1771C6E100555DE2 /* ZXSMSTOMMSTOResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF851771C6E100555DE2 /* ZXSMTPResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDEC1771C6E100555DE2 /* ZXSMTPResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF861771C6E100555DE2 /* ZXTelParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDEE1771C6E100555DE2 /* ZXTelParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF871771C6E100555DE2 /* ZXTelResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDF01771C6E100555DE2 /* ZXTelResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF881771C6E100555DE2 /* ZXTextParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDF21771C6E100555DE2 /* ZXTextParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF891771C6E100555DE2 /* ZXURIParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDF41771C6E100555DE2 /* ZXURIParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF8A1771C6E100555DE2 /* ZXURIResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDF61771C6E100555DE2 /* ZXURIResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF8B1771C6E100555DE2 /* ZXURLTOResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDF81771C6E100555DE2 /* ZXURLTOResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF8C1771C6E100555DE2 /* ZXVCardResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDFA1771C6E100555DE2 /* ZXVCardResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF8D1771C6E100555DE2 /* ZXVEventResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDFC1771C6E100555DE2 /* ZXVEventResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF8E1771C6E100555DE2 /* ZXWifiParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BDFE1771C6E100555DE2 /* ZXWifiParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF8F1771C6E100555DE2 /* ZXWifiResultParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE001771C6E100555DE2 /* ZXWifiResultParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF901771C6E100555DE2 /* ZXCapture.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE021771C6E100555DE2 /* ZXCapture.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF911771C6E100555DE2 /* ZXCaptureView.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE051771C6E100555DE2 /* ZXCaptureView.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF921771C6E100555DE2 /* ZXCGImageLuminanceSource.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE071771C6E100555DE2 /* ZXCGImageLuminanceSource.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF931771C6E100555DE2 /* ZXImage.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE091771C6E100555DE2 /* ZXImage.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF941771C6E100555DE2 /* ZXMathUtils.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE0E1771C6E100555DE2 /* ZXMathUtils.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF951771C6E100555DE2 /* ZXMonochromeRectangleDetector.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE101771C6E100555DE2 /* ZXMonochromeRectangleDetector.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF961771C6E100555DE2 /* ZXWhiteRectangleDetector.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE121771C6E100555DE2 /* ZXWhiteRectangleDetector.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF971771C6E100555DE2 /* ZXGenericGF.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE151771C6E100555DE2 /* ZXGenericGF.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF981771C6E100555DE2 /* ZXGenericGFPoly.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE171771C6E100555DE2 /* ZXGenericGFPoly.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF991771C6E100555DE2 /* ZXReedSolomonDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE191771C6E100555DE2 /* ZXReedSolomonDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF9A1771C6E100555DE2 /* ZXReedSolomonEncoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE1B1771C6E100555DE2 /* ZXReedSolomonEncoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF9B1771C6E100555DE2 /* ZXBitArray.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE1D1771C6E100555DE2 /* ZXBitArray.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF9C1771C6E100555DE2 /* ZXBitMatrix.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE1F1771C6E100555DE2 /* ZXBitMatrix.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF9D1771C6E100555DE2 /* ZXBitSource.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE211771C6E100555DE2 /* ZXBitSource.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF9E1771C6E100555DE2 /* ZXCharacterSetECI.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE231771C6E100555DE2 /* ZXCharacterSetECI.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BF9F1771C6E100555DE2 /* ZXDecoderResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE251771C6E100555DE2 /* ZXDecoderResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFA01771C6E100555DE2 /* ZXDefaultGridSampler.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE271771C6E100555DE2 /* ZXDefaultGridSampler.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFA11771C6E100555DE2 /* ZXDetectorResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE291771C6E100555DE2 /* ZXDetectorResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFA21771C6E100555DE2 /* ZXECI.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE2B1771C6E100555DE2 /* ZXECI.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFA31771C6E100555DE2 /* ZXGlobalHistogramBinarizer.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE2D1771C6E100555DE2 /* ZXGlobalHistogramBinarizer.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFA41771C6E100555DE2 /* ZXGridSampler.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE2F1771C6E100555DE2 /* ZXGridSampler.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFA51771C6E100555DE2 /* ZXHybridBinarizer.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE311771C6E100555DE2 /* ZXHybridBinarizer.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFA61771C6E100555DE2 /* ZXPerspectiveTransform.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE331771C6E100555DE2 /* ZXPerspectiveTransform.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFA71771C6E100555DE2 /* ZXStringUtils.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE351771C6E100555DE2 /* ZXStringUtils.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFA81771C6E100555DE2 /* ZXDataMatrixBitMatrixParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE391771C6E100555DE2 /* ZXDataMatrixBitMatrixParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFA91771C6E100555DE2 /* ZXDataMatrixDataBlock.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE3B1771C6E100555DE2 /* ZXDataMatrixDataBlock.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFAA1771C6E100555DE2 /* ZXDataMatrixDecodedBitStreamParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE3D1771C6E100555DE2 /* ZXDataMatrixDecodedBitStreamParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFAB1771C6E100555DE2 /* ZXDataMatrixDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE3F1771C6E100555DE2 /* ZXDataMatrixDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFAC1771C6E100555DE2 /* ZXDataMatrixVersion.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE411771C6E100555DE2 /* ZXDataMatrixVersion.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFAD1771C6E100555DE2 /* ZXDataMatrixDetector.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE441771C6E100555DE2 /* ZXDataMatrixDetector.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFAE1771C6E100555DE2 /* ZXASCIIEncoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE471771C6E100555DE2 /* ZXASCIIEncoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFAF1771C6E100555DE2 /* ZXBase256Encoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE491771C6E100555DE2 /* ZXBase256Encoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFB01771C6E100555DE2 /* ZXC40Encoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE4B1771C6E100555DE2 /* ZXC40Encoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFB11771C6E100555DE2 /* ZXDataMatrixErrorCorrection.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE4E1771C6E100555DE2 /* ZXDataMatrixErrorCorrection.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFB21771C6E100555DE2 /* ZXDataMatrixSymbolInfo144.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE501771C6E100555DE2 /* ZXDataMatrixSymbolInfo144.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFB31771C6E100555DE2 /* ZXDefaultPlacement.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE521771C6E100555DE2 /* ZXDefaultPlacement.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFB41771C6E100555DE2 /* ZXEdifactEncoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE541771C6E100555DE2 /* ZXEdifactEncoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFB51771C6E100555DE2 /* ZXEncoderContext.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE561771C6E100555DE2 /* ZXEncoderContext.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFB61771C6E100555DE2 /* ZXHighLevelEncoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE581771C6E100555DE2 /* ZXHighLevelEncoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFB71771C6E100555DE2 /* ZXSymbolInfo.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE5A1771C6E100555DE2 /* ZXSymbolInfo.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFB81771C6E100555DE2 /* ZXSymbolShapeHint.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE5C1771C6E100555DE2 /* ZXSymbolShapeHint.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFB91771C6E100555DE2 /* ZXTextEncoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE5E1771C6E100555DE2 /* ZXTextEncoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFBA1771C6E100555DE2 /* ZXX12Encoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE601771C6E100555DE2 /* ZXX12Encoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFBB1771C6E100555DE2 /* ZXDataMatrixReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE621771C6E100555DE2 /* ZXDataMatrixReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFBC1771C6E100555DE2 /* ZXDataMatrixWriter.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE641771C6E100555DE2 /* ZXDataMatrixWriter.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFBD1771C6E100555DE2 /* ZXMaxiCodeBitMatrixParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE681771C6E100555DE2 /* ZXMaxiCodeBitMatrixParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFBE1771C6E100555DE2 /* ZXMaxiCodeDecodedBitStreamParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE6A1771C6E100555DE2 /* ZXMaxiCodeDecodedBitStreamParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFBF1771C6E100555DE2 /* ZXMaxiCodeDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE6C1771C6E100555DE2 /* ZXMaxiCodeDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFC01771C6E100555DE2 /* ZXMaxiCodeReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE6E1771C6E100555DE2 /* ZXMaxiCodeReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFC11771C6E100555DE2 /* ZXMultiDetector.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE731771C6E100555DE2 /* ZXMultiDetector.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFC21771C6E100555DE2 /* ZXMultiFinderPatternFinder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE751771C6E100555DE2 /* ZXMultiFinderPatternFinder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFC31771C6E100555DE2 /* ZXQRCodeMultiReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE771771C6E100555DE2 /* ZXQRCodeMultiReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFC41771C6E100555DE2 /* ZXByQuadrantReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE791771C6E100555DE2 /* ZXByQuadrantReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFC51771C6E100555DE2 /* ZXGenericMultipleBarcodeReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE7B1771C6E100555DE2 /* ZXGenericMultipleBarcodeReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFC61771C6E100555DE2 /* ZXAbstractExpandedDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE821771C6E100555DE2 /* ZXAbstractExpandedDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFC71771C6E100555DE2 /* ZXAI013103decoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE841771C6E100555DE2 /* ZXAI013103decoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFC81771C6E100555DE2 /* ZXAI01320xDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE861771C6E100555DE2 /* ZXAI01320xDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFC91771C6E100555DE2 /* ZXAI01392xDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE881771C6E100555DE2 /* ZXAI01392xDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFCA1771C6E100555DE2 /* ZXAI01393xDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE8A1771C6E100555DE2 /* ZXAI01393xDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFCB1771C6E100555DE2 /* ZXAI013x0x1xDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE8C1771C6E100555DE2 /* ZXAI013x0x1xDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFCC1771C6E100555DE2 /* ZXAI013x0xDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE8E1771C6E100555DE2 /* ZXAI013x0xDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFCD1771C6E100555DE2 /* ZXAI01AndOtherAIs.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE901771C6E100555DE2 /* ZXAI01AndOtherAIs.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFCE1771C6E100555DE2 /* ZXAI01decoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE921771C6E100555DE2 /* ZXAI01decoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFCF1771C6E100555DE2 /* ZXAI01weightDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE941771C6E100555DE2 /* ZXAI01weightDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFD01771C6E100555DE2 /* ZXAnyAIDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE961771C6E100555DE2 /* ZXAnyAIDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFD11771C6E100555DE2 /* ZXBlockParsedResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE981771C6E100555DE2 /* ZXBlockParsedResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFD21771C6E100555DE2 /* ZXCurrentParsingState.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE9A1771C6E100555DE2 /* ZXCurrentParsingState.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFD31771C6E100555DE2 /* ZXDecodedChar.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE9C1771C6E100555DE2 /* ZXDecodedChar.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFD41771C6E100555DE2 /* ZXDecodedInformation.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BE9E1771C6E100555DE2 /* ZXDecodedInformation.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFD51771C6E100555DE2 /* ZXDecodedNumeric.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEA01771C6E100555DE2 /* ZXDecodedNumeric.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFD61771C6E100555DE2 /* ZXDecodedObject.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEA21771C6E100555DE2 /* ZXDecodedObject.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFD71771C6E100555DE2 /* ZXFieldParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEA41771C6E100555DE2 /* ZXFieldParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFD81771C6E100555DE2 /* ZXGeneralAppIdDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEA61771C6E100555DE2 /* ZXGeneralAppIdDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFD91771C6E100555DE2 /* ZXBitArrayBuilder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEA81771C6E100555DE2 /* ZXBitArrayBuilder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFDA1771C6E100555DE2 /* ZXExpandedPair.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEAA1771C6E100555DE2 /* ZXExpandedPair.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFDB1771C6E100555DE2 /* ZXExpandedRow.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEAC1771C6E100555DE2 /* ZXExpandedRow.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFDC1771C6E100555DE2 /* ZXRSSExpandedReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEAE1771C6E100555DE2 /* ZXRSSExpandedReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFDD1771C6E100555DE2 /* ZXAbstractRSSReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEB01771C6E100555DE2 /* ZXAbstractRSSReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFDE1771C6E100555DE2 /* ZXDataCharacter.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEB21771C6E100555DE2 /* ZXDataCharacter.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFDF1771C6E100555DE2 /* ZXPair.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEB41771C6E100555DE2 /* ZXPair.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFE01771C6E100555DE2 /* ZXRSS14Reader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEB61771C6E100555DE2 /* ZXRSS14Reader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFE11771C6E100555DE2 /* ZXRSSFinderPattern.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEB81771C6E100555DE2 /* ZXRSSFinderPattern.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFE21771C6E100555DE2 /* ZXRSSUtils.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEBA1771C6E100555DE2 /* ZXRSSUtils.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFE31771C6E100555DE2 /* ZXCodaBarReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEBC1771C6E100555DE2 /* ZXCodaBarReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFE41771C6E100555DE2 /* ZXCodaBarWriter.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEBE1771C6E100555DE2 /* ZXCodaBarWriter.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFE51771C6E100555DE2 /* ZXCode128Reader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEC01771C6E100555DE2 /* ZXCode128Reader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFE61771C6E100555DE2 /* ZXCode128Writer.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEC21771C6E100555DE2 /* ZXCode128Writer.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFE71771C6E100555DE2 /* ZXCode39Reader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEC41771C6E100555DE2 /* ZXCode39Reader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFE81771C6E100555DE2 /* ZXCode39Writer.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEC61771C6E100555DE2 /* ZXCode39Writer.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFE91771C6E100555DE2 /* ZXCode93Reader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEC81771C6E100555DE2 /* ZXCode93Reader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFEA1771C6E100555DE2 /* ZXEAN13Reader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BECA1771C6E100555DE2 /* ZXEAN13Reader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFEB1771C6E100555DE2 /* ZXEAN13Writer.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BECC1771C6E100555DE2 /* ZXEAN13Writer.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFEC1771C6E100555DE2 /* ZXEAN8Reader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BECE1771C6E100555DE2 /* ZXEAN8Reader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFED1771C6E100555DE2 /* ZXEAN8Writer.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BED01771C6E100555DE2 /* ZXEAN8Writer.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFEE1771C6E100555DE2 /* ZXEANManufacturerOrgSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BED21771C6E100555DE2 /* ZXEANManufacturerOrgSupport.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFEF1771C6E100555DE2 /* ZXITFReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BED41771C6E100555DE2 /* ZXITFReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFF01771C6E100555DE2 /* ZXITFWriter.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BED61771C6E100555DE2 /* ZXITFWriter.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFF11771C6E100555DE2 /* ZXMultiFormatOneDReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BED81771C6E100555DE2 /* ZXMultiFormatOneDReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFF21771C6E100555DE2 /* ZXMultiFormatUPCEANReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEDA1771C6E100555DE2 /* ZXMultiFormatUPCEANReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFF31771C6E100555DE2 /* ZXOneDimensionalCodeWriter.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEDC1771C6E100555DE2 /* ZXOneDimensionalCodeWriter.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFF41771C6E100555DE2 /* ZXOneDReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEDE1771C6E100555DE2 /* ZXOneDReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFF51771C6E100555DE2 /* ZXUPCAReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEE01771C6E100555DE2 /* ZXUPCAReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFF61771C6E100555DE2 /* ZXUPCAWriter.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEE21771C6E100555DE2 /* ZXUPCAWriter.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFF71771C6E100555DE2 /* ZXUPCEANExtension2Support.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEE41771C6E100555DE2 /* ZXUPCEANExtension2Support.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFF81771C6E100555DE2 /* ZXUPCEANExtension5Support.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEE61771C6E100555DE2 /* ZXUPCEANExtension5Support.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFF91771C6E100555DE2 /* ZXUPCEANExtensionSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEE81771C6E100555DE2 /* ZXUPCEANExtensionSupport.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFFA1771C6E100555DE2 /* ZXUPCEANReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEEA1771C6E100555DE2 /* ZXUPCEANReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFFB1771C6E100555DE2 /* ZXUPCEANWriter.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEEC1771C6E100555DE2 /* ZXUPCEANWriter.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFFC1771C6E100555DE2 /* ZXUPCEReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEEE1771C6E100555DE2 /* ZXUPCEReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFFD1771C6E100555DE2 /* ZXModulusGF.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEF31771C6E100555DE2 /* ZXModulusGF.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFFE1771C6E100555DE2 /* ZXModulusPoly.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEF51771C6E100555DE2 /* ZXModulusPoly.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07BFFF1771C6E100555DE2 /* ZXPDF417ECErrorCorrection.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEF71771C6E100555DE2 /* ZXPDF417ECErrorCorrection.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0001771C6E100555DE2 /* ZXPDF417BitMatrixParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEF91771C6E100555DE2 /* ZXPDF417BitMatrixParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0011771C6E100555DE2 /* ZXPDF417DecodedBitStreamParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEFB1771C6E100555DE2 /* ZXPDF417DecodedBitStreamParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0021771C6E100555DE2 /* ZXPDF417Decoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BEFD1771C6E100555DE2 /* ZXPDF417Decoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0031771C6E100555DE2 /* ZXPDF417Detector.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF001771C6E100555DE2 /* ZXPDF417Detector.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0041771C6E100555DE2 /* ZXBarcodeMatrix.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF031771C6E100555DE2 /* ZXBarcodeMatrix.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0051771C6E100555DE2 /* ZXBarcodeRow.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF051771C6E100555DE2 /* ZXBarcodeRow.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0061771C6E100555DE2 /* ZXDimensions.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF081771C6E100555DE2 /* ZXDimensions.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0071771C6E100555DE2 /* ZXPDF417.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF0A1771C6E100555DE2 /* ZXPDF417.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0081771C6E100555DE2 /* ZXPDF417ErrorCorrection.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF0C1771C6E100555DE2 /* ZXPDF417ErrorCorrection.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0091771C6E100555DE2 /* ZXPDF417HighLevelEncoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF0E1771C6E100555DE2 /* ZXPDF417HighLevelEncoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C00A1771C6E100555DE2 /* ZXPDF417Writer.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF101771C6E100555DE2 /* ZXPDF417Writer.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C00B1771C6E100555DE2 /* ZXPDF417Reader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF121771C6E100555DE2 /* ZXPDF417Reader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C00C1771C6E100555DE2 /* ZXDataMask.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF161771C6E100555DE2 /* ZXDataMask.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C00D1771C6E100555DE2 /* ZXErrorCorrectionLevel.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF181771C6E100555DE2 /* ZXErrorCorrectionLevel.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C00E1771C6E100555DE2 /* ZXFormatInformation.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF1A1771C6E100555DE2 /* ZXFormatInformation.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C00F1771C6E100555DE2 /* ZXMode.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF1C1771C6E100555DE2 /* ZXMode.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0101771C6E100555DE2 /* ZXQRCodeBitMatrixParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF1E1771C6E100555DE2 /* ZXQRCodeBitMatrixParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0111771C6E100555DE2 /* ZXQRCodeDataBlock.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF201771C6E100555DE2 /* ZXQRCodeDataBlock.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0121771C6E100555DE2 /* ZXQRCodeDecodedBitStreamParser.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF221771C6E100555DE2 /* ZXQRCodeDecodedBitStreamParser.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0131771C6E100555DE2 /* ZXQRCodeDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF241771C6E100555DE2 /* ZXQRCodeDecoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0141771C6E100555DE2 /* ZXQRCodeVersion.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF261771C6E100555DE2 /* ZXQRCodeVersion.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0151771C6E100555DE2 /* ZXAlignmentPattern.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF291771C6E100555DE2 /* ZXAlignmentPattern.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0161771C6E100555DE2 /* ZXAlignmentPatternFinder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF2B1771C6E100555DE2 /* ZXAlignmentPatternFinder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0171771C6E100555DE2 /* ZXFinderPatternFinder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF2D1771C6E100555DE2 /* ZXFinderPatternFinder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0181771C6E100555DE2 /* ZXFinderPatternInfo.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF2F1771C6E100555DE2 /* ZXFinderPatternInfo.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0191771C6E100555DE2 /* ZXQRCodeDetector.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF311771C6E100555DE2 /* ZXQRCodeDetector.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C01A1771C6E100555DE2 /* ZXQRCodeFinderPattern.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF331771C6E100555DE2 /* ZXQRCodeFinderPattern.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C01B1771C6E100555DE2 /* ZXBlockPair.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF361771C6E100555DE2 /* ZXBlockPair.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C01C1771C6E100555DE2 /* ZXByteMatrix.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF381771C6E100555DE2 /* ZXByteMatrix.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C01D1771C6E100555DE2 /* ZXEncoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF3A1771C6E100555DE2 /* ZXEncoder.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C01E1771C6E100555DE2 /* ZXMaskUtil.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF3C1771C6E100555DE2 /* ZXMaskUtil.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C01F1771C6E100555DE2 /* ZXMatrixUtil.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF3E1771C6E100555DE2 /* ZXMatrixUtil.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0201771C6E100555DE2 /* ZXQRCode.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF401771C6E100555DE2 /* ZXQRCode.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0211771C6E100555DE2 /* ZXQRCodeReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF421771C6E100555DE2 /* ZXQRCodeReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0221771C6E100555DE2 /* ZXQRCodeWriter.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF441771C6E100555DE2 /* ZXQRCodeWriter.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0231771C6E100555DE2 /* ZXBinarizer.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF471771C6E100555DE2 /* ZXBinarizer.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0241771C6E100555DE2 /* ZXBinaryBitmap.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF491771C6E100555DE2 /* ZXBinaryBitmap.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0251771C6E100555DE2 /* ZXDecodeHints.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF4B1771C6E100555DE2 /* ZXDecodeHints.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0261771C6E100555DE2 /* ZXDimension.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF4D1771C6E100555DE2 /* ZXDimension.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0271771C6E100555DE2 /* ZXEncodeHints.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF4F1771C6E100555DE2 /* ZXEncodeHints.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0281771C6E100555DE2 /* ZXErrors.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF511771C6E100555DE2 /* ZXErrors.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0291771C6E100555DE2 /* ZXInvertedLuminanceSource.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF541771C6E100555DE2 /* ZXInvertedLuminanceSource.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C02A1771C6E100555DE2 /* ZXLuminanceSource.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF561771C6E100555DE2 /* ZXLuminanceSource.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C02B1771C6E100555DE2 /* ZXMultiFormatReader.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF581771C6E100555DE2 /* ZXMultiFormatReader.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C02C1771C6E100555DE2 /* ZXMultiFormatWriter.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF5A1771C6E100555DE2 /* ZXMultiFormatWriter.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C02D1771C6E100555DE2 /* ZXPlanarYUVLuminanceSource.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF5C1771C6E100555DE2 /* ZXPlanarYUVLuminanceSource.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C02E1771C6E100555DE2 /* ZXResult.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF5F1771C6E100555DE2 /* ZXResult.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C02F1771C6E100555DE2 /* ZXResultPoint.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF621771C6E100555DE2 /* ZXResultPoint.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0301771C6E100555DE2 /* ZXRGBLuminanceSource.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07BF651771C6E100555DE2 /* ZXRGBLuminanceSource.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0331771C88400555DE2 /* CISDOBBarcodeViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = 5D07C0321771C88400555DE2 /* CISDOBBarcodeViewController.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc"; }; };
+ 5D07C0351771CBF800555DE2 /* AVFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5D07C0341771CBF800555DE2 /* AVFoundation.framework */; };
+ 5D07C0371771CC0600555DE2 /* CoreMedia.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5D07C0361771CC0600555DE2 /* CoreMedia.framework */; };
+ 5D07C0391771CC1100555DE2 /* CoreVideo.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5D07C0381771CC1100555DE2 /* CoreVideo.framework */; };
+ 5D07C03B1771CC1F00555DE2 /* ImageIO.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5D07C03A1771CC1F00555DE2 /* ImageIO.framework */; };
+ 5D07C03D1771CC4700555DE2 /* QuartzCore.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 5D07C03C1771CC4600555DE2 /* QuartzCore.framework */; };
/* End PBXBuildFile section */
/* Begin PBXContainerItemProxy section */
@@ -144,6 +352,429 @@
36F71F25161C4AE900C87277 /* readme.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = readme.md; sourceTree = "<group>"; };
36F97A2C1628123F005D063E /* CISDOBOpenBisModel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CISDOBOpenBisModel.h; sourceTree = "<group>"; };
36F97A2D1628123F005D063E /* CISDOBOpenBisModel.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CISDOBOpenBisModel.m; sourceTree = "<group>"; };
+ 5D07BDAA1771C6E100555DE2 /* ZXAztecDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAztecDecoder.h; sourceTree = "<group>"; };
+ 5D07BDAB1771C6E100555DE2 /* ZXAztecDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAztecDecoder.m; sourceTree = "<group>"; };
+ 5D07BDAD1771C6E100555DE2 /* ZXAztecDetector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAztecDetector.h; sourceTree = "<group>"; };
+ 5D07BDAE1771C6E100555DE2 /* ZXAztecDetector.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAztecDetector.m; sourceTree = "<group>"; };
+ 5D07BDB01771C6E100555DE2 /* ZXAztecCode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAztecCode.h; sourceTree = "<group>"; };
+ 5D07BDB11771C6E100555DE2 /* ZXAztecCode.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAztecCode.m; sourceTree = "<group>"; };
+ 5D07BDB21771C6E100555DE2 /* ZXAztecEncoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAztecEncoder.h; sourceTree = "<group>"; };
+ 5D07BDB31771C6E100555DE2 /* ZXAztecEncoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAztecEncoder.m; sourceTree = "<group>"; };
+ 5D07BDB41771C6E100555DE2 /* ZXAztecWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAztecWriter.h; sourceTree = "<group>"; };
+ 5D07BDB51771C6E100555DE2 /* ZXAztecWriter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAztecWriter.m; sourceTree = "<group>"; };
+ 5D07BDB61771C6E100555DE2 /* ZXAztecDetectorResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAztecDetectorResult.h; sourceTree = "<group>"; };
+ 5D07BDB71771C6E100555DE2 /* ZXAztecDetectorResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAztecDetectorResult.m; sourceTree = "<group>"; };
+ 5D07BDB81771C6E100555DE2 /* ZXAztecReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAztecReader.h; sourceTree = "<group>"; };
+ 5D07BDB91771C6E100555DE2 /* ZXAztecReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAztecReader.m; sourceTree = "<group>"; };
+ 5D07BDBC1771C6E100555DE2 /* ZXAbstractDoCoMoResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAbstractDoCoMoResultParser.h; sourceTree = "<group>"; };
+ 5D07BDBD1771C6E100555DE2 /* ZXAbstractDoCoMoResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAbstractDoCoMoResultParser.m; sourceTree = "<group>"; };
+ 5D07BDBE1771C6E100555DE2 /* ZXAddressBookAUResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAddressBookAUResultParser.h; sourceTree = "<group>"; };
+ 5D07BDBF1771C6E100555DE2 /* ZXAddressBookAUResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAddressBookAUResultParser.m; sourceTree = "<group>"; };
+ 5D07BDC01771C6E100555DE2 /* ZXAddressBookDoCoMoResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAddressBookDoCoMoResultParser.h; sourceTree = "<group>"; };
+ 5D07BDC11771C6E100555DE2 /* ZXAddressBookDoCoMoResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAddressBookDoCoMoResultParser.m; sourceTree = "<group>"; };
+ 5D07BDC21771C6E100555DE2 /* ZXAddressBookParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAddressBookParsedResult.h; sourceTree = "<group>"; };
+ 5D07BDC31771C6E100555DE2 /* ZXAddressBookParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAddressBookParsedResult.m; sourceTree = "<group>"; };
+ 5D07BDC41771C6E100555DE2 /* ZXBizcardResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBizcardResultParser.h; sourceTree = "<group>"; };
+ 5D07BDC51771C6E100555DE2 /* ZXBizcardResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXBizcardResultParser.m; sourceTree = "<group>"; };
+ 5D07BDC61771C6E100555DE2 /* ZXBookmarkDoCoMoResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBookmarkDoCoMoResultParser.h; sourceTree = "<group>"; };
+ 5D07BDC71771C6E100555DE2 /* ZXBookmarkDoCoMoResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXBookmarkDoCoMoResultParser.m; sourceTree = "<group>"; };
+ 5D07BDC81771C6E100555DE2 /* ZXCalendarParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCalendarParsedResult.h; sourceTree = "<group>"; };
+ 5D07BDC91771C6E100555DE2 /* ZXCalendarParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXCalendarParsedResult.m; sourceTree = "<group>"; };
+ 5D07BDCA1771C6E100555DE2 /* ZXEmailAddressParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXEmailAddressParsedResult.h; sourceTree = "<group>"; };
+ 5D07BDCB1771C6E100555DE2 /* ZXEmailAddressParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXEmailAddressParsedResult.m; sourceTree = "<group>"; };
+ 5D07BDCC1771C6E100555DE2 /* ZXEmailAddressResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXEmailAddressResultParser.h; sourceTree = "<group>"; };
+ 5D07BDCD1771C6E100555DE2 /* ZXEmailAddressResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXEmailAddressResultParser.m; sourceTree = "<group>"; };
+ 5D07BDCE1771C6E100555DE2 /* ZXEmailDoCoMoResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXEmailDoCoMoResultParser.h; sourceTree = "<group>"; };
+ 5D07BDCF1771C6E100555DE2 /* ZXEmailDoCoMoResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXEmailDoCoMoResultParser.m; sourceTree = "<group>"; };
+ 5D07BDD01771C6E100555DE2 /* ZXExpandedProductParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXExpandedProductParsedResult.h; sourceTree = "<group>"; };
+ 5D07BDD11771C6E100555DE2 /* ZXExpandedProductParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXExpandedProductParsedResult.m; sourceTree = "<group>"; };
+ 5D07BDD21771C6E100555DE2 /* ZXExpandedProductResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXExpandedProductResultParser.h; sourceTree = "<group>"; };
+ 5D07BDD31771C6E100555DE2 /* ZXExpandedProductResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXExpandedProductResultParser.m; sourceTree = "<group>"; };
+ 5D07BDD41771C6E100555DE2 /* ZXGeoParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXGeoParsedResult.h; sourceTree = "<group>"; };
+ 5D07BDD51771C6E100555DE2 /* ZXGeoParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXGeoParsedResult.m; sourceTree = "<group>"; };
+ 5D07BDD61771C6E100555DE2 /* ZXGeoResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXGeoResultParser.h; sourceTree = "<group>"; };
+ 5D07BDD71771C6E100555DE2 /* ZXGeoResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXGeoResultParser.m; sourceTree = "<group>"; };
+ 5D07BDD81771C6E100555DE2 /* ZXISBNParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXISBNParsedResult.h; sourceTree = "<group>"; };
+ 5D07BDD91771C6E100555DE2 /* ZXISBNParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXISBNParsedResult.m; sourceTree = "<group>"; };
+ 5D07BDDA1771C6E100555DE2 /* ZXISBNResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXISBNResultParser.h; sourceTree = "<group>"; };
+ 5D07BDDB1771C6E100555DE2 /* ZXISBNResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXISBNResultParser.m; sourceTree = "<group>"; };
+ 5D07BDDC1771C6E100555DE2 /* ZXParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXParsedResult.h; sourceTree = "<group>"; };
+ 5D07BDDD1771C6E100555DE2 /* ZXParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXParsedResult.m; sourceTree = "<group>"; };
+ 5D07BDDE1771C6E100555DE2 /* ZXParsedResultType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXParsedResultType.h; sourceTree = "<group>"; };
+ 5D07BDDF1771C6E100555DE2 /* ZXProductParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXProductParsedResult.h; sourceTree = "<group>"; };
+ 5D07BDE01771C6E100555DE2 /* ZXProductParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXProductParsedResult.m; sourceTree = "<group>"; };
+ 5D07BDE11771C6E100555DE2 /* ZXProductResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXProductResultParser.h; sourceTree = "<group>"; };
+ 5D07BDE21771C6E100555DE2 /* ZXProductResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXProductResultParser.m; sourceTree = "<group>"; };
+ 5D07BDE31771C6E100555DE2 /* ZXResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXResultParser.h; sourceTree = "<group>"; };
+ 5D07BDE41771C6E100555DE2 /* ZXResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXResultParser.m; sourceTree = "<group>"; };
+ 5D07BDE51771C6E100555DE2 /* ZXSMSMMSResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXSMSMMSResultParser.h; sourceTree = "<group>"; };
+ 5D07BDE61771C6E100555DE2 /* ZXSMSMMSResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXSMSMMSResultParser.m; sourceTree = "<group>"; };
+ 5D07BDE71771C6E100555DE2 /* ZXSMSParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXSMSParsedResult.h; sourceTree = "<group>"; };
+ 5D07BDE81771C6E100555DE2 /* ZXSMSParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXSMSParsedResult.m; sourceTree = "<group>"; };
+ 5D07BDE91771C6E100555DE2 /* ZXSMSTOMMSTOResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXSMSTOMMSTOResultParser.h; sourceTree = "<group>"; };
+ 5D07BDEA1771C6E100555DE2 /* ZXSMSTOMMSTOResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXSMSTOMMSTOResultParser.m; sourceTree = "<group>"; };
+ 5D07BDEB1771C6E100555DE2 /* ZXSMTPResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXSMTPResultParser.h; sourceTree = "<group>"; };
+ 5D07BDEC1771C6E100555DE2 /* ZXSMTPResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXSMTPResultParser.m; sourceTree = "<group>"; };
+ 5D07BDED1771C6E100555DE2 /* ZXTelParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXTelParsedResult.h; sourceTree = "<group>"; };
+ 5D07BDEE1771C6E100555DE2 /* ZXTelParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXTelParsedResult.m; sourceTree = "<group>"; };
+ 5D07BDEF1771C6E100555DE2 /* ZXTelResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXTelResultParser.h; sourceTree = "<group>"; };
+ 5D07BDF01771C6E100555DE2 /* ZXTelResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXTelResultParser.m; sourceTree = "<group>"; };
+ 5D07BDF11771C6E100555DE2 /* ZXTextParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXTextParsedResult.h; sourceTree = "<group>"; };
+ 5D07BDF21771C6E100555DE2 /* ZXTextParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXTextParsedResult.m; sourceTree = "<group>"; };
+ 5D07BDF31771C6E100555DE2 /* ZXURIParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXURIParsedResult.h; sourceTree = "<group>"; };
+ 5D07BDF41771C6E100555DE2 /* ZXURIParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXURIParsedResult.m; sourceTree = "<group>"; };
+ 5D07BDF51771C6E100555DE2 /* ZXURIResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXURIResultParser.h; sourceTree = "<group>"; };
+ 5D07BDF61771C6E100555DE2 /* ZXURIResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXURIResultParser.m; sourceTree = "<group>"; };
+ 5D07BDF71771C6E100555DE2 /* ZXURLTOResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXURLTOResultParser.h; sourceTree = "<group>"; };
+ 5D07BDF81771C6E100555DE2 /* ZXURLTOResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXURLTOResultParser.m; sourceTree = "<group>"; };
+ 5D07BDF91771C6E100555DE2 /* ZXVCardResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXVCardResultParser.h; sourceTree = "<group>"; };
+ 5D07BDFA1771C6E100555DE2 /* ZXVCardResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXVCardResultParser.m; sourceTree = "<group>"; };
+ 5D07BDFB1771C6E100555DE2 /* ZXVEventResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXVEventResultParser.h; sourceTree = "<group>"; };
+ 5D07BDFC1771C6E100555DE2 /* ZXVEventResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXVEventResultParser.m; sourceTree = "<group>"; };
+ 5D07BDFD1771C6E100555DE2 /* ZXWifiParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXWifiParsedResult.h; sourceTree = "<group>"; };
+ 5D07BDFE1771C6E100555DE2 /* ZXWifiParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXWifiParsedResult.m; sourceTree = "<group>"; };
+ 5D07BDFF1771C6E100555DE2 /* ZXWifiResultParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXWifiResultParser.h; sourceTree = "<group>"; };
+ 5D07BE001771C6E100555DE2 /* ZXWifiResultParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXWifiResultParser.m; sourceTree = "<group>"; };
+ 5D07BE011771C6E100555DE2 /* ZXCapture.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCapture.h; sourceTree = "<group>"; };
+ 5D07BE021771C6E100555DE2 /* ZXCapture.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXCapture.m; sourceTree = "<group>"; };
+ 5D07BE031771C6E100555DE2 /* ZXCaptureDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCaptureDelegate.h; sourceTree = "<group>"; };
+ 5D07BE041771C6E100555DE2 /* ZXCaptureView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCaptureView.h; sourceTree = "<group>"; };
+ 5D07BE051771C6E100555DE2 /* ZXCaptureView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXCaptureView.m; sourceTree = "<group>"; };
+ 5D07BE061771C6E100555DE2 /* ZXCGImageLuminanceSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCGImageLuminanceSource.h; sourceTree = "<group>"; };
+ 5D07BE071771C6E100555DE2 /* ZXCGImageLuminanceSource.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXCGImageLuminanceSource.m; sourceTree = "<group>"; };
+ 5D07BE081771C6E100555DE2 /* ZXImage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXImage.h; sourceTree = "<group>"; };
+ 5D07BE091771C6E100555DE2 /* ZXImage.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXImage.m; sourceTree = "<group>"; };
+ 5D07BE0A1771C6E100555DE2 /* ZXView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXView.h; sourceTree = "<group>"; };
+ 5D07BE0D1771C6E100555DE2 /* ZXMathUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMathUtils.h; sourceTree = "<group>"; };
+ 5D07BE0E1771C6E100555DE2 /* ZXMathUtils.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMathUtils.m; sourceTree = "<group>"; };
+ 5D07BE0F1771C6E100555DE2 /* ZXMonochromeRectangleDetector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMonochromeRectangleDetector.h; sourceTree = "<group>"; };
+ 5D07BE101771C6E100555DE2 /* ZXMonochromeRectangleDetector.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMonochromeRectangleDetector.m; sourceTree = "<group>"; };
+ 5D07BE111771C6E100555DE2 /* ZXWhiteRectangleDetector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXWhiteRectangleDetector.h; sourceTree = "<group>"; };
+ 5D07BE121771C6E100555DE2 /* ZXWhiteRectangleDetector.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXWhiteRectangleDetector.m; sourceTree = "<group>"; };
+ 5D07BE141771C6E100555DE2 /* ZXGenericGF.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXGenericGF.h; sourceTree = "<group>"; };
+ 5D07BE151771C6E100555DE2 /* ZXGenericGF.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXGenericGF.m; sourceTree = "<group>"; };
+ 5D07BE161771C6E100555DE2 /* ZXGenericGFPoly.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXGenericGFPoly.h; sourceTree = "<group>"; };
+ 5D07BE171771C6E100555DE2 /* ZXGenericGFPoly.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXGenericGFPoly.m; sourceTree = "<group>"; };
+ 5D07BE181771C6E100555DE2 /* ZXReedSolomonDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXReedSolomonDecoder.h; sourceTree = "<group>"; };
+ 5D07BE191771C6E100555DE2 /* ZXReedSolomonDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXReedSolomonDecoder.m; sourceTree = "<group>"; };
+ 5D07BE1A1771C6E100555DE2 /* ZXReedSolomonEncoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXReedSolomonEncoder.h; sourceTree = "<group>"; };
+ 5D07BE1B1771C6E100555DE2 /* ZXReedSolomonEncoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXReedSolomonEncoder.m; sourceTree = "<group>"; };
+ 5D07BE1C1771C6E100555DE2 /* ZXBitArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBitArray.h; sourceTree = "<group>"; };
+ 5D07BE1D1771C6E100555DE2 /* ZXBitArray.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXBitArray.m; sourceTree = "<group>"; };
+ 5D07BE1E1771C6E100555DE2 /* ZXBitMatrix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBitMatrix.h; sourceTree = "<group>"; };
+ 5D07BE1F1771C6E100555DE2 /* ZXBitMatrix.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXBitMatrix.m; sourceTree = "<group>"; };
+ 5D07BE201771C6E100555DE2 /* ZXBitSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBitSource.h; sourceTree = "<group>"; };
+ 5D07BE211771C6E100555DE2 /* ZXBitSource.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXBitSource.m; sourceTree = "<group>"; };
+ 5D07BE221771C6E100555DE2 /* ZXCharacterSetECI.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCharacterSetECI.h; sourceTree = "<group>"; };
+ 5D07BE231771C6E100555DE2 /* ZXCharacterSetECI.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXCharacterSetECI.m; sourceTree = "<group>"; };
+ 5D07BE241771C6E100555DE2 /* ZXDecoderResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDecoderResult.h; sourceTree = "<group>"; };
+ 5D07BE251771C6E100555DE2 /* ZXDecoderResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDecoderResult.m; sourceTree = "<group>"; };
+ 5D07BE261771C6E100555DE2 /* ZXDefaultGridSampler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDefaultGridSampler.h; sourceTree = "<group>"; };
+ 5D07BE271771C6E100555DE2 /* ZXDefaultGridSampler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDefaultGridSampler.m; sourceTree = "<group>"; };
+ 5D07BE281771C6E100555DE2 /* ZXDetectorResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDetectorResult.h; sourceTree = "<group>"; };
+ 5D07BE291771C6E100555DE2 /* ZXDetectorResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDetectorResult.m; sourceTree = "<group>"; };
+ 5D07BE2A1771C6E100555DE2 /* ZXECI.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXECI.h; sourceTree = "<group>"; };
+ 5D07BE2B1771C6E100555DE2 /* ZXECI.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXECI.m; sourceTree = "<group>"; };
+ 5D07BE2C1771C6E100555DE2 /* ZXGlobalHistogramBinarizer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXGlobalHistogramBinarizer.h; sourceTree = "<group>"; };
+ 5D07BE2D1771C6E100555DE2 /* ZXGlobalHistogramBinarizer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXGlobalHistogramBinarizer.m; sourceTree = "<group>"; };
+ 5D07BE2E1771C6E100555DE2 /* ZXGridSampler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXGridSampler.h; sourceTree = "<group>"; };
+ 5D07BE2F1771C6E100555DE2 /* ZXGridSampler.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXGridSampler.m; sourceTree = "<group>"; };
+ 5D07BE301771C6E100555DE2 /* ZXHybridBinarizer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXHybridBinarizer.h; sourceTree = "<group>"; };
+ 5D07BE311771C6E100555DE2 /* ZXHybridBinarizer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXHybridBinarizer.m; sourceTree = "<group>"; };
+ 5D07BE321771C6E100555DE2 /* ZXPerspectiveTransform.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXPerspectiveTransform.h; sourceTree = "<group>"; };
+ 5D07BE331771C6E100555DE2 /* ZXPerspectiveTransform.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXPerspectiveTransform.m; sourceTree = "<group>"; };
+ 5D07BE341771C6E100555DE2 /* ZXStringUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXStringUtils.h; sourceTree = "<group>"; };
+ 5D07BE351771C6E100555DE2 /* ZXStringUtils.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXStringUtils.m; sourceTree = "<group>"; };
+ 5D07BE381771C6E100555DE2 /* ZXDataMatrixBitMatrixParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDataMatrixBitMatrixParser.h; sourceTree = "<group>"; };
+ 5D07BE391771C6E100555DE2 /* ZXDataMatrixBitMatrixParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDataMatrixBitMatrixParser.m; sourceTree = "<group>"; };
+ 5D07BE3A1771C6E100555DE2 /* ZXDataMatrixDataBlock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDataMatrixDataBlock.h; sourceTree = "<group>"; };
+ 5D07BE3B1771C6E100555DE2 /* ZXDataMatrixDataBlock.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDataMatrixDataBlock.m; sourceTree = "<group>"; };
+ 5D07BE3C1771C6E100555DE2 /* ZXDataMatrixDecodedBitStreamParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDataMatrixDecodedBitStreamParser.h; sourceTree = "<group>"; };
+ 5D07BE3D1771C6E100555DE2 /* ZXDataMatrixDecodedBitStreamParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDataMatrixDecodedBitStreamParser.m; sourceTree = "<group>"; };
+ 5D07BE3E1771C6E100555DE2 /* ZXDataMatrixDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDataMatrixDecoder.h; sourceTree = "<group>"; };
+ 5D07BE3F1771C6E100555DE2 /* ZXDataMatrixDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDataMatrixDecoder.m; sourceTree = "<group>"; };
+ 5D07BE401771C6E100555DE2 /* ZXDataMatrixVersion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDataMatrixVersion.h; sourceTree = "<group>"; };
+ 5D07BE411771C6E100555DE2 /* ZXDataMatrixVersion.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDataMatrixVersion.m; sourceTree = "<group>"; };
+ 5D07BE431771C6E100555DE2 /* ZXDataMatrixDetector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDataMatrixDetector.h; sourceTree = "<group>"; };
+ 5D07BE441771C6E100555DE2 /* ZXDataMatrixDetector.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDataMatrixDetector.m; sourceTree = "<group>"; };
+ 5D07BE461771C6E100555DE2 /* ZXASCIIEncoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXASCIIEncoder.h; sourceTree = "<group>"; };
+ 5D07BE471771C6E100555DE2 /* ZXASCIIEncoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXASCIIEncoder.m; sourceTree = "<group>"; };
+ 5D07BE481771C6E100555DE2 /* ZXBase256Encoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBase256Encoder.h; sourceTree = "<group>"; };
+ 5D07BE491771C6E100555DE2 /* ZXBase256Encoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXBase256Encoder.m; sourceTree = "<group>"; };
+ 5D07BE4A1771C6E100555DE2 /* ZXC40Encoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXC40Encoder.h; sourceTree = "<group>"; };
+ 5D07BE4B1771C6E100555DE2 /* ZXC40Encoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXC40Encoder.m; sourceTree = "<group>"; };
+ 5D07BE4C1771C6E100555DE2 /* ZXDataMatrixEncoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDataMatrixEncoder.h; sourceTree = "<group>"; };
+ 5D07BE4D1771C6E100555DE2 /* ZXDataMatrixErrorCorrection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDataMatrixErrorCorrection.h; sourceTree = "<group>"; };
+ 5D07BE4E1771C6E100555DE2 /* ZXDataMatrixErrorCorrection.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDataMatrixErrorCorrection.m; sourceTree = "<group>"; };
+ 5D07BE4F1771C6E100555DE2 /* ZXDataMatrixSymbolInfo144.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDataMatrixSymbolInfo144.h; sourceTree = "<group>"; };
+ 5D07BE501771C6E100555DE2 /* ZXDataMatrixSymbolInfo144.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDataMatrixSymbolInfo144.m; sourceTree = "<group>"; };
+ 5D07BE511771C6E100555DE2 /* ZXDefaultPlacement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDefaultPlacement.h; sourceTree = "<group>"; };
+ 5D07BE521771C6E100555DE2 /* ZXDefaultPlacement.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDefaultPlacement.m; sourceTree = "<group>"; };
+ 5D07BE531771C6E100555DE2 /* ZXEdifactEncoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXEdifactEncoder.h; sourceTree = "<group>"; };
+ 5D07BE541771C6E100555DE2 /* ZXEdifactEncoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXEdifactEncoder.m; sourceTree = "<group>"; };
+ 5D07BE551771C6E100555DE2 /* ZXEncoderContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXEncoderContext.h; sourceTree = "<group>"; };
+ 5D07BE561771C6E100555DE2 /* ZXEncoderContext.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXEncoderContext.m; sourceTree = "<group>"; };
+ 5D07BE571771C6E100555DE2 /* ZXHighLevelEncoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXHighLevelEncoder.h; sourceTree = "<group>"; };
+ 5D07BE581771C6E100555DE2 /* ZXHighLevelEncoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXHighLevelEncoder.m; sourceTree = "<group>"; };
+ 5D07BE591771C6E100555DE2 /* ZXSymbolInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXSymbolInfo.h; sourceTree = "<group>"; };
+ 5D07BE5A1771C6E100555DE2 /* ZXSymbolInfo.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXSymbolInfo.m; sourceTree = "<group>"; };
+ 5D07BE5B1771C6E100555DE2 /* ZXSymbolShapeHint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXSymbolShapeHint.h; sourceTree = "<group>"; };
+ 5D07BE5C1771C6E100555DE2 /* ZXSymbolShapeHint.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXSymbolShapeHint.m; sourceTree = "<group>"; };
+ 5D07BE5D1771C6E100555DE2 /* ZXTextEncoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXTextEncoder.h; sourceTree = "<group>"; };
+ 5D07BE5E1771C6E100555DE2 /* ZXTextEncoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXTextEncoder.m; sourceTree = "<group>"; };
+ 5D07BE5F1771C6E100555DE2 /* ZXX12Encoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXX12Encoder.h; sourceTree = "<group>"; };
+ 5D07BE601771C6E100555DE2 /* ZXX12Encoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXX12Encoder.m; sourceTree = "<group>"; };
+ 5D07BE611771C6E100555DE2 /* ZXDataMatrixReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDataMatrixReader.h; sourceTree = "<group>"; };
+ 5D07BE621771C6E100555DE2 /* ZXDataMatrixReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDataMatrixReader.m; sourceTree = "<group>"; };
+ 5D07BE631771C6E100555DE2 /* ZXDataMatrixWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDataMatrixWriter.h; sourceTree = "<group>"; };
+ 5D07BE641771C6E100555DE2 /* ZXDataMatrixWriter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDataMatrixWriter.m; sourceTree = "<group>"; };
+ 5D07BE671771C6E100555DE2 /* ZXMaxiCodeBitMatrixParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMaxiCodeBitMatrixParser.h; sourceTree = "<group>"; };
+ 5D07BE681771C6E100555DE2 /* ZXMaxiCodeBitMatrixParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMaxiCodeBitMatrixParser.m; sourceTree = "<group>"; };
+ 5D07BE691771C6E100555DE2 /* ZXMaxiCodeDecodedBitStreamParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMaxiCodeDecodedBitStreamParser.h; sourceTree = "<group>"; };
+ 5D07BE6A1771C6E100555DE2 /* ZXMaxiCodeDecodedBitStreamParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMaxiCodeDecodedBitStreamParser.m; sourceTree = "<group>"; };
+ 5D07BE6B1771C6E100555DE2 /* ZXMaxiCodeDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMaxiCodeDecoder.h; sourceTree = "<group>"; };
+ 5D07BE6C1771C6E100555DE2 /* ZXMaxiCodeDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMaxiCodeDecoder.m; sourceTree = "<group>"; };
+ 5D07BE6D1771C6E100555DE2 /* ZXMaxiCodeReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMaxiCodeReader.h; sourceTree = "<group>"; };
+ 5D07BE6E1771C6E100555DE2 /* ZXMaxiCodeReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMaxiCodeReader.m; sourceTree = "<group>"; };
+ 5D07BE721771C6E100555DE2 /* ZXMultiDetector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMultiDetector.h; sourceTree = "<group>"; };
+ 5D07BE731771C6E100555DE2 /* ZXMultiDetector.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMultiDetector.m; sourceTree = "<group>"; };
+ 5D07BE741771C6E100555DE2 /* ZXMultiFinderPatternFinder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMultiFinderPatternFinder.h; sourceTree = "<group>"; };
+ 5D07BE751771C6E100555DE2 /* ZXMultiFinderPatternFinder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMultiFinderPatternFinder.m; sourceTree = "<group>"; };
+ 5D07BE761771C6E100555DE2 /* ZXQRCodeMultiReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXQRCodeMultiReader.h; sourceTree = "<group>"; };
+ 5D07BE771771C6E100555DE2 /* ZXQRCodeMultiReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXQRCodeMultiReader.m; sourceTree = "<group>"; };
+ 5D07BE781771C6E100555DE2 /* ZXByQuadrantReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXByQuadrantReader.h; sourceTree = "<group>"; };
+ 5D07BE791771C6E100555DE2 /* ZXByQuadrantReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXByQuadrantReader.m; sourceTree = "<group>"; };
+ 5D07BE7A1771C6E100555DE2 /* ZXGenericMultipleBarcodeReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXGenericMultipleBarcodeReader.h; sourceTree = "<group>"; };
+ 5D07BE7B1771C6E100555DE2 /* ZXGenericMultipleBarcodeReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXGenericMultipleBarcodeReader.m; sourceTree = "<group>"; };
+ 5D07BE7C1771C6E100555DE2 /* ZXMultipleBarcodeReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMultipleBarcodeReader.h; sourceTree = "<group>"; };
+ 5D07BE811771C6E100555DE2 /* ZXAbstractExpandedDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAbstractExpandedDecoder.h; sourceTree = "<group>"; };
+ 5D07BE821771C6E100555DE2 /* ZXAbstractExpandedDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAbstractExpandedDecoder.m; sourceTree = "<group>"; };
+ 5D07BE831771C6E100555DE2 /* ZXAI013103decoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAI013103decoder.h; sourceTree = "<group>"; };
+ 5D07BE841771C6E100555DE2 /* ZXAI013103decoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAI013103decoder.m; sourceTree = "<group>"; };
+ 5D07BE851771C6E100555DE2 /* ZXAI01320xDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAI01320xDecoder.h; sourceTree = "<group>"; };
+ 5D07BE861771C6E100555DE2 /* ZXAI01320xDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAI01320xDecoder.m; sourceTree = "<group>"; };
+ 5D07BE871771C6E100555DE2 /* ZXAI01392xDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAI01392xDecoder.h; sourceTree = "<group>"; };
+ 5D07BE881771C6E100555DE2 /* ZXAI01392xDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAI01392xDecoder.m; sourceTree = "<group>"; };
+ 5D07BE891771C6E100555DE2 /* ZXAI01393xDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAI01393xDecoder.h; sourceTree = "<group>"; };
+ 5D07BE8A1771C6E100555DE2 /* ZXAI01393xDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAI01393xDecoder.m; sourceTree = "<group>"; };
+ 5D07BE8B1771C6E100555DE2 /* ZXAI013x0x1xDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAI013x0x1xDecoder.h; sourceTree = "<group>"; };
+ 5D07BE8C1771C6E100555DE2 /* ZXAI013x0x1xDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAI013x0x1xDecoder.m; sourceTree = "<group>"; };
+ 5D07BE8D1771C6E100555DE2 /* ZXAI013x0xDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAI013x0xDecoder.h; sourceTree = "<group>"; };
+ 5D07BE8E1771C6E100555DE2 /* ZXAI013x0xDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAI013x0xDecoder.m; sourceTree = "<group>"; };
+ 5D07BE8F1771C6E100555DE2 /* ZXAI01AndOtherAIs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAI01AndOtherAIs.h; sourceTree = "<group>"; };
+ 5D07BE901771C6E100555DE2 /* ZXAI01AndOtherAIs.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAI01AndOtherAIs.m; sourceTree = "<group>"; };
+ 5D07BE911771C6E100555DE2 /* ZXAI01decoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAI01decoder.h; sourceTree = "<group>"; };
+ 5D07BE921771C6E100555DE2 /* ZXAI01decoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAI01decoder.m; sourceTree = "<group>"; };
+ 5D07BE931771C6E100555DE2 /* ZXAI01weightDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAI01weightDecoder.h; sourceTree = "<group>"; };
+ 5D07BE941771C6E100555DE2 /* ZXAI01weightDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAI01weightDecoder.m; sourceTree = "<group>"; };
+ 5D07BE951771C6E100555DE2 /* ZXAnyAIDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAnyAIDecoder.h; sourceTree = "<group>"; };
+ 5D07BE961771C6E100555DE2 /* ZXAnyAIDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAnyAIDecoder.m; sourceTree = "<group>"; };
+ 5D07BE971771C6E100555DE2 /* ZXBlockParsedResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBlockParsedResult.h; sourceTree = "<group>"; };
+ 5D07BE981771C6E100555DE2 /* ZXBlockParsedResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXBlockParsedResult.m; sourceTree = "<group>"; };
+ 5D07BE991771C6E100555DE2 /* ZXCurrentParsingState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCurrentParsingState.h; sourceTree = "<group>"; };
+ 5D07BE9A1771C6E100555DE2 /* ZXCurrentParsingState.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXCurrentParsingState.m; sourceTree = "<group>"; };
+ 5D07BE9B1771C6E100555DE2 /* ZXDecodedChar.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDecodedChar.h; sourceTree = "<group>"; };
+ 5D07BE9C1771C6E100555DE2 /* ZXDecodedChar.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDecodedChar.m; sourceTree = "<group>"; };
+ 5D07BE9D1771C6E100555DE2 /* ZXDecodedInformation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDecodedInformation.h; sourceTree = "<group>"; };
+ 5D07BE9E1771C6E100555DE2 /* ZXDecodedInformation.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDecodedInformation.m; sourceTree = "<group>"; };
+ 5D07BE9F1771C6E100555DE2 /* ZXDecodedNumeric.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDecodedNumeric.h; sourceTree = "<group>"; };
+ 5D07BEA01771C6E100555DE2 /* ZXDecodedNumeric.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDecodedNumeric.m; sourceTree = "<group>"; };
+ 5D07BEA11771C6E100555DE2 /* ZXDecodedObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDecodedObject.h; sourceTree = "<group>"; };
+ 5D07BEA21771C6E100555DE2 /* ZXDecodedObject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDecodedObject.m; sourceTree = "<group>"; };
+ 5D07BEA31771C6E100555DE2 /* ZXFieldParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXFieldParser.h; sourceTree = "<group>"; };
+ 5D07BEA41771C6E100555DE2 /* ZXFieldParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXFieldParser.m; sourceTree = "<group>"; };
+ 5D07BEA51771C6E100555DE2 /* ZXGeneralAppIdDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXGeneralAppIdDecoder.h; sourceTree = "<group>"; };
+ 5D07BEA61771C6E100555DE2 /* ZXGeneralAppIdDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXGeneralAppIdDecoder.m; sourceTree = "<group>"; };
+ 5D07BEA71771C6E100555DE2 /* ZXBitArrayBuilder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBitArrayBuilder.h; sourceTree = "<group>"; };
+ 5D07BEA81771C6E100555DE2 /* ZXBitArrayBuilder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXBitArrayBuilder.m; sourceTree = "<group>"; };
+ 5D07BEA91771C6E100555DE2 /* ZXExpandedPair.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXExpandedPair.h; sourceTree = "<group>"; };
+ 5D07BEAA1771C6E100555DE2 /* ZXExpandedPair.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXExpandedPair.m; sourceTree = "<group>"; };
+ 5D07BEAB1771C6E100555DE2 /* ZXExpandedRow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXExpandedRow.h; sourceTree = "<group>"; };
+ 5D07BEAC1771C6E100555DE2 /* ZXExpandedRow.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXExpandedRow.m; sourceTree = "<group>"; };
+ 5D07BEAD1771C6E100555DE2 /* ZXRSSExpandedReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXRSSExpandedReader.h; sourceTree = "<group>"; };
+ 5D07BEAE1771C6E100555DE2 /* ZXRSSExpandedReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXRSSExpandedReader.m; sourceTree = "<group>"; };
+ 5D07BEAF1771C6E100555DE2 /* ZXAbstractRSSReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAbstractRSSReader.h; sourceTree = "<group>"; };
+ 5D07BEB01771C6E100555DE2 /* ZXAbstractRSSReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAbstractRSSReader.m; sourceTree = "<group>"; };
+ 5D07BEB11771C6E100555DE2 /* ZXDataCharacter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDataCharacter.h; sourceTree = "<group>"; };
+ 5D07BEB21771C6E100555DE2 /* ZXDataCharacter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDataCharacter.m; sourceTree = "<group>"; };
+ 5D07BEB31771C6E100555DE2 /* ZXPair.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXPair.h; sourceTree = "<group>"; };
+ 5D07BEB41771C6E100555DE2 /* ZXPair.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXPair.m; sourceTree = "<group>"; };
+ 5D07BEB51771C6E100555DE2 /* ZXRSS14Reader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXRSS14Reader.h; sourceTree = "<group>"; };
+ 5D07BEB61771C6E100555DE2 /* ZXRSS14Reader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXRSS14Reader.m; sourceTree = "<group>"; };
+ 5D07BEB71771C6E100555DE2 /* ZXRSSFinderPattern.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXRSSFinderPattern.h; sourceTree = "<group>"; };
+ 5D07BEB81771C6E100555DE2 /* ZXRSSFinderPattern.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXRSSFinderPattern.m; sourceTree = "<group>"; };
+ 5D07BEB91771C6E100555DE2 /* ZXRSSUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXRSSUtils.h; sourceTree = "<group>"; };
+ 5D07BEBA1771C6E100555DE2 /* ZXRSSUtils.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXRSSUtils.m; sourceTree = "<group>"; };
+ 5D07BEBB1771C6E100555DE2 /* ZXCodaBarReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCodaBarReader.h; sourceTree = "<group>"; };
+ 5D07BEBC1771C6E100555DE2 /* ZXCodaBarReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXCodaBarReader.m; sourceTree = "<group>"; };
+ 5D07BEBD1771C6E100555DE2 /* ZXCodaBarWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCodaBarWriter.h; sourceTree = "<group>"; };
+ 5D07BEBE1771C6E100555DE2 /* ZXCodaBarWriter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXCodaBarWriter.m; sourceTree = "<group>"; };
+ 5D07BEBF1771C6E100555DE2 /* ZXCode128Reader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCode128Reader.h; sourceTree = "<group>"; };
+ 5D07BEC01771C6E100555DE2 /* ZXCode128Reader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXCode128Reader.m; sourceTree = "<group>"; };
+ 5D07BEC11771C6E100555DE2 /* ZXCode128Writer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCode128Writer.h; sourceTree = "<group>"; };
+ 5D07BEC21771C6E100555DE2 /* ZXCode128Writer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXCode128Writer.m; sourceTree = "<group>"; };
+ 5D07BEC31771C6E100555DE2 /* ZXCode39Reader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCode39Reader.h; sourceTree = "<group>"; };
+ 5D07BEC41771C6E100555DE2 /* ZXCode39Reader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXCode39Reader.m; sourceTree = "<group>"; };
+ 5D07BEC51771C6E100555DE2 /* ZXCode39Writer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCode39Writer.h; sourceTree = "<group>"; };
+ 5D07BEC61771C6E100555DE2 /* ZXCode39Writer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXCode39Writer.m; sourceTree = "<group>"; };
+ 5D07BEC71771C6E100555DE2 /* ZXCode93Reader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCode93Reader.h; sourceTree = "<group>"; };
+ 5D07BEC81771C6E100555DE2 /* ZXCode93Reader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXCode93Reader.m; sourceTree = "<group>"; };
+ 5D07BEC91771C6E100555DE2 /* ZXEAN13Reader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXEAN13Reader.h; sourceTree = "<group>"; };
+ 5D07BECA1771C6E100555DE2 /* ZXEAN13Reader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXEAN13Reader.m; sourceTree = "<group>"; };
+ 5D07BECB1771C6E100555DE2 /* ZXEAN13Writer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXEAN13Writer.h; sourceTree = "<group>"; };
+ 5D07BECC1771C6E100555DE2 /* ZXEAN13Writer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXEAN13Writer.m; sourceTree = "<group>"; };
+ 5D07BECD1771C6E100555DE2 /* ZXEAN8Reader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXEAN8Reader.h; sourceTree = "<group>"; };
+ 5D07BECE1771C6E100555DE2 /* ZXEAN8Reader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXEAN8Reader.m; sourceTree = "<group>"; };
+ 5D07BECF1771C6E100555DE2 /* ZXEAN8Writer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXEAN8Writer.h; sourceTree = "<group>"; };
+ 5D07BED01771C6E100555DE2 /* ZXEAN8Writer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXEAN8Writer.m; sourceTree = "<group>"; };
+ 5D07BED11771C6E100555DE2 /* ZXEANManufacturerOrgSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXEANManufacturerOrgSupport.h; sourceTree = "<group>"; };
+ 5D07BED21771C6E100555DE2 /* ZXEANManufacturerOrgSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXEANManufacturerOrgSupport.m; sourceTree = "<group>"; };
+ 5D07BED31771C6E100555DE2 /* ZXITFReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXITFReader.h; sourceTree = "<group>"; };
+ 5D07BED41771C6E100555DE2 /* ZXITFReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXITFReader.m; sourceTree = "<group>"; };
+ 5D07BED51771C6E100555DE2 /* ZXITFWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXITFWriter.h; sourceTree = "<group>"; };
+ 5D07BED61771C6E100555DE2 /* ZXITFWriter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXITFWriter.m; sourceTree = "<group>"; };
+ 5D07BED71771C6E100555DE2 /* ZXMultiFormatOneDReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMultiFormatOneDReader.h; sourceTree = "<group>"; };
+ 5D07BED81771C6E100555DE2 /* ZXMultiFormatOneDReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMultiFormatOneDReader.m; sourceTree = "<group>"; };
+ 5D07BED91771C6E100555DE2 /* ZXMultiFormatUPCEANReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMultiFormatUPCEANReader.h; sourceTree = "<group>"; };
+ 5D07BEDA1771C6E100555DE2 /* ZXMultiFormatUPCEANReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMultiFormatUPCEANReader.m; sourceTree = "<group>"; };
+ 5D07BEDB1771C6E100555DE2 /* ZXOneDimensionalCodeWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXOneDimensionalCodeWriter.h; sourceTree = "<group>"; };
+ 5D07BEDC1771C6E100555DE2 /* ZXOneDimensionalCodeWriter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXOneDimensionalCodeWriter.m; sourceTree = "<group>"; };
+ 5D07BEDD1771C6E100555DE2 /* ZXOneDReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXOneDReader.h; sourceTree = "<group>"; };
+ 5D07BEDE1771C6E100555DE2 /* ZXOneDReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXOneDReader.m; sourceTree = "<group>"; };
+ 5D07BEDF1771C6E100555DE2 /* ZXUPCAReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXUPCAReader.h; sourceTree = "<group>"; };
+ 5D07BEE01771C6E100555DE2 /* ZXUPCAReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXUPCAReader.m; sourceTree = "<group>"; };
+ 5D07BEE11771C6E100555DE2 /* ZXUPCAWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXUPCAWriter.h; sourceTree = "<group>"; };
+ 5D07BEE21771C6E100555DE2 /* ZXUPCAWriter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXUPCAWriter.m; sourceTree = "<group>"; };
+ 5D07BEE31771C6E100555DE2 /* ZXUPCEANExtension2Support.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXUPCEANExtension2Support.h; sourceTree = "<group>"; };
+ 5D07BEE41771C6E100555DE2 /* ZXUPCEANExtension2Support.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXUPCEANExtension2Support.m; sourceTree = "<group>"; };
+ 5D07BEE51771C6E100555DE2 /* ZXUPCEANExtension5Support.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXUPCEANExtension5Support.h; sourceTree = "<group>"; };
+ 5D07BEE61771C6E100555DE2 /* ZXUPCEANExtension5Support.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXUPCEANExtension5Support.m; sourceTree = "<group>"; };
+ 5D07BEE71771C6E100555DE2 /* ZXUPCEANExtensionSupport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXUPCEANExtensionSupport.h; sourceTree = "<group>"; };
+ 5D07BEE81771C6E100555DE2 /* ZXUPCEANExtensionSupport.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXUPCEANExtensionSupport.m; sourceTree = "<group>"; };
+ 5D07BEE91771C6E100555DE2 /* ZXUPCEANReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXUPCEANReader.h; sourceTree = "<group>"; };
+ 5D07BEEA1771C6E100555DE2 /* ZXUPCEANReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXUPCEANReader.m; sourceTree = "<group>"; };
+ 5D07BEEB1771C6E100555DE2 /* ZXUPCEANWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXUPCEANWriter.h; sourceTree = "<group>"; };
+ 5D07BEEC1771C6E100555DE2 /* ZXUPCEANWriter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXUPCEANWriter.m; sourceTree = "<group>"; };
+ 5D07BEED1771C6E100555DE2 /* ZXUPCEReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXUPCEReader.h; sourceTree = "<group>"; };
+ 5D07BEEE1771C6E100555DE2 /* ZXUPCEReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXUPCEReader.m; sourceTree = "<group>"; };
+ 5D07BEF21771C6E100555DE2 /* ZXModulusGF.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXModulusGF.h; sourceTree = "<group>"; };
+ 5D07BEF31771C6E100555DE2 /* ZXModulusGF.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXModulusGF.m; sourceTree = "<group>"; };
+ 5D07BEF41771C6E100555DE2 /* ZXModulusPoly.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXModulusPoly.h; sourceTree = "<group>"; };
+ 5D07BEF51771C6E100555DE2 /* ZXModulusPoly.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXModulusPoly.m; sourceTree = "<group>"; };
+ 5D07BEF61771C6E100555DE2 /* ZXPDF417ECErrorCorrection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXPDF417ECErrorCorrection.h; sourceTree = "<group>"; };
+ 5D07BEF71771C6E100555DE2 /* ZXPDF417ECErrorCorrection.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXPDF417ECErrorCorrection.m; sourceTree = "<group>"; };
+ 5D07BEF81771C6E100555DE2 /* ZXPDF417BitMatrixParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXPDF417BitMatrixParser.h; sourceTree = "<group>"; };
+ 5D07BEF91771C6E100555DE2 /* ZXPDF417BitMatrixParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXPDF417BitMatrixParser.m; sourceTree = "<group>"; };
+ 5D07BEFA1771C6E100555DE2 /* ZXPDF417DecodedBitStreamParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXPDF417DecodedBitStreamParser.h; sourceTree = "<group>"; };
+ 5D07BEFB1771C6E100555DE2 /* ZXPDF417DecodedBitStreamParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXPDF417DecodedBitStreamParser.m; sourceTree = "<group>"; };
+ 5D07BEFC1771C6E100555DE2 /* ZXPDF417Decoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXPDF417Decoder.h; sourceTree = "<group>"; };
+ 5D07BEFD1771C6E100555DE2 /* ZXPDF417Decoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXPDF417Decoder.m; sourceTree = "<group>"; };
+ 5D07BEFF1771C6E100555DE2 /* ZXPDF417Detector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXPDF417Detector.h; sourceTree = "<group>"; };
+ 5D07BF001771C6E100555DE2 /* ZXPDF417Detector.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXPDF417Detector.m; sourceTree = "<group>"; };
+ 5D07BF021771C6E100555DE2 /* ZXBarcodeMatrix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBarcodeMatrix.h; sourceTree = "<group>"; };
+ 5D07BF031771C6E100555DE2 /* ZXBarcodeMatrix.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXBarcodeMatrix.m; sourceTree = "<group>"; };
+ 5D07BF041771C6E100555DE2 /* ZXBarcodeRow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBarcodeRow.h; sourceTree = "<group>"; };
+ 5D07BF051771C6E100555DE2 /* ZXBarcodeRow.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXBarcodeRow.m; sourceTree = "<group>"; };
+ 5D07BF061771C6E100555DE2 /* ZXCompaction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXCompaction.h; sourceTree = "<group>"; };
+ 5D07BF071771C6E100555DE2 /* ZXDimensions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDimensions.h; sourceTree = "<group>"; };
+ 5D07BF081771C6E100555DE2 /* ZXDimensions.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDimensions.m; sourceTree = "<group>"; };
+ 5D07BF091771C6E100555DE2 /* ZXPDF417.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXPDF417.h; sourceTree = "<group>"; };
+ 5D07BF0A1771C6E100555DE2 /* ZXPDF417.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXPDF417.m; sourceTree = "<group>"; };
+ 5D07BF0B1771C6E100555DE2 /* ZXPDF417ErrorCorrection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXPDF417ErrorCorrection.h; sourceTree = "<group>"; };
+ 5D07BF0C1771C6E100555DE2 /* ZXPDF417ErrorCorrection.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXPDF417ErrorCorrection.m; sourceTree = "<group>"; };
+ 5D07BF0D1771C6E100555DE2 /* ZXPDF417HighLevelEncoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXPDF417HighLevelEncoder.h; sourceTree = "<group>"; };
+ 5D07BF0E1771C6E100555DE2 /* ZXPDF417HighLevelEncoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXPDF417HighLevelEncoder.m; sourceTree = "<group>"; };
+ 5D07BF0F1771C6E100555DE2 /* ZXPDF417Writer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXPDF417Writer.h; sourceTree = "<group>"; };
+ 5D07BF101771C6E100555DE2 /* ZXPDF417Writer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXPDF417Writer.m; sourceTree = "<group>"; };
+ 5D07BF111771C6E100555DE2 /* ZXPDF417Reader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXPDF417Reader.h; sourceTree = "<group>"; };
+ 5D07BF121771C6E100555DE2 /* ZXPDF417Reader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXPDF417Reader.m; sourceTree = "<group>"; };
+ 5D07BF151771C6E100555DE2 /* ZXDataMask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDataMask.h; sourceTree = "<group>"; };
+ 5D07BF161771C6E100555DE2 /* ZXDataMask.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDataMask.m; sourceTree = "<group>"; };
+ 5D07BF171771C6E100555DE2 /* ZXErrorCorrectionLevel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXErrorCorrectionLevel.h; sourceTree = "<group>"; };
+ 5D07BF181771C6E100555DE2 /* ZXErrorCorrectionLevel.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXErrorCorrectionLevel.m; sourceTree = "<group>"; };
+ 5D07BF191771C6E100555DE2 /* ZXFormatInformation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXFormatInformation.h; sourceTree = "<group>"; };
+ 5D07BF1A1771C6E100555DE2 /* ZXFormatInformation.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXFormatInformation.m; sourceTree = "<group>"; };
+ 5D07BF1B1771C6E100555DE2 /* ZXMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMode.h; sourceTree = "<group>"; };
+ 5D07BF1C1771C6E100555DE2 /* ZXMode.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMode.m; sourceTree = "<group>"; };
+ 5D07BF1D1771C6E100555DE2 /* ZXQRCodeBitMatrixParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXQRCodeBitMatrixParser.h; sourceTree = "<group>"; };
+ 5D07BF1E1771C6E100555DE2 /* ZXQRCodeBitMatrixParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXQRCodeBitMatrixParser.m; sourceTree = "<group>"; };
+ 5D07BF1F1771C6E100555DE2 /* ZXQRCodeDataBlock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXQRCodeDataBlock.h; sourceTree = "<group>"; };
+ 5D07BF201771C6E100555DE2 /* ZXQRCodeDataBlock.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXQRCodeDataBlock.m; sourceTree = "<group>"; };
+ 5D07BF211771C6E100555DE2 /* ZXQRCodeDecodedBitStreamParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXQRCodeDecodedBitStreamParser.h; sourceTree = "<group>"; };
+ 5D07BF221771C6E100555DE2 /* ZXQRCodeDecodedBitStreamParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXQRCodeDecodedBitStreamParser.m; sourceTree = "<group>"; };
+ 5D07BF231771C6E100555DE2 /* ZXQRCodeDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXQRCodeDecoder.h; sourceTree = "<group>"; };
+ 5D07BF241771C6E100555DE2 /* ZXQRCodeDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXQRCodeDecoder.m; sourceTree = "<group>"; };
+ 5D07BF251771C6E100555DE2 /* ZXQRCodeVersion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXQRCodeVersion.h; sourceTree = "<group>"; };
+ 5D07BF261771C6E100555DE2 /* ZXQRCodeVersion.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXQRCodeVersion.m; sourceTree = "<group>"; };
+ 5D07BF281771C6E100555DE2 /* ZXAlignmentPattern.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAlignmentPattern.h; sourceTree = "<group>"; };
+ 5D07BF291771C6E100555DE2 /* ZXAlignmentPattern.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAlignmentPattern.m; sourceTree = "<group>"; };
+ 5D07BF2A1771C6E100555DE2 /* ZXAlignmentPatternFinder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXAlignmentPatternFinder.h; sourceTree = "<group>"; };
+ 5D07BF2B1771C6E100555DE2 /* ZXAlignmentPatternFinder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXAlignmentPatternFinder.m; sourceTree = "<group>"; };
+ 5D07BF2C1771C6E100555DE2 /* ZXFinderPatternFinder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXFinderPatternFinder.h; sourceTree = "<group>"; };
+ 5D07BF2D1771C6E100555DE2 /* ZXFinderPatternFinder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXFinderPatternFinder.m; sourceTree = "<group>"; };
+ 5D07BF2E1771C6E100555DE2 /* ZXFinderPatternInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXFinderPatternInfo.h; sourceTree = "<group>"; };
+ 5D07BF2F1771C6E100555DE2 /* ZXFinderPatternInfo.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXFinderPatternInfo.m; sourceTree = "<group>"; };
+ 5D07BF301771C6E100555DE2 /* ZXQRCodeDetector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXQRCodeDetector.h; sourceTree = "<group>"; };
+ 5D07BF311771C6E100555DE2 /* ZXQRCodeDetector.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXQRCodeDetector.m; sourceTree = "<group>"; };
+ 5D07BF321771C6E100555DE2 /* ZXQRCodeFinderPattern.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXQRCodeFinderPattern.h; sourceTree = "<group>"; };
+ 5D07BF331771C6E100555DE2 /* ZXQRCodeFinderPattern.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXQRCodeFinderPattern.m; sourceTree = "<group>"; };
+ 5D07BF351771C6E100555DE2 /* ZXBlockPair.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBlockPair.h; sourceTree = "<group>"; };
+ 5D07BF361771C6E100555DE2 /* ZXBlockPair.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXBlockPair.m; sourceTree = "<group>"; };
+ 5D07BF371771C6E100555DE2 /* ZXByteMatrix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXByteMatrix.h; sourceTree = "<group>"; };
+ 5D07BF381771C6E100555DE2 /* ZXByteMatrix.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXByteMatrix.m; sourceTree = "<group>"; };
+ 5D07BF391771C6E100555DE2 /* ZXEncoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXEncoder.h; sourceTree = "<group>"; };
+ 5D07BF3A1771C6E100555DE2 /* ZXEncoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXEncoder.m; sourceTree = "<group>"; };
+ 5D07BF3B1771C6E100555DE2 /* ZXMaskUtil.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMaskUtil.h; sourceTree = "<group>"; };
+ 5D07BF3C1771C6E100555DE2 /* ZXMaskUtil.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMaskUtil.m; sourceTree = "<group>"; };
+ 5D07BF3D1771C6E100555DE2 /* ZXMatrixUtil.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMatrixUtil.h; sourceTree = "<group>"; };
+ 5D07BF3E1771C6E100555DE2 /* ZXMatrixUtil.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMatrixUtil.m; sourceTree = "<group>"; };
+ 5D07BF3F1771C6E100555DE2 /* ZXQRCode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXQRCode.h; sourceTree = "<group>"; };
+ 5D07BF401771C6E100555DE2 /* ZXQRCode.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXQRCode.m; sourceTree = "<group>"; };
+ 5D07BF411771C6E100555DE2 /* ZXQRCodeReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXQRCodeReader.h; sourceTree = "<group>"; };
+ 5D07BF421771C6E100555DE2 /* ZXQRCodeReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXQRCodeReader.m; sourceTree = "<group>"; };
+ 5D07BF431771C6E100555DE2 /* ZXQRCodeWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXQRCodeWriter.h; sourceTree = "<group>"; };
+ 5D07BF441771C6E100555DE2 /* ZXQRCodeWriter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXQRCodeWriter.m; sourceTree = "<group>"; };
+ 5D07BF451771C6E100555DE2 /* ZXBarcodeFormat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBarcodeFormat.h; sourceTree = "<group>"; };
+ 5D07BF461771C6E100555DE2 /* ZXBinarizer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBinarizer.h; sourceTree = "<group>"; };
+ 5D07BF471771C6E100555DE2 /* ZXBinarizer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXBinarizer.m; sourceTree = "<group>"; };
+ 5D07BF481771C6E100555DE2 /* ZXBinaryBitmap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXBinaryBitmap.h; sourceTree = "<group>"; };
+ 5D07BF491771C6E100555DE2 /* ZXBinaryBitmap.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXBinaryBitmap.m; sourceTree = "<group>"; };
+ 5D07BF4A1771C6E100555DE2 /* ZXDecodeHints.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDecodeHints.h; sourceTree = "<group>"; };
+ 5D07BF4B1771C6E100555DE2 /* ZXDecodeHints.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDecodeHints.m; sourceTree = "<group>"; };
+ 5D07BF4C1771C6E100555DE2 /* ZXDimension.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXDimension.h; sourceTree = "<group>"; };
+ 5D07BF4D1771C6E100555DE2 /* ZXDimension.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXDimension.m; sourceTree = "<group>"; };
+ 5D07BF4E1771C6E100555DE2 /* ZXEncodeHints.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXEncodeHints.h; sourceTree = "<group>"; };
+ 5D07BF4F1771C6E100555DE2 /* ZXEncodeHints.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXEncodeHints.m; sourceTree = "<group>"; };
+ 5D07BF501771C6E100555DE2 /* ZXErrors.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXErrors.h; sourceTree = "<group>"; };
+ 5D07BF511771C6E100555DE2 /* ZXErrors.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXErrors.m; sourceTree = "<group>"; };
+ 5D07BF521771C6E100555DE2 /* ZXingObjC.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXingObjC.h; sourceTree = "<group>"; };
+ 5D07BF531771C6E100555DE2 /* ZXInvertedLuminanceSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXInvertedLuminanceSource.h; sourceTree = "<group>"; };
+ 5D07BF541771C6E100555DE2 /* ZXInvertedLuminanceSource.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXInvertedLuminanceSource.m; sourceTree = "<group>"; };
+ 5D07BF551771C6E100555DE2 /* ZXLuminanceSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXLuminanceSource.h; sourceTree = "<group>"; };
+ 5D07BF561771C6E100555DE2 /* ZXLuminanceSource.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXLuminanceSource.m; sourceTree = "<group>"; };
+ 5D07BF571771C6E100555DE2 /* ZXMultiFormatReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMultiFormatReader.h; sourceTree = "<group>"; };
+ 5D07BF581771C6E100555DE2 /* ZXMultiFormatReader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMultiFormatReader.m; sourceTree = "<group>"; };
+ 5D07BF591771C6E100555DE2 /* ZXMultiFormatWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXMultiFormatWriter.h; sourceTree = "<group>"; };
+ 5D07BF5A1771C6E100555DE2 /* ZXMultiFormatWriter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXMultiFormatWriter.m; sourceTree = "<group>"; };
+ 5D07BF5B1771C6E100555DE2 /* ZXPlanarYUVLuminanceSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXPlanarYUVLuminanceSource.h; sourceTree = "<group>"; };
+ 5D07BF5C1771C6E100555DE2 /* ZXPlanarYUVLuminanceSource.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXPlanarYUVLuminanceSource.m; sourceTree = "<group>"; };
+ 5D07BF5D1771C6E100555DE2 /* ZXReader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXReader.h; sourceTree = "<group>"; };
+ 5D07BF5E1771C6E100555DE2 /* ZXResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXResult.h; sourceTree = "<group>"; };
+ 5D07BF5F1771C6E100555DE2 /* ZXResult.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXResult.m; sourceTree = "<group>"; };
+ 5D07BF601771C6E100555DE2 /* ZXResultMetadataType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXResultMetadataType.h; sourceTree = "<group>"; };
+ 5D07BF611771C6E100555DE2 /* ZXResultPoint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXResultPoint.h; sourceTree = "<group>"; };
+ 5D07BF621771C6E100555DE2 /* ZXResultPoint.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXResultPoint.m; sourceTree = "<group>"; };
+ 5D07BF631771C6E100555DE2 /* ZXResultPointCallback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXResultPointCallback.h; sourceTree = "<group>"; };
+ 5D07BF641771C6E100555DE2 /* ZXRGBLuminanceSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXRGBLuminanceSource.h; sourceTree = "<group>"; };
+ 5D07BF651771C6E100555DE2 /* ZXRGBLuminanceSource.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = ZXRGBLuminanceSource.m; sourceTree = "<group>"; };
+ 5D07BF661771C6E100555DE2 /* ZXWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ZXWriter.h; sourceTree = "<group>"; };
+ 5D07C0311771C88400555DE2 /* CISDOBBarcodeViewController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CISDOBBarcodeViewController.h; sourceTree = "<group>"; };
+ 5D07C0321771C88400555DE2 /* CISDOBBarcodeViewController.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CISDOBBarcodeViewController.m; sourceTree = "<group>"; };
+ 5D07C0341771CBF800555DE2 /* AVFoundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AVFoundation.framework; path = System/Library/Frameworks/AVFoundation.framework; sourceTree = SDKROOT; };
+ 5D07C0361771CC0600555DE2 /* CoreMedia.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreMedia.framework; path = System/Library/Frameworks/CoreMedia.framework; sourceTree = SDKROOT; };
+ 5D07C0381771CC1100555DE2 /* CoreVideo.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreVideo.framework; path = System/Library/Frameworks/CoreVideo.framework; sourceTree = SDKROOT; };
+ 5D07C03A1771CC1F00555DE2 /* ImageIO.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = ImageIO.framework; path = System/Library/Frameworks/ImageIO.framework; sourceTree = SDKROOT; };
+ 5D07C03C1771CC4600555DE2 /* QuartzCore.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = QuartzCore.framework; path = System/Library/Frameworks/QuartzCore.framework; sourceTree = SDKROOT; };
/* End PBXFileReference section */
/* Begin PBXFrameworksBuildPhase section */
@@ -151,6 +782,11 @@
isa = PBXFrameworksBuildPhase;
buildActionMask = 2147483647;
files = (
+ 5D07C03D1771CC4700555DE2 /* QuartzCore.framework in Frameworks */,
+ 5D07C03B1771CC1F00555DE2 /* ImageIO.framework in Frameworks */,
+ 5D07C0391771CC1100555DE2 /* CoreVideo.framework in Frameworks */,
+ 5D07C0371771CC0600555DE2 /* CoreMedia.framework in Frameworks */,
+ 5D07C0351771CBF800555DE2 /* AVFoundation.framework in Frameworks */,
36F71E79161C3AE900C87277 /* UIKit.framework in Frameworks */,
36F71E7B161C3AE900C87277 /* Foundation.framework in Frameworks */,
36F71E7D161C3AE900C87277 /* CoreGraphics.framework in Frameworks */,
@@ -215,6 +851,12 @@
36F71E77161C3AE900C87277 /* Frameworks */ = {
isa = PBXGroup;
children = (
+ 5D07BDA71771C6E100555DE2 /* ZXingObjC */,
+ 5D07C03C1771CC4600555DE2 /* QuartzCore.framework */,
+ 5D07C03A1771CC1F00555DE2 /* ImageIO.framework */,
+ 5D07C0381771CC1100555DE2 /* CoreVideo.framework */,
+ 5D07C0361771CC0600555DE2 /* CoreMedia.framework */,
+ 5D07C0341771CBF800555DE2 /* AVFoundation.framework */,
36F71E78161C3AE900C87277 /* UIKit.framework */,
36F71E7A161C3AE900C87277 /* Foundation.framework */,
36C5780716A5954900C21E06 /* Security.framework */,
@@ -245,6 +887,8 @@
36F71E9C161C3AE900C87277 /* CISDOBMasterViewController.m */,
36F97A2C1628123F005D063E /* CISDOBOpenBisModel.h */,
36F97A2D1628123F005D063E /* CISDOBOpenBisModel.m */,
+ 5D07C0311771C88400555DE2 /* CISDOBBarcodeViewController.h */,
+ 5D07C0321771C88400555DE2 /* CISDOBBarcodeViewController.m */,
364D509A161C6ADB00A739B0 /* DevData */,
36F71E81161C3AE900C87277 /* Supporting Files */,
);
@@ -348,6 +992,677 @@
name = "Supporting Files";
sourceTree = "<group>";
};
+ 5D07BDA71771C6E100555DE2 /* ZXingObjC */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BDA81771C6E100555DE2 /* aztec */,
+ 5D07BDBA1771C6E100555DE2 /* client */,
+ 5D07BE0B1771C6E100555DE2 /* common */,
+ 5D07BE361771C6E100555DE2 /* datamatrix */,
+ 5D07BE651771C6E100555DE2 /* maxicode */,
+ 5D07BE6F1771C6E100555DE2 /* multi */,
+ 5D07BE7D1771C6E100555DE2 /* oned */,
+ 5D07BEEF1771C6E100555DE2 /* pdf417 */,
+ 5D07BF131771C6E100555DE2 /* qrcode */,
+ 5D07BF451771C6E100555DE2 /* ZXBarcodeFormat.h */,
+ 5D07BF461771C6E100555DE2 /* ZXBinarizer.h */,
+ 5D07BF471771C6E100555DE2 /* ZXBinarizer.m */,
+ 5D07BF481771C6E100555DE2 /* ZXBinaryBitmap.h */,
+ 5D07BF491771C6E100555DE2 /* ZXBinaryBitmap.m */,
+ 5D07BF4A1771C6E100555DE2 /* ZXDecodeHints.h */,
+ 5D07BF4B1771C6E100555DE2 /* ZXDecodeHints.m */,
+ 5D07BF4C1771C6E100555DE2 /* ZXDimension.h */,
+ 5D07BF4D1771C6E100555DE2 /* ZXDimension.m */,
+ 5D07BF4E1771C6E100555DE2 /* ZXEncodeHints.h */,
+ 5D07BF4F1771C6E100555DE2 /* ZXEncodeHints.m */,
+ 5D07BF501771C6E100555DE2 /* ZXErrors.h */,
+ 5D07BF511771C6E100555DE2 /* ZXErrors.m */,
+ 5D07BF521771C6E100555DE2 /* ZXingObjC.h */,
+ 5D07BF531771C6E100555DE2 /* ZXInvertedLuminanceSource.h */,
+ 5D07BF541771C6E100555DE2 /* ZXInvertedLuminanceSource.m */,
+ 5D07BF551771C6E100555DE2 /* ZXLuminanceSource.h */,
+ 5D07BF561771C6E100555DE2 /* ZXLuminanceSource.m */,
+ 5D07BF571771C6E100555DE2 /* ZXMultiFormatReader.h */,
+ 5D07BF581771C6E100555DE2 /* ZXMultiFormatReader.m */,
+ 5D07BF591771C6E100555DE2 /* ZXMultiFormatWriter.h */,
+ 5D07BF5A1771C6E100555DE2 /* ZXMultiFormatWriter.m */,
+ 5D07BF5B1771C6E100555DE2 /* ZXPlanarYUVLuminanceSource.h */,
+ 5D07BF5C1771C6E100555DE2 /* ZXPlanarYUVLuminanceSource.m */,
+ 5D07BF5D1771C6E100555DE2 /* ZXReader.h */,
+ 5D07BF5E1771C6E100555DE2 /* ZXResult.h */,
+ 5D07BF5F1771C6E100555DE2 /* ZXResult.m */,
+ 5D07BF601771C6E100555DE2 /* ZXResultMetadataType.h */,
+ 5D07BF611771C6E100555DE2 /* ZXResultPoint.h */,
+ 5D07BF621771C6E100555DE2 /* ZXResultPoint.m */,
+ 5D07BF631771C6E100555DE2 /* ZXResultPointCallback.h */,
+ 5D07BF641771C6E100555DE2 /* ZXRGBLuminanceSource.h */,
+ 5D07BF651771C6E100555DE2 /* ZXRGBLuminanceSource.m */,
+ 5D07BF661771C6E100555DE2 /* ZXWriter.h */,
+ );
+ path = ZXingObjC;
+ sourceTree = "<group>";
+ };
+ 5D07BDA81771C6E100555DE2 /* aztec */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BDA91771C6E100555DE2 /* decoder */,
+ 5D07BDAC1771C6E100555DE2 /* detector */,
+ 5D07BDAF1771C6E100555DE2 /* encoder */,
+ 5D07BDB61771C6E100555DE2 /* ZXAztecDetectorResult.h */,
+ 5D07BDB71771C6E100555DE2 /* ZXAztecDetectorResult.m */,
+ 5D07BDB81771C6E100555DE2 /* ZXAztecReader.h */,
+ 5D07BDB91771C6E100555DE2 /* ZXAztecReader.m */,
+ );
+ path = aztec;
+ sourceTree = "<group>";
+ };
+ 5D07BDA91771C6E100555DE2 /* decoder */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BDAA1771C6E100555DE2 /* ZXAztecDecoder.h */,
+ 5D07BDAB1771C6E100555DE2 /* ZXAztecDecoder.m */,
+ );
+ path = decoder;
+ sourceTree = "<group>";
+ };
+ 5D07BDAC1771C6E100555DE2 /* detector */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BDAD1771C6E100555DE2 /* ZXAztecDetector.h */,
+ 5D07BDAE1771C6E100555DE2 /* ZXAztecDetector.m */,
+ );
+ path = detector;
+ sourceTree = "<group>";
+ };
+ 5D07BDAF1771C6E100555DE2 /* encoder */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BDB01771C6E100555DE2 /* ZXAztecCode.h */,
+ 5D07BDB11771C6E100555DE2 /* ZXAztecCode.m */,
+ 5D07BDB21771C6E100555DE2 /* ZXAztecEncoder.h */,
+ 5D07BDB31771C6E100555DE2 /* ZXAztecEncoder.m */,
+ 5D07BDB41771C6E100555DE2 /* ZXAztecWriter.h */,
+ 5D07BDB51771C6E100555DE2 /* ZXAztecWriter.m */,
+ );
+ path = encoder;
+ sourceTree = "<group>";
+ };
+ 5D07BDBA1771C6E100555DE2 /* client */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BDBB1771C6E100555DE2 /* result */,
+ 5D07BE011771C6E100555DE2 /* ZXCapture.h */,
+ 5D07BE021771C6E100555DE2 /* ZXCapture.m */,
+ 5D07BE031771C6E100555DE2 /* ZXCaptureDelegate.h */,
+ 5D07BE041771C6E100555DE2 /* ZXCaptureView.h */,
+ 5D07BE051771C6E100555DE2 /* ZXCaptureView.m */,
+ 5D07BE061771C6E100555DE2 /* ZXCGImageLuminanceSource.h */,
+ 5D07BE071771C6E100555DE2 /* ZXCGImageLuminanceSource.m */,
+ 5D07BE081771C6E100555DE2 /* ZXImage.h */,
+ 5D07BE091771C6E100555DE2 /* ZXImage.m */,
+ 5D07BE0A1771C6E100555DE2 /* ZXView.h */,
+ );
+ path = client;
+ sourceTree = "<group>";
+ };
+ 5D07BDBB1771C6E100555DE2 /* result */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BDBC1771C6E100555DE2 /* ZXAbstractDoCoMoResultParser.h */,
+ 5D07BDBD1771C6E100555DE2 /* ZXAbstractDoCoMoResultParser.m */,
+ 5D07BDBE1771C6E100555DE2 /* ZXAddressBookAUResultParser.h */,
+ 5D07BDBF1771C6E100555DE2 /* ZXAddressBookAUResultParser.m */,
+ 5D07BDC01771C6E100555DE2 /* ZXAddressBookDoCoMoResultParser.h */,
+ 5D07BDC11771C6E100555DE2 /* ZXAddressBookDoCoMoResultParser.m */,
+ 5D07BDC21771C6E100555DE2 /* ZXAddressBookParsedResult.h */,
+ 5D07BDC31771C6E100555DE2 /* ZXAddressBookParsedResult.m */,
+ 5D07BDC41771C6E100555DE2 /* ZXBizcardResultParser.h */,
+ 5D07BDC51771C6E100555DE2 /* ZXBizcardResultParser.m */,
+ 5D07BDC61771C6E100555DE2 /* ZXBookmarkDoCoMoResultParser.h */,
+ 5D07BDC71771C6E100555DE2 /* ZXBookmarkDoCoMoResultParser.m */,
+ 5D07BDC81771C6E100555DE2 /* ZXCalendarParsedResult.h */,
+ 5D07BDC91771C6E100555DE2 /* ZXCalendarParsedResult.m */,
+ 5D07BDCA1771C6E100555DE2 /* ZXEmailAddressParsedResult.h */,
+ 5D07BDCB1771C6E100555DE2 /* ZXEmailAddressParsedResult.m */,
+ 5D07BDCC1771C6E100555DE2 /* ZXEmailAddressResultParser.h */,
+ 5D07BDCD1771C6E100555DE2 /* ZXEmailAddressResultParser.m */,
+ 5D07BDCE1771C6E100555DE2 /* ZXEmailDoCoMoResultParser.h */,
+ 5D07BDCF1771C6E100555DE2 /* ZXEmailDoCoMoResultParser.m */,
+ 5D07BDD01771C6E100555DE2 /* ZXExpandedProductParsedResult.h */,
+ 5D07BDD11771C6E100555DE2 /* ZXExpandedProductParsedResult.m */,
+ 5D07BDD21771C6E100555DE2 /* ZXExpandedProductResultParser.h */,
+ 5D07BDD31771C6E100555DE2 /* ZXExpandedProductResultParser.m */,
+ 5D07BDD41771C6E100555DE2 /* ZXGeoParsedResult.h */,
+ 5D07BDD51771C6E100555DE2 /* ZXGeoParsedResult.m */,
+ 5D07BDD61771C6E100555DE2 /* ZXGeoResultParser.h */,
+ 5D07BDD71771C6E100555DE2 /* ZXGeoResultParser.m */,
+ 5D07BDD81771C6E100555DE2 /* ZXISBNParsedResult.h */,
+ 5D07BDD91771C6E100555DE2 /* ZXISBNParsedResult.m */,
+ 5D07BDDA1771C6E100555DE2 /* ZXISBNResultParser.h */,
+ 5D07BDDB1771C6E100555DE2 /* ZXISBNResultParser.m */,
+ 5D07BDDC1771C6E100555DE2 /* ZXParsedResult.h */,
+ 5D07BDDD1771C6E100555DE2 /* ZXParsedResult.m */,
+ 5D07BDDE1771C6E100555DE2 /* ZXParsedResultType.h */,
+ 5D07BDDF1771C6E100555DE2 /* ZXProductParsedResult.h */,
+ 5D07BDE01771C6E100555DE2 /* ZXProductParsedResult.m */,
+ 5D07BDE11771C6E100555DE2 /* ZXProductResultParser.h */,
+ 5D07BDE21771C6E100555DE2 /* ZXProductResultParser.m */,
+ 5D07BDE31771C6E100555DE2 /* ZXResultParser.h */,
+ 5D07BDE41771C6E100555DE2 /* ZXResultParser.m */,
+ 5D07BDE51771C6E100555DE2 /* ZXSMSMMSResultParser.h */,
+ 5D07BDE61771C6E100555DE2 /* ZXSMSMMSResultParser.m */,
+ 5D07BDE71771C6E100555DE2 /* ZXSMSParsedResult.h */,
+ 5D07BDE81771C6E100555DE2 /* ZXSMSParsedResult.m */,
+ 5D07BDE91771C6E100555DE2 /* ZXSMSTOMMSTOResultParser.h */,
+ 5D07BDEA1771C6E100555DE2 /* ZXSMSTOMMSTOResultParser.m */,
+ 5D07BDEB1771C6E100555DE2 /* ZXSMTPResultParser.h */,
+ 5D07BDEC1771C6E100555DE2 /* ZXSMTPResultParser.m */,
+ 5D07BDED1771C6E100555DE2 /* ZXTelParsedResult.h */,
+ 5D07BDEE1771C6E100555DE2 /* ZXTelParsedResult.m */,
+ 5D07BDEF1771C6E100555DE2 /* ZXTelResultParser.h */,
+ 5D07BDF01771C6E100555DE2 /* ZXTelResultParser.m */,
+ 5D07BDF11771C6E100555DE2 /* ZXTextParsedResult.h */,
+ 5D07BDF21771C6E100555DE2 /* ZXTextParsedResult.m */,
+ 5D07BDF31771C6E100555DE2 /* ZXURIParsedResult.h */,
+ 5D07BDF41771C6E100555DE2 /* ZXURIParsedResult.m */,
+ 5D07BDF51771C6E100555DE2 /* ZXURIResultParser.h */,
+ 5D07BDF61771C6E100555DE2 /* ZXURIResultParser.m */,
+ 5D07BDF71771C6E100555DE2 /* ZXURLTOResultParser.h */,
+ 5D07BDF81771C6E100555DE2 /* ZXURLTOResultParser.m */,
+ 5D07BDF91771C6E100555DE2 /* ZXVCardResultParser.h */,
+ 5D07BDFA1771C6E100555DE2 /* ZXVCardResultParser.m */,
+ 5D07BDFB1771C6E100555DE2 /* ZXVEventResultParser.h */,
+ 5D07BDFC1771C6E100555DE2 /* ZXVEventResultParser.m */,
+ 5D07BDFD1771C6E100555DE2 /* ZXWifiParsedResult.h */,
+ 5D07BDFE1771C6E100555DE2 /* ZXWifiParsedResult.m */,
+ 5D07BDFF1771C6E100555DE2 /* ZXWifiResultParser.h */,
+ 5D07BE001771C6E100555DE2 /* ZXWifiResultParser.m */,
+ );
+ path = result;
+ sourceTree = "<group>";
+ };
+ 5D07BE0B1771C6E100555DE2 /* common */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE0C1771C6E100555DE2 /* detector */,
+ 5D07BE131771C6E100555DE2 /* reedsolomon */,
+ 5D07BE1C1771C6E100555DE2 /* ZXBitArray.h */,
+ 5D07BE1D1771C6E100555DE2 /* ZXBitArray.m */,
+ 5D07BE1E1771C6E100555DE2 /* ZXBitMatrix.h */,
+ 5D07BE1F1771C6E100555DE2 /* ZXBitMatrix.m */,
+ 5D07BE201771C6E100555DE2 /* ZXBitSource.h */,
+ 5D07BE211771C6E100555DE2 /* ZXBitSource.m */,
+ 5D07BE221771C6E100555DE2 /* ZXCharacterSetECI.h */,
+ 5D07BE231771C6E100555DE2 /* ZXCharacterSetECI.m */,
+ 5D07BE241771C6E100555DE2 /* ZXDecoderResult.h */,
+ 5D07BE251771C6E100555DE2 /* ZXDecoderResult.m */,
+ 5D07BE261771C6E100555DE2 /* ZXDefaultGridSampler.h */,
+ 5D07BE271771C6E100555DE2 /* ZXDefaultGridSampler.m */,
+ 5D07BE281771C6E100555DE2 /* ZXDetectorResult.h */,
+ 5D07BE291771C6E100555DE2 /* ZXDetectorResult.m */,
+ 5D07BE2A1771C6E100555DE2 /* ZXECI.h */,
+ 5D07BE2B1771C6E100555DE2 /* ZXECI.m */,
+ 5D07BE2C1771C6E100555DE2 /* ZXGlobalHistogramBinarizer.h */,
+ 5D07BE2D1771C6E100555DE2 /* ZXGlobalHistogramBinarizer.m */,
+ 5D07BE2E1771C6E100555DE2 /* ZXGridSampler.h */,
+ 5D07BE2F1771C6E100555DE2 /* ZXGridSampler.m */,
+ 5D07BE301771C6E100555DE2 /* ZXHybridBinarizer.h */,
+ 5D07BE311771C6E100555DE2 /* ZXHybridBinarizer.m */,
+ 5D07BE321771C6E100555DE2 /* ZXPerspectiveTransform.h */,
+ 5D07BE331771C6E100555DE2 /* ZXPerspectiveTransform.m */,
+ 5D07BE341771C6E100555DE2 /* ZXStringUtils.h */,
+ 5D07BE351771C6E100555DE2 /* ZXStringUtils.m */,
+ );
+ path = common;
+ sourceTree = "<group>";
+ };
+ 5D07BE0C1771C6E100555DE2 /* detector */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE0D1771C6E100555DE2 /* ZXMathUtils.h */,
+ 5D07BE0E1771C6E100555DE2 /* ZXMathUtils.m */,
+ 5D07BE0F1771C6E100555DE2 /* ZXMonochromeRectangleDetector.h */,
+ 5D07BE101771C6E100555DE2 /* ZXMonochromeRectangleDetector.m */,
+ 5D07BE111771C6E100555DE2 /* ZXWhiteRectangleDetector.h */,
+ 5D07BE121771C6E100555DE2 /* ZXWhiteRectangleDetector.m */,
+ );
+ path = detector;
+ sourceTree = "<group>";
+ };
+ 5D07BE131771C6E100555DE2 /* reedsolomon */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE141771C6E100555DE2 /* ZXGenericGF.h */,
+ 5D07BE151771C6E100555DE2 /* ZXGenericGF.m */,
+ 5D07BE161771C6E100555DE2 /* ZXGenericGFPoly.h */,
+ 5D07BE171771C6E100555DE2 /* ZXGenericGFPoly.m */,
+ 5D07BE181771C6E100555DE2 /* ZXReedSolomonDecoder.h */,
+ 5D07BE191771C6E100555DE2 /* ZXReedSolomonDecoder.m */,
+ 5D07BE1A1771C6E100555DE2 /* ZXReedSolomonEncoder.h */,
+ 5D07BE1B1771C6E100555DE2 /* ZXReedSolomonEncoder.m */,
+ );
+ path = reedsolomon;
+ sourceTree = "<group>";
+ };
+ 5D07BE361771C6E100555DE2 /* datamatrix */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE371771C6E100555DE2 /* decoder */,
+ 5D07BE421771C6E100555DE2 /* detector */,
+ 5D07BE451771C6E100555DE2 /* encoder */,
+ 5D07BE611771C6E100555DE2 /* ZXDataMatrixReader.h */,
+ 5D07BE621771C6E100555DE2 /* ZXDataMatrixReader.m */,
+ 5D07BE631771C6E100555DE2 /* ZXDataMatrixWriter.h */,
+ 5D07BE641771C6E100555DE2 /* ZXDataMatrixWriter.m */,
+ );
+ path = datamatrix;
+ sourceTree = "<group>";
+ };
+ 5D07BE371771C6E100555DE2 /* decoder */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE381771C6E100555DE2 /* ZXDataMatrixBitMatrixParser.h */,
+ 5D07BE391771C6E100555DE2 /* ZXDataMatrixBitMatrixParser.m */,
+ 5D07BE3A1771C6E100555DE2 /* ZXDataMatrixDataBlock.h */,
+ 5D07BE3B1771C6E100555DE2 /* ZXDataMatrixDataBlock.m */,
+ 5D07BE3C1771C6E100555DE2 /* ZXDataMatrixDecodedBitStreamParser.h */,
+ 5D07BE3D1771C6E100555DE2 /* ZXDataMatrixDecodedBitStreamParser.m */,
+ 5D07BE3E1771C6E100555DE2 /* ZXDataMatrixDecoder.h */,
+ 5D07BE3F1771C6E100555DE2 /* ZXDataMatrixDecoder.m */,
+ 5D07BE401771C6E100555DE2 /* ZXDataMatrixVersion.h */,
+ 5D07BE411771C6E100555DE2 /* ZXDataMatrixVersion.m */,
+ );
+ path = decoder;
+ sourceTree = "<group>";
+ };
+ 5D07BE421771C6E100555DE2 /* detector */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE431771C6E100555DE2 /* ZXDataMatrixDetector.h */,
+ 5D07BE441771C6E100555DE2 /* ZXDataMatrixDetector.m */,
+ );
+ path = detector;
+ sourceTree = "<group>";
+ };
+ 5D07BE451771C6E100555DE2 /* encoder */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE461771C6E100555DE2 /* ZXASCIIEncoder.h */,
+ 5D07BE471771C6E100555DE2 /* ZXASCIIEncoder.m */,
+ 5D07BE481771C6E100555DE2 /* ZXBase256Encoder.h */,
+ 5D07BE491771C6E100555DE2 /* ZXBase256Encoder.m */,
+ 5D07BE4A1771C6E100555DE2 /* ZXC40Encoder.h */,
+ 5D07BE4B1771C6E100555DE2 /* ZXC40Encoder.m */,
+ 5D07BE4C1771C6E100555DE2 /* ZXDataMatrixEncoder.h */,
+ 5D07BE4D1771C6E100555DE2 /* ZXDataMatrixErrorCorrection.h */,
+ 5D07BE4E1771C6E100555DE2 /* ZXDataMatrixErrorCorrection.m */,
+ 5D07BE4F1771C6E100555DE2 /* ZXDataMatrixSymbolInfo144.h */,
+ 5D07BE501771C6E100555DE2 /* ZXDataMatrixSymbolInfo144.m */,
+ 5D07BE511771C6E100555DE2 /* ZXDefaultPlacement.h */,
+ 5D07BE521771C6E100555DE2 /* ZXDefaultPlacement.m */,
+ 5D07BE531771C6E100555DE2 /* ZXEdifactEncoder.h */,
+ 5D07BE541771C6E100555DE2 /* ZXEdifactEncoder.m */,
+ 5D07BE551771C6E100555DE2 /* ZXEncoderContext.h */,
+ 5D07BE561771C6E100555DE2 /* ZXEncoderContext.m */,
+ 5D07BE571771C6E100555DE2 /* ZXHighLevelEncoder.h */,
+ 5D07BE581771C6E100555DE2 /* ZXHighLevelEncoder.m */,
+ 5D07BE591771C6E100555DE2 /* ZXSymbolInfo.h */,
+ 5D07BE5A1771C6E100555DE2 /* ZXSymbolInfo.m */,
+ 5D07BE5B1771C6E100555DE2 /* ZXSymbolShapeHint.h */,
+ 5D07BE5C1771C6E100555DE2 /* ZXSymbolShapeHint.m */,
+ 5D07BE5D1771C6E100555DE2 /* ZXTextEncoder.h */,
+ 5D07BE5E1771C6E100555DE2 /* ZXTextEncoder.m */,
+ 5D07BE5F1771C6E100555DE2 /* ZXX12Encoder.h */,
+ 5D07BE601771C6E100555DE2 /* ZXX12Encoder.m */,
+ );
+ path = encoder;
+ sourceTree = "<group>";
+ };
+ 5D07BE651771C6E100555DE2 /* maxicode */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE661771C6E100555DE2 /* decoder */,
+ 5D07BE6D1771C6E100555DE2 /* ZXMaxiCodeReader.h */,
+ 5D07BE6E1771C6E100555DE2 /* ZXMaxiCodeReader.m */,
+ );
+ path = maxicode;
+ sourceTree = "<group>";
+ };
+ 5D07BE661771C6E100555DE2 /* decoder */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE671771C6E100555DE2 /* ZXMaxiCodeBitMatrixParser.h */,
+ 5D07BE681771C6E100555DE2 /* ZXMaxiCodeBitMatrixParser.m */,
+ 5D07BE691771C6E100555DE2 /* ZXMaxiCodeDecodedBitStreamParser.h */,
+ 5D07BE6A1771C6E100555DE2 /* ZXMaxiCodeDecodedBitStreamParser.m */,
+ 5D07BE6B1771C6E100555DE2 /* ZXMaxiCodeDecoder.h */,
+ 5D07BE6C1771C6E100555DE2 /* ZXMaxiCodeDecoder.m */,
+ );
+ path = decoder;
+ sourceTree = "<group>";
+ };
+ 5D07BE6F1771C6E100555DE2 /* multi */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE701771C6E100555DE2 /* qrcode */,
+ 5D07BE781771C6E100555DE2 /* ZXByQuadrantReader.h */,
+ 5D07BE791771C6E100555DE2 /* ZXByQuadrantReader.m */,
+ 5D07BE7A1771C6E100555DE2 /* ZXGenericMultipleBarcodeReader.h */,
+ 5D07BE7B1771C6E100555DE2 /* ZXGenericMultipleBarcodeReader.m */,
+ 5D07BE7C1771C6E100555DE2 /* ZXMultipleBarcodeReader.h */,
+ );
+ path = multi;
+ sourceTree = "<group>";
+ };
+ 5D07BE701771C6E100555DE2 /* qrcode */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE711771C6E100555DE2 /* detector */,
+ 5D07BE761771C6E100555DE2 /* ZXQRCodeMultiReader.h */,
+ 5D07BE771771C6E100555DE2 /* ZXQRCodeMultiReader.m */,
+ );
+ path = qrcode;
+ sourceTree = "<group>";
+ };
+ 5D07BE711771C6E100555DE2 /* detector */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE721771C6E100555DE2 /* ZXMultiDetector.h */,
+ 5D07BE731771C6E100555DE2 /* ZXMultiDetector.m */,
+ 5D07BE741771C6E100555DE2 /* ZXMultiFinderPatternFinder.h */,
+ 5D07BE751771C6E100555DE2 /* ZXMultiFinderPatternFinder.m */,
+ );
+ path = detector;
+ sourceTree = "<group>";
+ };
+ 5D07BE7D1771C6E100555DE2 /* oned */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE7E1771C6E100555DE2 /* rss */,
+ 5D07BEBB1771C6E100555DE2 /* ZXCodaBarReader.h */,
+ 5D07BEBC1771C6E100555DE2 /* ZXCodaBarReader.m */,
+ 5D07BEBD1771C6E100555DE2 /* ZXCodaBarWriter.h */,
+ 5D07BEBE1771C6E100555DE2 /* ZXCodaBarWriter.m */,
+ 5D07BEBF1771C6E100555DE2 /* ZXCode128Reader.h */,
+ 5D07BEC01771C6E100555DE2 /* ZXCode128Reader.m */,
+ 5D07BEC11771C6E100555DE2 /* ZXCode128Writer.h */,
+ 5D07BEC21771C6E100555DE2 /* ZXCode128Writer.m */,
+ 5D07BEC31771C6E100555DE2 /* ZXCode39Reader.h */,
+ 5D07BEC41771C6E100555DE2 /* ZXCode39Reader.m */,
+ 5D07BEC51771C6E100555DE2 /* ZXCode39Writer.h */,
+ 5D07BEC61771C6E100555DE2 /* ZXCode39Writer.m */,
+ 5D07BEC71771C6E100555DE2 /* ZXCode93Reader.h */,
+ 5D07BEC81771C6E100555DE2 /* ZXCode93Reader.m */,
+ 5D07BEC91771C6E100555DE2 /* ZXEAN13Reader.h */,
+ 5D07BECA1771C6E100555DE2 /* ZXEAN13Reader.m */,
+ 5D07BECB1771C6E100555DE2 /* ZXEAN13Writer.h */,
+ 5D07BECC1771C6E100555DE2 /* ZXEAN13Writer.m */,
+ 5D07BECD1771C6E100555DE2 /* ZXEAN8Reader.h */,
+ 5D07BECE1771C6E100555DE2 /* ZXEAN8Reader.m */,
+ 5D07BECF1771C6E100555DE2 /* ZXEAN8Writer.h */,
+ 5D07BED01771C6E100555DE2 /* ZXEAN8Writer.m */,
+ 5D07BED11771C6E100555DE2 /* ZXEANManufacturerOrgSupport.h */,
+ 5D07BED21771C6E100555DE2 /* ZXEANManufacturerOrgSupport.m */,
+ 5D07BED31771C6E100555DE2 /* ZXITFReader.h */,
+ 5D07BED41771C6E100555DE2 /* ZXITFReader.m */,
+ 5D07BED51771C6E100555DE2 /* ZXITFWriter.h */,
+ 5D07BED61771C6E100555DE2 /* ZXITFWriter.m */,
+ 5D07BED71771C6E100555DE2 /* ZXMultiFormatOneDReader.h */,
+ 5D07BED81771C6E100555DE2 /* ZXMultiFormatOneDReader.m */,
+ 5D07BED91771C6E100555DE2 /* ZXMultiFormatUPCEANReader.h */,
+ 5D07BEDA1771C6E100555DE2 /* ZXMultiFormatUPCEANReader.m */,
+ 5D07BEDB1771C6E100555DE2 /* ZXOneDimensionalCodeWriter.h */,
+ 5D07BEDC1771C6E100555DE2 /* ZXOneDimensionalCodeWriter.m */,
+ 5D07BEDD1771C6E100555DE2 /* ZXOneDReader.h */,
+ 5D07BEDE1771C6E100555DE2 /* ZXOneDReader.m */,
+ 5D07BEDF1771C6E100555DE2 /* ZXUPCAReader.h */,
+ 5D07BEE01771C6E100555DE2 /* ZXUPCAReader.m */,
+ 5D07BEE11771C6E100555DE2 /* ZXUPCAWriter.h */,
+ 5D07BEE21771C6E100555DE2 /* ZXUPCAWriter.m */,
+ 5D07BEE31771C6E100555DE2 /* ZXUPCEANExtension2Support.h */,
+ 5D07BEE41771C6E100555DE2 /* ZXUPCEANExtension2Support.m */,
+ 5D07BEE51771C6E100555DE2 /* ZXUPCEANExtension5Support.h */,
+ 5D07BEE61771C6E100555DE2 /* ZXUPCEANExtension5Support.m */,
+ 5D07BEE71771C6E100555DE2 /* ZXUPCEANExtensionSupport.h */,
+ 5D07BEE81771C6E100555DE2 /* ZXUPCEANExtensionSupport.m */,
+ 5D07BEE91771C6E100555DE2 /* ZXUPCEANReader.h */,
+ 5D07BEEA1771C6E100555DE2 /* ZXUPCEANReader.m */,
+ 5D07BEEB1771C6E100555DE2 /* ZXUPCEANWriter.h */,
+ 5D07BEEC1771C6E100555DE2 /* ZXUPCEANWriter.m */,
+ 5D07BEED1771C6E100555DE2 /* ZXUPCEReader.h */,
+ 5D07BEEE1771C6E100555DE2 /* ZXUPCEReader.m */,
+ );
+ path = oned;
+ sourceTree = "<group>";
+ };
+ 5D07BE7E1771C6E100555DE2 /* rss */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE7F1771C6E100555DE2 /* expanded */,
+ 5D07BEAF1771C6E100555DE2 /* ZXAbstractRSSReader.h */,
+ 5D07BEB01771C6E100555DE2 /* ZXAbstractRSSReader.m */,
+ 5D07BEB11771C6E100555DE2 /* ZXDataCharacter.h */,
+ 5D07BEB21771C6E100555DE2 /* ZXDataCharacter.m */,
+ 5D07BEB31771C6E100555DE2 /* ZXPair.h */,
+ 5D07BEB41771C6E100555DE2 /* ZXPair.m */,
+ 5D07BEB51771C6E100555DE2 /* ZXRSS14Reader.h */,
+ 5D07BEB61771C6E100555DE2 /* ZXRSS14Reader.m */,
+ 5D07BEB71771C6E100555DE2 /* ZXRSSFinderPattern.h */,
+ 5D07BEB81771C6E100555DE2 /* ZXRSSFinderPattern.m */,
+ 5D07BEB91771C6E100555DE2 /* ZXRSSUtils.h */,
+ 5D07BEBA1771C6E100555DE2 /* ZXRSSUtils.m */,
+ );
+ path = rss;
+ sourceTree = "<group>";
+ };
+ 5D07BE7F1771C6E100555DE2 /* expanded */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE801771C6E100555DE2 /* decoders */,
+ 5D07BEA71771C6E100555DE2 /* ZXBitArrayBuilder.h */,
+ 5D07BEA81771C6E100555DE2 /* ZXBitArrayBuilder.m */,
+ 5D07BEA91771C6E100555DE2 /* ZXExpandedPair.h */,
+ 5D07BEAA1771C6E100555DE2 /* ZXExpandedPair.m */,
+ 5D07BEAB1771C6E100555DE2 /* ZXExpandedRow.h */,
+ 5D07BEAC1771C6E100555DE2 /* ZXExpandedRow.m */,
+ 5D07BEAD1771C6E100555DE2 /* ZXRSSExpandedReader.h */,
+ 5D07BEAE1771C6E100555DE2 /* ZXRSSExpandedReader.m */,
+ );
+ path = expanded;
+ sourceTree = "<group>";
+ };
+ 5D07BE801771C6E100555DE2 /* decoders */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BE811771C6E100555DE2 /* ZXAbstractExpandedDecoder.h */,
+ 5D07BE821771C6E100555DE2 /* ZXAbstractExpandedDecoder.m */,
+ 5D07BE831771C6E100555DE2 /* ZXAI013103decoder.h */,
+ 5D07BE841771C6E100555DE2 /* ZXAI013103decoder.m */,
+ 5D07BE851771C6E100555DE2 /* ZXAI01320xDecoder.h */,
+ 5D07BE861771C6E100555DE2 /* ZXAI01320xDecoder.m */,
+ 5D07BE871771C6E100555DE2 /* ZXAI01392xDecoder.h */,
+ 5D07BE881771C6E100555DE2 /* ZXAI01392xDecoder.m */,
+ 5D07BE891771C6E100555DE2 /* ZXAI01393xDecoder.h */,
+ 5D07BE8A1771C6E100555DE2 /* ZXAI01393xDecoder.m */,
+ 5D07BE8B1771C6E100555DE2 /* ZXAI013x0x1xDecoder.h */,
+ 5D07BE8C1771C6E100555DE2 /* ZXAI013x0x1xDecoder.m */,
+ 5D07BE8D1771C6E100555DE2 /* ZXAI013x0xDecoder.h */,
+ 5D07BE8E1771C6E100555DE2 /* ZXAI013x0xDecoder.m */,
+ 5D07BE8F1771C6E100555DE2 /* ZXAI01AndOtherAIs.h */,
+ 5D07BE901771C6E100555DE2 /* ZXAI01AndOtherAIs.m */,
+ 5D07BE911771C6E100555DE2 /* ZXAI01decoder.h */,
+ 5D07BE921771C6E100555DE2 /* ZXAI01decoder.m */,
+ 5D07BE931771C6E100555DE2 /* ZXAI01weightDecoder.h */,
+ 5D07BE941771C6E100555DE2 /* ZXAI01weightDecoder.m */,
+ 5D07BE951771C6E100555DE2 /* ZXAnyAIDecoder.h */,
+ 5D07BE961771C6E100555DE2 /* ZXAnyAIDecoder.m */,
+ 5D07BE971771C6E100555DE2 /* ZXBlockParsedResult.h */,
+ 5D07BE981771C6E100555DE2 /* ZXBlockParsedResult.m */,
+ 5D07BE991771C6E100555DE2 /* ZXCurrentParsingState.h */,
+ 5D07BE9A1771C6E100555DE2 /* ZXCurrentParsingState.m */,
+ 5D07BE9B1771C6E100555DE2 /* ZXDecodedChar.h */,
+ 5D07BE9C1771C6E100555DE2 /* ZXDecodedChar.m */,
+ 5D07BE9D1771C6E100555DE2 /* ZXDecodedInformation.h */,
+ 5D07BE9E1771C6E100555DE2 /* ZXDecodedInformation.m */,
+ 5D07BE9F1771C6E100555DE2 /* ZXDecodedNumeric.h */,
+ 5D07BEA01771C6E100555DE2 /* ZXDecodedNumeric.m */,
+ 5D07BEA11771C6E100555DE2 /* ZXDecodedObject.h */,
+ 5D07BEA21771C6E100555DE2 /* ZXDecodedObject.m */,
+ 5D07BEA31771C6E100555DE2 /* ZXFieldParser.h */,
+ 5D07BEA41771C6E100555DE2 /* ZXFieldParser.m */,
+ 5D07BEA51771C6E100555DE2 /* ZXGeneralAppIdDecoder.h */,
+ 5D07BEA61771C6E100555DE2 /* ZXGeneralAppIdDecoder.m */,
+ );
+ path = decoders;
+ sourceTree = "<group>";
+ };
+ 5D07BEEF1771C6E100555DE2 /* pdf417 */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BEF01771C6E100555DE2 /* decoder */,
+ 5D07BEFE1771C6E100555DE2 /* detector */,
+ 5D07BF011771C6E100555DE2 /* encoder */,
+ 5D07BF111771C6E100555DE2 /* ZXPDF417Reader.h */,
+ 5D07BF121771C6E100555DE2 /* ZXPDF417Reader.m */,
+ );
+ path = pdf417;
+ sourceTree = "<group>";
+ };
+ 5D07BEF01771C6E100555DE2 /* decoder */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BEF11771C6E100555DE2 /* ec */,
+ 5D07BEF81771C6E100555DE2 /* ZXPDF417BitMatrixParser.h */,
+ 5D07BEF91771C6E100555DE2 /* ZXPDF417BitMatrixParser.m */,
+ 5D07BEFA1771C6E100555DE2 /* ZXPDF417DecodedBitStreamParser.h */,
+ 5D07BEFB1771C6E100555DE2 /* ZXPDF417DecodedBitStreamParser.m */,
+ 5D07BEFC1771C6E100555DE2 /* ZXPDF417Decoder.h */,
+ 5D07BEFD1771C6E100555DE2 /* ZXPDF417Decoder.m */,
+ );
+ path = decoder;
+ sourceTree = "<group>";
+ };
+ 5D07BEF11771C6E100555DE2 /* ec */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BEF21771C6E100555DE2 /* ZXModulusGF.h */,
+ 5D07BEF31771C6E100555DE2 /* ZXModulusGF.m */,
+ 5D07BEF41771C6E100555DE2 /* ZXModulusPoly.h */,
+ 5D07BEF51771C6E100555DE2 /* ZXModulusPoly.m */,
+ 5D07BEF61771C6E100555DE2 /* ZXPDF417ECErrorCorrection.h */,
+ 5D07BEF71771C6E100555DE2 /* ZXPDF417ECErrorCorrection.m */,
+ );
+ path = ec;
+ sourceTree = "<group>";
+ };
+ 5D07BEFE1771C6E100555DE2 /* detector */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BEFF1771C6E100555DE2 /* ZXPDF417Detector.h */,
+ 5D07BF001771C6E100555DE2 /* ZXPDF417Detector.m */,
+ );
+ path = detector;
+ sourceTree = "<group>";
+ };
+ 5D07BF011771C6E100555DE2 /* encoder */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BF021771C6E100555DE2 /* ZXBarcodeMatrix.h */,
+ 5D07BF031771C6E100555DE2 /* ZXBarcodeMatrix.m */,
+ 5D07BF041771C6E100555DE2 /* ZXBarcodeRow.h */,
+ 5D07BF051771C6E100555DE2 /* ZXBarcodeRow.m */,
+ 5D07BF061771C6E100555DE2 /* ZXCompaction.h */,
+ 5D07BF071771C6E100555DE2 /* ZXDimensions.h */,
+ 5D07BF081771C6E100555DE2 /* ZXDimensions.m */,
+ 5D07BF091771C6E100555DE2 /* ZXPDF417.h */,
+ 5D07BF0A1771C6E100555DE2 /* ZXPDF417.m */,
+ 5D07BF0B1771C6E100555DE2 /* ZXPDF417ErrorCorrection.h */,
+ 5D07BF0C1771C6E100555DE2 /* ZXPDF417ErrorCorrection.m */,
+ 5D07BF0D1771C6E100555DE2 /* ZXPDF417HighLevelEncoder.h */,
+ 5D07BF0E1771C6E100555DE2 /* ZXPDF417HighLevelEncoder.m */,
+ 5D07BF0F1771C6E100555DE2 /* ZXPDF417Writer.h */,
+ 5D07BF101771C6E100555DE2 /* ZXPDF417Writer.m */,
+ );
+ path = encoder;
+ sourceTree = "<group>";
+ };
+ 5D07BF131771C6E100555DE2 /* qrcode */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BF141771C6E100555DE2 /* decoder */,
+ 5D07BF271771C6E100555DE2 /* detector */,
+ 5D07BF341771C6E100555DE2 /* encoder */,
+ 5D07BF411771C6E100555DE2 /* ZXQRCodeReader.h */,
+ 5D07BF421771C6E100555DE2 /* ZXQRCodeReader.m */,
+ 5D07BF431771C6E100555DE2 /* ZXQRCodeWriter.h */,
+ 5D07BF441771C6E100555DE2 /* ZXQRCodeWriter.m */,
+ );
+ path = qrcode;
+ sourceTree = "<group>";
+ };
+ 5D07BF141771C6E100555DE2 /* decoder */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BF151771C6E100555DE2 /* ZXDataMask.h */,
+ 5D07BF161771C6E100555DE2 /* ZXDataMask.m */,
+ 5D07BF171771C6E100555DE2 /* ZXErrorCorrectionLevel.h */,
+ 5D07BF181771C6E100555DE2 /* ZXErrorCorrectionLevel.m */,
+ 5D07BF191771C6E100555DE2 /* ZXFormatInformation.h */,
+ 5D07BF1A1771C6E100555DE2 /* ZXFormatInformation.m */,
+ 5D07BF1B1771C6E100555DE2 /* ZXMode.h */,
+ 5D07BF1C1771C6E100555DE2 /* ZXMode.m */,
+ 5D07BF1D1771C6E100555DE2 /* ZXQRCodeBitMatrixParser.h */,
+ 5D07BF1E1771C6E100555DE2 /* ZXQRCodeBitMatrixParser.m */,
+ 5D07BF1F1771C6E100555DE2 /* ZXQRCodeDataBlock.h */,
+ 5D07BF201771C6E100555DE2 /* ZXQRCodeDataBlock.m */,
+ 5D07BF211771C6E100555DE2 /* ZXQRCodeDecodedBitStreamParser.h */,
+ 5D07BF221771C6E100555DE2 /* ZXQRCodeDecodedBitStreamParser.m */,
+ 5D07BF231771C6E100555DE2 /* ZXQRCodeDecoder.h */,
+ 5D07BF241771C6E100555DE2 /* ZXQRCodeDecoder.m */,
+ 5D07BF251771C6E100555DE2 /* ZXQRCodeVersion.h */,
+ 5D07BF261771C6E100555DE2 /* ZXQRCodeVersion.m */,
+ );
+ path = decoder;
+ sourceTree = "<group>";
+ };
+ 5D07BF271771C6E100555DE2 /* detector */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BF281771C6E100555DE2 /* ZXAlignmentPattern.h */,
+ 5D07BF291771C6E100555DE2 /* ZXAlignmentPattern.m */,
+ 5D07BF2A1771C6E100555DE2 /* ZXAlignmentPatternFinder.h */,
+ 5D07BF2B1771C6E100555DE2 /* ZXAlignmentPatternFinder.m */,
+ 5D07BF2C1771C6E100555DE2 /* ZXFinderPatternFinder.h */,
+ 5D07BF2D1771C6E100555DE2 /* ZXFinderPatternFinder.m */,
+ 5D07BF2E1771C6E100555DE2 /* ZXFinderPatternInfo.h */,
+ 5D07BF2F1771C6E100555DE2 /* ZXFinderPatternInfo.m */,
+ 5D07BF301771C6E100555DE2 /* ZXQRCodeDetector.h */,
+ 5D07BF311771C6E100555DE2 /* ZXQRCodeDetector.m */,
+ 5D07BF321771C6E100555DE2 /* ZXQRCodeFinderPattern.h */,
+ 5D07BF331771C6E100555DE2 /* ZXQRCodeFinderPattern.m */,
+ );
+ path = detector;
+ sourceTree = "<group>";
+ };
+ 5D07BF341771C6E100555DE2 /* encoder */ = {
+ isa = PBXGroup;
+ children = (
+ 5D07BF351771C6E100555DE2 /* ZXBlockPair.h */,
+ 5D07BF361771C6E100555DE2 /* ZXBlockPair.m */,
+ 5D07BF371771C6E100555DE2 /* ZXByteMatrix.h */,
+ 5D07BF381771C6E100555DE2 /* ZXByteMatrix.m */,
+ 5D07BF391771C6E100555DE2 /* ZXEncoder.h */,
+ 5D07BF3A1771C6E100555DE2 /* ZXEncoder.m */,
+ 5D07BF3B1771C6E100555DE2 /* ZXMaskUtil.h */,
+ 5D07BF3C1771C6E100555DE2 /* ZXMaskUtil.m */,
+ 5D07BF3D1771C6E100555DE2 /* ZXMatrixUtil.h */,
+ 5D07BF3E1771C6E100555DE2 /* ZXMatrixUtil.m */,
+ 5D07BF3F1771C6E100555DE2 /* ZXQRCode.h */,
+ 5D07BF401771C6E100555DE2 /* ZXQRCode.m */,
+ );
+ path = encoder;
+ sourceTree = "<group>";
+ };
/* End PBXGroup section */
/* Begin PBXNativeTarget section */
@@ -498,6 +1813,209 @@
36BDE60016555869007EC62A /* CISDOBLoginViewController.m in Sources */,
3656C9B4165A7A7E00E9B0FA /* CISDOBImageViewPopoverController.m in Sources */,
3611F7B1169D5D8E0072B61A /* CISDOBAuthenticationChallengeConfirmationDialog.m in Sources */,
+ 5D07BF671771C6E100555DE2 /* ZXAztecDecoder.m in Sources */,
+ 5D07BF681771C6E100555DE2 /* ZXAztecDetector.m in Sources */,
+ 5D07BF691771C6E100555DE2 /* ZXAztecCode.m in Sources */,
+ 5D07BF6A1771C6E100555DE2 /* ZXAztecEncoder.m in Sources */,
+ 5D07BF6B1771C6E100555DE2 /* ZXAztecWriter.m in Sources */,
+ 5D07BF6C1771C6E100555DE2 /* ZXAztecDetectorResult.m in Sources */,
+ 5D07BF6D1771C6E100555DE2 /* ZXAztecReader.m in Sources */,
+ 5D07BF6E1771C6E100555DE2 /* ZXAbstractDoCoMoResultParser.m in Sources */,
+ 5D07BF6F1771C6E100555DE2 /* ZXAddressBookAUResultParser.m in Sources */,
+ 5D07BF701771C6E100555DE2 /* ZXAddressBookDoCoMoResultParser.m in Sources */,
+ 5D07BF711771C6E100555DE2 /* ZXAddressBookParsedResult.m in Sources */,
+ 5D07BF721771C6E100555DE2 /* ZXBizcardResultParser.m in Sources */,
+ 5D07BF731771C6E100555DE2 /* ZXBookmarkDoCoMoResultParser.m in Sources */,
+ 5D07BF741771C6E100555DE2 /* ZXCalendarParsedResult.m in Sources */,
+ 5D07BF751771C6E100555DE2 /* ZXEmailAddressParsedResult.m in Sources */,
+ 5D07BF761771C6E100555DE2 /* ZXEmailAddressResultParser.m in Sources */,
+ 5D07BF771771C6E100555DE2 /* ZXEmailDoCoMoResultParser.m in Sources */,
+ 5D07BF781771C6E100555DE2 /* ZXExpandedProductParsedResult.m in Sources */,
+ 5D07BF791771C6E100555DE2 /* ZXExpandedProductResultParser.m in Sources */,
+ 5D07BF7A1771C6E100555DE2 /* ZXGeoParsedResult.m in Sources */,
+ 5D07BF7B1771C6E100555DE2 /* ZXGeoResultParser.m in Sources */,
+ 5D07BF7C1771C6E100555DE2 /* ZXISBNParsedResult.m in Sources */,
+ 5D07BF7D1771C6E100555DE2 /* ZXISBNResultParser.m in Sources */,
+ 5D07BF7E1771C6E100555DE2 /* ZXParsedResult.m in Sources */,
+ 5D07BF7F1771C6E100555DE2 /* ZXProductParsedResult.m in Sources */,
+ 5D07BF801771C6E100555DE2 /* ZXProductResultParser.m in Sources */,
+ 5D07BF811771C6E100555DE2 /* ZXResultParser.m in Sources */,
+ 5D07BF821771C6E100555DE2 /* ZXSMSMMSResultParser.m in Sources */,
+ 5D07BF831771C6E100555DE2 /* ZXSMSParsedResult.m in Sources */,
+ 5D07BF841771C6E100555DE2 /* ZXSMSTOMMSTOResultParser.m in Sources */,
+ 5D07BF851771C6E100555DE2 /* ZXSMTPResultParser.m in Sources */,
+ 5D07BF861771C6E100555DE2 /* ZXTelParsedResult.m in Sources */,
+ 5D07BF871771C6E100555DE2 /* ZXTelResultParser.m in Sources */,
+ 5D07BF881771C6E100555DE2 /* ZXTextParsedResult.m in Sources */,
+ 5D07BF891771C6E100555DE2 /* ZXURIParsedResult.m in Sources */,
+ 5D07BF8A1771C6E100555DE2 /* ZXURIResultParser.m in Sources */,
+ 5D07BF8B1771C6E100555DE2 /* ZXURLTOResultParser.m in Sources */,
+ 5D07BF8C1771C6E100555DE2 /* ZXVCardResultParser.m in Sources */,
+ 5D07BF8D1771C6E100555DE2 /* ZXVEventResultParser.m in Sources */,
+ 5D07BF8E1771C6E100555DE2 /* ZXWifiParsedResult.m in Sources */,
+ 5D07BF8F1771C6E100555DE2 /* ZXWifiResultParser.m in Sources */,
+ 5D07BF901771C6E100555DE2 /* ZXCapture.m in Sources */,
+ 5D07BF911771C6E100555DE2 /* ZXCaptureView.m in Sources */,
+ 5D07BF921771C6E100555DE2 /* ZXCGImageLuminanceSource.m in Sources */,
+ 5D07BF931771C6E100555DE2 /* ZXImage.m in Sources */,
+ 5D07BF941771C6E100555DE2 /* ZXMathUtils.m in Sources */,
+ 5D07BF951771C6E100555DE2 /* ZXMonochromeRectangleDetector.m in Sources */,
+ 5D07BF961771C6E100555DE2 /* ZXWhiteRectangleDetector.m in Sources */,
+ 5D07BF971771C6E100555DE2 /* ZXGenericGF.m in Sources */,
+ 5D07BF981771C6E100555DE2 /* ZXGenericGFPoly.m in Sources */,
+ 5D07BF991771C6E100555DE2 /* ZXReedSolomonDecoder.m in Sources */,
+ 5D07BF9A1771C6E100555DE2 /* ZXReedSolomonEncoder.m in Sources */,
+ 5D07BF9B1771C6E100555DE2 /* ZXBitArray.m in Sources */,
+ 5D07BF9C1771C6E100555DE2 /* ZXBitMatrix.m in Sources */,
+ 5D07BF9D1771C6E100555DE2 /* ZXBitSource.m in Sources */,
+ 5D07BF9E1771C6E100555DE2 /* ZXCharacterSetECI.m in Sources */,
+ 5D07BF9F1771C6E100555DE2 /* ZXDecoderResult.m in Sources */,
+ 5D07BFA01771C6E100555DE2 /* ZXDefaultGridSampler.m in Sources */,
+ 5D07BFA11771C6E100555DE2 /* ZXDetectorResult.m in Sources */,
+ 5D07BFA21771C6E100555DE2 /* ZXECI.m in Sources */,
+ 5D07BFA31771C6E100555DE2 /* ZXGlobalHistogramBinarizer.m in Sources */,
+ 5D07BFA41771C6E100555DE2 /* ZXGridSampler.m in Sources */,
+ 5D07BFA51771C6E100555DE2 /* ZXHybridBinarizer.m in Sources */,
+ 5D07BFA61771C6E100555DE2 /* ZXPerspectiveTransform.m in Sources */,
+ 5D07BFA71771C6E100555DE2 /* ZXStringUtils.m in Sources */,
+ 5D07BFA81771C6E100555DE2 /* ZXDataMatrixBitMatrixParser.m in Sources */,
+ 5D07BFA91771C6E100555DE2 /* ZXDataMatrixDataBlock.m in Sources */,
+ 5D07BFAA1771C6E100555DE2 /* ZXDataMatrixDecodedBitStreamParser.m in Sources */,
+ 5D07BFAB1771C6E100555DE2 /* ZXDataMatrixDecoder.m in Sources */,
+ 5D07BFAC1771C6E100555DE2 /* ZXDataMatrixVersion.m in Sources */,
+ 5D07BFAD1771C6E100555DE2 /* ZXDataMatrixDetector.m in Sources */,
+ 5D07BFAE1771C6E100555DE2 /* ZXASCIIEncoder.m in Sources */,
+ 5D07BFAF1771C6E100555DE2 /* ZXBase256Encoder.m in Sources */,
+ 5D07BFB01771C6E100555DE2 /* ZXC40Encoder.m in Sources */,
+ 5D07BFB11771C6E100555DE2 /* ZXDataMatrixErrorCorrection.m in Sources */,
+ 5D07BFB21771C6E100555DE2 /* ZXDataMatrixSymbolInfo144.m in Sources */,
+ 5D07BFB31771C6E100555DE2 /* ZXDefaultPlacement.m in Sources */,
+ 5D07BFB41771C6E100555DE2 /* ZXEdifactEncoder.m in Sources */,
+ 5D07BFB51771C6E100555DE2 /* ZXEncoderContext.m in Sources */,
+ 5D07BFB61771C6E100555DE2 /* ZXHighLevelEncoder.m in Sources */,
+ 5D07BFB71771C6E100555DE2 /* ZXSymbolInfo.m in Sources */,
+ 5D07BFB81771C6E100555DE2 /* ZXSymbolShapeHint.m in Sources */,
+ 5D07BFB91771C6E100555DE2 /* ZXTextEncoder.m in Sources */,
+ 5D07BFBA1771C6E100555DE2 /* ZXX12Encoder.m in Sources */,
+ 5D07BFBB1771C6E100555DE2 /* ZXDataMatrixReader.m in Sources */,
+ 5D07BFBC1771C6E100555DE2 /* ZXDataMatrixWriter.m in Sources */,
+ 5D07BFBD1771C6E100555DE2 /* ZXMaxiCodeBitMatrixParser.m in Sources */,
+ 5D07BFBE1771C6E100555DE2 /* ZXMaxiCodeDecodedBitStreamParser.m in Sources */,
+ 5D07BFBF1771C6E100555DE2 /* ZXMaxiCodeDecoder.m in Sources */,
+ 5D07BFC01771C6E100555DE2 /* ZXMaxiCodeReader.m in Sources */,
+ 5D07BFC11771C6E100555DE2 /* ZXMultiDetector.m in Sources */,
+ 5D07BFC21771C6E100555DE2 /* ZXMultiFinderPatternFinder.m in Sources */,
+ 5D07BFC31771C6E100555DE2 /* ZXQRCodeMultiReader.m in Sources */,
+ 5D07BFC41771C6E100555DE2 /* ZXByQuadrantReader.m in Sources */,
+ 5D07BFC51771C6E100555DE2 /* ZXGenericMultipleBarcodeReader.m in Sources */,
+ 5D07BFC61771C6E100555DE2 /* ZXAbstractExpandedDecoder.m in Sources */,
+ 5D07BFC71771C6E100555DE2 /* ZXAI013103decoder.m in Sources */,
+ 5D07BFC81771C6E100555DE2 /* ZXAI01320xDecoder.m in Sources */,
+ 5D07BFC91771C6E100555DE2 /* ZXAI01392xDecoder.m in Sources */,
+ 5D07BFCA1771C6E100555DE2 /* ZXAI01393xDecoder.m in Sources */,
+ 5D07BFCB1771C6E100555DE2 /* ZXAI013x0x1xDecoder.m in Sources */,
+ 5D07BFCC1771C6E100555DE2 /* ZXAI013x0xDecoder.m in Sources */,
+ 5D07BFCD1771C6E100555DE2 /* ZXAI01AndOtherAIs.m in Sources */,
+ 5D07BFCE1771C6E100555DE2 /* ZXAI01decoder.m in Sources */,
+ 5D07BFCF1771C6E100555DE2 /* ZXAI01weightDecoder.m in Sources */,
+ 5D07BFD01771C6E100555DE2 /* ZXAnyAIDecoder.m in Sources */,
+ 5D07BFD11771C6E100555DE2 /* ZXBlockParsedResult.m in Sources */,
+ 5D07BFD21771C6E100555DE2 /* ZXCurrentParsingState.m in Sources */,
+ 5D07BFD31771C6E100555DE2 /* ZXDecodedChar.m in Sources */,
+ 5D07BFD41771C6E100555DE2 /* ZXDecodedInformation.m in Sources */,
+ 5D07BFD51771C6E100555DE2 /* ZXDecodedNumeric.m in Sources */,
+ 5D07BFD61771C6E100555DE2 /* ZXDecodedObject.m in Sources */,
+ 5D07BFD71771C6E100555DE2 /* ZXFieldParser.m in Sources */,
+ 5D07BFD81771C6E100555DE2 /* ZXGeneralAppIdDecoder.m in Sources */,
+ 5D07BFD91771C6E100555DE2 /* ZXBitArrayBuilder.m in Sources */,
+ 5D07BFDA1771C6E100555DE2 /* ZXExpandedPair.m in Sources */,
+ 5D07BFDB1771C6E100555DE2 /* ZXExpandedRow.m in Sources */,
+ 5D07BFDC1771C6E100555DE2 /* ZXRSSExpandedReader.m in Sources */,
+ 5D07BFDD1771C6E100555DE2 /* ZXAbstractRSSReader.m in Sources */,
+ 5D07BFDE1771C6E100555DE2 /* ZXDataCharacter.m in Sources */,
+ 5D07BFDF1771C6E100555DE2 /* ZXPair.m in Sources */,
+ 5D07BFE01771C6E100555DE2 /* ZXRSS14Reader.m in Sources */,
+ 5D07BFE11771C6E100555DE2 /* ZXRSSFinderPattern.m in Sources */,
+ 5D07BFE21771C6E100555DE2 /* ZXRSSUtils.m in Sources */,
+ 5D07BFE31771C6E100555DE2 /* ZXCodaBarReader.m in Sources */,
+ 5D07BFE41771C6E100555DE2 /* ZXCodaBarWriter.m in Sources */,
+ 5D07BFE51771C6E100555DE2 /* ZXCode128Reader.m in Sources */,
+ 5D07BFE61771C6E100555DE2 /* ZXCode128Writer.m in Sources */,
+ 5D07BFE71771C6E100555DE2 /* ZXCode39Reader.m in Sources */,
+ 5D07BFE81771C6E100555DE2 /* ZXCode39Writer.m in Sources */,
+ 5D07BFE91771C6E100555DE2 /* ZXCode93Reader.m in Sources */,
+ 5D07BFEA1771C6E100555DE2 /* ZXEAN13Reader.m in Sources */,
+ 5D07BFEB1771C6E100555DE2 /* ZXEAN13Writer.m in Sources */,
+ 5D07BFEC1771C6E100555DE2 /* ZXEAN8Reader.m in Sources */,
+ 5D07BFED1771C6E100555DE2 /* ZXEAN8Writer.m in Sources */,
+ 5D07BFEE1771C6E100555DE2 /* ZXEANManufacturerOrgSupport.m in Sources */,
+ 5D07BFEF1771C6E100555DE2 /* ZXITFReader.m in Sources */,
+ 5D07BFF01771C6E100555DE2 /* ZXITFWriter.m in Sources */,
+ 5D07BFF11771C6E100555DE2 /* ZXMultiFormatOneDReader.m in Sources */,
+ 5D07BFF21771C6E100555DE2 /* ZXMultiFormatUPCEANReader.m in Sources */,
+ 5D07BFF31771C6E100555DE2 /* ZXOneDimensionalCodeWriter.m in Sources */,
+ 5D07BFF41771C6E100555DE2 /* ZXOneDReader.m in Sources */,
+ 5D07BFF51771C6E100555DE2 /* ZXUPCAReader.m in Sources */,
+ 5D07BFF61771C6E100555DE2 /* ZXUPCAWriter.m in Sources */,
+ 5D07BFF71771C6E100555DE2 /* ZXUPCEANExtension2Support.m in Sources */,
+ 5D07BFF81771C6E100555DE2 /* ZXUPCEANExtension5Support.m in Sources */,
+ 5D07BFF91771C6E100555DE2 /* ZXUPCEANExtensionSupport.m in Sources */,
+ 5D07BFFA1771C6E100555DE2 /* ZXUPCEANReader.m in Sources */,
+ 5D07BFFB1771C6E100555DE2 /* ZXUPCEANWriter.m in Sources */,
+ 5D07BFFC1771C6E100555DE2 /* ZXUPCEReader.m in Sources */,
+ 5D07BFFD1771C6E100555DE2 /* ZXModulusGF.m in Sources */,
+ 5D07BFFE1771C6E100555DE2 /* ZXModulusPoly.m in Sources */,
+ 5D07BFFF1771C6E100555DE2 /* ZXPDF417ECErrorCorrection.m in Sources */,
+ 5D07C0001771C6E100555DE2 /* ZXPDF417BitMatrixParser.m in Sources */,
+ 5D07C0011771C6E100555DE2 /* ZXPDF417DecodedBitStreamParser.m in Sources */,
+ 5D07C0021771C6E100555DE2 /* ZXPDF417Decoder.m in Sources */,
+ 5D07C0031771C6E100555DE2 /* ZXPDF417Detector.m in Sources */,
+ 5D07C0041771C6E100555DE2 /* ZXBarcodeMatrix.m in Sources */,
+ 5D07C0051771C6E100555DE2 /* ZXBarcodeRow.m in Sources */,
+ 5D07C0061771C6E100555DE2 /* ZXDimensions.m in Sources */,
+ 5D07C0071771C6E100555DE2 /* ZXPDF417.m in Sources */,
+ 5D07C0081771C6E100555DE2 /* ZXPDF417ErrorCorrection.m in Sources */,
+ 5D07C0091771C6E100555DE2 /* ZXPDF417HighLevelEncoder.m in Sources */,
+ 5D07C00A1771C6E100555DE2 /* ZXPDF417Writer.m in Sources */,
+ 5D07C00B1771C6E100555DE2 /* ZXPDF417Reader.m in Sources */,
+ 5D07C00C1771C6E100555DE2 /* ZXDataMask.m in Sources */,
+ 5D07C00D1771C6E100555DE2 /* ZXErrorCorrectionLevel.m in Sources */,
+ 5D07C00E1771C6E100555DE2 /* ZXFormatInformation.m in Sources */,
+ 5D07C00F1771C6E100555DE2 /* ZXMode.m in Sources */,
+ 5D07C0101771C6E100555DE2 /* ZXQRCodeBitMatrixParser.m in Sources */,
+ 5D07C0111771C6E100555DE2 /* ZXQRCodeDataBlock.m in Sources */,
+ 5D07C0121771C6E100555DE2 /* ZXQRCodeDecodedBitStreamParser.m in Sources */,
+ 5D07C0131771C6E100555DE2 /* ZXQRCodeDecoder.m in Sources */,
+ 5D07C0141771C6E100555DE2 /* ZXQRCodeVersion.m in Sources */,
+ 5D07C0151771C6E100555DE2 /* ZXAlignmentPattern.m in Sources */,
+ 5D07C0161771C6E100555DE2 /* ZXAlignmentPatternFinder.m in Sources */,
+ 5D07C0171771C6E100555DE2 /* ZXFinderPatternFinder.m in Sources */,
+ 5D07C0181771C6E100555DE2 /* ZXFinderPatternInfo.m in Sources */,
+ 5D07C0191771C6E100555DE2 /* ZXQRCodeDetector.m in Sources */,
+ 5D07C01A1771C6E100555DE2 /* ZXQRCodeFinderPattern.m in Sources */,
+ 5D07C01B1771C6E100555DE2 /* ZXBlockPair.m in Sources */,
+ 5D07C01C1771C6E100555DE2 /* ZXByteMatrix.m in Sources */,
+ 5D07C01D1771C6E100555DE2 /* ZXEncoder.m in Sources */,
+ 5D07C01E1771C6E100555DE2 /* ZXMaskUtil.m in Sources */,
+ 5D07C01F1771C6E100555DE2 /* ZXMatrixUtil.m in Sources */,
+ 5D07C0201771C6E100555DE2 /* ZXQRCode.m in Sources */,
+ 5D07C0211771C6E100555DE2 /* ZXQRCodeReader.m in Sources */,
+ 5D07C0221771C6E100555DE2 /* ZXQRCodeWriter.m in Sources */,
+ 5D07C0231771C6E100555DE2 /* ZXBinarizer.m in Sources */,
+ 5D07C0241771C6E100555DE2 /* ZXBinaryBitmap.m in Sources */,
+ 5D07C0251771C6E100555DE2 /* ZXDecodeHints.m in Sources */,
+ 5D07C0261771C6E100555DE2 /* ZXDimension.m in Sources */,
+ 5D07C0271771C6E100555DE2 /* ZXEncodeHints.m in Sources */,
+ 5D07C0281771C6E100555DE2 /* ZXErrors.m in Sources */,
+ 5D07C0291771C6E100555DE2 /* ZXInvertedLuminanceSource.m in Sources */,
+ 5D07C02A1771C6E100555DE2 /* ZXLuminanceSource.m in Sources */,
+ 5D07C02B1771C6E100555DE2 /* ZXMultiFormatReader.m in Sources */,
+ 5D07C02C1771C6E100555DE2 /* ZXMultiFormatWriter.m in Sources */,
+ 5D07C02D1771C6E100555DE2 /* ZXPlanarYUVLuminanceSource.m in Sources */,
+ 5D07C02E1771C6E100555DE2 /* ZXResult.m in Sources */,
+ 5D07C02F1771C6E100555DE2 /* ZXResultPoint.m in Sources */,
+ 5D07C0301771C6E100555DE2 /* ZXRGBLuminanceSource.m in Sources */,
+ 5D07C0331771C88400555DE2 /* CISDOBBarcodeViewController.m in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
};
@@ -592,7 +2110,7 @@
GCC_WARN_ABOUT_RETURN_TYPE = YES;
GCC_WARN_UNINITIALIZED_AUTOS = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
- IPHONEOS_DEPLOYMENT_TARGET = 6.0;
+ IPHONEOS_DEPLOYMENT_TARGET = 5.1;
SDKROOT = iphoneos;
TARGETED_DEVICE_FAMILY = "1,2";
};
@@ -613,7 +2131,7 @@
GCC_WARN_ABOUT_RETURN_TYPE = YES;
GCC_WARN_UNINITIALIZED_AUTOS = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
- IPHONEOS_DEPLOYMENT_TARGET = 6.0;
+ IPHONEOS_DEPLOYMENT_TARGET = 5.1;
OTHER_CFLAGS = "-DNS_BLOCK_ASSERTIONS=1";
SDKROOT = iphoneos;
TARGETED_DEVICE_FAMILY = "1,2";
@@ -627,7 +2145,9 @@
GCC_PRECOMPILE_PREFIX_HEADER = YES;
GCC_PREFIX_HEADER = "openBIS/openBIS-Prefix.pch";
INFOPLIST_FILE = "openBIS/openBIS-Info.plist";
+ IPHONEOS_DEPLOYMENT_TARGET = 5.1;
PRODUCT_NAME = "$(TARGET_NAME)";
+ TARGETED_DEVICE_FAMILY = 2;
WRAPPER_EXTENSION = app;
};
name = Debug;
@@ -638,7 +2158,9 @@
GCC_PRECOMPILE_PREFIX_HEADER = YES;
GCC_PREFIX_HEADER = "openBIS/openBIS-Prefix.pch";
INFOPLIST_FILE = "openBIS/openBIS-Info.plist";
+ IPHONEOS_DEPLOYMENT_TARGET = 5.1;
PRODUCT_NAME = "$(TARGET_NAME)";
+ TARGETED_DEVICE_FAMILY = 2;
WRAPPER_EXTENSION = app;
};
name = Release;
diff --git a/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/project.xcworkspace/xcuserdata/juanf.xcuserdatad/UserInterfaceState.xcuserstate b/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/project.xcworkspace/xcuserdata/juanf.xcuserdatad/UserInterfaceState.xcuserstate
new file mode 100644
index 0000000000000000000000000000000000000000..14037a5ba35e8f1604a0b3abf8e8fed0bf1beb9c
Binary files /dev/null and b/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/project.xcworkspace/xcuserdata/juanf.xcuserdatad/UserInterfaceState.xcuserstate differ
diff --git a/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/xcuserdata/juanf.xcuserdatad/xcdebugger/Breakpoints.xcbkptlist b/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/xcuserdata/juanf.xcuserdatad/xcdebugger/Breakpoints.xcbkptlist
new file mode 100644
index 0000000000000000000000000000000000000000..05301bc253830381195ba116901612a8e115bfa7
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/xcuserdata/juanf.xcuserdatad/xcdebugger/Breakpoints.xcbkptlist
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Bucket
+ type = "1"
+ version = "1.0">
+</Bucket>
diff --git a/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/xcuserdata/juanf.xcuserdatad/xcschemes/openBIS.xcscheme b/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/xcuserdata/juanf.xcuserdatad/xcschemes/openBIS.xcscheme
new file mode 100644
index 0000000000000000000000000000000000000000..01b4c6ad1db4b1efdf5127033e3dfae17a63c0b1
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/xcuserdata/juanf.xcuserdatad/xcschemes/openBIS.xcscheme
@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+ LastUpgradeVersion = "0460"
+ version = "1.3">
+ <BuildAction
+ parallelizeBuildables = "YES"
+ buildImplicitDependencies = "YES">
+ <BuildActionEntries>
+ <BuildActionEntry
+ buildForTesting = "YES"
+ buildForRunning = "YES"
+ buildForProfiling = "YES"
+ buildForArchiving = "YES"
+ buildForAnalyzing = "YES">
+ <BuildableReference
+ BuildableIdentifier = "primary"
+ BlueprintIdentifier = "36F71E73161C3AE900C87277"
+ BuildableName = "openBIS.app"
+ BlueprintName = "openBIS"
+ ReferencedContainer = "container:openBIS.xcodeproj">
+ </BuildableReference>
+ </BuildActionEntry>
+ </BuildActionEntries>
+ </BuildAction>
+ <TestAction
+ selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+ selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+ shouldUseLaunchSchemeArgsEnv = "YES"
+ buildConfiguration = "Debug">
+ <Testables>
+ <TestableReference
+ skipped = "NO">
+ <BuildableReference
+ BuildableIdentifier = "primary"
+ BlueprintIdentifier = "36F71EA5161C3AEA00C87277"
+ BuildableName = "openBISTests.octest"
+ BlueprintName = "openBISTests"
+ ReferencedContainer = "container:openBIS.xcodeproj">
+ </BuildableReference>
+ </TestableReference>
+ </Testables>
+ <MacroExpansion>
+ <BuildableReference
+ BuildableIdentifier = "primary"
+ BlueprintIdentifier = "36F71E73161C3AE900C87277"
+ BuildableName = "openBIS.app"
+ BlueprintName = "openBIS"
+ ReferencedContainer = "container:openBIS.xcodeproj">
+ </BuildableReference>
+ </MacroExpansion>
+ </TestAction>
+ <LaunchAction
+ selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+ selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+ launchStyle = "0"
+ useCustomWorkingDirectory = "NO"
+ buildConfiguration = "Debug"
+ ignoresPersistentStateOnLaunch = "NO"
+ debugDocumentVersioning = "YES"
+ allowLocationSimulation = "YES">
+ <BuildableProductRunnable>
+ <BuildableReference
+ BuildableIdentifier = "primary"
+ BlueprintIdentifier = "36F71E73161C3AE900C87277"
+ BuildableName = "openBIS.app"
+ BlueprintName = "openBIS"
+ ReferencedContainer = "container:openBIS.xcodeproj">
+ </BuildableReference>
+ </BuildableProductRunnable>
+ <AdditionalOptions>
+ </AdditionalOptions>
+ </LaunchAction>
+ <ProfileAction
+ shouldUseLaunchSchemeArgsEnv = "YES"
+ savedToolIdentifier = ""
+ useCustomWorkingDirectory = "NO"
+ buildConfiguration = "Release"
+ debugDocumentVersioning = "YES">
+ <BuildableProductRunnable>
+ <BuildableReference
+ BuildableIdentifier = "primary"
+ BlueprintIdentifier = "36F71E73161C3AE900C87277"
+ BuildableName = "openBIS.app"
+ BlueprintName = "openBIS"
+ ReferencedContainer = "container:openBIS.xcodeproj">
+ </BuildableReference>
+ </BuildableProductRunnable>
+ </ProfileAction>
+ <AnalyzeAction
+ buildConfiguration = "Debug">
+ </AnalyzeAction>
+ <ArchiveAction
+ buildConfiguration = "Release"
+ revealArchiveInOrganizer = "YES">
+ </ArchiveAction>
+</Scheme>
diff --git a/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/xcuserdata/juanf.xcuserdatad/xcschemes/openBISData.xcscheme b/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/xcuserdata/juanf.xcuserdatad/xcschemes/openBISData.xcscheme
new file mode 100644
index 0000000000000000000000000000000000000000..acdaec8a6d23b3ffdc3e8bdc9d646667cf6a9d44
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/xcuserdata/juanf.xcuserdatad/xcschemes/openBISData.xcscheme
@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+ LastUpgradeVersion = "0460"
+ version = "1.3">
+ <BuildAction
+ parallelizeBuildables = "YES"
+ buildImplicitDependencies = "YES">
+ <BuildActionEntries>
+ <BuildActionEntry
+ buildForTesting = "YES"
+ buildForRunning = "YES"
+ buildForProfiling = "YES"
+ buildForArchiving = "YES"
+ buildForAnalyzing = "YES">
+ <BuildableReference
+ BuildableIdentifier = "primary"
+ BlueprintIdentifier = "36F71F13161C4AA000C87277"
+ BuildableName = "openBISData"
+ BlueprintName = "openBISData"
+ ReferencedContainer = "container:openBIS.xcodeproj">
+ </BuildableReference>
+ </BuildActionEntry>
+ </BuildActionEntries>
+ </BuildAction>
+ <TestAction
+ selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+ selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+ shouldUseLaunchSchemeArgsEnv = "YES"
+ buildConfiguration = "Debug">
+ <Testables>
+ </Testables>
+ <MacroExpansion>
+ <BuildableReference
+ BuildableIdentifier = "primary"
+ BlueprintIdentifier = "36F71F13161C4AA000C87277"
+ BuildableName = "openBISData"
+ BlueprintName = "openBISData"
+ ReferencedContainer = "container:openBIS.xcodeproj">
+ </BuildableReference>
+ </MacroExpansion>
+ </TestAction>
+ <LaunchAction
+ selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+ selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+ launchStyle = "0"
+ useCustomWorkingDirectory = "NO"
+ buildConfiguration = "Debug"
+ ignoresPersistentStateOnLaunch = "NO"
+ debugDocumentVersioning = "YES"
+ allowLocationSimulation = "YES">
+ <BuildableProductRunnable>
+ <BuildableReference
+ BuildableIdentifier = "primary"
+ BlueprintIdentifier = "36F71F13161C4AA000C87277"
+ BuildableName = "openBISData"
+ BlueprintName = "openBISData"
+ ReferencedContainer = "container:openBIS.xcodeproj">
+ </BuildableReference>
+ </BuildableProductRunnable>
+ <AdditionalOptions>
+ </AdditionalOptions>
+ </LaunchAction>
+ <ProfileAction
+ shouldUseLaunchSchemeArgsEnv = "YES"
+ savedToolIdentifier = ""
+ useCustomWorkingDirectory = "NO"
+ buildConfiguration = "Release"
+ debugDocumentVersioning = "YES">
+ <BuildableProductRunnable>
+ <BuildableReference
+ BuildableIdentifier = "primary"
+ BlueprintIdentifier = "36F71F13161C4AA000C87277"
+ BuildableName = "openBISData"
+ BlueprintName = "openBISData"
+ ReferencedContainer = "container:openBIS.xcodeproj">
+ </BuildableReference>
+ </BuildableProductRunnable>
+ </ProfileAction>
+ <AnalyzeAction
+ buildConfiguration = "Debug">
+ </AnalyzeAction>
+ <ArchiveAction
+ buildConfiguration = "Release"
+ revealArchiveInOrganizer = "YES">
+ </ArchiveAction>
+</Scheme>
diff --git a/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/xcuserdata/juanf.xcuserdatad/xcschemes/xcschememanagement.plist b/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/xcuserdata/juanf.xcuserdatad/xcschemes/xcschememanagement.plist
new file mode 100644
index 0000000000000000000000000000000000000000..7be365fa143dbd9406ad04f4a407e5853b5c0b3c
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/openBIS.xcodeproj/xcuserdata/juanf.xcuserdatad/xcschemes/xcschememanagement.plist
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+ <key>SchemeUserState</key>
+ <dict>
+ <key>openBIS.xcscheme</key>
+ <dict>
+ <key>orderHint</key>
+ <integer>0</integer>
+ </dict>
+ <key>openBISData.xcscheme</key>
+ <dict>
+ <key>orderHint</key>
+ <integer>1</integer>
+ </dict>
+ </dict>
+ <key>SuppressBuildableAutocreation</key>
+ <dict>
+ <key>36F71E73161C3AE900C87277</key>
+ <dict>
+ <key>primary</key>
+ <true/>
+ </dict>
+ <key>36F71EA5161C3AEA00C87277</key>
+ <dict>
+ <key>primary</key>
+ <true/>
+ </dict>
+ <key>36F71F13161C4AA000C87277</key>
+ <dict>
+ <key>primary</key>
+ <true/>
+ </dict>
+ </dict>
+</dict>
+</plist>
diff --git a/openbis-ipad/source/objc/openBIS/openBIS/CISDOBBarcodeViewController.h b/openbis-ipad/source/objc/openBIS/openBIS/CISDOBBarcodeViewController.h
new file mode 100644
index 0000000000000000000000000000000000000000..98c7c6f55a08867c1edb0a3e94e7ed600592ed15
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/openBIS/CISDOBBarcodeViewController.h
@@ -0,0 +1,11 @@
+//
+// CISDOBBarcodeViewController.h
+// openBIS
+//
+// Created by Fuentes Serna Juan Mariano on 6/4/13.
+// Copyright (c) 2013 ETHZ, CISD. All rights reserved.
+//
+
+@interface CISDOBBarcodeViewController : UIViewController <ZXCaptureDelegate>
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/openBIS/CISDOBBarcodeViewController.m b/openbis-ipad/source/objc/openBIS/openBIS/CISDOBBarcodeViewController.m
new file mode 100644
index 0000000000000000000000000000000000000000..152ebfde2dfe68ec6f409fcfb2bf2b2cdd2367b4
--- /dev/null
+++ b/openbis-ipad/source/objc/openBIS/openBIS/CISDOBBarcodeViewController.m
@@ -0,0 +1,173 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <AudioToolbox/AudioToolbox.h>
+#import <AVFoundation/AVFoundation.h>
+#import "CISDOBBarcodeViewController.h"
+
+@interface CISDOBBarcodeViewController ()
+
+@property (nonatomic, retain) ZXCapture* capture;
+@property (nonatomic, retain) IBOutlet UILabel* decodedLabel;
+@property (nonatomic, retain) IBOutlet UIView* cameraView;
+
+- (NSString*)displayForResult:(ZXResult*)result;
+
+@end
+
+@implementation CISDOBBarcodeViewController
+
+@synthesize capture;
+@synthesize decodedLabel;
+@synthesize cameraView;
+
+#pragma mark - Creation/Deletion Methods
+
+- (IBAction) dismissModalViewController {
+ [self.capture.layer removeFromSuperlayer];
+ [self.capture stop];
+ [self dismissViewControllerAnimated:YES completion:nil];
+}
+
+#pragma mark - Creation/Deletion Methods
+- (void)dealloc {
+ [self.capture release];
+ [self.decodedLabel release];
+ [self.cameraView release];
+
+ [super dealloc];
+}
+#pragma mark - View Controller Methods
+
+- (void)viewWillAppear:(BOOL)animated {
+ [super viewWillAppear:animated];
+
+ self.capture = [[ZXCapture alloc] init];
+ self.capture.delegate = self;
+ self.capture.rotation = 90.0f;
+
+ // Use the back camera
+ self.capture.camera = self.capture.back;
+ self.capture.layer.frame = CGRectMake(0.f, 0.f, 360.f, 360.f);
+ [self.cameraView.layer addSublayer: self.capture.layer];
+}
+
+- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation {
+ return toInterfaceOrientation == UIInterfaceOrientationPortrait;
+}
+
+#pragma mark - Private Methods
+
+- (NSString*)displayForResult:(ZXResult*)result {
+ [self dismissModalViewController];
+ [[NSNotificationCenter defaultCenter]
+ postNotificationName:@"SearchNotification"
+ object:result.text];
+
+ return result.text;
+}
+
+- (NSString*)displayForResultDemo:(ZXResult*)result {
+
+ NSString *formatString;
+ switch (result.barcodeFormat) {
+ case kBarcodeFormatAztec:
+ formatString = @"Aztec";
+ break;
+
+ case kBarcodeFormatCodabar:
+ formatString = @"CODABAR";
+ break;
+
+ case kBarcodeFormatCode39:
+ formatString = @"Code 39";
+ break;
+
+ case kBarcodeFormatCode93:
+ formatString = @"Code 93";
+ break;
+
+ case kBarcodeFormatCode128:
+ formatString = @"Code 128";
+ break;
+
+ case kBarcodeFormatDataMatrix:
+ formatString = @"Data Matrix";
+ break;
+
+ case kBarcodeFormatEan8:
+ formatString = @"EAN-8";
+ break;
+
+ case kBarcodeFormatEan13:
+ formatString = @"EAN-13";
+ break;
+
+ case kBarcodeFormatITF:
+ formatString = @"ITF";
+ break;
+
+ case kBarcodeFormatPDF417:
+ formatString = @"PDF417";
+ break;
+
+ case kBarcodeFormatQRCode:
+ formatString = @"QR Code";
+ break;
+
+ case kBarcodeFormatRSS14:
+ formatString = @"RSS 14";
+ break;
+
+ case kBarcodeFormatRSSExpanded:
+ formatString = @"RSS Expanded";
+ break;
+
+ case kBarcodeFormatUPCA:
+ formatString = @"UPCA";
+ break;
+
+ case kBarcodeFormatUPCE:
+ formatString = @"UPCE";
+ break;
+
+ case kBarcodeFormatUPCEANExtension:
+ formatString = @"UPC/EAN extension";
+ break;
+
+ default:
+ formatString = @"Unknown";
+ break;
+ }
+
+ NSString *resultText = [NSString stringWithFormat:@"Scanned!\nFormat: %@\nContents:\n%@", formatString, result.text];
+
+ return resultText;
+}
+
+#pragma mark - ZXCaptureDelegate Methods
+
+- (void)captureResult:(ZXCapture*)capture result:(ZXResult*)result {
+ if (result) {
+ // We got a result. Display information about the result onscreen.
+ [self.decodedLabel performSelectorOnMainThread:@selector(setText:) withObject:[self displayForResult:result] waitUntilDone:YES];
+ }
+}
+
+- (void)captureSize:(ZXCapture*)capture width:(NSNumber*)width height:(NSNumber*)height {
+}
+
+@end
diff --git a/openbis-ipad/source/objc/openBIS/openBIS/CISDOBMasterViewController.m b/openbis-ipad/source/objc/openBIS/openBIS/CISDOBMasterViewController.m
index c5e353eee0bda5f078cc45d35d963c67cea77c44..d2efcd7748e01c6314cd2855b98bfd9ba46c1d35 100644
--- a/openbis-ipad/source/objc/openBIS/openBIS/CISDOBMasterViewController.m
+++ b/openbis-ipad/source/objc/openBIS/openBIS/CISDOBMasterViewController.m
@@ -26,6 +26,7 @@
#import "CISDOBDetailViewController.h"
#import "CISDOBIpadEntity.h"
#import "CISDOBOpenBisModel.h"
+#import "CISDOBBarcodeViewController.h"
@interface CISDOBMasterViewController ()
- (void)configureCell:(UITableViewCell *)cell atIndexPath:(NSIndexPath *)indexPath;
@@ -60,6 +61,12 @@
self.filterState = [[CISDOBTableFilterState alloc] initWithController: self];
self.searchState = [[CISDOBTableSearchState alloc] initWithController: self];
self.searchFilterState = self.filterState;
+
+ [[NSNotificationCenter defaultCenter]
+ addObserver:self
+ selector:@selector(receiveSearchNotification:)
+ name:@"SearchNotification"
+ object:nil];
}
- (IBAction)refreshFromServer:(id)sender
@@ -219,7 +226,7 @@
- (void)controller:(NSFetchedResultsController *)controller didChangeSection:(id <NSFetchedResultsSectionInfo>)sectionInfo
atIndex:(NSUInteger)sectionIndex forChangeType:(NSFetchedResultsChangeType)type
{
- switch(type) {
+ switch(type) {
case NSFetchedResultsChangeInsert:
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:sectionIndex] withRowAnimation:UITableViewRowAnimationFade];
break;
@@ -272,6 +279,16 @@
*/
#pragma mark - UISearchDisplayDelegate
+
+- (void) receiveSearchNotification:(NSNotification *) notification
+{
+ NSString * searchString = [notification object];
+ [self searchDisplayControllerWillBeginSearch: self.searchDisplayController];
+ self.searchDisplayController.searchBar.text = searchString;
+ self.openBisModel.searchString = searchString;
+ [self searchDisplayController: self.searchDisplayController shouldReloadTableForSearchScope: 0];
+}
+
- (BOOL)searchDisplayController:(UISearchDisplayController *)controller shouldReloadTableForSearchString:(NSString *)searchString
{
self.openBisModel.searchString = searchString;
@@ -282,10 +299,23 @@
{
CISDOBTableDisplayState *oldDisplayState = self.searchFilterState;
self.openBisModel.selectedSearchScopeIndex = searchOption;
+ NSString* searchTitle = [self scopeButtonTitles][self.openBisModel.selectedSearchScopeIndex];
self.searchFilterState = [self.openBisModel isSelectedSearchScopeIndexSearch] ? self.searchState : self.filterState;
- return (oldDisplayState != self.searchFilterState) ?
+ if (self.openBisModel.searchString == nil) {
+ self.openBisModel.searchString = @"";
+ }
+
+ if ([searchTitle isEqualToString:@"Barcode"]) {
+ UIStoryboard *storyboard = [UIStoryboard storyboardWithName:@"MainStoryboard_iPad" bundle:nil];
+ CISDOBBarcodeViewController *barcodeController = [storyboard instantiateViewControllerWithIdentifier:@"Barcode"];
+ barcodeController.modalPresentationStyle = UIModalPresentationFullScreen;
+ [self presentModalViewController:barcodeController animated:YES];
+ return NO;
+ } else {
+ return (oldDisplayState != self.searchFilterState) ?
[self.searchFilterState searchDisplayController: controller shouldReloadTableForSearchString: self.openBisModel.searchString] :
YES;
+ }
}
- (void)searchDisplayControllerWillBeginSearch:(UISearchDisplayController *)controller
diff --git a/openbis-ipad/source/objc/openBIS/openBIS/en.lproj/MainStoryboard_iPad.storyboard b/openbis-ipad/source/objc/openBIS/openBIS/en.lproj/MainStoryboard_iPad.storyboard
index 67ec53eda312552ca919942d009bd1c30447e776..93e0e3b1f5b319306b34310d56ef06709e138ff2 100644
--- a/openbis-ipad/source/objc/openBIS/openBIS/en.lproj/MainStoryboard_iPad.storyboard
+++ b/openbis-ipad/source/objc/openBIS/openBIS/en.lproj/MainStoryboard_iPad.storyboard
@@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="2.0" toolsVersion="3084" systemVersion="11G63" targetRuntime="iOS.CocoaTouch.iPad" propertyAccessControl="none" useAutolayout="YES" initialViewController="5">
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="2.0" toolsVersion="3084" systemVersion="12D78" targetRuntime="iOS.CocoaTouch.iPad" propertyAccessControl="none" useAutolayout="YES" initialViewController="5">
<dependencies>
<development version="4500" identifier="xcode"/>
<plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="2083"/>
@@ -31,7 +31,7 @@
<label clipsSubviews="YES" userInteractionEnabled="NO" contentMode="scaleToFill" text="" lineBreakMode="tailTruncation" minimumFontSize="10" translatesAutoresizingMaskIntoConstraints="NO" id="27">
<color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
<constraints>
- <constraint firstAttribute="height" constant="28" type="user" id="j4P-P6-Ayn"/>
+ <constraint firstAttribute="height" constant="28" id="WoK-Ge-WnC"/>
</constraints>
<fontDescription key="fontDescription" type="boldSystem" pointSize="16"/>
<color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
@@ -40,7 +40,7 @@
<label clipsSubviews="YES" userInteractionEnabled="NO" contentMode="scaleToFill" text="" lineBreakMode="tailTruncation" minimumFontSize="10" translatesAutoresizingMaskIntoConstraints="NO" id="gor-tF-mFh">
<color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
<constraints>
- <constraint firstAttribute="height" constant="28" id="NeY-AR-8Ub"/>
+ <constraint firstAttribute="height" constant="28" id="4jz-O3-nTV"/>
</constraints>
<fontDescription key="fontDescription" type="system" pointSize="14"/>
<color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
@@ -49,8 +49,8 @@
<label clipsSubviews="YES" userInteractionEnabled="NO" contentMode="scaleToFill" text="" lineBreakMode="tailTruncation" minimumFontSize="10" translatesAutoresizingMaskIntoConstraints="NO" id="T4E-dH-b3j">
<color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
<constraints>
- <constraint firstAttribute="height" constant="118" id="Txf-bY-brd"/>
- <constraint firstAttribute="width" constant="410" id="YWT-eM-uXI"/>
+ <constraint firstAttribute="height" constant="118" id="QR9-6Z-X9t"/>
+ <constraint firstAttribute="width" constant="410" id="aO9-QM-2mE"/>
</constraints>
<fontDescription key="fontDescription" type="system" size="system"/>
<color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
@@ -58,9 +58,6 @@
</label>
<tableView clipsSubviews="YES" contentMode="scaleToFill" alwaysBounceVertical="YES" dataMode="prototypes" style="plain" rowHeight="44" sectionHeaderHeight="22" sectionFooterHeight="22" translatesAutoresizingMaskIntoConstraints="NO" id="bUx-j7-YCF">
<color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
- <constraints>
- <constraint firstAttribute="height" relation="greaterThanOrEqual" constant="350" type="user" id="7bz-Yw-afd"/>
- </constraints>
<prototypes>
<tableViewCell contentMode="scaleToFill" verticalHuggingPriority="1" horizontalCompressionResistancePriority="1000" verticalCompressionResistancePriority="1000" selectionStyle="blue" indentationWidth="10" reuseIdentifier="Property" textLabel="qrE-EN-cse" detailTextLabel="9aq-ke-4ab" style="IBUITableViewCellStyleValue2" id="mfZ-bV-mLK">
<rect key="frame" x="0.0" y="22" width="703" height="44"/>
@@ -69,12 +66,14 @@
<rect key="frame" x="0.0" y="0.0" width="703" height="43"/>
<autoresizingMask key="autoresizingMask"/>
<subviews>
- <label opaque="NO" clipsSubviews="YES" multipleTouchEnabled="YES" contentMode="left" horizontalCompressionResistancePriority="1000" text="Title" textAlignment="right" lineBreakMode="tailTruncation" numberOfLines="0" baselineAdjustment="alignBaselines" adjustsLetterSpacingToFitWidth="YES" adjustsFontSizeToFit="NO" preferredMaxLayoutWidth="91" translatesAutoresizingMaskIntoConstraints="NO" id="qrE-EN-cse">
+ <label opaque="NO" clipsSubviews="YES" multipleTouchEnabled="YES" contentMode="left" horizontalCompressionResistancePriority="1000" text="Title" textAlignment="right" lineBreakMode="tailTruncation" numberOfLines="0" baselineAdjustment="alignBaselines" adjustsLetterSpacingToFitWidth="YES" adjustsFontSizeToFit="NO" preferredMaxLayoutWidth="91" id="qrE-EN-cse">
+ <rect key="frame" x="10" y="15" width="91" height="15"/>
<fontDescription key="fontDescription" type="boldSystem" pointSize="12"/>
<color key="textColor" red="0.32156862745098042" green="0.40000000000000002" blue="0.56862745098039214" alpha="1" colorSpace="calibratedRGB"/>
<color key="highlightedColor" red="1" green="1" blue="1" alpha="1" colorSpace="calibratedRGB"/>
</label>
- <label opaque="NO" clipsSubviews="YES" multipleTouchEnabled="YES" contentMode="left" text="Detail" lineBreakMode="tailTruncation" numberOfLines="0" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" preferredMaxLayoutWidth="41" translatesAutoresizingMaskIntoConstraints="NO" id="9aq-ke-4ab">
+ <label opaque="NO" clipsSubviews="YES" multipleTouchEnabled="YES" contentMode="left" text="Detail" lineBreakMode="tailTruncation" numberOfLines="0" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" preferredMaxLayoutWidth="41" id="9aq-ke-4ab">
+ <rect key="frame" x="107" y="12" width="41" height="19"/>
<fontDescription key="fontDescription" type="boldSystem" pointSize="15"/>
<color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
<color key="highlightedColor" red="1" green="1" blue="1" alpha="1" colorSpace="calibratedRGB"/>
@@ -92,21 +91,26 @@
<webView multipleTouchEnabled="YES" contentMode="scaleToFill" scalesPageToFit="YES" translatesAutoresizingMaskIntoConstraints="NO" id="rUU-Fj-t5t">
<color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="calibratedRGB"/>
<constraints>
- <constraint firstAttribute="width" constant="231" id="1jB-hU-Cjx"/>
+ <constraint firstAttribute="width" constant="231" id="AQb-uU-ZgJ"/>
</constraints>
<dataDetectorType key="dataDetectorTypes"/>
</webView>
<toolbar opaque="NO" clearsContextBeforeDrawing="NO" contentMode="scaleToFill" translatesAutoresizingMaskIntoConstraints="NO" id="Du1-DN-a8M">
<items>
+ <barButtonItem title="Barcode Reader" id="qCX-Gc-qO7">
+ <connections>
+ <segue destination="m5H-hb-BWc" kind="modal" id="LND-UK-9bR"/>
+ </connections>
+ </barButtonItem>
<barButtonItem style="plain" id="XMA-G9-CGH">
<view key="customView" userInteractionEnabled="NO" contentMode="scaleToFill" id="iLy-GA-rxW">
- <rect key="frame" x="12" y="6" width="527" height="33"/>
+ <rect key="frame" x="130" y="6" width="527" height="33"/>
<autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMaxY="YES"/>
<subviews>
<label opaque="NO" clipsSubviews="YES" contentMode="left" text="" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="xTL-xF-3F3">
<color key="backgroundColor" white="0.0" alpha="0.0" colorSpace="calibratedWhite"/>
<constraints>
- <constraint firstAttribute="height" constant="21" id="3ah-YY-mCe"/>
+ <constraint firstAttribute="height" constant="21" id="UR7-FL-Of0"/>
</constraints>
<fontDescription key="fontDescription" type="system" pointSize="12"/>
<color key="textColor" white="0.33333333333333331" alpha="1" colorSpace="calibratedWhite"/>
@@ -115,9 +119,9 @@
</subviews>
<color key="backgroundColor" white="0.0" alpha="0.0" colorSpace="calibratedWhite"/>
<constraints>
- <constraint firstItem="xTL-xF-3F3" firstAttribute="trailing" secondItem="iLy-GA-rxW" secondAttribute="trailing" type="default" id="Ejn-fN-yPK"/>
- <constraint firstItem="xTL-xF-3F3" firstAttribute="leading" secondItem="iLy-GA-rxW" secondAttribute="leading" type="default" id="Suw-n8-iOA"/>
- <constraint firstItem="xTL-xF-3F3" firstAttribute="centerY" secondItem="iLy-GA-rxW" secondAttribute="centerY" type="default" id="gIo-Rm-JYf"/>
+ <constraint firstItem="xTL-xF-3F3" firstAttribute="leading" secondItem="iLy-GA-rxW" secondAttribute="leading" type="default" id="AyU-gu-VIo"/>
+ <constraint firstItem="xTL-xF-3F3" firstAttribute="centerY" secondItem="iLy-GA-rxW" secondAttribute="centerY" type="default" id="FPK-h5-o2P"/>
+ <constraint firstItem="xTL-xF-3F3" firstAttribute="trailing" secondItem="iLy-GA-rxW" secondAttribute="trailing" type="default" id="HbI-Yg-8VH"/>
</constraints>
</view>
</barButtonItem>
@@ -136,24 +140,24 @@
</subviews>
<color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
<constraints>
- <constraint firstItem="Du1-DN-a8M" firstAttribute="bottom" secondItem="26" secondAttribute="bottom" type="default" id="14y-wU-vCh"/>
- <constraint firstItem="bUx-j7-YCF" firstAttribute="top" secondItem="T4E-dH-b3j" secondAttribute="bottom" constant="8" symbolic="YES" type="default" id="34W-Bo-fwe"/>
- <constraint firstItem="T4E-dH-b3j" firstAttribute="top" secondItem="gor-tF-mFh" secondAttribute="bottom" constant="8" symbolic="YES" type="default" id="8xN-U9-aRY"/>
- <constraint firstItem="T4E-dH-b3j" firstAttribute="leading" secondItem="26" secondAttribute="leading" constant="25" id="AXi-9e-oWq"/>
- <constraint firstItem="27" firstAttribute="top" secondItem="26" secondAttribute="top" constant="20" symbolic="YES" type="user" id="FD4-HZ-RnC"/>
- <constraint firstItem="gor-tF-mFh" firstAttribute="leading" secondItem="26" secondAttribute="leading" constant="20" symbolic="YES" type="default" id="FvH-Wf-aa1"/>
- <constraint firstItem="rUU-Fj-t5t" firstAttribute="leading" secondItem="27" secondAttribute="trailing" constant="8" symbolic="YES" type="default" id="GUS-JI-w7u"/>
- <constraint firstItem="bUx-j7-YCF" firstAttribute="trailing" secondItem="26" secondAttribute="trailing" type="default" id="J5w-YE-X9r"/>
- <constraint firstItem="Du1-DN-a8M" firstAttribute="leading" secondItem="26" secondAttribute="leading" type="default" id="JBT-1Q-07O"/>
- <constraint firstItem="bUx-j7-YCF" firstAttribute="top" secondItem="rUU-Fj-t5t" secondAttribute="bottom" constant="8" symbolic="YES" type="default" id="NfB-38-VMG"/>
- <constraint firstItem="rUU-Fj-t5t" firstAttribute="top" secondItem="26" secondAttribute="top" constant="20" symbolic="YES" type="default" id="QCg-PZ-dXE"/>
- <constraint firstAttribute="trailing" secondItem="rUU-Fj-t5t" secondAttribute="trailing" constant="20" symbolic="YES" type="default" id="Qpl-Gy-9XI"/>
- <constraint firstItem="gor-tF-mFh" firstAttribute="top" secondItem="27" secondAttribute="bottom" constant="8" symbolic="YES" type="default" id="T1F-6Z-kbc"/>
- <constraint firstItem="rUU-Fj-t5t" firstAttribute="leading" secondItem="gor-tF-mFh" secondAttribute="trailing" constant="8" symbolic="YES" type="default" id="lbL-ti-Ku6"/>
- <constraint firstItem="Du1-DN-a8M" firstAttribute="trailing" secondItem="26" secondAttribute="trailing" type="default" id="nFU-L9-Dya"/>
- <constraint firstItem="Du1-DN-a8M" firstAttribute="top" secondItem="bUx-j7-YCF" secondAttribute="bottom" type="default" id="nzY-hY-ThJ"/>
- <constraint firstItem="bUx-j7-YCF" firstAttribute="leading" secondItem="26" secondAttribute="leading" type="default" id="tBx-gM-VfN"/>
- <constraint firstItem="27" firstAttribute="leading" secondItem="26" secondAttribute="leading" constant="20" symbolic="YES" type="default" id="vrS-8t-WFg"/>
+ <constraint firstItem="bUx-j7-YCF" firstAttribute="trailing" secondItem="26" secondAttribute="trailing" type="default" id="6Oo-Zz-r8b"/>
+ <constraint firstItem="Du1-DN-a8M" firstAttribute="leading" secondItem="26" secondAttribute="leading" type="default" id="7vI-Hv-B2y"/>
+ <constraint firstAttribute="trailing" secondItem="rUU-Fj-t5t" secondAttribute="trailing" constant="20" symbolic="YES" type="default" id="8ay-ES-gaf"/>
+ <constraint firstItem="bUx-j7-YCF" firstAttribute="top" secondItem="rUU-Fj-t5t" secondAttribute="bottom" constant="8" symbolic="YES" type="default" id="9gE-iU-fiS"/>
+ <constraint firstItem="bUx-j7-YCF" firstAttribute="leading" secondItem="26" secondAttribute="leading" type="default" id="H4v-FB-M1b"/>
+ <constraint firstItem="gor-tF-mFh" firstAttribute="top" secondItem="27" secondAttribute="bottom" constant="8" symbolic="YES" type="default" id="Hqb-DS-wvT"/>
+ <constraint firstItem="27" firstAttribute="top" secondItem="26" secondAttribute="top" constant="20" symbolic="YES" type="default" id="MVD-DQ-HNa"/>
+ <constraint firstItem="27" firstAttribute="leading" secondItem="26" secondAttribute="leading" constant="20" symbolic="YES" type="default" id="ODs-fX-zpt"/>
+ <constraint firstItem="rUU-Fj-t5t" firstAttribute="top" secondItem="26" secondAttribute="top" constant="20" symbolic="YES" type="default" id="Pcx-Nv-A9T"/>
+ <constraint firstItem="rUU-Fj-t5t" firstAttribute="leading" secondItem="27" secondAttribute="trailing" constant="8" symbolic="YES" type="default" id="V6j-uT-FJQ"/>
+ <constraint firstItem="rUU-Fj-t5t" firstAttribute="leading" secondItem="gor-tF-mFh" secondAttribute="trailing" constant="8" symbolic="YES" type="default" id="Y5k-qg-9Dv"/>
+ <constraint firstItem="T4E-dH-b3j" firstAttribute="leading" secondItem="26" secondAttribute="leading" constant="25" id="gRn-tK-HgP"/>
+ <constraint firstItem="T4E-dH-b3j" firstAttribute="top" secondItem="gor-tF-mFh" secondAttribute="bottom" constant="8" symbolic="YES" type="default" id="kLw-Rb-D81"/>
+ <constraint firstItem="Du1-DN-a8M" firstAttribute="bottom" secondItem="26" secondAttribute="bottom" type="default" id="krU-XS-2po"/>
+ <constraint firstItem="Du1-DN-a8M" firstAttribute="top" secondItem="bUx-j7-YCF" secondAttribute="bottom" type="default" id="oTS-Dq-wSS"/>
+ <constraint firstItem="gor-tF-mFh" firstAttribute="leading" secondItem="26" secondAttribute="leading" constant="20" symbolic="YES" type="default" id="uK6-Rf-Ekf"/>
+ <constraint firstItem="Du1-DN-a8M" firstAttribute="trailing" secondItem="26" secondAttribute="trailing" type="default" id="url-xl-7i2"/>
+ <constraint firstItem="bUx-j7-YCF" firstAttribute="top" secondItem="T4E-dH-b3j" secondAttribute="bottom" constant="8" symbolic="YES" type="default" id="yYe-pt-kGL"/>
</constraints>
<simulatedOrientationMetrics key="simulatedOrientationMetrics" orientation="landscapeRight"/>
</view>
@@ -211,31 +215,26 @@
<autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMaxY="YES"/>
<subviews>
<textField opaque="NO" clipsSubviews="YES" contentMode="scaleToFill" verticalHuggingPriority="1000" contentHorizontalAlignment="left" contentVerticalAlignment="center" borderStyle="roundedRect" placeholder="URL" minimumFontSize="17" translatesAutoresizingMaskIntoConstraints="NO" id="sWb-wa-6qu">
- <constraints>
- <constraint firstAttribute="height" constant="30" type="user" id="pHg-8X-gDH"/>
- </constraints>
<fontDescription key="fontDescription" type="system" pointSize="14"/>
<textInputTraits key="textInputTraits" keyboardType="URL"/>
</textField>
<textField opaque="NO" clipsSubviews="YES" contentMode="scaleToFill" contentHorizontalAlignment="left" contentVerticalAlignment="center" borderStyle="roundedRect" placeholder="User" minimumFontSize="17" translatesAutoresizingMaskIntoConstraints="NO" id="IEY-Jd-Yi1">
<constraints>
- <constraint firstAttribute="height" constant="30" type="user" id="9GI-qd-VyX"/>
- <constraint firstAttribute="width" constant="166" id="Jtp-1J-Ywx"/>
+ <constraint firstAttribute="width" constant="166" id="nBl-9l-hh6"/>
</constraints>
<fontDescription key="fontDescription" type="system" pointSize="14"/>
<textInputTraits key="textInputTraits"/>
</textField>
<textField opaque="NO" clipsSubviews="YES" contentMode="scaleToFill" contentHorizontalAlignment="left" contentVerticalAlignment="center" borderStyle="roundedRect" placeholder="Password" minimumFontSize="17" translatesAutoresizingMaskIntoConstraints="NO" id="156-KK-cHv">
<constraints>
- <constraint firstAttribute="height" constant="30" type="user" id="3ED-wa-5yJ"/>
- <constraint firstAttribute="width" constant="300" id="hMu-HO-BTO"/>
+ <constraint firstAttribute="width" constant="300" id="OOb-NM-yL4"/>
</constraints>
<fontDescription key="fontDescription" type="system" pointSize="14"/>
<textInputTraits key="textInputTraits" secureTextEntry="YES"/>
</textField>
<label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" text="Login" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="Fv2-LT-eNm">
<constraints>
- <constraint firstAttribute="height" constant="22" type="user" id="nEH-LM-o8w"/>
+ <constraint firstAttribute="height" constant="22" id="oQy-zV-3Ke"/>
</constraints>
<fontDescription key="fontDescription" type="system" pointSize="17"/>
<color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
@@ -243,7 +242,7 @@
</label>
<label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" text="openBIS Server" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="LRp-55-gt6">
<constraints>
- <constraint firstAttribute="height" constant="22" type="user" id="bv2-6m-E5U"/>
+ <constraint firstAttribute="height" constant="22" id="g2c-dk-7Y9"/>
</constraints>
<fontDescription key="fontDescription" type="system" pointSize="17"/>
<color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
@@ -256,8 +255,8 @@
</label>
<label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" lineBreakMode="tailTruncation" numberOfLines="6" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" preferredMaxLayoutWidth="518" translatesAutoresizingMaskIntoConstraints="NO" id="7Aq-O2-MYr">
<constraints>
- <constraint firstAttribute="height" constant="82" id="TlM-Xl-NTi"/>
- <constraint firstAttribute="width" constant="518" id="sEK-mV-gLe"/>
+ <constraint firstAttribute="width" constant="518" id="RZW-rF-J4b"/>
+ <constraint firstAttribute="height" constant="82" id="c4A-JC-mqB"/>
</constraints>
<string key="text">This iPad app is designed to give users of openBIS access to their data from their iPad.
@@ -268,7 +267,7 @@ If you are a user of an openBIS server, plese enter the URL and your login detai
</label>
<button opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="center" contentVerticalAlignment="center" buttonType="roundedRect" reversesTitleShadowWhenHighlighted="YES" lineBreakMode="wordWrap" translatesAutoresizingMaskIntoConstraints="NO" id="3rW-ET-vQX">
<constraints>
- <constraint firstAttribute="width" constant="92" id="HFo-et-YQ6"/>
+ <constraint firstAttribute="width" constant="92" id="tPb-3G-TIl"/>
</constraints>
<fontDescription key="fontDescription" type="boldSystem" pointSize="15"/>
<state key="normal" title="Browse Offline">
@@ -284,7 +283,7 @@ If you are a user of an openBIS server, plese enter the URL and your login detai
</button>
<button opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="center" contentVerticalAlignment="center" buttonType="roundedRect" reversesTitleShadowWhenHighlighted="YES" lineBreakMode="middleTruncation" translatesAutoresizingMaskIntoConstraints="NO" id="t1Z-Hl-UZu">
<constraints>
- <constraint firstAttribute="height" constant="44" type="user" id="hat-U2-hIZ"/>
+ <constraint firstAttribute="height" constant="44" id="1NX-wy-Sev"/>
</constraints>
<fontDescription key="fontDescription" type="boldSystem" pointSize="15"/>
<state key="normal" title="Log In">
@@ -300,7 +299,8 @@ If you are a user of an openBIS server, plese enter the URL and your login detai
</button>
<label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" text="" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="5qJ-y2-Sq5">
<constraints>
- <constraint firstAttribute="width" constant="480" id="821-GF-pXb"/>
+ <constraint firstAttribute="height" constant="276" id="t2k-wM-AuO"/>
+ <constraint firstAttribute="width" constant="480" id="vvn-MP-tkF"/>
</constraints>
<fontDescription key="fontDescription" type="system" pointSize="17"/>
<color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
@@ -309,29 +309,27 @@ If you are a user of an openBIS server, plese enter the URL and your login detai
</subviews>
<color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
<constraints>
- <constraint firstAttribute="trailing" secondItem="3rW-ET-vQX" secondAttribute="trailing" constant="93" id="0Wa-cx-Rpu"/>
- <constraint firstItem="t1Z-Hl-UZu" firstAttribute="trailing" secondItem="156-KK-cHv" secondAttribute="trailing" type="default" id="3Cm-ZJ-4ej"/>
- <constraint firstItem="LRp-55-gt6" firstAttribute="top" secondItem="RL9-Rf-b7S" secondAttribute="top" constant="263" type="user" id="4Tt-tZ-zJQ"/>
- <constraint firstItem="IEY-Jd-Yi1" firstAttribute="baseline" secondItem="156-KK-cHv" secondAttribute="baseline" type="user" id="7HG-Jt-IJz"/>
- <constraint firstItem="sWb-wa-6qu" firstAttribute="top" secondItem="LRp-55-gt6" secondAttribute="bottom" constant="8" symbolic="YES" type="user" id="9z7-0Y-lQD"/>
- <constraint firstItem="IEY-Jd-Yi1" firstAttribute="top" secondItem="Fv2-LT-eNm" secondAttribute="bottom" constant="11" type="user" id="BKN-CR-KUd"/>
- <constraint firstItem="y8r-6g-CzC" firstAttribute="leading" secondItem="RL9-Rf-b7S" secondAttribute="leading" constant="31" id="DtS-bD-LhH"/>
- <constraint firstItem="156-KK-cHv" firstAttribute="leading" secondItem="IEY-Jd-Yi1" secondAttribute="trailing" constant="8" symbolic="YES" type="default" id="MMa-ki-yYc"/>
- <constraint firstItem="7Aq-O2-MYr" firstAttribute="top" secondItem="y8r-6g-CzC" secondAttribute="bottom" constant="8" symbolic="YES" type="default" id="RJ0-gw-cc5"/>
- <constraint firstItem="Fv2-LT-eNm" firstAttribute="leading" secondItem="IEY-Jd-Yi1" secondAttribute="leading" type="default" id="W0P-8D-xEd"/>
- <constraint firstItem="3rW-ET-vQX" firstAttribute="top" secondItem="RL9-Rf-b7S" secondAttribute="top" constant="126" id="bF1-sU-35U"/>
- <constraint firstItem="5qJ-y2-Sq5" firstAttribute="leading" secondItem="IEY-Jd-Yi1" secondAttribute="leading" type="default" id="diM-o0-wZw"/>
- <constraint firstItem="156-KK-cHv" firstAttribute="top" secondItem="Fv2-LT-eNm" secondAttribute="bottom" constant="11" type="user" id="hfd-gT-q4j"/>
- <constraint firstItem="Fv2-LT-eNm" firstAttribute="leading" secondItem="sWb-wa-6qu" secondAttribute="leading" type="default" id="iAC-ad-Bwq"/>
- <constraint firstItem="5qJ-y2-Sq5" firstAttribute="top" secondItem="t1Z-Hl-UZu" secondAttribute="bottom" constant="10" type="user" id="jVP-dc-4DT"/>
- <constraint firstItem="sWb-wa-6qu" firstAttribute="trailing" secondItem="156-KK-cHv" secondAttribute="trailing" type="default" id="kFD-Ip-DpD"/>
- <constraint firstItem="LRp-55-gt6" firstAttribute="leading" secondItem="sWb-wa-6qu" secondAttribute="leading" type="default" id="sJ8-Gb-txC"/>
- <constraint firstItem="7Aq-O2-MYr" firstAttribute="leading" secondItem="LRp-55-gt6" secondAttribute="leading" type="default" id="tgp-P1-o0q"/>
- <constraint firstAttribute="bottom" secondItem="5qJ-y2-Sq5" secondAttribute="bottom" constant="21" type="user" id="tjb-h2-b5S"/>
- <constraint firstItem="Fv2-LT-eNm" firstAttribute="top" secondItem="sWb-wa-6qu" secondAttribute="bottom" constant="6" type="user" id="vdx-DQ-m3E"/>
- <constraint firstItem="t1Z-Hl-UZu" firstAttribute="top" secondItem="156-KK-cHv" secondAttribute="bottom" constant="5" type="user" id="xyp-7f-3Dr"/>
- <constraint firstItem="y8r-6g-CzC" firstAttribute="top" secondItem="RL9-Rf-b7S" secondAttribute="top" constant="76" id="yXB-7i-tkJ"/>
- <constraint firstItem="7Aq-O2-MYr" firstAttribute="leading" secondItem="y8r-6g-CzC" secondAttribute="leading" type="default" id="ybM-Ej-2gb"/>
+ <constraint firstItem="y8r-6g-CzC" firstAttribute="leading" secondItem="RL9-Rf-b7S" secondAttribute="leading" constant="31" id="3Qb-Nk-x5w"/>
+ <constraint firstAttribute="trailing" secondItem="3rW-ET-vQX" secondAttribute="trailing" constant="93" id="544-o3-xtn"/>
+ <constraint firstItem="LRp-55-gt6" firstAttribute="leading" secondItem="sWb-wa-6qu" secondAttribute="leading" type="default" id="6ZS-4g-Ywb"/>
+ <constraint firstAttribute="bottom" secondItem="5qJ-y2-Sq5" secondAttribute="bottom" constant="21" id="951-95-OId"/>
+ <constraint firstItem="IEY-Jd-Yi1" firstAttribute="top" secondItem="RL9-Rf-b7S" secondAttribute="top" constant="362" id="CVm-my-MWZ"/>
+ <constraint firstItem="156-KK-cHv" firstAttribute="baseline" secondItem="IEY-Jd-Yi1" secondAttribute="baseline" type="default" id="Hh6-gJ-igf"/>
+ <constraint firstItem="7Aq-O2-MYr" firstAttribute="top" secondItem="y8r-6g-CzC" secondAttribute="bottom" constant="8" symbolic="YES" type="default" id="J7M-dx-ecf"/>
+ <constraint firstItem="IEY-Jd-Yi1" firstAttribute="leading" secondItem="5qJ-y2-Sq5" secondAttribute="leading" type="default" id="O5F-Zr-Poi"/>
+ <constraint firstAttribute="bottom" secondItem="t1Z-Hl-UZu" secondAttribute="bottom" constant="307" id="QtM-vU-Sbj"/>
+ <constraint firstItem="Fv2-LT-eNm" firstAttribute="leading" secondItem="IEY-Jd-Yi1" secondAttribute="leading" type="default" id="TUM-E2-4c3"/>
+ <constraint firstItem="Fv2-LT-eNm" firstAttribute="top" secondItem="RL9-Rf-b7S" secondAttribute="top" constant="329" id="W0F-RH-kgq"/>
+ <constraint firstItem="7Aq-O2-MYr" firstAttribute="leading" secondItem="y8r-6g-CzC" secondAttribute="leading" type="default" id="Z2F-le-NBl"/>
+ <constraint firstItem="156-KK-cHv" firstAttribute="leading" secondItem="IEY-Jd-Yi1" secondAttribute="trailing" constant="8" symbolic="YES" type="default" id="dDn-cY-pb3"/>
+ <constraint firstItem="y8r-6g-CzC" firstAttribute="top" secondItem="RL9-Rf-b7S" secondAttribute="top" constant="76" id="dha-cI-42U"/>
+ <constraint firstItem="156-KK-cHv" firstAttribute="trailing" secondItem="sWb-wa-6qu" secondAttribute="trailing" type="default" id="eat-Zg-2zi"/>
+ <constraint firstItem="3rW-ET-vQX" firstAttribute="top" secondItem="RL9-Rf-b7S" secondAttribute="top" constant="126" id="esf-i5-zLM"/>
+ <constraint firstItem="sWb-wa-6qu" firstAttribute="top" secondItem="LRp-55-gt6" secondAttribute="bottom" constant="8" symbolic="YES" type="default" id="fbt-HC-gtU"/>
+ <constraint firstItem="7Aq-O2-MYr" firstAttribute="leading" secondItem="LRp-55-gt6" secondAttribute="leading" type="default" id="hYg-wi-Bzf"/>
+ <constraint firstItem="Fv2-LT-eNm" firstAttribute="leading" secondItem="sWb-wa-6qu" secondAttribute="leading" type="default" id="lar-OL-1Qu"/>
+ <constraint firstItem="LRp-55-gt6" firstAttribute="top" secondItem="RL9-Rf-b7S" secondAttribute="top" constant="263" id="wdc-Kf-47Y"/>
+ <constraint firstItem="t1Z-Hl-UZu" firstAttribute="trailing" secondItem="156-KK-cHv" secondAttribute="trailing" type="default" id="xY4-eH-g4i"/>
</constraints>
<simulatedOrientationMetrics key="simulatedOrientationMetrics" orientation="landscapeRight"/>
</view>
@@ -355,7 +353,7 @@ If you are a user of an openBIS server, plese enter the URL and your login detai
<autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
<color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
<simulatedOrientationMetrics key="simulatedOrientationMetrics" orientation="landscapeRight"/>
- <searchBar key="tableHeaderView" contentMode="redraw" placeholder="Search / Filter" id="SNF-vi-vRB">
+ <searchBar key="tableHeaderView" contentMode="redraw" text="" placeholder="Search / Filter" id="SNF-vi-vRB">
<rect key="frame" x="0.0" y="0.0" width="320" height="44"/>
<autoresizingMask key="autoresizingMask" widthSizable="YES" flexibleMaxY="YES"/>
<textInputTraits key="textInputTraits"/>
@@ -466,55 +464,70 @@ If you are a user of an openBIS server, plese enter the URL and your login detai
</objects>
<point key="canvasLocation" x="-366" y="248"/>
</scene>
+ <!--Barcode View Controller - Barcode Reader-->
+ <scene sceneID="ojK-61-GW8">
+ <objects>
+ <viewController storyboardIdentifier="Barcode" title="Barcode Reader" id="m5H-hb-BWc" customClass="CISDOBBarcodeViewController" sceneMemberID="viewController">
+ <view key="view" contentMode="scaleToFill" id="yix-wn-HfT">
+ <rect key="frame" x="0.0" y="20" width="1024" height="748"/>
+ <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMaxY="YES"/>
+ <subviews>
+ <navigationBar contentMode="scaleToFill" translatesAutoresizingMaskIntoConstraints="NO" id="wRF-uy-Ag3">
+ <items>
+ <navigationItem title="Barcode Reader" id="nCs-SH-94O">
+ <barButtonItem key="leftBarButtonItem" title="Back" id="Thn-OB-Ryg">
+ <connections>
+ <action selector="dismissModalViewController" destination="m5H-hb-BWc" id="qJi-4C-s7I"/>
+ </connections>
+ </barButtonItem>
+ </navigationItem>
+ </items>
+ </navigationBar>
+ <label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" text="Hold up to a barcode to scan" textAlignment="center" lineBreakMode="tailTruncation" numberOfLines="10" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" preferredMaxLayoutWidth="367" translatesAutoresizingMaskIntoConstraints="NO" id="6wU-An-596">
+ <constraints>
+ <constraint firstAttribute="width" constant="367" id="Mgw-ab-X16"/>
+ <constraint firstAttribute="height" constant="134" id="yT0-bZ-zpH"/>
+ </constraints>
+ <fontDescription key="fontDescription" type="system" pointSize="16"/>
+ <color key="textColor" red="1" green="0.0" blue="0.0" alpha="1" colorSpace="calibratedRGB"/>
+ <nil key="highlightedColor"/>
+ </label>
+ <view userInteractionEnabled="NO" contentMode="center" horizontalHuggingPriority="1" verticalHuggingPriority="1" horizontalCompressionResistancePriority="1000" verticalCompressionResistancePriority="1000" translatesAutoresizingMaskIntoConstraints="NO" id="vFb-Tp-Uap">
+ <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
+ <accessibility key="accessibilityConfiguration">
+ <accessibilityTraits key="traits" none="YES" notEnabled="YES"/>
+ </accessibility>
+ <constraints>
+ <constraint firstAttribute="width" constant="360" type="user" id="AhB-w2-dO2"/>
+ <constraint firstAttribute="height" constant="360" type="user" id="zx2-gM-LXw"/>
+ </constraints>
+ </view>
+ </subviews>
+ <color key="backgroundColor" cocoaTouchSystemColor="darkTextColor"/>
+ <constraints>
+ <constraint firstAttribute="centerX" secondItem="vFb-Tp-Uap" secondAttribute="centerX" type="user" id="Eeb-R7-DTj"/>
+ <constraint firstAttribute="centerY" secondItem="vFb-Tp-Uap" secondAttribute="centerY" type="user" id="Iz9-PT-7DJ"/>
+ <constraint firstItem="6wU-An-596" firstAttribute="centerX" secondItem="wRF-uy-Ag3" secondAttribute="centerX" type="user" id="LUG-x8-d0q"/>
+ <constraint firstItem="vFb-Tp-Uap" firstAttribute="top" secondItem="6wU-An-596" secondAttribute="bottom" constant="8" symbolic="YES" type="user" id="RxQ-JG-e8a"/>
+ <constraint firstItem="wRF-uy-Ag3" firstAttribute="trailing" secondItem="yix-wn-HfT" secondAttribute="trailing" type="user" id="T3M-Yb-4yG"/>
+ <constraint firstItem="wRF-uy-Ag3" firstAttribute="leading" secondItem="yix-wn-HfT" secondAttribute="leading" type="user" id="dAA-nq-FWn"/>
+ <constraint firstItem="wRF-uy-Ag3" firstAttribute="top" secondItem="yix-wn-HfT" secondAttribute="top" type="default" id="qFw-C2-feX"/>
+ </constraints>
+ <simulatedOrientationMetrics key="simulatedOrientationMetrics" orientation="landscapeRight"/>
+ </view>
+ <connections>
+ <outlet property="cameraView" destination="vFb-Tp-Uap" id="u7B-v1-i9E"/>
+ <outlet property="decodedLabel" destination="6wU-An-596" id="tZ6-5s-Dju"/>
+ </connections>
+ </viewController>
+ <placeholder placeholderIdentifier="IBFirstResponder" id="3mU-0u-NJI" userLabel="First Responder" sceneMemberID="firstResponder"/>
+ </objects>
+ <point key="canvasLocation" x="1516" y="928"/>
+ </scene>
</scenes>
<resources>
<image name="Zoom-small.png" width="32" height="32"/>
</resources>
- <classes>
- <class className="CISDOBDetailViewController" superclassName="UIViewController">
- <source key="sourceIdentifier" type="project" relativePath="./Classes/CISDOBDetailViewController.h"/>
- <relationships>
- <relationship kind="action" name="goOnline:"/>
- <relationship kind="action" name="refreshFromServer:"/>
- <relationship kind="outlet" name="goOnlineButton" candidateClass="UIBarButtonItem"/>
- <relationship kind="outlet" name="identifierLabel" candidateClass="UILabel"/>
- <relationship kind="outlet" name="propertiesTableView" candidateClass="UITableView"/>
- <relationship kind="outlet" name="refreshButton" candidateClass="UIBarButtonItem"/>
- <relationship kind="outlet" name="statusLabel" candidateClass="UILabel"/>
- <relationship kind="outlet" name="summaryHeaderLabel" candidateClass="UILabel"/>
- <relationship kind="outlet" name="summaryLabel" candidateClass="UILabel"/>
- <relationship kind="outlet" name="webView" candidateClass="UIWebView"/>
- </relationships>
- </class>
- <class className="CISDOBImageViewPopoverController" superclassName="UIViewController">
- <source key="sourceIdentifier" type="project" relativePath="./Classes/CISDOBImageViewPopoverController.h"/>
- <relationships>
- <relationship kind="outlet" name="webView" candidateClass="UIWebView"/>
- </relationships>
- </class>
- <class className="CISDOBLoginViewController" superclassName="UIViewController">
- <source key="sourceIdentifier" type="project" relativePath="./Classes/CISDOBLoginViewController.h"/>
- <relationships>
- <relationship kind="action" name="demoClicked:"/>
- <relationship kind="action" name="loginClicked:"/>
- <relationship kind="outlet" name="errorLabel" candidateClass="UILabel"/>
- <relationship kind="outlet" name="passwordTextField" candidateClass="UITextField"/>
- <relationship kind="outlet" name="urlTextField" candidateClass="UITextField"/>
- <relationship kind="outlet" name="usernameTextField" candidateClass="UITextField"/>
- </relationships>
- </class>
- <class className="CISDOBMasterViewController" superclassName="UITableViewController">
- <source key="sourceIdentifier" type="project" relativePath="./Classes/CISDOBMasterViewController.h"/>
- <relationships>
- <relationship kind="action" name="refreshFromServer:"/>
- <relationship kind="outlet" name="activityIndicator" candidateClass="UIActivityIndicatorView"/>
- <relationship kind="outlet" name="browseTableView" candidateClass="UITableView"/>
- </relationships>
- </class>
- <class className="NSLayoutConstraint" superclassName="NSObject">
- <source key="sourceIdentifier" type="project" relativePath="./Classes/NSLayoutConstraint.h"/>
- </class>
- </classes>
<simulatedMetricsContainer key="defaultSimulatedMetrics">
<simulatedStatusBarMetrics key="statusBar" statusBarStyle="blackTranslucent"/>
<simulatedOrientationMetrics key="orientation"/>
diff --git a/openbis-ipad/source/objc/openBIS/openBIS/openBIS-Prefix.pch b/openbis-ipad/source/objc/openBIS/openBIS/openBIS-Prefix.pch
index e78fdc300be0677e556a56223039c88645bda15d..5dc9504e2612f5ee2182cf23deed458635443290 100644
--- a/openbis-ipad/source/objc/openBIS/openBIS/openBIS-Prefix.pch
+++ b/openbis-ipad/source/objc/openBIS/openBIS/openBIS-Prefix.pch
@@ -12,4 +12,5 @@
#import <UIKit/UIKit.h>
#import <Foundation/Foundation.h>
#import <CoreData/CoreData.h>
+ #import "ZXingObjC.h"
#endif