dmtxencodec40textx12.c

Go to the documentation of this file.

 
#include <assert.h>
 
#include "dmtx.h"
#include "dmtxstatic.h"
 
#undef CHKERR
#define CHKERR                                      \
    {                                               \
        if (stream->status != DmtxStatusEncoding) { \
            return;                                 \
        }                                           \
    }
 
#undef CHKSIZE
#define CHKSIZE                                          \
    {                                                    \
        if (sizeIdx == DmtxUndefined) {                  \
            streamMarkInvalid(stream, DmtxErrorUnknown); \
            return;                                      \
        }                                                \
    }
 
#undef CHKPASS
#define CHKPASS                                        \
    {                                                  \
        if (passFail == DmtxFail) {                    \
            streamMarkFatal(stream, DmtxErrorUnknown); \
            return;                                    \
        }                                              \
    }
 
#undef RETURN_IF_FAIL
#define RETURN_IF_FAIL             \
    {                              \
        if (*passFail == DmtxFail) \
            return;                \
    }
 
static void encodeNextChunkCTX(DmtxEncodeStream *stream, int sizeIdxRequest)
{
    int i;
    DmtxPassFail passFail;
    DmtxByte inputValue;
    DmtxByte valueListStorage[6];
    DmtxByteList valueList = dmtxByteListBuild(valueListStorage, sizeof(valueListStorage));
 
    while (streamInputHasNext(stream)) {
        if (stream->currentScheme == DmtxSchemeX12) {
            /* Check for FNC1 character */
            inputValue = streamInputPeekNext(stream);
            CHKERR;
            if (stream->fnc1 != DmtxUndefined && (int)inputValue == stream->fnc1) {
                /* X12 does not allow partial blocks, resend last 1 or 2 as ASCII */
                encodeChangeScheme(stream, DmtxSchemeAscii, DmtxUnlatchExplicit);
                CHKERR;
                for (i = 0; i < valueList.length % 3; i++) {
                    streamInputAdvancePrev(stream);
                }
                CHKERR;
 
                while (i) {
                    inputValue = streamInputAdvanceNext(stream);
                    CHKERR;
                    appendValueAscii(stream, inputValue + 1);
                    CHKERR;
                    i--;
                }
 
                streamInputAdvanceNext(stream);
                CHKERR;
                appendValueAscii(stream, DmtxValueFNC1);
                CHKERR;
                return;
            }
        }
        inputValue = streamInputAdvanceNext(stream);
        CHKERR;
 
        /* Expand next input value into up to 4 CTX values and add to valueList */
        pushCTXValues(&valueList, inputValue, stream->currentScheme, &passFail, stream->fnc1);
        if (passFail == DmtxFail) {
            /* XXX Perhaps pushCTXValues should return this error code */
            streamMarkInvalid(stream, DmtxErrorUnsupportedCharacter);
            return;
        }
 
        /* If there at least 3 CTX values available encode them to output */
        while (valueList.length >= 3) {
            appendValuesCTX(stream, &valueList);
            CHKERR;
            shiftValueListBy3(&valueList, &passFail);
            CHKPASS;
        }
 
        /* Finished on byte boundary -- done with current chunk */
        if (valueList.length == 0) {
            break;
        }
    }
 
    /*
     * Special case: If all input values have been consumed and 1 or 2 unwritten
     * C40/Text/X12 values remain, finish encoding the symbol according to the
     * established end-of-symbol conditions.
     */
    if (!streamInputHasNext(stream) && valueList.length > 0) {
        if (stream->currentScheme == DmtxSchemeX12) {
            completePartialX12(stream, &valueList, sizeIdxRequest);
            CHKERR;
        } else {
            completePartialC40Text(stream, &valueList, sizeIdxRequest);
            CHKERR;
        }
    }
}
 
static void appendValuesCTX(DmtxEncodeStream *stream, DmtxByteList *valueList)
{
    int pairValue;
    DmtxByte cw0, cw1;
 
    if (!isCTX(stream->currentScheme)) {
        streamMarkFatal(stream, DmtxErrorUnexpectedScheme);
        return;
    }
 
    if (valueList->length < 3) {
        streamMarkFatal(stream, DmtxErrorIncompleteValueList);
        return;
    }
 
    /* Build codewords from computed value */
    pairValue = (1600 * valueList->b[0]) + (40 * valueList->b[1]) + valueList->b[2] + 1;
    cw0 = pairValue / 256;
    cw1 = pairValue % 256;
 
    /* Append 2 codewords */
    streamOutputChainAppend(stream, cw0);
    CHKERR;
    streamOutputChainAppend(stream, cw1);
    CHKERR;
 
    /* Update count for 3 encoded values */
    stream->outputChainValueCount += 3;
}
 
static void appendUnlatchCTX(DmtxEncodeStream *stream)
{
    if (!isCTX(stream->currentScheme)) {
        streamMarkFatal(stream, DmtxErrorUnexpectedScheme);
        return;
    }
 
    /* Verify we are on byte boundary */
    if (stream->outputChainValueCount % 3 != 0) {
        streamMarkInvalid(stream, DmtxErrorNotOnByteBoundary);
        return;
    }
 
    streamOutputChainAppend(stream, DmtxValueCTXUnlatch);
    CHKERR;
 
    stream->outputChainValueCount++;
}
 
static void completeIfDoneCTX(DmtxEncodeStream *stream, int sizeIdxRequest)
{
    int sizeIdx;
    int symbolRemaining;
 
    if (stream->status == DmtxStatusComplete) {
        return;
    }
 
    if (!streamInputHasNext(stream)) {
        sizeIdx = findSymbolSize(stream->output->length, sizeIdxRequest);
        CHKSIZE;
        symbolRemaining = getRemainingSymbolCapacity(stream->output->length, sizeIdx);
 
        if (symbolRemaining > 0) {
            encodeChangeScheme(stream, DmtxSchemeAscii, DmtxUnlatchExplicit);
            CHKERR;
            padRemainingInAscii(stream, sizeIdx);
        }
 
        streamMarkComplete(stream, sizeIdx);
    }
}
 
static void completePartialC40Text(DmtxEncodeStream *stream, DmtxByteList *valueList, int sizeIdxRequest)
{
    int i;
    int sizeIdx1, sizeIdx2;
    int symbolRemaining1, symbolRemaining2;
    DmtxPassFail passFail;
    DmtxByte inputValue;
    DmtxByte outputTmpStorage[4];
    DmtxByteList outputTmp = dmtxByteListBuild(outputTmpStorage, sizeof(outputTmpStorage));
 
    if (stream->currentScheme != DmtxSchemeC40 && stream->currentScheme != DmtxSchemeText) {
        streamMarkFatal(stream, DmtxErrorUnexpectedScheme);
        return;
    }
 
    /* Should have exactly one or two input values left */
    DmtxAssert(valueList->length == 1 || valueList->length == 2);
 
    sizeIdx1 = findSymbolSize(stream->output->length + 1, sizeIdxRequest);
    sizeIdx2 = findSymbolSize(stream->output->length + 2, sizeIdxRequest);
 
    symbolRemaining1 = getRemainingSymbolCapacity(stream->output->length, sizeIdx1);
    symbolRemaining2 = getRemainingSymbolCapacity(stream->output->length, sizeIdx2);
 
    if (valueList->length == 2 && symbolRemaining2 == 2) {
        /* End of symbol condition (b) -- Use Shift1 to pad final list value */
        dmtxByteListPush(valueList, DmtxValueCTXShift1, &passFail);
        CHKPASS;
        appendValuesCTX(stream, valueList);
        CHKERR;
        streamMarkComplete(stream, sizeIdx2);
    } else {
        /*
         * Rollback progress of previously consumed input value(s) since ASCII
         * encoder will be used to finish the symbol. 2 rollbacks are needed if
         * valueList holds 2 data words (i.e., not shifts or upper shifts).
         */
 
        streamInputAdvancePrev(stream);
        CHKERR;
        inputValue = streamInputPeekNext(stream);
        CHKERR;
 
        /* Test-encode most recently consumed input value to C40/Text/X12 */
        pushCTXValues(&outputTmp, inputValue, stream->currentScheme, &passFail, stream->fnc1);
        if (valueList->length == 2 && outputTmp.length == 1) {
            streamInputAdvancePrev(stream);
        }
        CHKERR;
 
        /* Re-use outputTmp to hold ASCII representation of 1-2 input values */
        /* XXX Refactor how the DmtxByteList is passed back here */
        outputTmp = encodeTmpRemainingInAscii(stream, outputTmpStorage, sizeof(outputTmpStorage), &passFail);
 
        if (passFail == DmtxFail) {
            streamMarkFatal(stream, DmtxErrorUnknown);
            return;
        }
 
        if (outputTmp.length == 1 && symbolRemaining1 == 1) {
            /* End of symbol condition (d) */
            encodeChangeScheme(stream, DmtxSchemeAscii, DmtxUnlatchImplicit);
            CHKERR;
            appendValueAscii(stream, outputTmp.b[0]);
            CHKERR;
 
            /* Register progress since encoding happened outside normal path */
            stream->inputNext = stream->input->length;
            streamMarkComplete(stream, sizeIdx1);
        } else {
            /* Finish in ASCII (c) */
            encodeChangeScheme(stream, DmtxSchemeAscii, DmtxUnlatchExplicit);
            CHKERR;
            for (i = 0; i < outputTmp.length; i++) {
                appendValueAscii(stream, outputTmp.b[i]);
            }
            CHKERR;
 
            sizeIdx1 = findSymbolSize(stream->output->length, sizeIdxRequest);
            padRemainingInAscii(stream, sizeIdx1);
 
            /* Register progress since encoding happened outside normal path */
            stream->inputNext = stream->input->length;
            streamMarkComplete(stream, sizeIdx1);
        }
    }
}
 
static void completePartialX12(DmtxEncodeStream *stream, DmtxByteList *valueList, int sizeIdxRequest)
{
    int i;
    int sizeIdx;
    int symbolRemaining;
    DmtxPassFail passFail;
    DmtxByte outputTmpStorage[2];
    DmtxByteList outputTmp;
 
    if (stream->currentScheme != DmtxSchemeX12) {
        streamMarkFatal(stream, DmtxErrorUnexpectedScheme);
        return;
    }
 
    /* Should have exactly one or two input values left */
    DmtxAssert(valueList->length == 1 || valueList->length == 2);
 
    /* Roll back input progress */
    for (i = 0; i < valueList->length; i++) {
        streamInputAdvancePrev(stream);
        CHKERR;
    }
 
    /* Encode up to 2 codewords to a temporary stream */
    outputTmp = encodeTmpRemainingInAscii(stream, outputTmpStorage, sizeof(outputTmpStorage), &passFail);
 
    sizeIdx = findSymbolSize(stream->output->length + 1, sizeIdxRequest);
    symbolRemaining = getRemainingSymbolCapacity(stream->output->length, sizeIdx);
 
    if (outputTmp.length == 1 && symbolRemaining == 1) {
        /* End of symbol condition (XXX) */
        encodeChangeScheme(stream, DmtxSchemeAscii, DmtxUnlatchImplicit);
        CHKERR;
        appendValueAscii(stream, outputTmp.b[0]);
        CHKERR;
 
        /* Register progress since encoding happened outside normal path */
        stream->inputNext = stream->input->length;
        streamMarkComplete(stream, sizeIdx);
    } else {
        /* Finish in ASCII (XXX) */
        encodeChangeScheme(stream, DmtxSchemeAscii, DmtxUnlatchExplicit);
        CHKERR;
        for (i = 0; i < outputTmp.length; i++) {
            appendValueAscii(stream, outputTmp.b[i]);
        }
        CHKERR;
 
        sizeIdx = findSymbolSize(stream->output->length, sizeIdxRequest);
        padRemainingInAscii(stream, sizeIdx);
 
        /* Register progress since encoding happened outside normal path */
        stream->inputNext = stream->input->length;
        streamMarkComplete(stream, sizeIdx);
    }
}
 
static DmtxBoolean partialX12ChunkRemains(DmtxEncodeStream *stream)
{
    DmtxEncodeStream streamTmp;
    DmtxByte inputValue;
    DmtxByte valueListStorage[6];
    DmtxByteList valueList = dmtxByteListBuild(valueListStorage, sizeof(valueListStorage));
    DmtxPassFail passFail;
 
    /* Create temporary copy of stream to track test input progress */
    streamTmp = *stream;
    streamTmp.currentScheme = DmtxSchemeX12;
    streamTmp.outputChainValueCount = 0;
    streamTmp.outputChainWordCount = 0;
    streamTmp.reason = NULL;
    streamTmp.sizeIdx = DmtxUndefined;
    streamTmp.status = DmtxStatusEncoding;
    streamTmp.output = NULL;
 
    while (streamInputHasNext(&streamTmp)) {
        inputValue = streamInputAdvanceNext(&streamTmp);
        if (stream->status != DmtxStatusEncoding) {
            streamMarkInvalid(stream, DmtxErrorUnknown);
            return DmtxFalse;
        }
 
        /* Expand next input value into up to 4 CTX values and add to valueList */
        pushCTXValues(&valueList, inputValue, streamTmp.currentScheme, &passFail, stream->fnc1);
        if (passFail == DmtxFail) {
            streamMarkInvalid(stream, DmtxErrorUnknown);
            return DmtxFalse;
        }
 
        /* Not a final partial chunk */
        if (valueList.length >= 3) {
            return DmtxFalse;
        }
    }
 
    return (valueList.length == 0) ? DmtxFalse : DmtxTrue;
}
 
static void pushCTXValues(DmtxByteList *valueList, DmtxByte inputValue, int targetScheme, DmtxPassFail *passFail,
                          int fnc1)
{
    DmtxAssert(valueList->length <= 2);
 
    /* Handle extended ASCII with Upper Shift character */
    if (inputValue > 127 && (fnc1 == DmtxUndefined || (int)inputValue != fnc1)) {
        if (targetScheme == DmtxSchemeX12) {
            *passFail = DmtxFail;
            return;
        } else {
            dmtxByteListPush(valueList, DmtxValueCTXShift2, passFail);
            RETURN_IF_FAIL;
            dmtxByteListPush(valueList, 30, passFail);
            RETURN_IF_FAIL;
            inputValue -= 128;
        }
    }
 
    /* Handle all other characters according to encodation scheme */
    if (targetScheme == DmtxSchemeX12) {
        if (inputValue == 13) {
            dmtxByteListPush(valueList, 0, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue == 42) {
            dmtxByteListPush(valueList, 1, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue == 62) {
            dmtxByteListPush(valueList, 2, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue == 32) {
            dmtxByteListPush(valueList, 3, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue >= 48 && inputValue <= 57) {
            dmtxByteListPush(valueList, inputValue - 44, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue >= 65 && inputValue <= 90) {
            dmtxByteListPush(valueList, inputValue - 51, passFail);
            RETURN_IF_FAIL;
        } else {
            *passFail = DmtxFail;
            return;
        }
    } else {
        /* targetScheme is C40 or Text */
 
        /* Check for FNC1 character */
        if (fnc1 != DmtxUndefined && (int)inputValue == fnc1) {
            dmtxByteListPush(valueList, DmtxValueCTXShift2, passFail);
            RETURN_IF_FAIL;
            dmtxByteListPush(valueList, 27, passFail);
            RETURN_IF_FAIL; /* C40 version of FNC1 */
        } else if (inputValue <= 31) {
            dmtxByteListPush(valueList, DmtxValueCTXShift1, passFail);
            RETURN_IF_FAIL;
            dmtxByteListPush(valueList, inputValue, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue == 32) {
            dmtxByteListPush(valueList, 3, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue <= 47) {
            dmtxByteListPush(valueList, DmtxValueCTXShift2, passFail);
            RETURN_IF_FAIL;
            dmtxByteListPush(valueList, inputValue - 33, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue <= 57) {
            dmtxByteListPush(valueList, inputValue - 44, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue <= 64) {
            dmtxByteListPush(valueList, DmtxValueCTXShift2, passFail);
            RETURN_IF_FAIL;
            dmtxByteListPush(valueList, inputValue - 43, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue <= 90 && targetScheme == DmtxSchemeC40) {
            dmtxByteListPush(valueList, inputValue - 51, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue <= 90 && targetScheme == DmtxSchemeText) {
            dmtxByteListPush(valueList, DmtxValueCTXShift3, passFail);
            RETURN_IF_FAIL;
            dmtxByteListPush(valueList, inputValue - 64, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue <= 95) {
            dmtxByteListPush(valueList, DmtxValueCTXShift2, passFail);
            RETURN_IF_FAIL;
            dmtxByteListPush(valueList, inputValue - 69, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue == 96 && targetScheme == DmtxSchemeText) {
            dmtxByteListPush(valueList, DmtxValueCTXShift3, passFail);
            RETURN_IF_FAIL;
            dmtxByteListPush(valueList, 0, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue <= 122 && targetScheme == DmtxSchemeText) {
            dmtxByteListPush(valueList, inputValue - 83, passFail);
            RETURN_IF_FAIL;
        } else if (inputValue <= 127) {
            dmtxByteListPush(valueList, DmtxValueCTXShift3, passFail);
            RETURN_IF_FAIL;
            dmtxByteListPush(valueList, inputValue - 96, passFail);
            RETURN_IF_FAIL;
        } else {
            *passFail = DmtxFail;
            return;
        }
    }
 
    *passFail = DmtxPass;
}
 
static DmtxBoolean isCTX(int scheme)
{
    DmtxBoolean isCTX;
 
    if (scheme == DmtxSchemeC40 || scheme == DmtxSchemeText || scheme == DmtxSchemeX12) {
        isCTX = DmtxTrue;
    } else {
        isCTX = DmtxFalse;
    }
 
    return isCTX;
}
 
static void shiftValueListBy3(DmtxByteList *list, DmtxPassFail *passFail)
{
    int i;
 
    /* Shift values */
    for (i = 0; i < list->length - 3; i++) {
        list->b[i] = list->b[i + 3];
    }
 
    /* Shorten list by 3 (or less) */
    for (i = 0; i < 3; i++) {
        dmtxByteListPop(list, passFail);
        if (*passFail == DmtxFail) {
            return;
        }
 
        if (list->length == 0) {
            break;
        }
    }
 
    *passFail = DmtxPass;
}