Barst  2.0
A server that controls lab hardware.
rtv device.cpp
1 
12 #include "base classses.h"
13 #include "named pipes.h"
14 #include "rtv device.h"
15 #include "misc tools.h"
16 
17 short (PASCAL *lpf_AngeloRTV_Initial)(unsigned short PortNo)= NULL; //
18 short (PASCAL *lpf_AngeloRTV_Close)(unsigned short PortNo)= NULL; //
19 unsigned short (PASCAL *lpf_AngeloRTV_Read_Serial)(unsigned short CardNo, unsigned long* HighByte, unsigned long* LowByte)= NULL; //
20 short (PASCAL *lpf_AngeloRTV_Get_Version)(unsigned long *DriverVersion,unsigned long *DLLVersion,unsigned long *Reserved)= NULL; //
21 short (PASCAL *lpf_AngeloRTV_Set_Image_Config)(unsigned short PortNo,unsigned char ConfigIndex ,unsigned char Value)= NULL; //
22 short (PASCAL *lpf_AngeloRTV_Set_Color_Format)(unsigned short PortNo,unsigned char ColorFormat)= NULL; //
23 short (PASCAL *lpf_AngeloRTV_Set_Video_Format)(unsigned short PortNo,unsigned char Value)= NULL; //
24 short (PASCAL *lpf_AngeloRTV_Capture_Start)(unsigned short PortNo, unsigned long CaptureNo)= NULL; //
25 short (PASCAL *lpf_AngeloRTV_Capture_Stop)(unsigned short PortNo)= NULL; //
26 short (PASCAL *lpf_AngeloRTV_Select_Channel)(unsigned short PortNo,unsigned short Multiplex)= NULL; //
27 short (PASCAL *lpf_AngeloRTV_Capture_Config)(unsigned short PortNo, unsigned long Start_Field)= NULL; //
28 short (PASCAL *lpf_AngeloRTV_Set_Callback)(unsigned short PortNo, void ( __stdcall *CallBackProc)(void *VideoBufferaddress ,unsigned short PortNo))= NULL; //
29 short (PASCAL *lpf_AngeloRTV_Get_Int_Status)(unsigned short PortNo,unsigned long *IntStatus)= NULL; //
30 
31 static CManagerRTV* s_pCRTVMan= NULL;
32 
33 extern "C" void __stdcall MediaStreamProc(void* VideoBufferAddress ,unsigned short PortNo)
34 {
35  DWORD dwStatus;
36  if (s_pCRTVMan && !lpf_AngeloRTV_Get_Int_Status(PortNo, &dwStatus) && (dwStatus&~0x01) == 0x02)
37  s_pCRTVMan->NextFrame((unsigned char*)VideoBufferAddress, PortNo);
38 }
39 
40 
41 CManagerRTV::CManagerRTV(CComm* pcComm, const TCHAR szPipe[], int nChan, int &nError) :
42  CManager(RTV_MAN_STR, std::tstring(szPipe), nChan)
43 {
44  nError= 0;
45  m_bError= true;
46  m_pcComm= NULL;
47  m_pcLogBuffer= NULL;
48  m_pcMemPool= new CMemPool;
49  m_hLib= NULL;
50  m_usChans= 0;
51 
52  if(s_pCRTVMan)
53  {
54  nError= ALREADY_OPEN;
55  return;
56  }
57  s_pCRTVMan= this;
58  if (!pcComm || !szPipe)
59  {
60  nError= BAD_INPUT_PARAMS;
61  return;
62  }
63  BOOL bRes= GetProcAddresses(&m_hLib, _T("AngeloRTV.dll"), 13, &lpf_AngeloRTV_Initial, "AngeloRTV_Initial",
64  &lpf_AngeloRTV_Close, "AngeloRTV_Close", &lpf_AngeloRTV_Read_Serial, "AngeloRTV_Read_Serial",
65  &lpf_AngeloRTV_Get_Version, "AngeloRTV_Get_Version", &lpf_AngeloRTV_Set_Image_Config, "AngeloRTV_Set_Image_Config",
66  &lpf_AngeloRTV_Set_Color_Format, "AngeloRTV_Set_Color_Format", &lpf_AngeloRTV_Set_Video_Format,
67  "AngeloRTV_Set_Video_Format", &lpf_AngeloRTV_Capture_Start, "AngeloRTV_Capture_Start", &lpf_AngeloRTV_Capture_Stop,
68  "AngeloRTV_Capture_Stop", &lpf_AngeloRTV_Select_Channel, "AngeloRTV_Select_Channel", &lpf_AngeloRTV_Capture_Config,
69  "AngeloRTV_Capture_Config", &lpf_AngeloRTV_Set_Callback, "AngeloRTV_Set_Callback", &lpf_AngeloRTV_Get_Int_Status,
70  "AngeloRTV_Get_Int_Status");
71  if (!bRes || !m_hLib)
72  {
73  nError= DRIVER_ERROR;
74  return;
75  }
76  DWORD dwDriverVersion[4]= {0};
77  DWORD dwDLLVersion[4]= {0};
78  DWORD dwReserved[4]= {0};
79  if (nError= RTV_ERROR(lpf_AngeloRTV_Get_Version(dwDriverVersion, dwDLLVersion, dwReserved), nError))
80  return;
81  if (dwDLLVersion[0]*1000+dwDLLVersion[1]*100+dwDLLVersion[2]*10+dwDLLVersion[3] < MIN_RTV_LIB_VER)
82  {
83  nError= DRIVER_ERROR;
84  return;
85  }
86  unsigned short i= 0;
87  while (!lpf_AngeloRTV_Initial(i)) // find out how many cards total we have
88  {
89  i+= 4;
90  }
91  m_usChans= i; // total ports
92  m_ahCallbackSafe.assign(m_usChans, NULL);
93  m_acRTVDevices.assign(m_usChans, NULL);
94  for (i= 0; i<m_usChans; ++i)
95  {
96  m_ahCallbackSafe[i]= new CRITICAL_SECTION;
97  InitializeCriticalSection(m_ahCallbackSafe[i]);
98  }
99  m_bError= false;
100  m_pcComm= pcComm;
101 }
102 
103 DWORD CManagerRTV::GetInfo(void* pHead, DWORD dwSize)
104 {
105  if (!pHead)
106  return sizeof(SBaseOut);
107  if (dwSize<sizeof(SBaseOut))
108  return 0;
109 
110  ((SBaseOut*)pHead)->sBaseIn.dwSize= sizeof(SBaseOut);
111  ((SBaseOut*)pHead)->sBaseIn.eType= eResponseEx;
112  ((SBaseOut*)pHead)->sBaseIn.nChan= m_nChan;
113  ((SBaseOut*)pHead)->sBaseIn.nError= 0;
114  ((SBaseOut*)pHead)->bActive= true;
115  _tcsncpy_s(((SBaseOut*)pHead)->szName, DEVICE_NAME_SIZE, m_csName.c_str(), _TRUNCATE);
116 
117  return sizeof(SBaseOut);
118 }
119 
120 CManagerRTV::~CManagerRTV()
121 {
122  for (size_t i= 0; i<m_usChans; ++i)
123  delete m_acRTVDevices[i];
124  if (m_hLib != NULL)
125  FreeLibrary(m_hLib);
126  delete m_pcMemPool;
127  for (unsigned short i= 0; i<m_usChans; ++i)
128  {
129  DeleteCriticalSection(m_ahCallbackSafe[i]);
130  delete m_ahCallbackSafe[i];
131  }
132  s_pCRTVMan= NULL;
133 }
134 
135 void CManagerRTV::ProcessData(const void *pHead, DWORD dwSize, __int64 llId)
136 {
137  if (m_bError)
138  return;
139  SBaseIn* pBase;
140  SData sData;
141  sData.pDevice= this;
142  SBaseIn sBase;
143  sBase.dwSize= sizeof(SBaseIn);
144  sBase.nChan= -1;
145  sBase.nError= 0;
146  bool bRes= true;
147  if (!pHead || dwSize < sizeof(SBaseIn) || dwSize != ((SBaseIn*)pHead)->dwSize) // incorrect size read
148  {
149  sBase.nError= SIZE_MISSMATCH;
150  } else if (((SBaseIn*)pHead)->eType == eQuery && dwSize == sizeof(SBaseIn)) // need info
151  {
152  sBase.eType= eQuery;
153  if (((SBaseIn*)pHead)->nChan < 0 || ((SBaseIn*)pHead)->nChan >= m_acRTVDevices.size() ||
154  !m_acRTVDevices[((SBaseIn*)pHead)->nChan]) // invalid channel
155  {
156  sBase.nError= INVALID_CHANN;
157  } else // send info on particular chann
158  {
159  bRes= false;
160  DWORD dwSizeInfo= m_acRTVDevices[((SBaseIn*)pHead)->nChan]->GetInfo(NULL, 0);
161  pBase= (SBaseIn*)m_pcMemPool->PoolAcquire(dwSizeInfo);
162  if (pBase)
163  {
164  m_acRTVDevices[((SBaseIn*)pHead)->nChan]->GetInfo(pBase, dwSizeInfo);
165  sData.dwSize= dwSizeInfo;
166  sData.pHead= pBase;
167  m_pcComm->SendData(&sData, llId);
168  }
169  }
170  } else if (dwSize == sizeof(SBaseIn) && ((SBaseIn*)pHead)->eType == eDelete) // delete a channel
171  {
172  sBase.eType= eDelete;
173  if (((SBaseIn*)pHead)->nChan < 0 || ((SBaseIn*)pHead)->nChan >= m_acRTVDevices.size() ||
174  !m_acRTVDevices[((SBaseIn*)pHead)->nChan])
175  sBase.nError= INVALID_CHANN;
176  else
177  {
178  EnterCriticalSection(m_ahCallbackSafe[((SBaseIn*)pHead)->nChan]);
179  delete m_acRTVDevices[((SBaseIn*)pHead)->nChan];
180  m_acRTVDevices[((SBaseIn*)pHead)->nChan]= NULL;
181  LeaveCriticalSection(m_ahCallbackSafe[((SBaseIn*)pHead)->nChan]);
182  sBase.nChan= ((SBaseIn*)pHead)->nChan;
183  }
184  } else if (dwSize == sizeof(SBaseIn) && ((SBaseIn*)pHead)->eType == eVersion &&
185  ((SBaseIn*)pHead)->nChan == -1)
186  {
187  DWORD dw1[4]= {0}, dw2[4]= {0}, dwDLLVersion[4]= {0};
188  sBase.nError= RTV_ERROR(lpf_AngeloRTV_Get_Version(dw1, dwDLLVersion, dw2), sBase.nError);
189  sBase.dwInfo= dwDLLVersion[0]*1000+dwDLLVersion[1]*100+dwDLLVersion[2]*10+dwDLLVersion[3];
190  sBase.eType= eVersion;
191  } else if (((SBaseIn*)pHead)->nChan < 0 || ((SBaseIn*)pHead)->nChan >= m_acRTVDevices.size())
192  {
193  sBase.eType= ((SBaseIn*)pHead)->eType;
194  sBase.nError= INVALID_CHANN;
195  } else if (((SBaseIn*)pHead)->eType == eSet && m_acRTVDevices[((SBaseIn*)pHead)->nChan])
196  {
197  sBase.eType= ((SBaseIn*)pHead)->eType;
198  sBase.nError= ALREADY_OPEN;
199  } else if (((SBaseIn*)pHead)->eType == eSet &&
200  ((SBaseIn*)pHead)->dwSize == sizeof(SBaseIn)+sizeof(SBase)+sizeof(SChanInitRTV) &&
201  ((SBase*)((char*)pHead+sizeof(SBaseIn)))->eType == eRTVChanInit) // set a channel
202  {
203  bRes= false;
204  LARGE_INTEGER llStart;
205  sBase.eType= eSet; // in case of error we do respond at end
206  SChanInitRTV sChanInit= *(SChanInitRTV*)((char*)pHead+sizeof(SBase)+sizeof(SBaseIn));
207  int nWidth; // Image height
208  int nHeight;// Image width
209  unsigned char ucBpp; // Image depth (bytes per pixel)
210  // Calculate frame size from the video format selected
211  switch (sChanInit.ucVideoFmt)
212  {
213  case 0: //Full NTSC
214  nWidth= 640;
215  nHeight= 480;
216  break;
217  case 1: //Full PAL
218  nWidth= 768;
219  nHeight= 576;
220  break;
221  case 2: //CIF NTSC
222  nWidth= 320;
223  nHeight= 240;
224  break;
225  case 3: //CIF PAL
226  nWidth= 384;
227  nHeight= 288;
228  break;
229  case 4: //QCIF NTSC
230  nWidth= 160;
231  nHeight= 120;
232  break;
233  case 5: //QCIF PAL
234  nWidth= 192;
235  nHeight= 144;
236  break;
237  default: // Other case, use full NTSC
238  sBase.nError= BAD_INPUT_PARAMS;
239  break;
240  }
241 
242  // Calculate the image depth and output format
243  switch (sChanInit.ucColorFmt)
244  {
245  case 0: // RGB16, PIX_FMT_RGB565LE
246  ucBpp= 2;
247  break;
248  case 2: // RGB15, PIX_FMT_RGB555LE
249  ucBpp= 2;
250  break;
251  case 1: // Gray, PIX_FMT_GRAY8
252  ucBpp= 1;
253  break;
254  case 5: // RGB8, PIX_FMT_RGB8
255  ucBpp= 1;
256  break;
257  case 6: // RAW8X
258  ucBpp= 1;
259  // sEncodeParams.ePixelFmtIn= (PixelFormat)0;
260  break;
261  case 7: // YUY2, PIX_FMT_YUYV422, PIX_FMT_YUV422P
262  ucBpp= 2;
263  break;
264  case 8: // btYUV
265  ucBpp= 1;
266  // sEncodeParams.ePixelFmtIn= (PixelFormat)0;
267  break;
268  case 3: // RGB24, PIX_FMT_BGR24
269  ucBpp= 3;
270  break;
271  case 4: // RGB32, PIX_FMT_BGRA
272  ucBpp= 4;
273  break;
274  default: // use PIX_FMT_GRAY8
275  sBase.nError= BAD_INPUT_PARAMS;
276  break;
277  }
278  sChanInit.nHeight= nHeight;
279  sChanInit.nWidth= nWidth;
280  sChanInit.ucBpp= ucBpp;
281  sChanInit.dwBuffSize= nHeight*nWidth*ucBpp;
282  std::tstringstream ss; // rtv channel
283  ss<<((SBaseIn*)pHead)->nChan;
284  std::tstringstream ss2; // rtv manager index
285  ss2<<m_nChan;
286  std::tstring csPipeName= m_csPipeName+_T(":")+ss2.str()+_T(":")+ss.str(); // new channel pipe name
287  CChannelRTV* pcChan= NULL;
288  if (!sBase.nError)
289  pcChan= new CChannelRTV(csPipeName.c_str(), ((SBaseIn*)pHead)->nChan, sChanInit, sBase.nError, llStart);
290  if (!sBase.nError)
291  {
292  EnterCriticalSection(m_ahCallbackSafe[((SBaseIn*)pHead)->nChan]);
293  m_acRTVDevices[((SBaseIn*)pHead)->nChan]= pcChan;
294  LeaveCriticalSection(m_ahCallbackSafe[((SBaseIn*)pHead)->nChan]);
295  SBaseOut* pBaseO= (SBaseOut*)m_pcMemPool->PoolAcquire(sizeof(SBaseOut)+sizeof(SBase)+sizeof(SChanInitRTV));
296  if (pBaseO)
297  {
298  pBaseO->sBaseIn.dwSize= sizeof(SBaseOut)+sizeof(SBase)+sizeof(SChanInitRTV);
299  pBaseO->sBaseIn.eType= eResponseExL;
300  pBaseO->sBaseIn.nChan= ((SBaseIn*)pHead)->nChan;
301  pBaseO->sBaseIn.nError= 0;
302  pBaseO->llLargeInteger= llStart;
303  pBaseO->bActive= false;
304  ((SBase*)((char*)pBaseO+sizeof(SBaseOut)))->dwSize= sizeof(SBase)+sizeof(SChanInitRTV);
305  ((SBase*)((char*)pBaseO+sizeof(SBaseOut)))->eType= eRTVChanInit;
306  *((SChanInitRTV*)((char*)pBaseO+sizeof(SBaseOut)+sizeof(SBase)))= sChanInit;
307  sData.pHead= pBaseO;
308  sData.dwSize= pBaseO->sBaseIn.dwSize;
309  m_pcComm->SendData(&sData, llId);
310  }
311  } else
312  delete pcChan;
313  } else
314  sBase.nError= INVALID_COMMAND;
315 
316  if (sBase.nError || bRes)
317  {
318  sData.pHead= (SBaseIn*)m_pcMemPool->PoolAcquire(sizeof(SBaseIn));
319  if (sData.pHead)
320  {
321  sData.dwSize= sizeof(SBaseIn);
322  memcpy(sData.pHead, &sBase, sizeof(SBaseIn));
323  m_pcComm->SendData(&sData, llId);
324  }
325  }
326 }
327 
328 void CManagerRTV::NextFrame(unsigned char* aucData, unsigned short usChan)
329 {
330  if (usChan < m_usChans)
331  {
332  EnterCriticalSection(m_ahCallbackSafe[usChan]); // make sure devices isn't changed while we're working on it
333  if (m_acRTVDevices[usChan])
334  m_acRTVDevices[usChan]->NextFrame(aucData);
335  LeaveCriticalSection(m_ahCallbackSafe[usChan]);
336  }
337 }
338 
339 
340 
341 
342 
343 CChannelRTV::CChannelRTV(const TCHAR szPipe[], int nChan, SChanInitRTV &sChanInit, int &nError,
344  LARGE_INTEGER &llStart) : CDevice(RTV_CHAN_STR), m_csPipeName(szPipe),
345  m_sChanInit(sChanInit), m_usChan(nChan)
346 {
347  m_bError= true;
348  m_pcComm= NULL;
349  m_bSent= false;
350  m_pLastSent= NULL;
351  m_bActive= false;
352  m_pcMemPool= new CMemPool;
353  InitializeCriticalSection(&m_hSentSafe);
354  nError= 0;
355  if (!szPipe)
356  {
357  nError= BAD_INPUT_PARAMS;
358  return;
359  }
360 
361  lpf_AngeloRTV_Close(m_usChan);
362  nError= RTV_ERROR(lpf_AngeloRTV_Initial(m_usChan), nError);
363  if (!nError) nError= RTV_ERROR(lpf_AngeloRTV_Set_Video_Format(m_usChan, sChanInit.ucVideoFmt), nError);
364  if (!nError) nError= RTV_ERROR(lpf_AngeloRTV_Set_Color_Format(m_usChan, sChanInit.ucColorFmt), nError);
365  if (!nError) nError= RTV_ERROR(lpf_AngeloRTV_Set_Image_Config(m_usChan, 0, sChanInit.ucBrightness), nError);
366  if (!nError) nError= RTV_ERROR(lpf_AngeloRTV_Set_Image_Config(m_usChan, 1, sChanInit.ucHue), nError);
367  if (!nError) nError= RTV_ERROR(lpf_AngeloRTV_Set_Image_Config(m_usChan, 2, sChanInit.ucUSat), nError);
368  if (!nError) nError= RTV_ERROR(lpf_AngeloRTV_Set_Image_Config(m_usChan, 3, sChanInit.ucVSat), nError);
369  if (!nError) nError= RTV_ERROR(lpf_AngeloRTV_Set_Image_Config(m_usChan, 4, sChanInit.ucLumaContrast), nError);
370  if (!nError) nError= RTV_ERROR(lpf_AngeloRTV_Set_Image_Config(m_usChan, 5, sChanInit.ucLumaFilt), nError);
371  if (!nError) nError= RTV_ERROR(lpf_AngeloRTV_Select_Channel(m_usChan, 0x01), nError);
372  if (!nError) nError= RTV_ERROR(lpf_AngeloRTV_Capture_Config(m_usChan, 0), nError); // Odd field + Even field
373  if (!nError) nError= RTV_ERROR(lpf_AngeloRTV_Set_Callback(m_usChan, MediaStreamProc), nError);
374  if (nError)
375  return;
376 
377  m_pcComm= new CPipeServer; // our pipe over which comm to devices will occur
378  nError= static_cast<CPipeServer*>(m_pcComm)->Init(szPipe, ~0x80000000, MIN_BUFF_IN,
379  sChanInit.dwBuffSize+MIN_BUFF_OUT, this, NULL);
380  if (nError)
381  return;
382  llStart= m_cTimer.GetStart();
383  m_bError= false;
384 }
385 
386 DWORD CChannelRTV::GetInfo(void* pHead, DWORD dwSize)
387 {
388  if (!pHead)
389  return sizeof(SBaseOut)+sizeof(SBase)+sizeof(SChanInitRTV);
390  if (dwSize<sizeof(SBaseOut)+sizeof(SBase)+sizeof(SChanInitRTV))
391  return 0;
392 
393  ((SBaseOut*)pHead)->sBaseIn.dwSize= sizeof(SBaseOut)+sizeof(SBase)+sizeof(SChanInitRTV);
394  ((SBaseOut*)pHead)->sBaseIn.eType= eResponseEx;
395  ((SBaseOut*)pHead)->sBaseIn.nChan= m_usChan;
396  ((SBaseOut*)pHead)->sBaseIn.nError= 0;
397  EnterCriticalSection(&m_hSentSafe);
398  ((SBaseOut*)pHead)->bActive= m_bActive;
399  LeaveCriticalSection(&m_hSentSafe);
400  _tcsncpy_s(((SBaseOut*)pHead)->szName, DEVICE_NAME_SIZE, m_csName.c_str(), _TRUNCATE);
401  pHead= (char*)pHead+ sizeof(SBaseOut);
402 
403  ((SBase*)pHead)->dwSize= sizeof(SChanInitRTV)+sizeof(SBase);
404  ((SBase*)pHead)->eType= eRTVChanInit;
405  pHead= (char*)pHead+ sizeof(SBase);
406  memcpy(pHead, &m_sChanInit, sizeof(SChanInitRTV));
407 
408  return sizeof(SBaseOut)+sizeof(SBase)+sizeof(SChanInitRTV);
409 }
410 
411 CChannelRTV::~CChannelRTV()
412 {
413  lpf_AngeloRTV_Capture_Stop(m_usChan);
414  lpf_AngeloRTV_Set_Callback(m_usChan, NULL);
415  lpf_AngeloRTV_Close(m_usChan);
416  if (m_pcComm) m_pcComm->Close();
417  delete m_pcComm;
418  DeleteCriticalSection(&m_hSentSafe);
419  delete m_pcMemPool;
420 }
421 
422 void CChannelRTV::ProcessData(const void *pHead, DWORD dwSize, __int64 llId)
423 {
424  if (m_bError)
425  return;
426  int nError= 0;
427  SBaseIn* pBase= (SBaseIn*)pHead;
428  if (!pBase || dwSize != sizeof(SBaseIn) || dwSize != pBase->dwSize) // incorrect size read
429  nError= SIZE_MISSMATCH;
430  else if (pBase->eType != eActivate && pBase->eType != eInactivate && pBase->eType != eQuery)
431  nError= INVALID_COMMAND;
432  else if (pBase->nChan != m_usChan)
433  nError= INVALID_CHANN;
434 
435  SData sData;
436  sData.pDevice= this;
437  sData.dwSize= sizeof(SBaseIn);
438  if (nError) // bad read
439  {
440  pBase= (SBaseIn*)m_pcMemPool->PoolAcquire(sData.dwSize);
441  if (pBase)
442  {
443  pBase->dwSize= sizeof(SBaseIn);
444  pBase->eType= eResponse;
445  pBase->nChan= -1;
446  pBase->nError= nError;
447  sData.pHead= pBase;
448  m_pcComm->SendData(&sData, llId);
449  }
450  } else if (pBase->eType == eQuery) // send back info on devices
451  {
452  sData.dwSize= GetInfo(NULL, 0);
453  sData.pHead= m_pcMemPool->PoolAcquire(sData.dwSize);
454  if (sData.pHead && GetInfo(sData.pHead, sData.dwSize) == sData.dwSize)
455  m_pcComm->SendData(&sData, llId);
456  } else // start or stop device, respond with ok
457  {
458  EnterCriticalSection(&m_hSentSafe);
459  if (pBase->eType == eActivate)
460  {
461  if (m_bActive)
462  nError= ALREADY_OPEN;
463  else
464  {
465  nError= RTV_ERROR(lpf_AngeloRTV_Capture_Start(m_usChan, 0xFFFFFFFF), nError);
466  if (!nError)
467  {
468  m_bActive= true;
469  m_llId= llId;
470  }
471  }
472  } else
473  {
474  lpf_AngeloRTV_Capture_Stop(m_usChan);
475  m_bActive= false;
476  pBase= (SBaseIn*)m_pcMemPool->PoolAcquire(sData.dwSize);
477  if (pBase)
478  {
479  pBase->dwSize= sizeof(SBaseIn);
480  pBase->eType= eResponse;
481  pBase->nChan= ((SBaseIn*)pHead)->nChan;
482  pBase->nError= DEVICE_CLOSING;
483  sData.pHead= pBase;
484  m_pcComm->SendData(&sData, m_llId);
485  }
486  m_llId= -1;
487  m_bSent= false;
488  m_pLastSent= NULL;
489  }
490  pBase= (SBaseIn*)m_pcMemPool->PoolAcquire(sData.dwSize);
491  if (pBase)
492  {
493  pBase->dwSize= sizeof(SBaseIn);
494  pBase->eType= ((SBaseIn*)pHead)->eType;
495  pBase->nChan= ((SBaseIn*)pHead)->nChan;
496  pBase->nError= nError;
497  sData.pHead= pBase;
498  m_pcComm->SendData(&sData, llId);
499  }
500  LeaveCriticalSection(&m_hSentSafe); // don't exit earlier so this massege is first response
501  }
502 }
503 
504 void CChannelRTV::NextFrame(unsigned char* aucData)
505 {
506  SData sData;
507  sData.pHead= NULL;
508  EnterCriticalSection(&m_hSentSafe);
509  if(m_bActive && !m_bSent)
510  {
511  sData.pHead= m_pcMemPool->PoolAcquire(sizeof(SBaseOut)+sizeof(SBase)+m_sChanInit.dwBuffSize);
512  if (!m_sChanInit.bLossless && sData.pHead)
513  {
514  m_bSent= true;
515  m_pLastSent= sData.pHead;
516  }
517  }
518  LeaveCriticalSection(&m_hSentSafe);
519 
520  if (!sData.pHead)
521  return;
522  sData.pDevice= this;
523  sData.dwSize= sizeof(SBaseOut)+sizeof(SBase)+m_sChanInit.dwBuffSize;
524  ((SBaseOut*)sData.pHead)->sBaseIn.dwSize= sData.dwSize;
525  ((SBaseOut*)sData.pHead)->sBaseIn.eType= eResponseExD;
526  ((SBaseOut*)sData.pHead)->sBaseIn.nChan= m_usChan;
527  ((SBaseOut*)sData.pHead)->sBaseIn.nError= 0;
528  ((SBaseOut*)sData.pHead)->bActive= true;
529  ((SBaseOut*)sData.pHead)->dDouble= g_cTimer.Seconds();
530  ((SBase*)((char*)sData.pHead+sizeof(SBaseOut)))->dwSize= sizeof(SBase)+m_sChanInit.dwBuffSize;
531  ((SBase*)((char*)sData.pHead+sizeof(SBaseOut)))->eType= eRTVImageBuf;
532  memcpy((char*)sData.pHead+sizeof(SBaseOut)+sizeof(SBase), aucData, m_sChanInit.dwBuffSize);
533  m_pcComm->SendData(&sData, m_llId);
534 }
535 
536 void CChannelRTV::Result(void *pHead, bool bPass)
537 {
538  EnterCriticalSection(&m_hSentSafe);
539  if(m_bSent && m_pLastSent == pHead)
540  {
541  m_bSent= false;
542  m_pLastSent= NULL;
543  }
544  LeaveCriticalSection(&m_hSentSafe);
545  m_pcMemPool->PoolRelease(pHead);
546 }
CChannelRTV::Result
void Result(void *pHead, bool bPass)
Definition: rtv device.cpp:536
CManagerRTV::GetInfo
virtual DWORD GetInfo(void *pHead, DWORD dwSize)
Definition: rtv device.cpp:103
SChanInitRTV::ucBrightness
unsigned char ucBrightness
Definition: cpl defs.h:451
CComm::SendData
virtual int SendData(const SData *pData, __int64 llId)=0
SChanInitRTV::ucBpp
unsigned char ucBpp
Definition: cpl defs.h:478
SChanInitRTV::ucVSat
unsigned char ucVSat
Definition: cpl defs.h:457
CTimer::GetStart
LARGE_INTEGER GetStart() const
Definition: misc tools.h:69
SChanInitRTV::ucLumaFilt
unsigned char ucLumaFilt
Definition: cpl defs.h:461
CChannelRTV::NextFrame
void NextFrame(unsigned char *aucData)
Definition: rtv device.cpp:504
CChannelRTV::CChannelRTV
CChannelRTV(const TCHAR szPipe[], int nChan, SChanInitRTV &sChanInit, int &nError, LARGE_INTEGER &llStart)
Definition: rtv device.cpp:343
CManagerRTV::NextFrame
void NextFrame(unsigned char *aucData, unsigned short usChan)
Definition: rtv device.cpp:328
CChannelRTV::GetInfo
DWORD GetInfo(void *pHead, DWORD dwSize)
Definition: rtv device.cpp:386
SChanInitRTV::ucUSat
unsigned char ucUSat
Definition: cpl defs.h:455
SChanInitRTV::bLossless
bool bLossless
Definition: cpl defs.h:474
CChannelRTV::ProcessData
void ProcessData(const void *pHead, DWORD dwSize, __int64 llId)
Definition: rtv device.cpp:422
SChanInitRTV::dwBuffSize
DWORD dwBuffSize
Definition: cpl defs.h:485
CManagerRTV::ProcessData
void ProcessData(const void *pHead, DWORD dwSize, __int64 llId)
Definition: rtv device.cpp:135
SChanInitRTV::ucVideoFmt
unsigned char ucVideoFmt
Definition: cpl defs.h:467
SChanInitRTV::ucHue
unsigned char ucHue
Definition: cpl defs.h:453
CTimer::Seconds
double Seconds() const
Definition: misc tools.cpp:63
CComm::Close
virtual void Close()=0
SChanInitRTV::ucColorFmt
unsigned char ucColorFmt
Definition: cpl defs.h:464
SChanInitRTV::ucLumaContrast
unsigned char ucLumaContrast
Definition: cpl defs.h:459
CDevice::m_csName
const std::tstring m_csName
Definition: base classses.h:98
Generated on Fri Oct 18 2019 00:06:07 for Barst by   doxygen 1.8.13