C4Playback Class Reference

#include <C4Record.h>

Public Member Functions
	C4Playback ()
	~C4Playback ()
bool	Open (C4Group &rGrp)
bool	ReadBinary (const StdBuf &Buf)
bool	ReadText (const StdStrBuf &Buf)
void	NextChunk ()
bool	NextSequentialChunk ()
StdStrBuf	ReWriteText ()
StdBuf	ReWriteBinary ()
void	Strip ()
bool	ExecuteControl (C4Control *pCtrl, int iFrame)
bool	IsFinished ()
void	Clear ()
void	Check (C4RecordChunkType eType, const uint8_t *pData, int iSize)
void	DebugRecError (const char *szError)

Static Public Member Functions
static bool	StreamToRecord (const char *szStream, StdStrBuf *pRecord)

Detailed Description

Definition at line 285 of file C4Record.h.

Constructor & Destructor Documentation

C4Playback()

C4Playback::C4Playback ( )

default

~C4Playback()

C4Playback::~C4Playback

(

)

Definition at line 377 of file C4Record.cpp.

{
    Clear();
}

References Clear().

Here is the call graph for this function:

Member Function Documentation

Check()

void C4Playback::Check	(	C4RecordChunkType	eType,
		const uint8_t *	pData,
		int	iSize
	)

Definition at line 992 of file C4Record.cpp.

{
    // only if enabled
    if (DoNoDebugRec>0) return;
    if (Game.FrameCounter < DEBUGREC_START_FRAME) return;
 
    C4PktDebugRec PktInReplay;
    bool fHasPacketFromHead = false;
    if (Config.General.DebugRecExternalFile[0])
    {
        if (Config.General.DebugRecWrite)
        {
            // writing of external debugrec file
            DbgRecFile.Write(&eType, sizeof eType);
            int32_t iSize32 = iSize;
            DbgRecFile.Write(&iSize32, sizeof iSize32);
            DbgRecFile.Write(pData, iSize);
            return;
        }
        else
        {
            int32_t iSize32 = 0;
            C4RecordChunkType eTypeRec = RCT_Undefined;
            DbgRecFile.Read(&eTypeRec, sizeof eTypeRec);
            DbgRecFile.Read(&iSize32, sizeof iSize32);
            if (iSize32)
            {
                StdBuf buf;
                buf.SetSize(iSize32);
                DbgRecFile.Read(buf.getMData(), iSize32);
                PktInReplay = C4PktDebugRec(eTypeRec, buf);
            }
        }
    }
    else
    {
        // check debug rec in list
        C4IDPacket *pkt;
        if ((pkt = DebugRec.firstPkt()))
        {
            // copy from list
            PktInReplay = *static_cast<C4PktDebugRec *>(pkt->getPkt());
            DebugRec.Delete(pkt);
        }
        else
        {
            // special sync check skip...
            while (currChunk != chunks.end() && currChunk->Type == RCT_CtrlPkt)
            {
                C4IDPacket Packet(*currChunk->pPkt);
                C4ControlPacket *pCtrlPck = static_cast<C4ControlPacket *>(Packet.getPkt());
                assert(!pCtrlPck->Sync());
                ::Control.ExecControlPacket(Packet.getPktType(), pCtrlPck);
                NextChunk();
            }
            // record end?
            if (currChunk == chunks.end() || currChunk->Type == RCT_End || Finished)
            {
                Log("DebugRec end: All in sync!");
                ++DoNoDebugRec;
                return;
            }
            // unpack directly from head
            if (currChunk->Type != eType)
            {
                DebugRecError(FormatString("Playback type %x, this type %x", currChunk->Type, eType).getData());
                return;
            }
            if (currChunk->pDbg)
                PktInReplay = *currChunk->pDbg;
 
            fHasPacketFromHead = true;
        }
    }
    // record end?
    if (PktInReplay.getType() == RCT_End)
    {
        Log("DebugRec end: All in sync (2)!");
        ++DoNoDebugRec;
        return;
    }
    // replay packet is unpacked to PktInReplay now; check it
    if (PktInReplay.getType() != eType)
    {
        DebugRecError(FormatString("Type %s != %s", GetRecordChunkTypeName(PktInReplay.getType()), GetRecordChunkTypeName(eType)).getData());
        return;
    }
    if (PktInReplay.getSize() != unsigned(iSize))
    {
        DebugRecError(FormatString("Size %d != %d", (int) PktInReplay.getSize(), (int) iSize).getData());
    }
    // check packet data
    if (memcmp(PktInReplay.getData(), pData, iSize))
    {
        StdStrBuf sErr;
        sErr.Format("DbgRecPkt Type %s, size %d", GetRecordChunkTypeName(eType), iSize);
        sErr.Append(" Replay: ");
        StdBuf replay(PktInReplay.getData(), PktInReplay.getSize());
        sErr.Append(GetDbgRecPktData(eType, replay));
        sErr.Append(" Here: ");
        StdBuf here(pData, iSize);
        sErr.Append(GetDbgRecPktData(eType, here));
        DebugRecError(sErr.getData());
    }
    // packet is fine, jump over it
    if (fHasPacketFromHead)
        NextChunk();
}

References StdStrBuf::Append(), Config, Control, DbgRecFile, DEBUGREC_START_FRAME, DebugRecError(), C4ConfigGeneral::DebugRecExternalFile, C4ConfigGeneral::DebugRecWrite, C4PacketList::Delete(), DoNoDebugRec, C4GameControl::ExecControlPacket(), C4PacketList::firstPkt(), StdStrBuf::Format(), FormatString(), C4Game::FrameCounter, Game, C4Config::General, StdStrBuf::getData(), C4PktBuf::getData(), GetDbgRecPktData(), StdBuf::getMData(), C4IDPacket::getPkt(), C4IDPacket::getPktType(), GetRecordChunkTypeName(), C4PktBuf::getSize(), C4PktDebugRec::getType(), iSize, Log(), NextChunk(), RCT_CtrlPkt, RCT_End, RCT_Undefined, CStdFile::Read(), StdBuf::SetSize(), C4ControlPacket::Sync(), and CStdFile::Write().

Referenced by C4GameControl::DbgRec().

Here is the call graph for this function:

Here is the caller graph for this function:

Clear()

void C4Playback::Clear

(

)

Definition at line 909 of file C4Record.cpp.

{
    // free stuff
    for (auto & chunk : chunks) chunk.Delete();
    chunks.clear(); currChunk = chunks.end();
    playbackFile.Close();
    sequentialBuffer.Clear();
    fLoadSequential = false;
    if (Config.General.DebugRec)
    {
        C4IDPacket *pkt;
        while ((pkt = DebugRec.firstPkt())) DebugRec.Delete(pkt);
        if (Config.General.DebugRecExternalFile[0])
            DbgRecFile.Close();
    }
    // done
    Finished = true;
}

References StdBuf::Clear(), CStdFile::Close(), Config, DbgRecFile, C4ConfigGeneral::DebugRec, C4ConfigGeneral::DebugRecExternalFile, C4PacketList::Delete(), C4PacketList::firstPkt(), and C4Config::General.

Referenced by Open(), and ~C4Playback().

Here is the call graph for this function:

Here is the caller graph for this function:

DebugRecError()

void C4Playback::DebugRecError

(

const char *

szError

)

Definition at line 1101 of file C4Record.cpp.

{
    LogF("Playback error: %s", szError);
    BREAKPOINT_HERE;
}

References BREAKPOINT_HERE, and LogF().

Referenced by Check(), and ExecuteControl().

Here is the call graph for this function:

Here is the caller graph for this function:

ExecuteControl()

bool C4Playback::ExecuteControl	(	C4Control *	pCtrl,
		int	iFrame
	)

Definition at line 840 of file C4Record.cpp.

{
    // still playbacking?
    if (currChunk == chunks.end()) return false;
    if (Finished) { Finish(); return false; }
    if (Config.General.DebugRec)
    {
        if (DebugRec.firstPkt())
            DebugRecError("Debug rec overflow!");
        DebugRec.Clear();
    }
    // return all control until this frame
    while (currChunk != chunks.end() && currChunk->Frame <= iFrame)
    {
        switch (currChunk->Type)
        {
        case RCT_Ctrl:
            pCtrl->Append(*currChunk->pCtrl);
            break;
 
        case RCT_CtrlPkt:
        {
            C4IDPacket Packet(*currChunk->pPkt);
            pCtrl->Add(Packet.getPktType(), static_cast<C4ControlPacket *>(Packet.getPkt()));
            Packet.Default();
            break;
        }
 
        case RCT_End:
            // end of playback; stop it!
            Finished=true;
            break;
 
        default: // expect it to be debug rec
            if (Config.General.DebugRec)
            {
                // append to debug rec buffer
                if (currChunk->pDbg)
                {
                    DebugRec.Add(CID_DebugRec, currChunk->pDbg);
                    // the debugrec buffer is now responsible for deleting the packet
                    currChunk->pDbg = nullptr;
                }
                break;
            }
        }
        // next chunk
        NextChunk();
    }
    return true;
}

References C4PacketList::Add(), C4Control::Add(), C4Control::Append(), CID_DebugRec, C4PacketList::Clear(), Config, C4ConfigGeneral::DebugRec, DebugRecError(), C4IDPacket::Default(), C4PacketList::firstPkt(), C4Config::General, C4IDPacket::getPkt(), C4IDPacket::getPktType(), NextChunk(), RCT_Ctrl, RCT_CtrlPkt, and RCT_End.

Referenced by C4GameControl::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

IsFinished()

bool C4Playback::IsFinished ( )

inline

Definition at line 311 of file C4Record.h.

{ return Finished; }

NextChunk()

void C4Playback::NextChunk

(

)

Definition at line 609 of file C4Record.cpp.

{
    assert(currChunk != chunks.end());
    ++currChunk;
    if (currChunk != chunks.end()) return;
    // end of all chunks if not loading sequential here
    if (!fLoadSequential) return;
    // otherwise, get next few chunks
    for (auto & chunk : chunks) chunk.Delete();
    chunks.clear(); currChunk = chunks.end();
    NextSequentialChunk();
}

References NextSequentialChunk().

Referenced by Check(), and ExecuteControl().

Here is the call graph for this function:

Here is the caller graph for this function:

NextSequentialChunk()

bool C4Playback::NextSequentialChunk

(

)

Definition at line 622 of file C4Record.cpp.

{
    StdBuf BinaryBuf; size_t iRealSize;
    BinaryBuf.New(4096);
    // load data until a chunk could be filled
    for (;;)
    {
        iRealSize = 0;
        playbackFile.Read(BinaryBuf.getMData(), 4096, &iRealSize);
        if (!iRealSize) return false;
        BinaryBuf.SetSize(iRealSize);
        if (!ReadBinary(BinaryBuf)) return false;
        // okay, at least one chunk has been read!
        if (chunks.size())
        {
            currChunk = chunks.begin();
            return true;
        }
    }
    // playback file reading failed - looks like we're done
    return false;
}

References StdBuf::getMData(), StdBuf::New(), CStdFile::Read(), ReadBinary(), and StdBuf::SetSize().

Referenced by NextChunk(), and Open().

Here is the call graph for this function:

Here is the caller graph for this function:

Open()

bool C4Playback::Open

(

C4Group &

rGrp

)

Definition at line 382 of file C4Record.cpp.

{
    // clean up
    Clear();
    iLastSequentialFrame = 0;
    bool fStrip = false;
 
    // open group? Then do some sequential reading for large files
    // Can't do this when a dump is forced, because the dump needs all data
    // Also can't do this when stripping is desired
    fLoadSequential = !rGrp.IsPacked() && !Game.RecordDumpFile.getLength() && !fStrip;
 
    // get text record file
    StdStrBuf TextBuf;
    if (rGrp.LoadEntryString(C4CFN_CtrlRecText, &TextBuf))
    {
        if (!ReadText(TextBuf))
            return false;
    }
    else
    {
        // get record file
        if (fLoadSequential)
        {
            if (!rGrp.FindEntry(C4CFN_CtrlRec)) return false;
            if (!playbackFile.Open(FormatString("%s%c%s", rGrp.GetFullName().getData(), (char) DirectorySeparator, (const char *) C4CFN_CtrlRec).getData())) return false;
            // forcing first chunk to be read; will call ReadBinary
            currChunk = chunks.end();
            if (!NextSequentialChunk())
            {
                // empty replay??!
                LogFatal("Record: Binary read error.");
                return false;
            }
        }
        else
        {
            // non-sequential reading: Just read as a whole
            StdBuf BinaryBuf;
            if (rGrp.LoadEntry(C4CFN_CtrlRec, &BinaryBuf))
            {
                if (!ReadBinary(BinaryBuf))
                    return false;
            }
            else
            {
                // file too large? Try sequential loading and parsing
                /*        size_t iSize;
                        if (rGrp.AccessEntry(C4CFN_CtrlRec, &iSize))
                          {
                          CStdFile fOut; fOut.Create(Game.RecordDumpFile.getData());
                          fLoadSequential = true;
                          const size_t iChunkSize = 1024*1024*16; // 16M
                          while (iSize)
                            {
                            size_t iLoadSize = std::min<size_t>(iChunkSize, iSize);
                            BinaryBuf.SetSize(iLoadSize);
                            if (!rGrp.Read(BinaryBuf.getMData(), iLoadSize))
                              {
                              LogFatal("Record: Binary load error!");
                              return false;
                              }
                            iSize -= iLoadSize;
                            if (!ReadBinary(BinaryBuf)) return false;
                            LogF("%d binary remaining", iSize);
                            currChunk = chunks.begin();
                            if (fStrip) Strip();
                            StdStrBuf s(ReWriteText());
                            fOut.WriteString(s.getData());
                            LogF("Wrote %d text bytes (%d binary remaining)", s.getLength(), iSize);
                            chunks.clear();
                            }
                          fOut.Close();
                          fLoadSequential = false;
                          }
                        else*/
                {
                    // no control data?
                    LogFatal("Record: No control data found!");
                    return false;
                }
            }
        }
    }
    // rewrite record
    if (fStrip) Strip();
    if (Game.RecordDumpFile.getLength())
    {
        if (SEqualNoCase(GetExtension(Game.RecordDumpFile.getData()), "txt"))
            ReWriteText().SaveToFile(Game.RecordDumpFile.getData());
        else
            ReWriteBinary().SaveToFile(Game.RecordDumpFile.getData());
    }
    // reset status
    currChunk = chunks.begin();
    Finished = false;
    // external debugrec file
    if (Config.General.DebugRecExternalFile[0] && Config.General.DebugRec)
    {
        if (Config.General.DebugRecWrite)
        {
            if (!DbgRecFile.Create(Config.General.DebugRecExternalFile))
            {
                LogFatal(FormatString(R"(DbgRec: Creation of external file "%s" failed!)", Config.General.DebugRecExternalFile).getData());
                return false;
            }
            else LogF(R"(DbgRec: Writing to "%s"...)", Config.General.DebugRecExternalFile);
        }
        else
        {
            if (!DbgRecFile.Open(Config.General.DebugRecExternalFile))
            {
                LogFatal(FormatString(R"(DbgRec: Opening of external file "%s" failed!)", Config.General.DebugRecExternalFile).getData());
                return false;
            }
            else LogF(R"(DbgRec: Checking against "%s"...)", Config.General.DebugRecExternalFile);
        }
    }
    // ok
    return true;
}

References C4CFN_CtrlRec, C4CFN_CtrlRecText, Clear(), Config, CStdFile::Create(), DbgRecFile, C4ConfigGeneral::DebugRec, C4ConfigGeneral::DebugRecExternalFile, C4ConfigGeneral::DebugRecWrite, DirectorySeparator, C4Group::FindEntry(), FormatString(), Game, C4Config::General, StdStrBuf::getData(), GetExtension(), C4Group::GetFullName(), StdStrBuf::getLength(), C4Group::IsPacked(), C4Group::LoadEntry(), C4Group::LoadEntryString(), LogF(), LogFatal(), NextSequentialChunk(), CStdFile::Open(), ReadBinary(), ReadText(), C4Game::RecordDumpFile, ReWriteBinary(), ReWriteText(), StdBuf::SaveToFile(), StdStrBuf::SaveToFile(), SEqualNoCase(), and Strip().

Referenced by C4GameControl::InitReplay().

Here is the call graph for this function:

Here is the caller graph for this function:

ReadBinary()

bool C4Playback::ReadBinary

(

const StdBuf &

Buf

)

Definition at line 504 of file C4Record.cpp.

{
    // sequential reading: Take over rest from last buffer
    const StdBuf *pUseBuf; uint32_t iFrame = 0;
    if (fLoadSequential)
    {
        sequentialBuffer.Append(Buf);
        pUseBuf = &sequentialBuffer;
        iFrame = iLastSequentialFrame;
    }
    else
        pUseBuf = &Buf;
    // get buffer data
    size_t iPos = 0; bool fFinished = false;
    do
    {
        // unpack header
        if (pUseBuf->getSize() - iPos < sizeof(C4RecordChunkHead)) break;
        const C4RecordChunkHead *pHead = getBufPtr<C4RecordChunkHead>(*pUseBuf, iPos);
        // get chunk
        iPos += sizeof(C4RecordChunkHead);
        StdBuf Chunk = pUseBuf->getPart(iPos, pUseBuf->getSize() - iPos);
        // Create entry
        C4RecordChunk c;
        c.Frame = (iFrame + pHead->iFrm);
        c.Type = pHead->Type;
        // Unpack data
        try
        {
            // Initialize compiler
            StdCompilerBinRead Compiler;
            Compiler.setInput(Chunk.getRef());
            Compiler.Begin();
            // Read chunk
            switch (pHead->Type)
            {
            case RCT_Ctrl:
                Compiler.Value(mkPtrAdaptNoNull(c.pCtrl));
                break;
            case RCT_CtrlPkt:
                Compiler.Value(mkPtrAdaptNoNull(c.pPkt));
                break;
            case RCT_End:
                fFinished = true;
                break;
            case RCT_File:
                Compiler.Value(c.Filename);
                Compiler.Value(mkPtrAdaptNoNull(c.pFileData));
                break;
            default:
                // debugrec
                if (pHead->Type >= 0x80)
                    Compiler.Value(mkPtrAdaptNoNull(c.pDbg));
            }
            // Advance over data
            Compiler.End();
            iPos += Compiler.getPosition();
        }
        catch (StdCompiler::EOFException *pEx)
        {
            // This is to be expected for sequential reading
            if (fLoadSequential)
            {
                iPos -= sizeof(C4RecordChunkHead);
                delete pEx;
                break;
            }
            LogF("Record: Binary unpack error: %s", pEx->Msg.getData());
            c.Delete();
            delete pEx;
            return false;
        }
        catch (StdCompiler::Exception *pEx)
        {
            LogF("Record: Binary unpack error: %s", pEx->Msg.getData());
            c.Delete();
            delete pEx;
            return false;
        }
        // Add to list
        chunks.push_back(c); c.pPkt = nullptr;
        iFrame = c.Frame;
    }
    while (!fFinished);
    // erase everything but the trailing part from sequential buffer
    if (fLoadSequential)
    {
        if (iPos >= sequentialBuffer.getSize())
            sequentialBuffer.Clear();
        else if (iPos)
        {
            sequentialBuffer.Move(iPos, sequentialBuffer.getSize() - iPos);
            sequentialBuffer.Shrink(iPos);
        }
        // remember frame
        iLastSequentialFrame = iFrame;
    }
    return true;
}

References StdBuf::Append(), StdCompilerBinRead::Begin(), StdBuf::Clear(), C4RecordChunk::Delete(), StdCompiler::End(), C4RecordChunk::Filename, C4RecordChunk::Frame, StdStrBuf::getData(), StdBuf::getPart(), StdCompilerBinRead::getPosition(), StdBuf::getRef(), StdBuf::getSize(), C4RecordChunkHead::iFrm, LogF(), mkPtrAdaptNoNull(), StdBuf::Move(), StdCompiler::Exception::Msg, RCT_Ctrl, RCT_CtrlPkt, RCT_End, RCT_File, StdCompilerBinRead::setInput(), StdBuf::Shrink(), C4RecordChunkHead::Type, C4RecordChunk::Type, and StdCompiler::Value().

Referenced by NextSequentialChunk(), Open(), and StreamToRecord().

Here is the call graph for this function:

Here is the caller graph for this function:

ReadText()

bool C4Playback::ReadText

(

const StdStrBuf &

Buf

)

Definition at line 604 of file C4Record.cpp.

{
    return CompileFromBuf_LogWarn<StdCompilerINIRead>(mkNamingAdapt(mkSTLContainerAdapt(chunks), "Rec"), Buf, C4CFN_CtrlRecText);
}

References C4CFN_CtrlRecText, mkNamingAdapt(), and mkSTLContainerAdapt().

Referenced by Open().

Here is the call graph for this function:

Here is the caller graph for this function:

ReWriteBinary()

StdBuf C4Playback::ReWriteBinary

(

)

Definition at line 658 of file C4Record.cpp.

{
    const int OUTPUT_GROW = 16 * 1024;
    StdBuf Output; int iPos = 0;
    bool fFinished = false;
    int32_t iFrame = 0;
    for (chunks_t::const_iterator i = chunks.begin(); !fFinished && i != chunks.end(); i++)
    {
        // Check frame difference
        if (i->Frame - iFrame < 0 || i->Frame - iFrame > 0xff)
            LogF("ERROR: Invalid frame difference between chunks (0-255 allowed)! Data will be invalid!");
        // Pack data
        StdBuf Chunk;
        try
        {
            switch (i->Type)
            {
            case RCT_Ctrl:
                Chunk = DecompileToBuf<StdCompilerBinWrite>(*i->pCtrl);
                break;
            case RCT_CtrlPkt:
                Chunk = DecompileToBuf<StdCompilerBinWrite>(*i->pPkt);
                break;
            case RCT_End:
                fFinished = true;
                break;
            default: // debugrec
                if (i->pDbg)
                    Chunk = DecompileToBuf<StdCompilerBinWrite>(*i->pDbg);
                break;
            }
        }
        catch (StdCompiler::Exception *pEx)
        {
            LogF("Record: Binary unpack error: %s", pEx->Msg.getData());
            delete pEx;
            return StdBuf();
        }
        // Grow output
        while (Output.getSize() - iPos < sizeof(C4RecordChunkHead) + Chunk.getSize())
            Output.Grow(OUTPUT_GROW);
        // Write header
        C4RecordChunkHead *pHead = getMBufPtr<C4RecordChunkHead>(Output, iPos);
        pHead->Type = i->Type;
        pHead->iFrm = i->Frame - iFrame;
        iPos += sizeof(C4RecordChunkHead);
        iFrame = i->Frame;
        // Write chunk
        Output.Write(Chunk, iPos);
        iPos += Chunk.getSize();
    }
    Output.SetSize(iPos);
    return Output;
}

References StdStrBuf::getData(), StdBuf::getSize(), StdBuf::Grow(), C4RecordChunkHead::iFrm, LogF(), StdCompiler::Exception::Msg, RCT_Ctrl, RCT_CtrlPkt, RCT_End, StdBuf::SetSize(), C4RecordChunkHead::Type, and StdBuf::Write().

Referenced by Open(), and StreamToRecord().

Here is the call graph for this function:

Here is the caller graph for this function:

ReWriteText()

StdStrBuf C4Playback::ReWriteText

(

)

Definition at line 645 of file C4Record.cpp.

{
    // Would work, too, but is currently too slow due to bad buffering inside StdCompilerINIWrite:
    // return DecompileToBuf<StdCompilerINIWrite>(mkNamingAdapt(mkSTLContainerAdapt(chunks), "Rec"));
    StdStrBuf Output;
    for (chunks_t::const_iterator i = chunks.begin(); i != chunks.end(); i++)
    {
        Output.Append(static_cast<const StdStrBuf&>(DecompileToBuf<StdCompilerINIWrite>(mkNamingAdapt(mkDecompileAdapt(*i), "Rec"))));
        Output.Append("\n\n");
    }
    return Output;
}

References StdStrBuf::Append(), mkDecompileAdapt(), and mkNamingAdapt().

Referenced by Open().

Here is the call graph for this function:

Here is the caller graph for this function:

StreamToRecord()

bool C4Playback::StreamToRecord ( const char *  szStream, StdStrBuf *  pRecord  )

static

Definition at line 1107 of file C4Record.cpp.

{
 
    // Load data
    StdBuf CompressedData;
    Log("Reading stream...");
    if (!CompressedData.LoadFromFile(szStream))
        return false;
 
    // Decompress
    unsigned long iStreamSize = CompressedData.getSize() * 5;
    StdBuf StreamData; StreamData.New(iStreamSize);
    while (true)
    {
 
        // Initialize stream
        z_stream strm;
        ZeroMem(&strm, sizeof strm);
        strm.next_in = getMBufPtr<BYTE>(CompressedData);
        strm.avail_in = CompressedData.getSize();
        strm.next_out = getMBufPtr<BYTE>(StreamData);
        strm.avail_out = StreamData.getSize();
 
        // Decompress
        if (inflateInit(&strm) != Z_OK)
            return false;
        int ret = inflate(&strm, Z_FINISH);
        if (ret == Z_OK)
        {
            inflateEnd(&strm);
            break;
        }
        if (ret != Z_BUF_ERROR)
            return false;
 
        // All input consumed?
        iStreamSize = strm.total_out;
        if (strm.avail_in == 0)
        {
            Log("Stream data incomplete, using as much data as possible");
            break;
        }
 
        // Larger buffer needed
        StreamData.Grow(CompressedData.getSize());
        iStreamSize = StreamData.getSize();
    }
    StreamData.SetSize(iStreamSize);
 
    // Parse
    C4Playback Playback;
    Playback.ReadBinary(StreamData);
    LogF("Got %lu chunks from stream", static_cast<unsigned long>(Playback.chunks.size()));
 
    // Get first chunk, which must contain the initial
    chunks_t::iterator chunkIter = Playback.chunks.begin();
    if (chunkIter == Playback.chunks.end() || chunkIter->Type != RCT_File)
        return false;
 
    // Get initial chunk, go over file name
    StdBuf InitialData = *chunkIter->pFileData;
 
    // Put to temporary file and unpack
    char szInitial[_MAX_PATH_LEN] = "~initial.tmp";
    MakeTempFilename(szInitial);
    if (!InitialData.SaveToFile(szInitial) ||
        !C4Group_UnpackDirectory(szInitial))
        return false;
 
    // Load Scenario.txt from Initial
    C4Group Grp; C4Scenario Initial;
    if (!Grp.Open(szInitial) ||
        !Initial.Load(Grp) ||
        !Grp.Close())
        return false;
 
    // Copy original scenario
    const char *szOrigin = Initial.Head.Origin.getData();
    char szRecord[_MAX_PATH_LEN];
    SCopy(szStream, szRecord, _MAX_PATH);
    if (GetExtension(szRecord))
        *(GetExtension(szRecord) - 1) = 0;
    SAppend(".ocs", szRecord, _MAX_PATH);
    LogF("Original scenario is %s, creating %s.", szOrigin, szRecord);
    if (!C4Group_CopyItem(szOrigin, szRecord, false, false))
        return false;
 
    // Merge initial
    if (!Grp.Open(szRecord) ||
        !Grp.Merge(szInitial))
        return false;
 
    // Process other files in stream
    chunkIter->Delete();
    chunkIter = Playback.chunks.erase(chunkIter);
    while (chunkIter != Playback.chunks.end())
        if (chunkIter->Type == RCT_File)
        {
            LogF("Inserting %s...", chunkIter->Filename.getData());
            StdStrBuf Temp; Temp.Copy(chunkIter->Filename);
            MakeTempFilename(&Temp);
            if (!chunkIter->pFileData->SaveToFile(Temp.getData()))
                return false;
            if (!Grp.Move(Temp.getData(), chunkIter->Filename.getData()))
                return false;
            chunkIter = Playback.chunks.erase(chunkIter);
        }
        else
            chunkIter++;
 
    // Write record data
    StdBuf RecordData = Playback.ReWriteBinary();
    if (!Grp.Add(C4CFN_CtrlRec, RecordData, false, true))
        return false;
 
    // Done
    Log("Writing record file...");
    Grp.Close();
    pRecordFile->Copy(szRecord);
    return true;
}

References _MAX_PATH, _MAX_PATH_LEN, C4Group::Add(), C4CFN_CtrlRec, C4Group_CopyItem(), C4Group_UnpackDirectory(), C4Group::Close(), StdStrBuf::Copy(), StdStrBuf::getData(), GetExtension(), StdBuf::getSize(), StdBuf::Grow(), C4Scenario::Head, C4Scenario::Load(), StdBuf::LoadFromFile(), Log(), LogF(), MakeTempFilename(), C4Group::Merge(), C4Group::Move(), StdBuf::New(), C4Group::Open(), C4SHead::Origin, RCT_File, ReadBinary(), ReWriteBinary(), SAppend(), StdBuf::SaveToFile(), SCopy(), StdBuf::SetSize(), and ZeroMem().

Referenced by C4Game::OpenScenario().

Here is the call graph for this function:

Here is the caller graph for this function:

Strip()

void C4Playback::Strip

(

)

Definition at line 713 of file C4Record.cpp.

{
    // Strip what?
    const bool fStripPlayers = false;
    const bool fStripSyncChecks = false;
    const bool fStripDebugRec = true;
    const bool fCheckCheat = false;
    const bool fStripMessages = true;
    const int32_t iEndFrame = -1;
    // Iterate over chunk list
    for (chunks_t::iterator i = chunks.begin(); i != chunks.end(); )
    {
        // Strip rest of record?
        if (iEndFrame >= 0 && i->Frame > iEndFrame)
        {
            // Remove this and all remaining chunks
            while (i != chunks.end())
            {
                i->Delete();
                i = chunks.erase(i);
            }
            // Push new End-Chunk
            C4RecordChunk EndChunk;
            EndChunk.Frame = iEndFrame;
            EndChunk.Type = RCT_End;
            chunks.push_back(EndChunk);
            // Done
            break;
        }
        switch (i->Type)
        {
        case RCT_Ctrl:
        {
            // Iterate over controls
            C4Control *pCtrl = i->pCtrl;
            for (C4IDPacket *pPkt = pCtrl->firstPkt(), *pNext; pPkt; pPkt = pNext)
            {
                pNext = pCtrl->nextPkt(pPkt);
                switch (pPkt->getPktType())
                {
                    // Player join: Strip player file (if possible)
                case CID_JoinPlr:
                    if (fStripPlayers)
                    {
                        C4ControlJoinPlayer *pJoinPlr = static_cast<C4ControlJoinPlayer *>(pPkt->getPkt());
                        pJoinPlr->Strip();
                    }
                    break;
                    // EM commands: May be cheats, so log them
                case CID_Script:
                case CID_EMMoveObj:
                case CID_EMDrawTool:
                case CID_ReInitScenario:
                case CID_EditGraph:
                    if (fCheckCheat) Log(DecompileToBuf<StdCompilerINIWrite>(mkNamingAdapt(*pPkt, FormatString("Frame %d", i->Frame).getData())).getData());
                    break;
                    // Strip sync check
                case CID_SyncCheck:
                    if (fStripSyncChecks)
                    {
                        i->pCtrl->Remove(pPkt);
                    }
                    break;
                default:
                    // TODO
                    break;
                }
            }
            // Strip empty control lists (always)
            if (!pCtrl->firstPkt())
            {
                i->Delete();
                i = chunks.erase(i);
            }
            else
                i++;
        }
        break;
        case RCT_CtrlPkt:
        {
            bool fStripThis=false;
            switch (i->pPkt->getPktType())
            {
                // EM commands: May be cheats, so log them
            case CID_Script:
            case CID_EMMoveObj:
            case CID_EMDrawTool:
            case CID_ReInitScenario:
            case CID_EditGraph:
                if (fCheckCheat) Log(DecompileToBuf<StdCompilerINIWrite>(mkNamingAdapt(*i->pPkt, FormatString("Frame %d", i->Frame).getData())).getData());
                break;
                // Strip some stuff
            case CID_SyncCheck:
                if (fStripSyncChecks) fStripThis = true;
                break;
            case CID_Message:
                if (fStripMessages) fStripThis=true;
                break;
            default:
                // TODO
                break;
            }
            if (fStripThis)
            {
                i->Delete();
                i = chunks.erase(i);
            }
            else i++;
        }
        break;
        case RCT_End:
            i++;
            break;
        default:
            // Strip debugrec
            if (fStripDebugRec)
            {
                i->Delete();
                i = chunks.erase(i);
            }
            else
                i++;
        }
    }
}

References CID_EditGraph, CID_EMDrawTool, CID_EMMoveObj, CID_JoinPlr, CID_Message, CID_ReInitScenario, CID_Script, CID_SyncCheck, C4Control::firstPkt(), FormatString(), C4RecordChunk::Frame, StdStrBuf::getData(), Log(), mkNamingAdapt(), C4Control::nextPkt(), RCT_Ctrl, RCT_CtrlPkt, RCT_End, C4ControlJoinPlayer::Strip(), and C4RecordChunk::Type.

Referenced by Open().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• C4Record.h
• C4Record.cpp