//int CPROC CompressFrame( PCOMPRESS pCompress, POINTER *data, INDEX *len )
int CPROC CompressFrame( uintptr_t psv, PCAPTURE_DEVICE pDevice )
{
PCOMPRESS pCompress = (PCOMPRESS)psv;
int xerr;
Image frame;
GetDeviceData( pDevice, &frame, NULL );
{ // setup constant factors about encoding behavior
pCompress->xframe.version = XVID_VERSION;
//pCompress->xframe.general = 0;
pCompress->xframe.motion = 0; /*PMV_ADVANCEDDIAMOND16;*/
pCompress->xframe.quant = 0; //1-31 specify quantizer...
//pCompress->xframe.intra = -0; // 1- force keyframe, 0-force not keyframe
pCompress->xframe.quant_intra_matrix = NULL;
pCompress->xframe.quant_inter_matrix = NULL;
/* setup the input frame here... */
pCompress->xframe.type = XVID_TYPE_AUTO;
pCompress->xframe.input.csp = XVID_CSP_BGRA;
pCompress->xframe.input.plane[0] = frame->image;
pCompress->xframe.input.stride[0] = frame->pwidth*sizeof(CDATA);
if( !pCompress->xframe.bitstream )
{
pCompress->xframe.length = frame->pwidth * frame->height; //frame->width * frame->height * 4;
pCompress->xframe.bitstream = Allocate( frame->pwidth * frame->height );
}
}
pCompress->xstats.version = XVID_VERSION;
xerr = xvid_encore( pCompress->xparam.handle, XVID_ENC_ENCODE, &pCompress->xframe, &pCompress->xstats );
if(0)
lprintf( WIDE("stats! %d %d %d %d %d %d")
, xerr
, pCompress->xstats.length
, pCompress->xstats.hlength
, pCompress->xstats.kblks
, pCompress->xstats.mblks
, pCompress->xstats.ublks );
if( xerr < 0 || xerr > 512000 )
{
lprintf( WIDE("Resulting %d data was %p(%d)")
, xerr
, pCompress->xframe.bitstream
, pCompress->xframe.length );
}
MemCpy( pCompress->bitstream, pCompress->xframe.bitstream, xerr );
SetDeviceData( pDevice, pCompress->bitstream, xerr );
// at this point pCompress->xframe.intra 0 did not result in keyframe
// 1 is a keyframe (scene change) 2 is keyframe (max keyfram interval)
return 1;
}
// returns FALSE on END command, TRUE otherwise
bool tScriptState::ExecuteCommand(tCommand& cmd)
{
bool bContinue = TRUE;
switch(cmd.cmdId)
{
case cmdLabel:
break;
case cmdGoto:
{
ULONG step;
const tParameter *pParam = cmd.params.GetAt(0);
if (!FindLabelByName(*pParam, &step))
{
FailCase("Can't find label %s", (LPCSTR)pParam->String());
}
else
{
currentCommandIndex = step;
}
}
break;
case cmdIf:
{
bool bTrue = EvaluateCondition(cmd.params[0]->String());
if (!bTrue)
{
currentCommandIndex = cmd.elseStepForIf;
}
}
break;
case cmdEnd:
bContinue = FALSE;
break;
case cmdSet:
{
ULONG data;
ULONG value = cmd.params[1]->Value();
if (!GetVariable(cmd.params[0]->String(), data) || data != value)
{
data = value;
SetVariable(cmd.params[0]->String(), data);
}
}
break;
case cmdAdd:
{
ULONG data;
if (GetVariable(cmd.params[0]->String(), data))
{
data += cmd.params[1]->Value();
SetVariable(cmd.params[0]->String(), data);
}
else
{
FailCase("Can't add %s", cmd.params[0]->String());
}
}
break;
case cmdPrepare:
{
ULONG data;
if (GetVariable("use_merged_buffers", data))
bUseMergedBuffers = !!data;
if (GetVariable("use_published_events", data))
bUsePublishedIndices = !!data;
if (GetVariable("use_msix", data))
bMSIXUsed = !!data;
SimulationPrepare();
}
break;
case cmdTxAsync:
{
bAsyncTransmit = !!cmd.params[0]->Value();
}
break;
case cmdSend:
{
AddTxBuffers(cmd.params[0]->Value(), cmd.params[1]->Value());
}
break;
case cmdTxComplete:
{
CompleteTx((int)cmd.params[0]->Value());
}
break;
case cmdTxGet:
{
GetTxBuffer(cmd.params[0]->Value());
}
break;
case cmdRxReturn:
{
ReturnRxBuffer(cmd.params[0]->Value());
}
break;
case cmdRxReceive:
{
RxReceivePacket((UCHAR)cmd.params[0]->Value());
}
break;
case cmdDataGet:
{
UCHAR offset, val, res;
offset = (UCHAR)cmd.params[0]->Value();
val = (UCHAR)cmd.params[1]->Value();
res = GetDeviceData(offset);
if (res != val)
{
FailCase("cmdDataGet(%d) = %d, expected %d", offset, res, val);
}
}
break;
case cmdDataSet:
{
UCHAR offset, val;
offset = (UCHAR)cmd.params[0]->Value();
val = (UCHAR)cmd.params[1]->Value();
SetDeviceData(offset, val);
}
break;
case cmdRxRestart:
{
BOOLEAN bExpected = (BOOLEAN)cmd.params[0]->Value();
BOOLEAN b = RxRestart();
if (b != bExpected)
{
FailCase("RxRestart: %d, expected %d", b, bExpected);
}
}
break;
case cmdTxRestart:
{
BOOLEAN bExpected = (BOOLEAN)cmd.params[0]->Value();
BOOLEAN b = TxRestart();
if (b != bExpected)
{
FailCase("TxRestart: %d, expected %d", b, bExpected);
}
}
break;
case cmdTxEnableInterrupt:
{
TxEnableInterrupt();
}
break;
case cmdTxDisableInterrupt:
{
TxDisableInterrupt();
}
break;
case cmdRxEnableInterrupt:
{
RxEnableInterrupt();
}
break;
case cmdRxDisableInterrupt:
{
RxDisableInterrupt();
}
break;
case cmdRxGet:
{
ULONG len;
GetRxBuffer(&len);
}
break;
case cmdControlRxMode:
{
SetRxMode((UCHAR)cmd.params[0]->Value(), cmd.params[1]->Value() != 0);
}
break;
case cmdControlVlanAdd:
{
USHORT us = (USHORT)cmd.params[0]->Value();
VlansAdd(&us, 1);
}
break;
case cmdControlVlanDel:
{
USHORT us = (USHORT)cmd.params[0]->Value();
VlansDel(&us, 1);
}
break;
case cmdControlMacTable:
{
SetMacAddresses(cmd.params[0]->Value());
}
default:
result = 1;
break;
}
return bContinue;
}
DWORD
ProcessSessionThreadRequest(SessionInfo* session_info)
{
MMRESULT result = MMSYSERR_NOERROR;
switch ( session_info->thread.function )
{
case WODM_WRITE :
{
result = QueueWaveBuffer(session_info,
(LPWAVEHDR) session_info->thread.parameter);
break;
}
case WODM_RESET :
{
/* TODO */
break;
}
case WODM_PAUSE :
{
/* TODO */
break;
}
case WODM_RESTART :
{
/* TODO */
break;
}
case WODM_GETPOS :
{
/* TODO */
break;
}
case WODM_SETPITCH :
{
result = SetDeviceData(session_info->kernel_device_handle,
IOCTL_WAVE_SET_PITCH,
(PBYTE) session_info->thread.parameter,
sizeof(DWORD));
break;
}
case WODM_GETPITCH :
{
result = GetDeviceData(session_info->kernel_device_handle,
IOCTL_WAVE_GET_PITCH,
(PBYTE) session_info->thread.parameter,
sizeof(DWORD));
break;
}
case WODM_SETVOLUME :
{
break;
}
case WODM_GETVOLUME :
{
#if 0
result = GetDeviceData(session_info->kernel_device_handle,
IOCTL_WAVE_GET_VOLUME,
(PBYTE) session_info->thread.parameter,);
#endif
break;
}
case WODM_SETPLAYBACKRATE :
{
result = SetDeviceData(session_info->kernel_device_handle,
IOCTL_WAVE_SET_PLAYBACK_RATE,
(PBYTE) session_info->thread.parameter,
sizeof(DWORD));
break;
}
case WODM_GETPLAYBACKRATE :
{
result = GetDeviceData(session_info->kernel_device_handle,
IOCTL_WAVE_GET_PLAYBACK_RATE,
(PBYTE) session_info->thread.parameter,
sizeof(DWORD));
break;
}
case WODM_CLOSE :
{
DPRINT("Thread was asked if OK to close device\n");
if ( session_info->wave_queue != NULL )
result = WAVERR_STILLPLAYING;
else
result = MMSYSERR_NOERROR;
break;
}
case DRVM_TERMINATE :
{
DPRINT("Terminating thread...\n");
result = MMSYSERR_NOERROR;
break;
}
default :
{
DPRINT("INVALID FUNCTION\n");
result = MMSYSERR_ERROR;
break;
}
}
/* We're done with the function now */
return result;
}
