int main()
{
// Set wave format when sampling the audio
WAVEFORMATEX wf;
SetWaveFormat(&wf,1,1,12000,1,8,0);
// Open wave input channel
HWAVEIN hWaveIn;
OpenWaveIn(&hWaveIn,&wf);
// Prepare Wave In Header and allocate memory
WAVEHDR waveHdr;
DWORD dataSize = 240000L;
PrepareWaveIn(&hWaveIn, &waveHdr, dataSize);
// Start recording
StartRecord(&hWaveIn);
Sleep(10000);
// Stop recording
MMTIME mmt;
StopRecord(&hWaveIn, &mmt);
SaveRecordtoFile("test//myTest.wav",&wf,&hWaveIn,&waveHdr,&mmt);
ReleaseWaveIn(&hWaveIn, &waveHdr);
CloseWaveIn(&hWaveIn);
system("pause");
return 0;
}
bool VideoCam::RecordNFrames(int f_num){
bool r=StartRecord();
rec_n_frames=f_num;
return r;
}
void CGhost::CheckStart()
{
int RaceTick = -m_pClient->m_Snap.m_pGameInfoObj->m_WarmupTimer;
int RenderTick = m_NewRenderTick;
if(m_LastRaceTick != RaceTick && Client()->GameTick() - RaceTick < Client()->GameTickSpeed())
{
if(m_Rendering && m_RenderingStartedByServer) // race restarted: stop rendering
StopRender();
if(m_Recording && m_LastRaceTick != -1) // race restarted: activate restarting for local start detection so we have a smooth transition
m_AllowRestart = true;
if(m_LastRaceTick == -1) // no restart: reset rendering preparations
m_NewRenderTick = -1;
if(GhostRecorder()->IsRecording()) // race restarted: stop recording
GhostRecorder()->Stop(0, -1);
int StartTick = RaceTick;
CServerInfo ServerInfo;
Client()->GetServerInfo(&ServerInfo);
if(IsDDRace(&ServerInfo)) // the client recognizes the start one tick earlier than ddrace servers
StartTick--;
StartRecord(StartTick);
RenderTick = StartTick;
}
TryRenderStart(RenderTick, true);
}
void FrameSaver::Toggle(int w)
{
if( m_record == 0 )
StartRecord(w) ;
else
m_record = 0 ;
}
void MOV_StartMovie(int mode)
{
Movie.mode = mode;
Movie.currentFrame = 0;
Movie.MaxRecFrames = 0;
Movie.lagCounter = 0;
Movie.currentCdrom = 1;
cdOpenCase = 0;
cheatsEnabled = 0;
Config.Sio = 0;
Config.VSyncWA = 0;
memset(&MovieControl, 0, sizeof(MovieControl));
if (Movie.mode == MOVIEMODE_RECORD)
{
StartRecord();
GPUdisplayText("Movie recording started.");
}
else if (Movie.mode == MOVIEMODE_PLAY)
{
if (!StartReplay())
MOV_StopMovie();
else
GPUdisplayText("Movie playback started.");
}
}
DeviceStatus Device::CheckDevice(astring strUrl, astring strUrlSubStream,
BOOL bHasSubStream, BOOL bOnline, BOOL bOnlineUrl)
{
if (bOnline == TRUE)
{
/* Camera from offline to online */
if (m_param.m_OnlineUrl == FALSE)
{
BOOL HWAccel = FALSE;
if (m_param.m_Conf.data.conf.HWAccel == 1)
{
HWAccel = TRUE;
}
if (bOnlineUrl == FALSE)
{
return DEV_NO_CHANGE;
}
m_param.m_strUrl = strUrl;
m_param.m_strUrlSubStream = strUrlSubStream;
m_param.m_bHasSubStream = bHasSubStream;
if (m_param.m_Conf.data.conf.nSubType == VSC_SUB_DEVICE_FILE)
{
m_vPlay.Init(m_param.m_strUrl, HWAccel);
}else
{
m_vPlay.Init(TRUE, m_param.m_strUrl, m_param.m_Conf.data.conf.User,
m_param.m_Conf.data.conf.Password, HWAccel);
VDC_DEBUG( "%s url %s\n",__FUNCTION__, m_param.m_strUrl.c_str());
if (m_param.m_bHasSubStream == TRUE)
{
m_vPlaySubStream.Init(TRUE, m_param.m_strUrlSubStream, m_param.m_Conf.data.conf.User,
m_param.m_Conf.data.conf.Password, HWAccel);
}
}
VDC_DEBUG( "%s url %s\n",__FUNCTION__, m_param.m_strUrl.c_str());
StartRecord();
StartHdfsRecord();
m_param.m_OnlineUrl = TRUE;
UpdatePTZConf();
}
if (m_param.m_Online == FALSE)
{
m_param.m_Online = TRUE;
return DEV_OFF2ON;
}
}else
{
if (m_param.m_Online == TRUE)
{
m_param.m_Online = FALSE;
return DEV_ON2OFF;
}
}
return DEV_NO_CHANGE;
}
////////////////////////////////////////////////////////////////
// リプレイ記録再開
//
// 引数: filename 出力ファイル名
// 引数: frame 途中再開するフレーム
// 返値: bool true:成功 false:失敗
////////////////////////////////////////////////////////////////
bool REPLAY::ResumeRecord( const char *filename, int frame )
{
if( !StartRecord( filename ) ) return false;
char buf[16];
sprintf( buf, "%08lX", frame );
// 指定されたフレーム以降のリプレイを削除し、そこから再開
Ini->DeleteAfter( "REPLAY", buf );
RepFrm = frame;
return true;
}
void CTestPage::OnRecord()
/////////////////////////////////////////////////////////////////////////////
{
static char BASED_CODE szFilter[] = "Wave Files(*.wav)|*.wav|All Files(*.*)|*.*||";
char szInitialDir[ _MAX_PATH ];
char szFileName[ _MAX_PATH ];
UpdateData( TRUE ); // Get data from the controls
if( !m_pHalAdapter->IsOpen() )
{
MessageBox( "Must Open Adapter First!" );
return;
}
if( m_nRecordMode == MODE_STOP )
{
// Pop up the file dialog box
CFileDialog dlg( TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_PATHMUSTEXIST, szFilter, this );
if( m_szFileName[0] )
{
char szDrive[ _MAX_DRIVE ];
char szDir[ _MAX_DIR ];
char szBaseName[ _MAX_FNAME ];
char szExt[ _MAX_EXT ];
_splitpath( m_szFileName, szDrive, szDir, szBaseName, szExt );
sprintf( szInitialDir, "%s%s", szDrive, szDir );
sprintf( szFileName, "%s%s", szBaseName, szExt );
dlg.m_ofn.lpstrInitialDir = szInitialDir;
dlg.m_ofn.lpstrFile = szFileName;
}
else
dlg.m_ofn.lpstrInitialDir = "D:\\Audio";
if( dlg.DoModal() == IDCANCEL )
return;
CString PathName;
PathName = dlg.GetPathName();
strcpy( m_szFileName, PathName.GetBuffer( _MAX_PATH - 1 ) );
PathName.ReleaseBuffer();
StartRecord();
}
else
{
StopRecord();
}
}
inline BOOL StorFactory::StartRecordAll()
{
Lock();
CameraParamMap CameraMap = m_CameraParamMap;
UnLock();
CameraParamMap::iterator it = CameraMap.begin();
for(; it!=CameraMap.end(); ++it)
{
StartRecord((*it).second.m_Conf.data.conf.nId);
}
return TRUE;
}
inline BOOL Factory::StartRecordAll()
{
Lock();
DeviceParamMap DeviceMap = m_DeviceParamMap;
UnLock();
DeviceParamMap::iterator it = DeviceMap.begin();
for(; it!=DeviceMap.end(); ++it)
{
StartRecord((*it).second.m_Conf.data.conf.nId);
}
return TRUE;
}
void CGhost::CheckStartLocal(bool Predicted)
{
if(Predicted) // rendering
{
int RenderTick = m_NewRenderTick;
vec2 PrevPos = m_pClient->m_PredictedPrevChar.m_Pos;
vec2 Pos = m_pClient->m_PredictedChar.m_Pos;
if(((!m_Rendering && RenderTick == -1) || m_AllowRestart) && CRaceHelper::IsStart(m_pClient, PrevPos, Pos))
{
if(m_Rendering && !m_RenderingStartedByServer) // race restarted: stop rendering
StopRender();
RenderTick = Client()->PredGameTick();
}
TryRenderStart(RenderTick, false);
}
else // recording
{
int PrevTick = m_pClient->m_Snap.m_pLocalPrevCharacter->m_Tick;
int CurTick = m_pClient->m_Snap.m_pLocalCharacter->m_Tick;
vec2 PrevPos = vec2(m_pClient->m_Snap.m_pLocalPrevCharacter->m_X, m_pClient->m_Snap.m_pLocalPrevCharacter->m_Y);
vec2 Pos = vec2(m_pClient->m_Snap.m_pLocalCharacter->m_X, m_pClient->m_Snap.m_pLocalCharacter->m_Y);
// detecting death, needed because race allows immediate respawning
if((!m_Recording || m_AllowRestart) && m_LastDeathTick < PrevTick)
{
// estimate the exact start tick
int RecordTick = -1;
int TickDiff = CurTick - PrevTick;
for(int i = 0; i < TickDiff; i++)
{
if(CRaceHelper::IsStart(m_pClient, mix(PrevPos, Pos, (float)i / TickDiff), mix(PrevPos, Pos, (float)(i + 1) / TickDiff)))
{
RecordTick = PrevTick + i + 1;
if(!m_AllowRestart)
break;
}
}
if(RecordTick != -1)
{
if(GhostRecorder()->IsRecording()) // race restarted: stop recording
GhostRecorder()->Stop(0, -1);
StartRecord(RecordTick);
}
}
}
}
LRESULT CALLBACK WinKongZhiProc(
HWND hwnd, // handle to window
UINT uMsg, // message identifier
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter
)
{
switch(uMsg)
{
case WM_LBUTTONDOWN:
{
if (!m_bRecording)
{
StartRecord(hwnd);
m_bRecording = TRUE;
}
else
{
StopAndSave();
PostQuitMessage(0);
}
break;
}
case WM_CLOSE:
if(IDYES==MessageBox(hwnd,"是否真的结束？",NULL,MB_YESNO))
{
DestroyWindow(hwnd);
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd,uMsg,wParam,lParam);
}
return 0;
}
void VideoAndSound() {
VideoCapture capture;
//capture.open("rtsp://*****:*****@192.168.1.65/Streaming/Channels/1"); //����ͷ1
capture.open("rtsp://*****:*****@192.168.1.141:554/axis-media/media.amp"); // ����ͷ2
//capture.open("rtsp://service:@10.153.33.11/?line=1$camera"); //�˴�ΰ ����
//capture.open(0); //open ���ݱ�Ŵ�����ͷ
//AVI or ASF
// MPEG4 CV_FOURCC('D', 'I', 'V', 'X')
// MJPG CV_FOURCC('M', 'J', 'P', 'G')
VideoWriter writer("VideoTestDemo.avi", CV_FOURCC('M', 'J', 'P', 'G'), 30.0, Size(640, 480));
std::cout << "-------------" << std::endl;
if (!capture.isOpened())
{
std::cout << "Read video Failed !" << std::endl;
return;
}
//cv::VideoCapture capture;
cv::Mat frame;
cv::namedWindow("video test");
int frame_num = 800;
//��ʼ¼��
StartRecord();
//for (;;) {
// if (!capture.read(frame)) {
// std::cout << "No frame" << std::endl;
// cv::waitKey();
// }
// writer << frame;
// cv::imshow("Output Window", frame);
// if (cv::waitKey(1) >= 0) break;
//}
for (int i = 0; i < frame_num - 1; ++i)
{
capture >> frame;
capture.read(frame);
//���۽���ǰ
imshow("video test", frame);
writer << frame;
//���۽����� ��Ƶ�洢��¼����������
//writer << fisheye2pano2(frame);
//frame = fisheye2pano2(frame);
//imshow("fisheyevideo test", frame);
if (cv::waitKey(30) == 'q')
{
break;
}
}
//������Ƶ
StopRecord();
SaveRecord();
cv::destroyWindow("video test");
//cv::destroyAllWindows();
capture.release();
Encode();
}
//
// 函数: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// 目的: 处理主窗口的消息。
//
// WM_COMMAND - 处理应用程序菜单
// WM_PAINT - 绘制主窗口
// WM_DESTROY - 发送退出消息并返回
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_CREATE:
{
g_hWndMain = hWnd;
CreateControlButtons(hWnd);
UpdateButtonStatus();
}
break;
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// 分析菜单选择:
switch (wmId)
{
case IDM_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
case START_CAPTURE_ID:
StartRecord();
break;
case STOP_CAPTURE_ID:
StopRecord();
break;
case START_PLAY_ID:
StartPlay();
break;
case STOP_PLAY_ID:
StopPlay();
break;
case START_EXTRACT_ID:
StartExtract();
break;
case STOP_EXTRACT_ID:
StopExtract();
break;
case ADD_SCALE_ID:
AddScale();
break;
case SUB_SCALE_ID:
SubScale();
break;
case PAINT_RECORD_ID:
PaintRecorder();
break;
case PAINT_EXTRACT_ID:
PaintExtractor();
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
// TODO: 在此添加任意绘图代码...
if (g_pAudioPainter->IsEnable())
{
RECT rect;
::GetWindowRect(hWnd, &rect);
rect.right = rect.right - rect.left - 20;
rect.left = 10;
rect.bottom = (rect.bottom - rect.top) / 2;
rect.top = 200;
g_pAudioPainter->Paint(hWnd, hdc, rect, 10.0f);
}
wchar_t buf[20];
wsprintf(buf, L"Scale: %d%%", (int)(g_pAudioPainter->GetScale() * 100));
::TextOut(hdc, 0, 0, buf, ::wcslen(buf));
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
case WM_TIMER:
if (g_pAudioPainter->IsEnable())
{
RECT rect = { 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT };
::InvalidateRect(hWnd, &rect, true);
}
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
/**
* Server command receiver routine.
*
* @param pkt
* packet node.
* @return
* 15 to exit command thread, all other value
* are considered normal.
*/
int
SrvRxCmd( void * pkt )
{
int ret = 0;
int acked = 0;
pkt_node_t * p = (pkt_node_t *)pkt;
DBGLOG("command: %d", p->hdr.cmd);
switch (p->hdr.cmd)
{
case CMD_GET_VERSION:
DBGLOG("CMD_GET_VERSION.");
CoolCmdSendPacket(p->fd, CMD_GET_VERSION|NMS_CMD_ACK,
(void*)version, strlen(version)+1);
acked = 1;
break;
// careful: this will be the last command server responds to.
case CMD_STOP_SERVER:
DBGLOG("CMD_STOP_SERVER.");
ret = 15;
break;
case CMD_SET_INPUT_MODE:
DBGLOG("CMD_SET_INPUT_MODE.");
EncInputSetMode(*(int*)p->data);
break;
case CMD_SET_OUTPUT_MODE:
DBGLOG("CMD_SET_OUTPUT_MODE.");
{
OutputSetMode(*(int*)p->data);
if (SrvIsMonitorActive())
{
SrvStartMonitorInternal();
}
else if (SrvIsRecording())
{
}
else if (SrvIsPlaying())
{
OutputActivateMode(0);
}
}
break;
case CMD_SET_OUTPUT_PROPORTIONS:
DBGLOG("CMD_SET_OUTPUT_PROPORTIONS.");
SrvSetProportions((*(int*)p->data));
break;
case CMD_GET_OUTPUT_PROPORTIONS:
DBGLOG("CMD_GET_OUTPUT_PROPORTIONS.");
int proportions = SrvGetProportions();
CoolCmdSendPacket(p->fd, CMD_GET_OUTPUT_PROPORTIONS|NMS_CMD_ACK,
(void*)&proportions, sizeof(int));
acked = 1;
break;
case CMD_START_SLIDE_SHOW:
DBGLOG("CMD_START_SLIDE_SHOW.");
{
int startslideshow;
startslideshow = SrvStartSlideShow();
CoolCmdSendPacket(p->fd, CMD_START_SLIDE_SHOW|NMS_CMD_ACK,
(void*)&startslideshow, sizeof(int));
acked = 1;
DBGLOG("CMD_START_SLIDE_SHOW completed.");
}
break;
case CMD_SET_SLIDE_SHOW_IMAGE:
DBGLOG("CMD_SLIDE_SHOW_SET_IMAGE.");
{
SrvSlideShowSetImage((char *)p->data);
}
break;
case CMD_STOP_SLIDE_SHOW:
DBGLOG("CMD_SLIDE_SHOW_STOP.");
SrvStopSlideShow();
break;
case CMD_PLAY:
DBGLOG("CMD_PLAY.");
int ret = StartPlay(p->data, p->hdr.dataLen);
CoolCmdSendPacket(p->fd, CMD_PLAY|NMS_CMD_ACK,
(void*)&ret, sizeof(int));
acked = 1;
break;
case CMD_PAUSE_UNPAUSE:
DBGLOG("CMD_PAUSE_UNPAUSE.");
SrvPauseUnpause();
break;
case CMD_STOP_PLAY:
DBGLOG("CMD_STOP_PLAY.");
SrvStop();
break;
case CMD_GET_SRV_STATUS:
DBGLOG("CMD_GET_SRV_STATUS.");
{
int status;
status = SrvGetSrvStatus();
CoolCmdSendPacket(p->fd, CMD_GET_SRV_STATUS|NMS_CMD_ACK,
(void*)&status, sizeof(int));
acked = 1;
}
break;
case CMD_GET_VOLUME:
DBGLOG("CMD_GET_VOLUME.");
{
int vol[2];
SrvGetVolume(&vol[0], &vol[1]);
CoolCmdSendPacket(p->fd, CMD_GET_VOLUME|NMS_CMD_ACK,
(void*)vol, sizeof(vol));
acked = 1;
}
break;
case CMD_SET_VOLUME:
DBGLOG("CMD_SET_VOLUME.");
{
int vol[2];
int * pv;
pv = (int*)p->data;
vol[0] = *pv++;
vol[1] = *pv;
SrvSetVolume(vol[0], vol[1]);
}
break;
case CMD_GET_PLAY_TIME:
DBGLOG("CMD_GET_PLAYTIME.");
{
int t;
t = SrvGetPlaytime();
CoolCmdSendPacket(p->fd, CMD_GET_PLAY_TIME|NMS_CMD_ACK,
(void*)&t, sizeof(int));
acked = 1;
}
break;
case CMD_SEEK:
DBGLOG("CMD_SEEK.");
{
int t;
int *pv;
pv = (int*)p->data;
t = *pv;
t = SrvSeek(t);
CoolCmdSendPacket(p->fd, CMD_SEEK|NMS_CMD_ACK,
(void*)&t, sizeof(int));
acked = 1;
}
break;
case CMD_TRACK_CHANGE:
DBGLOG("CMD_TRACK_CHANGE.");
{
int track;
int *pv;
int retv;
pv = (int*)p->data;
track = *pv;
retv = SrvTrackChange(track);
CoolCmdSendPacket(p->fd, CMD_TRACK_CHANGE|NMS_CMD_ACK,
(void*)&retv, sizeof(int));
acked = 1;
}
break;
case CMD_FF_RW:
DBGLOG("CMD_FF_RW.");
SrvFfRw(*(int*)p->data);
break;
case CMD_GET_FFRW_LEVEL:
DBGLOG("CMD_GET_FFRW_LEVEL.");
{
int level = SrvGetFFRWLevel();
CoolCmdSendPacket(p->fd, CMD_GET_FFRW_LEVEL|NMS_CMD_ACK,
(void*)&level, sizeof(int));
acked = 1;
}
break;
case CMD_SF_RW:
DBGLOG("CMD_SF_RW.");
SrvSfRw(*(int*)p->data);
break;
case CMD_GET_SFRW_LEVEL:
DBGLOG("CMD_GET_SFRW_LEVEL.");
{
int level = SrvGetSFRWLevel();
CoolCmdSendPacket(p->fd, CMD_GET_SFRW_LEVEL|NMS_CMD_ACK,
(void*)&level, sizeof(int));
acked = 1;
}
break;
case CMD_FRAME_BY_FRAME:
DBGLOG("CMD_FRAME_BY_FRAME.");
SrvFrameByFrame(*(int*)p->data);
break;
case CMD_REPEAT_A_B:
DBGLOG("CMD_REPEAT_A_B.");
SrvRepeatAB(*(int*)p->data);
break;
case CMD_GET_REPEAT_AB_STATUS:
DBGLOG("CMD_GET_REPEAT_AB_STATUS.");
{
int status = SrvGetRepeatABStatus();
CoolCmdSendPacket(p->fd, CMD_GET_REPEAT_AB_STATUS|NMS_CMD_ACK,
(void*)&status, sizeof(int));
acked = 1;
}
break;
case CMD_IS_PLAYING:
DBGLOG("CMD_IS_PLAYING.");
{
int playing = SrvIsPlaying();
CoolCmdSendPacket(p->fd, CMD_IS_PLAYING|NMS_CMD_ACK,
(void*)&playing, sizeof(int));
acked = 1;
}
break;
case CMD_GET_PLAYMODE:
DBGLOG("CMD_GET_PLAYMODE.");
{
int mode = SrvGetPlaymode();
CoolCmdSendPacket(p->fd, CMD_GET_PLAYMODE|NMS_CMD_ACK,
(void*)&mode, sizeof(int));
acked = 1;
}
break;
case CMD_SET_PLAYMODE:
DBGLOG("CMD_SET_PLAYMODE.");
{
SrvSetPlaymode(*((int*)p->data));
}
break;
case CMD_SET_EDITMODE:
DBGLOG("CMD_SET_EDITMODE.");
{
SrvSetEditmode(*((int*)p->data));
}
break;
case CMD_GET_REPEATMODE:
DBGLOG("CMD_GET_REPEATMODE.");
{
int mode = SrvGetRepeatmode();
CoolCmdSendPacket(p->fd, CMD_GET_REPEATMODE|NMS_CMD_ACK,
(void*)&mode, sizeof(int));
acked = 1;
}
break;
case CMD_SET_REPEATMODE:
DBGLOG("CMD_SET_REPEATMODE.");
{
SrvSetRepeatmode(*((int*)p->data));
}
break;
case CMD_GET_TOTAL_FILES:
DBGLOG("CMD_GET_TOTAL_FILES.");
{
int num = SrvGetTotalFiles();
CoolCmdSendPacket(p->fd, CMD_GET_TOTAL_FILES|NMS_CMD_ACK,
(void*)&num, sizeof(int));
acked = 1;
}
break;
case CMD_GET_FILE_INDEX:
DBGLOG("CMD_GET_FILE_INDEX.");
{
int idx = SrvGetFileIndex();
CoolCmdSendPacket(p->fd, CMD_GET_FILE_INDEX|NMS_CMD_ACK,
(void*)&idx, sizeof(int));
acked = 1;
}
break;
case CMD_GET_FILE_PATH:
DBGLOG("CMD_GET_FILE_PATH.");
{
char path[PATH_MAX];
int idx;
int *pv;
pv = (int*)p->data;
idx = *pv;
SrvGetFilePath(idx, path,PATH_MAX);
CoolCmdSendPacket(p->fd, CMD_GET_FILE_PATH|NMS_CMD_ACK,
(void*)path, strlen(path)+1);
acked = 1;
}
break;
case CMD_MEDIA_INFO:
DBGLOG("CMD_MEDIA_INFO.");
{
media_info_t media_info;
memset(&media_info, 0 , sizeof(media_info_t));
SrvGetMediaInfo((char *)p->data, &media_info);
CoolCmdSendPacket(p->fd,CMD_MEDIA_INFO|NMS_CMD_ACK,
(void *)(&media_info),sizeof(media_info_t));
acked = 1;
}
break;
/* start of encoder interface. */
case CMD_RECORD:
DBGLOG("CMD_RECORD.");
NMS_SRV_ERROR_DETAIL result;
StartRecord(p->data, p->hdr.dataLen, &result);
CoolCmdSendPacket(p->fd, CMD_RECORD | NMS_CMD_ACK,
(void *)(&result), sizeof(NMS_SRV_ERROR_DETAIL));
acked = 1;
break;
case CMD_PAUSE_UNPAUSE_RECORD:
DBGLOG("CMD_PAUSE_UNPAUSE_RECORD.");
SrvPauseRecord(*(int*)p->data);
break;
case CMD_STOP_RECORD:
DBGLOG("CMD_STOP_RECORD.");
SrvStopRecord();
break;
case CMD_GET_GAIN:
DBGLOG("CMD_GET_GAIN.");
{
int gain[2];
SrvGetGain(&gain[0], &gain[1]);
CoolCmdSendPacket(p->fd, CMD_GET_GAIN|NMS_CMD_ACK,
(void*)gain, sizeof(gain));
acked = 1;
}
break;
case CMD_SET_GAIN:
DBGLOG("CMD_SET_GAIN.");
{
int gain[2];
int * pg;
pg = (int*)p->data;
gain[0] = *pg++;
gain[1] = *pg;
SrvSetGain(gain[0], gain[1]);
}
break;
case CMD_GET_RECORD_TIME:
DBGLOG("CMD_GET_RECORD_TIME.");
{
int t;
t = SrvGetRecordtime();
CoolCmdSendPacket(p->fd, CMD_GET_RECORD_TIME|NMS_CMD_ACK,
(void*)&t, sizeof(int));
acked = 1;
}
break;
case CMD_GET_RECORD_SIZE:
DBGLOG("CMD_GET_RECORD_SIZE.");
{
unsigned int t;
t = SrvGetRecordsize();
CoolCmdSendPacket(p->fd, CMD_GET_RECORD_SIZE|NMS_CMD_ACK,
(void*)&t, sizeof(unsigned int));
acked = 1;
}
break;
case CMD_GET_RECORD_ERROR:
DBGLOG("CMD_GET_RECORD_ERROR.");
{
NMS_SRV_ERROR_DETAIL det;
SrvGetRecordError(&det);
CoolCmdSendPacket(p->fd, CMD_GET_RECORD_ERROR|NMS_CMD_ACK,
(void*)&det, sizeof(NMS_SRV_ERROR_DETAIL));
acked = 1;
}
break;
case CMD_IS_RECORDING:
DBGLOG("CMD_IS_RECORDING.");
{
int recording = SrvIsRecording();
CoolCmdSendPacket(p->fd, CMD_IS_RECORDING|NMS_CMD_ACK,
(void*)&recording, sizeof(int));
acked = 1;
}
break;
case CMD_START_MONITOR:
DBGLOG("CMD_START_MONITOR.");
{
int startmonitor;
int pid = (*(int*)p->data);
startmonitor = SrvStartMonitor(pid);
CoolCmdSendPacket(p->fd, CMD_START_MONITOR|NMS_CMD_ACK,
(void*)&startmonitor, sizeof(int));
acked = 1;
DBGLOG("CMD_START_MONITOR completed.");
}
break;
case CMD_STOP_MONITOR:
DBGLOG("CMD_STOP_MONITOR.");
int pid = (*(int*)p->data);
SrvStopMonitor(pid);
break;
case CMD_IS_MONITOR_ENABLED:
DBGLOG("CMD_IS_MONITOR_ENABLED.");
{
int monitoractive = SrvIsMonitorActive();
CoolCmdSendPacket(p->fd, CMD_IS_MONITOR_ENABLED|NMS_CMD_ACK,
(void*)&monitoractive, sizeof(int));
acked = 1;
}
break;
case CMD_CAP_INIT:
DBGLOG("CMD_CAP_INIT.");
{
capture_desc_t desc;
capture_ret_t capret;
desc.capture_type = (*(int*)p->data);
int suc = CaptureInit(&desc);
if(suc)
{
capret.width = -1;
capret.height = -1;
}
else
{
capret.width = desc.width;
capret.height = desc.height;
}
capret.ret = suc;
CoolCmdSendPacket(p->fd,CMD_CAP_INIT|NMS_CMD_ACK,
(void *)(&capret),sizeof(capture_ret_t));
acked = 1;
}
break;
case CMD_CAP_GET_FRAME:
DBGLOG("CMD_CAP_GET_FRAME.");
{
frame_desc_t desc;
int suc = CaptureGetFrame(&desc);
if(suc)
{
CoolCmdSendPacket(p->fd, CMD_CAP_GET_FRAME|NMS_CMD_ACK,
(void *)(&suc), sizeof(int));
}
else
{
CoolCmdSendPacket(p->fd, CMD_CAP_GET_FRAME|NMS_CMD_ACK,
(void *)(desc.data), desc.size);
CaptureReleaseFrame();
}
acked = 1;
}
break;
case CMD_CAP_FINISH:
DBGLOG("CMD_CAP_FINISH.");
{
int suc = CaptureFinish();
CoolCmdSendPacket(p->fd, CMD_CAP_FINISH|NMS_CMD_ACK,
(void*)&suc, sizeof(int));
acked = 1;
}
break;
case CMD_PING:
DBGLOG("CMD_PING.");
break;
default:
/* retain the data for now. */
WPRINT("unknown command, data retained.");
ret = 1;
break;
}
/* send back original command as ack. */
if (!acked)
{
CoolCmdSendPacket(p->fd, p->hdr.cmd|NMS_CMD_ACK, NULL, 0);
DBGLOG("server acked.");
}
close(p->fd);
/* release data. */
if ( 0 == ret )
{
if (p->hdr.dataLen) free(p->data);
}
return ret;
}
tBool DAXAudio::Start()
{
return StartRecord() && StartPlay();
}
