decode-I25.c

Go to the documentation of this file.

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

decode-i25.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-i25.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-i25.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 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 DecodeI25(struct BC_STRUCT *p, unsigned char length);
static unsigned short FindStart(struct BC_STRUCT *p, unsigned char length);
static unsigned short FindStop(struct BC_STRUCT *p, unsigned char length);
static unsigned short Decode(struct BC_STRUCT *p, unsigned char length, unsigned short reference);
static unsigned short DecodeChar(struct BC_STRUCT *p, unsigned char decode_pair[2], unsigned short reference);

/*----------------------------------------------------------------------------*/
unsigned short 
DecodeI25(struct BC_STRUCT *p, unsigned char length)
{
    // Check the input length
    if(length == 0 || length > MAX_DECODE){
        return 0;
    }

    // Leave if insufficent number of samples
    if(p->sample_ctr < ((length * 5) + 7)){
        return 0;
    }

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

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

    // Unable to decode
    return NO_DECODE;
}

/*----------------------------------------------------------------------------*/
// Main decode loop
// Returns OK_DECODE if decode successful
//         NO_DECODE if unable to decode
static 
unsigned short 
Decode(struct BC_STRUCT *p, unsigned char length, unsigned short reference)
{
unsigned char DecodePair[2];

    // Initially, no decode count
    p->decode_count = 0;

    // Try for a decode
    while((DecodeChar(p, &DecodePair[0], reference) != NO_CODE)){

        // Only decode up to the specified number of digits
        if(p->decode_count >= MAX_DECODE){
            return NO_DECODE;
        }
        // Store the character pair
        p->decode_buffer[p->decode_count++] = DecodePair[0];
        p->decode_buffer[p->decode_count++] = DecodePair[1];

        // Specified number of characters decoded, stop code must be next
        if(p->decode_count == length){
            if(FindStop(p, length)){

                // 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) > *(p->sample_ptr - 1) * QUIET_MULTIPLIER){
                    return OK_DECODE;
                }

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

    // Unable to decode
    return NO_DECODE;
}

/*----------------------------------------------------------------------------*/
// Generate ASCII character from bar/space pattern
// Returns OK_CODE if successful with digit pair in DecodePair[2]
//         NO_CODE if unable to decode
static 
unsigned short 
DecodeChar(struct BC_STRUCT *p, unsigned char decode_pair[2], unsigned short reference)
{
static const unsigned char DecodeTable[32] = {
    0,0,0,'3',0,'5','6',0,0,'8','9',0,'0',0,0,0,0,'1','2',0,'4',0,0,0,'7',0,0,0,0,0,0,0
};

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

    TempPtr = p->sample_ptr;
    BarThreshold = SpaceThreshold = 0;

    // Standard combined bar/space threshold
    if(reference == STANDARD){
        for(c = 0; c < 10; c++){
            if((*TempPtr) == NO_SAMPLE){
                return NO_CODE;
            }
            BarThreshold += *TempPtr++;
        }
        BarThreshold *= .1; //(7/64);
        SpaceThreshold = BarThreshold;
    }

    // Separate bar/space threshold
    if(reference == SPECIAL){
        for(c = 0; c < 5; c++){
            if((*TempPtr) == NO_SAMPLE){
                return NO_CODE;
            }

            BarThreshold += *TempPtr++;
            if((*TempPtr) == NO_SAMPLE){
                return NO_CODE;
            }
            SpaceThreshold += *TempPtr++;
        }
        BarThreshold *= .2;   //(7/32);
        SpaceThreshold *= .2; //(7/32);
    }

    // Invalid reference specifier
    else{
        return NO_CODE;
    }

    // Initial bar/space pattern
    Bars = 0;
    Spaces = 0;

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

        // Do the bars
        if(*p->sample_ptr++ > BarThreshold){
            Bars |= 0x20;
        }
        Bars >>= 1;

        // Do the spaces
        if(*p->sample_ptr++ > SpaceThreshold){
            Spaces |= 0x20;
        }
        Spaces >>= 1;
    }

    // Perform lookup to get the interleaved digit pair
    if(Bars > 31 || Spaces > 31){
        return NO_CODE;
    }

    // Store MSD if code is valid
    if((decode_pair[0] = DecodeTable[Bars]) == NO_CODE){
        return NO_CODE;
    }

    // Store LSD if code is valid
    if((decode_pair[1] = DecodeTable[Spaces]) == NO_CODE){
        return NO_CODE;
    }

    // Digit pair successfully decoded
    else{
        return OK_CODE;
    }
}

/*----------------------------------------------------------------------------*/
// Find start code - four narrow elements
// Returns OK_CODE if found
//         NO_CODE if not found
static 
unsigned short 
FindStart(struct BC_STRUCT *p, unsigned char length)
{
unsigned short Found;
unsigned short AttemptCount, c;
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 >= ((length * 5) + 7)){

        // Confirm 4 samples
        for(c = 0; c < 4; c++){
            if((TempPtr[c]) == NO_SAMPLE){
                return NO_CODE;
            }
        }
        Found = 1;

        // Verify the start pattern as 4 narrows
        for(c = 1; c < 4; c++){
            if(TempPtr[c] < (TempPtr[c + 1] * .25) ||
               TempPtr[c] > (TempPtr[c + 1] * 1.75)){
                Found = 0;
            }
        }

        // If start code was found verify the leading quiet zone
        if(Found){

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

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

            // Not a valid start code
            else{
                Found = NO_CODE;
            }
        }

        // If start code not found prepare next loop iteraction
        if(!Found){
            AttemptCount--;
            TempCount--;
            TempPtr++;
            p->sample_ptr = TempPtr;
        }
    }

    // Unable to find start code
    return NO_CODE;
}

/*----------------------------------------------------------------------------*/
// Find stop code - One wide and two narrow elements
// Returns OK_CODE if found
//         NO_CODE if not found
static 
unsigned short 
FindStop(struct BC_STRUCT *p, unsigned char length)
{
unsigned char c;
unsigned short TempCount;
unsigned short *TempPtr;

    TempCount = p->sample_ctr;
    TempPtr = p->sample_ptr;

    while(TempCount >= ((length * 5) + 7)){

        // Confirm 3 samples
        for(c = 0; c < 3; c++){
            if((TempPtr[c]) == NO_SAMPLE){
                return NO_CODE;
            }
        }

        // 1st element should be wide
        if(TempPtr[0] < TempPtr[1] * 1.75){
             return NO_CODE;
        }

        // 2nd should be narrow
        if(TempPtr[1] < TempPtr[2] *.25 || TempPtr[1] > TempPtr[2] * 1.75){
            return NO_CODE;
        }

        // Stop code found
        else{
            p->sample_ptr += 3;
            return OK_CODE;
        }
    }

    // Not found
    return NO_CODE;
}

Download Source Code