CPipeFindSync.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "CPipeFindSync.h"

AxPipe::Stock::CPipeFindSync *
AxPipe::Stock::CPipeFindSync::Init(const void *p, size_t cb, bool fInvert, int iSkipTo) {
    m_pPattern = (const unsigned char *)p;
    m_cbPattern = cb;
    m_iNext = 0;
    if (m_fSkipAfterSync = ((m_iSkipTo = iSkipTo) < 0)) {
        m_iSkipTo = -m_iSkipTo;
    }
    m_iInvert = fInvert ? 0xff : 0;

    return this;
}
void AxPipe::Stock::CPipeFindSync::PumpBuf(size_t cbBuf) {
    if (cbBuf) {
        CSeg *pBufSeg = new CSeg(m_pPattern, cbBuf);
        for (size_t i = 0; i < cbBuf; i++) {
            pBufSeg->PtrWr()[i] ^= m_iInvert;
        }
        Pump(pBufSeg);
        pBufSeg = NULL;
    }
}

void AxPipe::Stock::CPipeFindSync::Out(AxPipe::CSeg *pSeg) {
    // Already matched the right number of patterns?
    if (!m_iSkipTo) {
        if (m_fSkipAfterSync) {
            // Already skipping
            pSeg->Release();
        } else {
            // We've already matched the required number, so let's send it onwards
            Pump(pSeg);
        }
        return;
    }
    // Step one byte at a time, attempting to find a match. The pattern buffer
    // serves a dual purpose - to record previously seen, and matched, bytes
    // and of course to serve as the comparison to find matches. The idea is that
    // we do not need to store previous matched bytes, since they by definition
    // must be a part of the pattern - otherwise they should be output or skipped.
    // m_iNext keeps track of the next byte we want to match in the pattern.
    const unsigned char *pData = pSeg->PtrRd();
    size_t cbDataRemain = pSeg->Len();  // Can't be zero
    size_t iPrevBuf = m_iNext;          // Number of old bytes from previous segment(s)
    size_t iOutPrevBuf = 0;             // Number of old bytes not part of buffer after this seg

    // While more data to compare against the pattern
    while (cbDataRemain--) {
        // If we still have a pattern match
        if (*pData++ == (m_pPattern[m_iNext] ^ m_iInvert)) {
            m_iNext++;
            if (m_iNext == m_cbPattern) {
                // If we've matched the entire pattern - bingo!
                if (--m_iSkipTo) {
                    // Still not zero. Must match more patterns.
                    m_iNext = 0;
                } else {
                    // Now we've found the right number of syncs.
                    // Reduce the length so that data including and after this found sync
                    // is not part of the segment to pump. This is calculated by first reducing
                    // the length by cbDataRemain (these are the bytes after the sync).
                    // Then we either reduce by a whole sync length, or by the partial length
                    // we had to start with.
                    // cbDataRemain is only updated to the start of the matched sequence
                    if (m_fSkipAfterSync) {
                        // Pump what we've got so far, and start skipping....
                        Pump(pSeg->Len(pSeg->Len() - (cbDataRemain + (m_cbPattern - iPrevBuf))));
                    } else {
                        // Drop all up until the start of this sequence, then start...
                        PumpBuf(iPrevBuf);
                        Pump(pSeg->Drop(pSeg->Len() - (cbDataRemain + (m_cbPattern - iPrevBuf))));
                    }
                    return;
                }
            }
        } else {
            if (m_iNext) {
                for (size_t i = 0; i < m_iNext; i++) {
                    if (iPrevBuf) {
                        iPrevBuf--;
                        iOutPrevBuf++;
                    }
                    if (i && (memcmp(m_pPattern, &m_pPattern[i], m_iNext - i) == 0)) {
                        break;
                    }
                }
                m_iNext -= i;
                continue;
            }
        }
    }
    if (m_fSkipAfterSync) {
        // Pump 'i' bytes that were buffered, but no match.
        PumpBuf(iOutPrevBuf);

        // Pump the whole segment, except for newly buffered bytes, if any.
        Pump(pSeg->Len(pSeg->Len() - (m_iNext - iPrevBuf)));
    } else {
        // We're to skip before sync, and since we've exhausted this seg,
        // we just drop it.
        pSeg->Release();
    }
}

---