decode_codabar.c

Go to the documentation of this file.

/*
Codabar decoding - Copyright (C) 2009 John Dybowski - All rights reserved
V1.0.0

decode-codabar.c is part of the ESE Auto-ID software distribution.

Redistribution and use in source and binary forms, with or without modification, is
permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of
conditions and the following disclaimer. Redistributions in binary form must reproduce
the above copyright notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

The end-user documentation included with the redistribution, if any, must include the
following acknowledgment: 'This product includes software developed by John Dybowski.'
Alternately, this acknowledgment may appear in the software itself, if and wherever such
third-party acknowledgments normally appear.

The name 'John Dybowski' must not be used to endorse or promote products derived from
this software without prior written permission.

decode-codabar.c is free software; you can redistribute it and/or modify it under the terms
of the GNU General Public License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version. See the GNU General
Public License for more details.

You should have received a copy of the GNU General Public License along with this software;
if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
MA 02111-1307 USA

A special exception to the GPL can be applied should you wish to distribute a combined work
that includes decode-codabar.c, without being obliged to provide the source code for any proprietary
components. See the licensing section at http://embeddedsoftwareengineering.com/license.html 
for full details of how and when the exception can be applied.

THIS SOFTWARE IS PROVIDED 'AS IS' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JOHN DYBOWSKI OR ITS CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include "reader.h"

/*----------------------------------------------------------------------------*/
#define STORE_SS_CODES

/*----------------------------------------------------------------------------*/
// Constants

#define NO_SAMPLE NUL

#define NO_CODE 0

#define OK_CODE 1

#define NO_DECODE 0

#define OK_DECODE 1

#define MAX_DECODE 32

#define StartCode1 'A'

#define StartCode2 'B'

#define StartCode3 'C'

#define StartCode4 'D'

#define StopCode1  'A'

#define StopCode2  'B'

#define StopCode3  'C'

#define StopCode4  'D'

#define QUIET_MULTIPLIER 10

/*----------------------------------------------------------------------------*/
// Function prototypes
unsigned short DecodeCodabar(struct BC_STRUCT *p);
static unsigned short FindStart(struct BC_STRUCT *p);
static unsigned short Decode(struct BC_STRUCT *p);
static unsigned short DecodeChar(struct BC_STRUCT *p, unsigned short *reference);

/*----------------------------------------------------------------------------*/
unsigned short 
DecodeCodabar(struct BC_STRUCT *p)
{
    // Minimum sample count
    if(p->sample_ctr < 21){
        return  0;
    }

    // Try to decode
    p->sample_ptr = &p->sample_buffer[0];
    if(FindStart(p) != NO_CODE){
        if(Decode(p) != NO_DECODE){
            return p->decode_count;
        }
    }

    // Unable to decode
    return 0;
}

/*----------------------------------------------------------------------------*/
// Main decode loop
// Returns OK_DECODE if decode successful
//         NO_DECODE if unable to decode
static 
unsigned short 
Decode(struct BC_STRUCT *p)
{
unsigned short reference;
unsigned char DecodeByte;

    // We're checking the inter-character gap for the end of data then
    // attempting to decode the next character.
    while((*p->sample_ptr++ != NO_SAMPLE) && ((DecodeByte = DecodeChar(p, &reference)) != NO_CODE)){

        // Check for one of the stop codes
        if(DecodeByte == StopCode1 || DecodeByte == StopCode2 ||
           DecodeByte == StopCode3 || DecodeByte == StopCode4){

            #ifdef STORE_SS_CODES
            // Decode only up to the maximum allowed decode length
            if(p->decode_count > MAX_DECODE-1){
                return NO_DECODE;
            }

            // Store the stop code
            p->decode_buffer[p->decode_count++] = DecodeByte;
            #endif 

            // Stop code found, terminate the decode buffer
            p->decode_buffer[p->decode_count] = NUL;

            // No more samples qualifies as a quiet zone
            if(*p->sample_ptr == NO_SAMPLE){
                return OK_DECODE;
            }

            // Following sample must meet quiet zone width
            else if(*(p->sample_ptr) > (reference * QUIET_MULTIPLIER)){
                return OK_DECODE;
            }

            // Unable to decode
            else{
                return NO_DECODE;
            }
        }

       // Decode only up to the maximum allowed decode length
        if(p->decode_count > MAX_DECODE-1){
            return NO_DECODE;
        }

        // Store the data character
        else{
            p->decode_buffer[p->decode_count++] = DecodeByte;
        }
    }

    // Unable to decode
    return NO_DECODE;
}

/*----------------------------------------------------------------------------*/
// Generate ASCII character from bar/space pattern
// Returns NO_CODE if unable to decode, else decoded ASCII code
static 
unsigned short 
DecodeChar(struct BC_STRUCT *p, unsigned short *reference)
{
unsigned short BarThreshold, SpaceThreshold;

static const struct key{
    unsigned char key;
    unsigned char value;
}
search_table[20] = {
     3,  '0',
     6,  '1',
     9,  '2',
    96,  '3',
    18,  '4',
    66,  '5',
    33,  '6',
    36,  '7',
    48,  '8',
    72,  '9',
    12,  '-',
    24,  '$',
    69,  ':',
    81,  '/',
    84,  '.',
    21,  '+',
    26,  'A',
    41,  'B',
    11,  'C',
    14,  'D',
};

unsigned short *TempPtr;
unsigned char BarSpace;
unsigned short WideBar, WideSpace;
unsigned short wide_bars;
unsigned short c;

    // Find the widest bar and widest space
    WideBar = 0;
    WideSpace = 0;
    TempPtr = p->sample_ptr;
    for(c = 0; c < 7; c++){

        // Leave if out of samples
        if((*TempPtr) == NO_SAMPLE){
            return NO_CODE;
        }

        // Process as space
        if(c & 1){
            if(*TempPtr > WideSpace){
                WideSpace = *TempPtr;
            }
        }

        // Process as bar
        else{
            if(*TempPtr > WideBar){
                WideBar = *TempPtr;
            }
        }
        ++TempPtr;
    }

    // Determine how many bars are wide
    wide_bars = 0;
    TempPtr = p->sample_ptr;
    BarThreshold = WideBar * .625;
    for(c = 0; c < 4; c++){
        if(*TempPtr > BarThreshold){
            ++wide_bars;
        }
        TempPtr += 2;
    }

    // One wide bar?
    if(wide_bars == 1){

        // Build binary bar/space image
        BarSpace = 0;
        SpaceThreshold = WideSpace * .625;
        for(c = 0; c < 3; c++){

            // Do the bar
            if(*p->sample_ptr++ > BarThreshold){
                BarSpace |= 1;
            }
            BarSpace <<= 1;

            // Do the space
            if(*p->sample_ptr++ > SpaceThreshold){
                BarSpace |= 1;
            }
            BarSpace <<= 1;
        }

        // One more bar
        if(*p->sample_ptr++ > BarThreshold){
            BarSpace |= 1;
        }

        // Now do the lookup based on bar/space combination
        for(c = 0; c < sizeof search_table / 2; c++){
            if(search_table[c].key == BarSpace){
                return search_table[c].value;
            }
        }
    }

    // Three wide bars?
    else if(wide_bars == 3){
        // Build binary bar/space image
        BarSpace = 0;
        SpaceThreshold = WideSpace * .375;
        for(c = 0; c < 3; c++){

            // Do the bar
            if(*p->sample_ptr++ > BarThreshold){
                BarSpace |= 1;
            }
            BarSpace <<= 1;

            // Do the space
            if(*p->sample_ptr++ < SpaceThreshold){
                BarSpace |= 0xfe;
            }
            BarSpace <<= 1;
        }

        // One more bar
        if(*p->sample_ptr++ > BarThreshold){
            BarSpace |= 1;
        }

        // Now do lookup based on bar/space combination
        for(c = 0; c < sizeof search_table / 2; c++){
            if(search_table[c].key == BarSpace){
                *reference = BarThreshold;
                return search_table[c].value;
            }
        }
    }

    // Unable to decode
    return NO_CODE;
}

/*----------------------------------------------------------------------------*/
// Find the start code
// Returns OK_CODE if found
//         NO_CODE if not found
static 
unsigned short 
FindStart(struct BC_STRUCT *p)
{
unsigned short AttemptCount;
unsigned short TempCount;
unsigned short *TempPtr;
unsigned short reference;
unsigned short c;

    // Five tries to find the start code
    TempCount = p->sample_ctr;
    AttemptCount = 5;
    TempPtr = p->sample_ptr;

    // Main start code search loop
    while(AttemptCount != 0 && TempCount >= 21){

        // Look for a valid start code
        c = DecodeChar(p, &reference);
        if(c == StartCode1 || c == StartCode2 ||
           c == StartCode3 || c == StartCode4){

            // Check the quiet zone
            p->decode_count = 0;

            // Store the start code
            #ifdef STORE_SS_CODES
            p->decode_buffer[p->decode_count++] = c;
            #endif

            // No preceeding samples qualifies as a quiet zone
            if(TempPtr == &p->sample_buffer[0]){
                return c;
            }

           // Preceeding sample must meet quiet zone width
            else if(*(TempPtr - 1) > (reference * QUIET_MULTIPLIER)){
                return NO_CODE;
            }
        }

        // Not found, prepare next loop iteraction
        AttemptCount--;
        TempCount--;
        TempPtr++;
        p->sample_ptr = TempPtr;
    }

    // Not found
    return NO_CODE;
}

Download Source Code