Subversion Repositories Projects

Compare Revisions

Ignore whitespace Rev 1701 → Rev 1702

/C-OSD/arducam-osd/libraries/PTPCamera/examples/EOSHDRCapture/hdrcapture.cpp
0,0 → 1,336
#include "hdrcapture.h"
#include "expcomp_macro.h"
 
/* fixes avr-gcc incompatibility with virtual destructors */
void operator delete( void *p ) {}
 
QState HDRCapture::Initial(HDRCapture *me, QEvent const *e)
{
return Q_TRAN(&HDRCapture::Inactive);
}
 
QState HDRCapture::Inactive(HDRCapture *me, QEvent const *e)
{
switch(e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("Inactive\r\n");
return Q_HANDLED();
case SET_FRAMES_SIG:
me->frmCount = (uint16_t)((SetEvt*)e)->value;
return Q_HANDLED();
case SET_SELF_TIMEOUT_SIG:
me->selfTimeout = ((SetEvt*)e)->value;
return Q_HANDLED();
case SET_FRAME_TIMEOUT_SIG:
me->frameTimeout = ((SetEvt*)e)->value;
return Q_HANDLED();
case SET_BRACKETING_SIG:
me->bktStep = ((SetBktEvt*)e)->step;
me->bktNegative = ((SetBktEvt*)e)->negative;
me->bktPositive = ((SetBktEvt*)e)->positive;
return Q_HANDLED();
case RUN_SIG:
me->frmCntdn = me->frmCount;
me->bktCntdn = (me->bktStep) ? (me->bktPositive - me->bktNegative) / me->bktStep + 1 : 1;
me->bktPos = me->bktNegative;
return Q_TRAN(&HDRCapture::Active);
}
return Q_SUPER(&QHsm::top);
}
 
QState HDRCapture::Active(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("Active\r\n");
return Q_HANDLED();
case Q_EXIT_SIG:
PTPTRACE("::Q_EXIT_SIG\r\n");
return Q_HANDLED();
case Q_INIT_SIG:
PTPTRACE("Q_INIT_SIG\r\n");
return Q_TRAN(&HDRCapture::SaveSettings);
case RUN_SIG:
PTPTRACE("::RUN_SIG\r\n");
return Q_TRAN(&HDRCapture::SaveSettings);
case ABORT_SIG:
PTPTRACE("ABORT_SIG\r\n");
return Q_TRAN(&HDRCapture::RestoreSettings);
case PTP_RC_SIG:
PTPTRACE("::PTP_RC_SIG\r\n");
switch (((PTP_RC_Evt*)e)->rc)
{
case PTP_RC_OK:
me->qpEvt.sig = PTP_RC_OK_SIG;
me->theQueue.Push(&me->qpEvt);
return Q_HANDLED();
case PTP_RC_DeviceBusy:
me->toEvt.timeout = PTP_TIMEOUT;
me->toEvt.attribs = TA_PTP_TIMEOUT;
me->theQueue.Push(&me->toEvt);
return Q_TRAN(&HDRCapture::Timeout);
default:
return Q_TRAN(&HDRCapture::Inactive);
}
case SET_TIMEOUT_SIG:
PTPTRACE("::SET_TIMEOUT_SIG\r\n");
return Q_HANDLED();
case TIMEOUT_SIG:
PTPTRACE("::TIMEOUT_SIG\r\n");
return Q_TRAN(me->activeHistory);
case PTP_RC_OK_SIG:
PTPTRACE("::PTP_RC_OK_SIG\r\n");
return Q_TRAN(me->activeHistory);
case TICK_MILLIS_SIG:
PTPTRACE("::TICK_MILLIS_SIG\r\n");
return Q_HANDLED();
}
return Q_SUPER(&QHsm::top);
}
 
QState HDRCapture::SaveSettings(HDRCapture *me, QEvent const *e)
{
static bool bSaved = false;
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("SaveSettings\r\n");
me->activeHistory = (QStateHandler)&SaveSettings;
// me->rcEvt.rc = me->Eos.GetProperty(EOS_DPC_ExposureCompensation, me->bktOldVal);
me->rcEvt.rc = PTP_RC_OK;
me->theQueue.Push(&me->rcEvt);
me->bktOldVal = (uint8_t)0;
return Q_HANDLED();
case PTP_RC_OK_SIG:
PTPTRACE("PTP_RC_OK_SIG\r\n");
if (me->selfTimeout)
{
me->theQueue.Push((QEvent*)e);
return Q_TRAN(&HDRCapture::SelfTimer);
}
return Q_TRAN(&HDRCapture::PreCapture);
} // switch
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::SelfTimer(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("SelfTimer\r\n");
me->activeHistory = (QStateHandler)&SelfTimer;
return Q_HANDLED();
case TICK_MILLIS_SIG:
PTPTRACE("TICK_MILLIS_SIG\r\n");
return Q_TRAN(&HDRCapture::PreCapture);
case PTP_RC_OK_SIG:
PTPTRACE("PTP_RC_OK_SIG\r\n");
me->toEvt.timeout = me->selfTimeout;
me->toEvt.attribs = TA_SELF_TIMER;
me->theQueue.Push(&me->toEvt);
return Q_TRAN(&HDRCapture::Timeout);
case TIMEOUT_SIG:
PTPTRACE("TIMEOUT_SIG\r\n");
return Q_TRAN(&HDRCapture::PreCapture);
} // switch
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::RestoreSettings(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("RestoreSettings\r\n");
me->activeHistory = (QStateHandler)&RestoreSettings;
me->rcEvt.rc = me->Eos.SetProperty(EOS_DPC_ExposureCompensation, me->bktOldVal);
me->theQueue.Push(&me->rcEvt);
return Q_HANDLED();
case PTP_RC_OK_SIG:
return Q_TRAN(&HDRCapture::Inactive);
} // switch
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::PreCapture(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("PreCapture\r\n");
me->activeHistory = (QStateHandler)&PreCapture;
return Q_HANDLED();
case TICK_MILLIS_SIG:
PTPTRACE("TICK_MILLIS_SIG\r\n");
if (!me->bktCntdn)
{
me->bktCntdn = (me->bktStep) ? (me->bktPositive - me->bktNegative) / me->bktStep + 1 : 1;
me->bktPos = me->bktNegative;
}
if (me->bktStep)
return Q_TRAN(&HDRCapture::ExpCompSet);
return Q_TRAN(&HDRCapture::Capture);
} // switch
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::Capture(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("Capture\r\n");
me->activeHistory = (QStateHandler)&Capture;
me->rcEvt.rc = me->Eos.Capture();
// me->rcEvt.rc = PTP_RC_OK;
me->theQueue.Push(&me->rcEvt);
return Q_HANDLED();
case PTP_RC_OK_SIG:
PTPTRACE("PTP_RC_OK_SIG\r\n");
return Q_TRAN(&HDRCapture::PostCapture);
} // switch
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::PostCapture(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("PostCapture\r\n");
me->activeHistory = (QStateHandler)&PostCapture;
return Q_HANDLED();
case TICK_MILLIS_SIG:
PTPTRACE("TICK_MILLIS_SIG\r\n");
 
if (!me->bktCntdn)
return Q_TRAN(&HDRCapture::PreCapture);
 
me->bktPos += me->bktStep;
if (--me->bktCntdn == 0)
{
--me->frmCntdn;
me->OnFrameCaptured(me->frmCntdn);
}
me->OnBktFrameCaptured(me->bktCntdn);
 
// if it was the last frame in total
if (!me->frmCntdn)
{
me->qpEvt.sig = ABORT_SIG;
me->theQueue.Push(&me->qpEvt);
return Q_HANDLED();
}
if (me->bktCntdn)
return Q_TRAN(&HDRCapture::PreCapture);
 
// if it was the last frame in bracketing
me->toEvt.timeout = me->frameTimeout;
me->toEvt.attribs = TA_INTR_TIMER;
me->theQueue.Push(&me->toEvt);
return Q_TRAN(&HDRCapture::Timeout);
case TIMEOUT_SIG:
PTPTRACE("TIMEOUT_SIG\r\n");
return Q_TRAN(&HDRCapture::PreCapture);
}
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::ExpCompSet(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("ExpCompSet\r\n");
me->activeHistory = (QStateHandler)&ExpCompSet;
me->rcEvt.rc = me->Eos.SetProperty(EOS_DPC_ExposureCompensation, EXP_COMP_VALUE(me->bktPos));
// me->rcEvt.rc = PTP_RC_OK;
me->theQueue.Push(&me->rcEvt);
return Q_HANDLED();
case PTP_RC_OK_SIG:
PTPTRACE("PTP_RC_OK_SIG\r\n");
return Q_TRAN(&HDRCapture::Capture);
} // switch
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::Timeout(HDRCapture *me, QEvent const *e)
{
static uint32_t timeout = 0;
static uint32_t local_time = 0;
static uint32_t seconds_left = 0;
static uint8_t attribs = 0;
static uint16_t sec_cntdn = 1000;
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("Timeout\r\n");
return Q_HANDLED();
case SET_TIMEOUT_SIG:
attribs = ((SetTimeoutEvt*)e)->attribs;
timeout = (attribs & 0x01) ? ((SetTimeoutEvt*)e)->timeout * 1000 : ((SetTimeoutEvt*)e)->timeout;
if (attribs & 0x01)
{
seconds_left = ((SetTimeoutEvt*)e)->timeout;
sec_cntdn = 1000;
switch (attribs)
{
case TA_SELF_TIMER:
me->OnSelfTimerProgress(seconds_left);
break;
case TA_INTR_TIMER:
me->OnIntrTimerProgress(seconds_left);
break;
// case TA_BULB_TIMER:
// me->OnBulbTimerProgress(seconds_left);
// break;
} // switch
}
local_time = millis();
return Q_HANDLED();
case TICK_MILLIS_SIG:
uint32_t dt = local_time;
local_time = millis();
dt = local_time - dt;
timeout = (timeout < dt) ? 0 : timeout - dt;
 
if (attribs & 1)
{
bool bTick = (sec_cntdn <= dt);
sec_cntdn = (sec_cntdn > dt) ? sec_cntdn - dt : 1000 - dt;
if (bTick)
{
seconds_left --;
switch (attribs)
{
case TA_SELF_TIMER:
me->OnSelfTimerProgress(seconds_left);
break;
case TA_INTR_TIMER:
me->OnIntrTimerProgress(seconds_left);
break;
} // switch
} // if (--sec_cntdn == 0)
} // if (attribs & 1)
if (!timeout)
{
me->qpEvt.sig = TIMEOUT_SIG;
me->theQueue.Push(&me->qpEvt);
}
return Q_HANDLED();
} // switch
return Q_SUPER(&HDRCapture::Active);
}