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

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


CamDeframer::CamDeframer(CamDevice *device)
        : CamFilterInterface(device),
        fDevice(device),
        fState(ST_SYNC),
        fFrameSem(B_ERROR),
        fLocker("CamDeframer Framelist lock", true),
        fSOFTags(NULL),
        fEOFTags(NULL),
        fNumSOFTags(0),
        fNumEOFTags(0),
        fLenSOFTags(0),
        fLenEOFTags(0),
        fSkipSOFTags(0),
        fSkipEOFTags(0)
{
        fMinFrameSize = fDevice->MinRawFrameSize();
        fMaxFrameSize = fDevice->MaxRawFrameSize();
        fFrameSem = create_sem(0, "CamDeframer sem");
        fCurrentFrame = AllocFrame();
}


CamDeframer::~CamDeframer()
{
        delete_sem(fFrameSem);
        BAutolock l(fLocker);
        delete fCurrentFrame;
}


ssize_t
CamDeframer::Read(void *buffer, size_t size)
{
        BAutolock l(fLocker);
        CamFrame *f = (CamFrame *)fFrames.ItemAt(0);
        if (!f)
                return EIO;
        return f->Read(buffer, size);
}


ssize_t
CamDeframer::ReadAt(off_t pos, void *buffer, size_t size)
{
        BAutolock l(fLocker);
        CamFrame *f = (CamFrame *)fFrames.ItemAt(0);
        if (!f)
                return EIO;
        return f->ReadAt(pos, buffer, size);
}


off_t
CamDeframer::Seek(off_t position, uint32 seek_mode)
{
        BAutolock l(fLocker);
        CamFrame *f = (CamFrame *)fFrames.ItemAt(0);
        if (!f)
                return EIO;
        return f->Seek(position, seek_mode);
}


off_t
CamDeframer::Position() const
{
        BAutolock l((BLocker &)fLocker); // need to get rid of const here
        CamFrame *f = (CamFrame *)fFrames.ItemAt(0);
        if (!f)
                return EIO;
        return f->Position();
}


status_t
CamDeframer::SetSize(off_t size)
{
        (void)size;
        return EINVAL;
}


ssize_t
CamDeframer::Write(const void *buffer, size_t size)
{
        (void)buffer;
        (void)size;
        return EINVAL;
}


ssize_t
CamDeframer::WriteAt(off_t pos, const void *buffer, size_t size)
{
        (void)pos;
        (void)buffer;
        (void)size;
        return EINVAL;
}


status_t
CamDeframer::WaitFrame(bigtime_t timeout)
{
        return acquire_sem_etc(fFrameSem, 1, B_RELATIVE_TIMEOUT, timeout);
}


status_t
CamDeframer::GetFrame(CamFrame **frame, bigtime_t *stamp)
{
        PRINT((CH "()" CT));
        BAutolock l(fLocker);
        CamFrame *f = (CamFrame *)fFrames.RemoveItem((int32)0);
        if (!f)
                return ENOENT;
        *frame = f;
        *stamp = f->Stamp();
        return B_OK;
}


status_t
CamDeframer::DropFrame()
{
        PRINT((CH "()" CT));
        BAutolock l(fLocker);
        CamFrame *f = (CamFrame *)fFrames.RemoveItem((int32)0);
        if (!f)
                return ENOENT;
        delete f;
        return B_OK;
}


status_t
CamDeframer::RegisterSOFTags(const uint8 **tags, int count, size_t len, size_t skip)
{
        if (fSOFTags)
                return EALREADY;
        if (len > MAX_TAG_LEN)
                return EINVAL;
        if (count > 16)
                return EINVAL;
        fSOFTags = tags;
        fNumSOFTags = count;
        fLenSOFTags = len;
        fSkipSOFTags = skip;
        return B_OK;
}


status_t
CamDeframer::RegisterEOFTags(const uint8 **tags, int count, size_t len, size_t skip)
{
        if (fEOFTags)
                return EALREADY;
        if (len > MAX_TAG_LEN)
                return EINVAL;
        if (count > 16)
                return EINVAL;
        fEOFTags = tags;
        fNumEOFTags = count;
        fLenEOFTags = len;
        fSkipEOFTags = skip;
        return B_OK;
}


int
CamDeframer::FindTags(const uint8 *buf, size_t buflen, const uint8 **tags, int tagcount, size_t taglen, size_t skiplen, int *which)
{
        int i, t;
        for (i = 0; i < (int)(buflen - skiplen + 1); i++) {
                for (t = 0; t < tagcount; t++) {
                        if (!memcmp(buf+i, tags[t], taglen)) {
                                if (which)
                                        *which = t;
                                return i;
                        }
                }
        }
        return -1;
}


int
CamDeframer::FindSOF(const uint8 *buf, size_t buflen, int *which)
{
        return FindTags(buf, buflen, fSOFTags, fNumSOFTags, fLenSOFTags, fSkipSOFTags, which);
}


int
CamDeframer::FindEOF(const uint8 *buf, size_t buflen, int *which)
{
        return FindTags(buf, buflen, fEOFTags, fNumEOFTags, fLenEOFTags, fSkipEOFTags, which);
}


CamFrame *
CamDeframer::AllocFrame()
{
        return new CamFrame();
}