/*
 * Copyright 2004-2008, François Revol, <revol@free.fr>.
 * Distributed under the terms of the MIT License.
 */

/*
 * stream based deframer
 * has a state machine and handles each packet separately.
 * much more complex than the buffering one, and I thought it didn't work,
 * but since I fixed the rest it seems to be working even better without
 * taking the cpu over like the other one.
 */

#define CD_COL "31"
#include "CamStreamingDeframer.h"
#include "CamDevice.h"
#include "CamDebug.h"
#include <Autolock.h>
#define MAX_TAG_LEN CAMDEFRAMER_MAX_TAG_LEN
#define MAXFRAMEBUF CAMDEFRAMER_MAX_QUEUED_FRAMES


CamStreamingDeframer::CamStreamingDeframer(CamDevice *device)
        : CamDeframer(device)
{
}


CamStreamingDeframer::~CamStreamingDeframer()
{
}


ssize_t
CamStreamingDeframer::Write(const void *buffer, size_t size)
{
        int i = -1;
        int j;
        int end = size;
        int which;
        const uint8 *buf = (const uint8 *)buffer;
        int bufsize = size;
        bool detach = false;
        bool discard = false;
        //PRINT((CH "(%p, %d); state=%s framesz=%u queued=%u" CT, buffer, size, (fState==ST_SYNC)?"sync":"frame", (size_t)(fCurrentFrame?(fCurrentFrame->Position()):-1), (size_t)fInputBuff.Position()));
        if (!fCurrentFrame) {
                BAutolock l(fLocker);
                if (fFrames.CountItems() < MAXFRAMEBUF)
                        fCurrentFrame = AllocFrame();
                else {
                        PRINT((CH "DROPPED %" B_PRIuSIZE " bytes! "
                                "(too many queued frames)" CT, size));
                        return size; // drop XXX
                }
        }

        // update in case resolution changed
        fMinFrameSize = fDevice->MinRawFrameSize();
        fMaxFrameSize = fDevice->MaxRawFrameSize();

        if (fInputBuff.Position()) {
                // residual data ? append to it
                fInputBuff.Write(buffer, size);
                // and use it as input buf
                buf = (uint8 *)fInputBuff.Buffer();
                bufsize = fInputBuff.BufferLength();
                end = bufsize;
        }
        // whole buffer belongs to a frame, simple
        if (fState == ST_FRAME) {
                off_t position = fCurrentFrame->Position();
                if (position + bufsize < 0
                        || (size_t)(position + bufsize) < fMinFrameSize) {
                        // no residual data, and
                        fCurrentFrame->Write(buf, bufsize);
                        fInputBuff.Seek(0LL, SEEK_SET);
                        fInputBuff.SetSize(0);
                        return size;
                }
        }

        // waiting for a frame...
        if (fState == ST_SYNC) {
                i = 0;
                while ((j = FindSOF(buf+i, bufsize-i, &which)) > -1) {
                        i += j;
                        if (fDevice->ValidateStartOfFrameTag(buf+i, fSkipSOFTags))
                                break;
                        i++;
                }
                // got one
                if (j >= 0) {
                        PRINT((CH ": SOF[%d] at offset %d" CT, which, i));
                        //PRINT((CH ": SOF: ... %02x %02x %02x %02x %02x %02x" CT, buf[i+6], buf[i+7], buf[i+8], buf[i+9], buf[i+10], buf[i+11]));
                        int start = i + fSkipSOFTags;
                        buf += start;
                        bufsize -= start;
                        end = bufsize;
                        fState = ST_FRAME;
                }
        }

        // check for end of frame
        if (fState == ST_FRAME) {
#if 0
                int j, k;
                i = -1;
                k = 0;
                while ((j = FindEOF(buf + k, bufsize - k, &which)) > -1) {
                        k += j;
                        //PRINT((CH "| EOF[%d] at offset %d; pos %lld" CT, which, k, fCurrentFrame->Position()));
                        if (fCurrentFrame->Position()+k >= fMinFrameSize) {
                                i = k;
                                break;
                        }
                        k++;
                        if (k >= bufsize)
                                break;
                }
#endif
#if 1
                i = 0;
                off_t currentFramePosition = fCurrentFrame->Position();
                if (currentFramePosition < 0
                        || (size_t)currentFramePosition < fMinFrameSize) {
                        if (currentFramePosition + bufsize > 0
                                && (size_t)(currentFramePosition + bufsize) >= fMinFrameSize) {
                                i = (fMinFrameSize - (size_t)fCurrentFrame->Position());
                        } else
                                i = bufsize;
                }
                PRINT((CH ": checking for EOF; bufsize=%d i=%d" CT, bufsize, i));

                if (i + (int)fSkipEOFTags > bufsize) { // not enough room to check for EOF, leave it for next time
                        end = i;
                        i = -1; // don't detach yet
                } else {
                        PRINT((CH ": EOF? %02x [%02x %02x %02x %02x] %02x" CT, buf[i-1], buf[i], buf[i+1], buf[i+2], buf[i+3], buf[i+4]));
                        while ((j = FindEOF(buf + i, bufsize - i, &which)) > -1) {
                                i += j;
                                PRINT((CH "| EOF[%d] at offset %d; pos %" B_PRIdOFF CT,
                                        which, i, fCurrentFrame->Position()));
                                off_t position = fCurrentFrame->Position();
                                if (position + i >= 0
                                        && (size_t)(position + i) >= fMaxFrameSize) {
                                        // too big: discard
                                        //i = -1;
                                        discard = true;
                                        break;
                                }
                                if (fDevice->ValidateEndOfFrameTag(buf+i, fSkipEOFTags, fCurrentFrame->Position()+i))
                                        break;
                                i++;
                                if (i >= bufsize) {
                                        i = -1;
                                        break;
                                }
                        }
                        if (j < 0)
                                i = -1;
                }
#endif
                if (i >= 0) {
                        PRINT((CH ": EOF[%d] at offset %d" CT, which, i));
                        end = i;
                        detach = true;
                }
                PRINT((CH ": writing %d bytes" CT, end));
                if (end <= bufsize)
                        fCurrentFrame->Write(buf, end);
                off_t currentPosition = fCurrentFrame->Position();
                if (currentPosition > 0
                        && (size_t)currentPosition > fMaxFrameSize) {
                        fCurrentFrame->SetSize(fMaxFrameSize);
                        detach = true;
                }
                if (detach) {
                        BAutolock f(fLocker);
                        PRINT((CH ": Detaching a frame "
                                "(%" B_PRIuSIZE " bytes, end = %d, )" CT,
                                (size_t)fCurrentFrame->Position(), end));
                        fCurrentFrame->Seek(0LL, SEEK_SET);
                        if (discard) {
                                delete fCurrentFrame;
                        } else {
                                fFrames.AddItem(fCurrentFrame);
                                release_sem(fFrameSem);
                        }
                        fCurrentFrame = NULL;
                        if (fFrames.CountItems() < MAXFRAMEBUF) {
                                fCurrentFrame = AllocFrame();
                        }
                        fState = ST_SYNC;
                }
        }




        // put the remainder in input buff, discarding old data
#if 0
        fInputBuff.Seek(0LL, SEEK_SET);
        if (bufsize - end > 0)
                fInputBuff.Write(buf+end, bufsize - end);
#endif
        BMallocIO m;
        m.Write(buf+end, bufsize - end);
        fInputBuff.Seek(0LL, SEEK_SET);
        if (bufsize - end > 0)
                fInputBuff.Write(m.Buffer(), bufsize - end);
        fInputBuff.SetSize(bufsize - end);
        return size;
}