CPipeInflate.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "CPipeInflate.h"

// Can't use this for convenient notation below:
// using AxPipe::Stock::CPipeInflate;
// because the Doxygen get's confused.

namespace AxPipe {
    namespace Stock {
        CPipeInflate::CPipeInflate() {
            m_pOutSeg = NULL;
            m_cb = 0;
            ZeroMemory(&m_Zstream, sizeof m_Zstream);
        }

        CPipeInflate::~CPipeInflate() {
            if (m_pOutSeg) {
                m_pOutSeg->Release();
            }
        }

        bool
        CPipeInflate::OutOpen() {
            bool fReturn = CPipe::OutOpen();        // Open base first, like constructor
            m_cb = 0;                               // Total output bytes counter
            ZeroMemory(&m_Zstream, sizeof m_Zstream);
            m_Zstream.next_in = Z_NULL;             // Defer check to first call to inflate
            m_Zstream.zalloc = Z_NULL;              // Use default alloc()
            m_Zstream.zfree = Z_NULL;               // Use default free()

            if (inflateInit(&m_Zstream) != Z_OK) {
                SetError(ERROR_CODE_STOCK, _T("ZLIB initialization error"));
            }
            ASSCHK(m_pOutSeg == NULL, _T("CPipeInflate::OutOpen() [m_pOutSeg non-NULL]"));

            return fReturn;                         // Return the saved return code.
        }

        bool
        CPipeInflate::OutClose() {
            // This is a safety first measure, should not really be needed.
            if (m_pOutSeg) {
                m_pOutSeg->Release();
                m_pOutSeg = NULL;
            }
            return CPipe::OutClose();               // End by closing base, like destructor
        }

        void
        CPipeInflate::Out(AxPipe::CSeg *pSeg) {
            m_Zstream.next_in = (unsigned char *)pSeg->PtrRd();
            m_Zstream.avail_in = (UINT)pSeg->Len();
            while (true) {
                if (!m_pOutSeg) {
                    // Allocate the output segment, and point the Zstream structure to it
                    m_pOutSeg = GetSeg(m_Zstream.avail_in + m_Zstream.avail_in);
                    ASSPTR(m_pOutSeg);
                    m_Zstream.avail_out = (UINT)m_pOutSeg->Size();
                    m_Zstream.next_out = m_pOutSeg->PtrWr();
                }
                int iZerror = inflate(&m_Zstream, 0);
                m_cb += m_Zstream.total_out;        // Update total output bytes ctr
                m_Zstream.total_out = 0;            // can't use total_out since it's 32-bit
                switch (iZerror) {
                case Z_OK:
                    // ZLib guarantees to either use all input or all output buffer.
                    if (m_Zstream.avail_in && m_Zstream.avail_out) {
                        SetError(ERROR_CODE_DERIVED, _T("ZLIB sequence error"));
                    }
                    if (!m_Zstream.avail_out) {
                        Pump(m_pOutSeg);
                        m_pOutSeg = NULL;
                    }
                    if (m_Zstream.avail_in) {
                        continue;                   // More data to inflate!
                    }
                    // If we have no more input, we need to return and wait for more
                    break;
                case Z_STREAM_END:
                    m_pOutSeg->Len(m_pOutSeg->Size() - m_Zstream.avail_out);
                    Pump(m_pOutSeg);
                    m_pOutSeg = NULL;
                    if (m_Zstream.avail_in) {
                        SetError(ERROR_CODE_STOCK, _T("Trailing data"));
                    }
                    break;
                default:
                    SetError(ERROR_CODE_STOCK, _T("ZLIB inflate error"));
                    break;
                }
                break;
            }
            pSeg->Release();
        }
    }
}

---