decode-39.c

Go to the documentation of this file.

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

decode-39.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-39.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-39.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"

/*----------------------------------------------------------------------------*/
// 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 StartCode '*'

#define StopCode '*'

#define QUIET_MULTIPLIER 10

/*----------------------------------------------------------------------------*/
// Standard: Calculate reference using combined bars and spaces
// Special: Calculate reference separately for bars and spaces
enum{STANDARD, SPECIAL};

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

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

    // Standard reference
    p->sample_ptr = &p->sample_buffer[0];
    if(FindStart(p, STANDARD) != NO_CODE){
        if(Decode(p, STANDARD) != NO_DECODE){
            return p->decode_count;
        }
    }

    // Special reference
    p->sample_ptr = &p->sample_buffer[0];
    if(FindStart(p, SPECIAL) != NO_CODE){
        if(Decode(p, SPECIAL) != 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;

    // Initial decode count
    p->decode_count = 0;

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

        // Process the stop code
        if(DecodeByte == StopCode){

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

            // Decode length of 0 is invalid
            if(p->decode_count == 0){
                return NO_DECODE;
            }

            // Terminate the decode buffer
            p->decode_buffer[p->decode_count] = NUL;

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

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

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

        // Continue buffering
        else{
            p->decode_buffer[p->decode_count++] = DecodeByte;
        }
    }

    // Unable to decode
    return NO_DECODE;
}

/*----------------------------------------------------------------------------*/
// Generate ASCII character from bar/space pattern
// Returns NoCode is unable to decode, else decoded ASCII code
static 
unsigned short 
DecodeChar(struct BC_STRUCT *p, reference)
{
static const unsigned char BarTable[4][25] = {
    {0,0,0,'7',0,'4','0',0,0,'2','9',0,'6',0,0,0,0,'1','8',0,'5',0,0,0,'3'},
    {0,0,0,'G',0,'D','J',0,0,'B','I',0,'F',0,0,0,0,'A','H',0,'E',0,0,0,'C'},
    {0,0,0,'Q',0,'N','T',0,0,'L','S',0,'P',0,0,0,0,'K','R',0,'O',0,0,0,'M'},
    {0,0,0,'-',0,'X','*',0,0,'V',' ',0,'Z',0,0,0,0,'U','.',0,'Y',0,0,0,'W'}
};

unsigned short *TempPtr;
unsigned int BarThreshold, SpaceThreshold;
unsigned char Bars;
unsigned char Spaces;
unsigned short c;

    // Generate the reference threshold
    TempPtr = p->sample_ptr;
    BarThreshold = 0;
    SpaceThreshold = 0;

    // Calculate the character width
    for(c = 0; c < 9; c++){

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

        // Standard combined bar/space threshold
        if(reference == STANDARD){
            BarThreshold += *TempPtr++;
        }

        // Separate bar/space threshold
        else if(reference == SPECIAL){

            // Spaces
            if(c & 1){
                SpaceThreshold += *TempPtr++;
            }

            // Bars
            else{
                BarThreshold += *TempPtr++;
            }
        }

        // Invalid reference specifier
        else{
            return NO_CODE;
        }
    }

    if(reference == STANDARD){
        BarThreshold /= 8;
        SpaceThreshold = BarThreshold;
    }

    else if(reference == SPECIAL){
        BarThreshold /= 6;
        SpaceThreshold /= 5;
    }

    // Invalid reference specifier
    else{
        return NO_CODE;
    }

    // Build binary bar/space image
    Bars = 0;
    Spaces = 0;
    for(c = 0; c < 4; c++){

        if((long)*p->sample_ptr > BarThreshold){
            Bars |= 1;
        }
        p->sample_ptr++;
        Bars <<= 1;

        if((long)*p->sample_ptr > SpaceThreshold){
            Spaces |= 1;
        }
        p->sample_ptr++;
        Spaces <<= 1;
    }

    if((long)*p->sample_ptr++ > BarThreshold){
        Bars |= 1;
    }
    Spaces >>= 1;

    // Now do lookup based on bar/space combination
    if(Bars > 24){
        return NO_CODE;
    }

    switch(Spaces){
        case 0x4: // 0100b
        return BarTable[0][Bars];

        case 0x2: // 0010b
        return BarTable[1][Bars];

        case 0x1: // 0001b
        return BarTable[2][Bars];

        case 0x8: // 1000b
        return BarTable[3][Bars];

        case 0xe: // 1110b
        if(Bars == 0){
            return '$';
        }
        break;

        case 0xd: // 1101b
        if(Bars == 0){
            return '/';
        }
        break;

        case 0xb: // 1011b
        if(Bars == 0){
            return '+';
        }
        break;

        case 0x7: // 0111b
        if(Bars == 0){
            return '%';
        }
        break;

        default: // Unable to decode
        return NO_CODE;
    }
    return NO_CODE;
}

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

    // Setup for 5 passes of start code search
    AttemptCount = 5;
    TempCount = p->sample_ctr;
    TempPtr = p->sample_ptr;

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

        // If start code was found verify the leading quiet zone
        if(DecodeChar(p, reference) == StartCode){

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

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

        // If start code not found prepare next loop iteraction
        AttemptCount--;
        TempCount--;
        TempPtr++;
        p->sample_ptr = TempPtr;
    }

    // Not found
    return NO_CODE;
}

Download Source Code