开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
revplaymdichildwnd.cpp
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：24k
源码类别：

VC书籍

开发平台：

Visual C++

revplaymdichildwnd.cpp：源码内容
  1. // RevPlayMDIChildWnd.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "RevPlayThread.h"
  6. #include "RevPlayMDIChildWnd.h"
  7. #include "ConnectDlg.h"
  8. #include "resource.h"
  10. #include "asyncio.h"
  11. #include "asyncrdr.h"
  12. #include "mainfrm.h"
  15. #ifdef _DEBUG
  16. #define new DEBUG_NEW
  17. #undef THIS_FILE
  18. static char THIS_FILE[] = __FILE__;
  19. #endif
  21. //#define IDC_REVPLAY_WND 1
  22. #define LISTEN_PORT 1500
  23. #define BUFSIZE 32768
  24. #define WSA_CONNECT WM_USER+200
  25. #define WSA_READ WM_USER+300  //读取视频数据
  27. //{ 36a5f771-fe4c-11ce-a8ed-00aa002feab5 }
  28. const CLSID  CLSID_Stream = {
  29. 0x36a5f771, 0xfe4c, 0x11ce, 0xa8, 0xed, 0x00, 0xaa, 0x00, 0x2f, 0xea, 0xb5
  30. };
  32. const AMOVIESETUP_MEDIATYPE sudPinTypes =
  33. {
  34.     &MEDIATYPE_NULL,            // Major type
  35.     &MEDIASUBTYPE_NULL          // Minor type
  36. };
  38. const AMOVIESETUP_PIN sudPins =
  39. {
  40.     L"Input",                   // Pin string name
  41.     FALSE,                      // Is it rendered
  42.     FALSE,                      // Is it an output
  43.     FALSE,                      // Allowed none
  44.     FALSE,                      // Likewise many
  45.     &CLSID_NULL,                // Connects to filter
  46.     L"Output",                  // Connects to pin
  47.     1,                          // Number of types
  48.     &sudPinTypes                // Pin information
  49. };
  51. const AMOVIESETUP_FILTER sudStream =
  52. {
  53.     &CLSID_Stream,                // Filter CLSID
  54.     L"Stream",                    // String name
  55.     MERIT_DO_NOT_USE,           // Filter merit
  56.     1,                          // Number pins
  57.     &sudPins                    // Pin details
  58. };
  61. //
  62. //  Object creation stuff
  63. //
  64. CFactoryTemplate g_Templates[]= {
  65.     L"Stream", &CLSID_Stream, NULL, NULL, &sudStream
  66. };
  67. int g_cTemplates = 1;
  70. class CMemStream : public CAsyncStream
  71. {
  72. public:
  73.     CRevPlayWnd* pWnd;  //接收播放窗口指针
  74. public:
  75. BOOL PeekAndPump();
  76.     CMemStream( LPBYTE pbData, LONGLONG llLength, DWORD dwKBPerSec = INFINITE) :
  77. m_pbData(pbData),
  78.         m_llLength(llLength),
  79.         m_llPosition(0),
  80.         m_dwKBPerSec(dwKBPerSec)
  81.     {
  82.         m_dwTimeStart = timeGetTime();
  83.     }
  84. //设置当前位置
  85. HRESULT SetPointer(LONGLONG llPos)
  86.     {
  87.         if (llPos < 0 || llPos > m_llLength) {
  88.             return S_FALSE;
  89.         } else {
  90.             m_llPosition = llPos;
  91.             return S_OK;
  92.         }
  93.     }
  94. //当MPEG1 Stream Splitter请求数据时，由Read函数提供
  95.     HRESULT Read(PBYTE pbBuffer,
  96. DWORD dwBytesToRead,
  97. BOOL bAlign,
  98. LPDWORD pdwBytesRead)
  99.     {
  100.         CAutoLock lck(&m_csLock);
  101.         DWORD dwReadLength, cbRet;
  102.         DWORD dwTime = timeGetTime();
  103. //如果要求读取的字节数大于剩余的字节数，则只直接读取剩余的字节
  104.         if (m_llPosition + dwBytesToRead > m_llLength) 
  105. {
  106.             dwReadLength = (DWORD)(m_llLength - m_llPosition);
  107.         } 
  108. else 
  109. {
  110.             dwReadLength = dwBytesToRead;
  111.         }
  113.         DWORD dwTimeToArrive =
  114.             ((DWORD)m_llPosition + dwReadLength) / m_dwKBPerSec;
  115.         if (dwTime - m_dwTimeStart < dwTimeToArrive) {
  116.             Sleep(dwTimeToArrive - dwTime + m_dwTimeStart);
  117.         }
  118. static int rwIndex =0;
  119. static int Block = pWnd->Block;
  120.         int temp=pWnd->rIndex;
  121. // if (pWnd->m_RenderOk) 
  122. // {
  123. /* while (rwIndex>temp) 
  124. PeekAndPump();*/
  126. //将存放接收的数据缓冲区数组中的数据拷贝到pbBuffer中，传给Splitter
  127. CopyMemory((PVOID)pbBuffer, (PVOID)(pWnd->pRevMem[rwIndex]), pWnd->RevLen);
  128. rwIndex = (rwIndex + 1) % 100;
  129. TRACE1("Read Addr = %dn",rwIndex);
  130. cbRet=pWnd->RevLen;
  131. // }
  132. /* else
  133. {
  134. if (Block == 0)
  135. {
  137. CopyMemory((PVOID)pbBuffer, (PVOID)(m_pbData),
  138. dwReadLength);
  139. Block ++;
  140. }
  141. else 
  142. {
  143. CopyMemory((PVOID)pbBuffer, (PVOID)(m_pbData + dwReadLength),
  144. dwReadLength);
  145. Block = 0;
  146. }
  147. cbRet = dwReadLength;
  149. }*/
  150. //当前位置向后移读出的字节数
  151.         m_llPosition += cbRet;
  152.         *pdwBytesRead = cbRet;
  153. if (cbRet != dwReadLength)
  154. m_llLength = m_llPosition;
  155. return S_OK;
  156. }
  157. //得到当前的数据总长度
  158.     LONGLONG Size(LONGLONG *pSizeAvailable)
  159.     {
  160.         LONGLONG llCurrentAvailable =
  161.             Int32x32To64((timeGetTime() - m_dwTimeStart),m_dwKBPerSec);
  162.         *pSizeAvailable = min(m_llLength, llCurrentAvailable);
  163.         return m_llLength;
  164.     }
  165.     DWORD Alignment()
  166.     {
  167. //按1字节对齐
  168.         return 1;
  169.     }
  170.     void Lock()
  171.     {
  172.         m_csLock.Lock();
  173.     }
  174.     void Unlock()
  175.     {
  176.         m_csLock.Unlock();
  177.     }
  179. private:
  180.     CCritSec       m_csLock;     //数据操作的同步对象
  181.     const PBYTE    m_pbData;     //读写的内存数据指针
  182.     LONGLONG       m_llLength;   //数据总长度 
  183.     LONGLONG       m_llPosition; //实际读写的内存数据位置指针
  184.     DWORD          m_dwKBPerSec; //播放的的速率
  185.     DWORD          m_dwTimeStart;//开始时间
  186. };
  188. class CMemReader : public CAsyncReader
  189. {
  190. public:
  191.     STDMETHODIMP Register()
  192.     {
  193.         return S_OK;
  194.     }
  195.     STDMETHODIMP Unregister()
  196.     {
  197.         return S_OK;
  198.     }
  199.     CMemReader(CMemStream *pStream, CMediaType *pmt, HRESULT *phr) :
  200. CAsyncReader(NAME("Mem Reader"), NULL, pStream, phr)
  201.     {
  202.         m_mt = *pmt;
  203.     }
  204. };
  209. /////////////////////////////////////////////////////////////////////////////
  210. // CRevPlayMDIChildWnd
  212. CMenu CRevPlayMDIChildWnd::menu;   
  214. IMPLEMENT_DYNCREATE(CRevPlayMDIChildWnd, CMDIChildWnd)
  216. CRevPlayMDIChildWnd::CRevPlayMDIChildWnd()
  217. {
  218. }
  220. CRevPlayMDIChildWnd::~CRevPlayMDIChildWnd()
  221. {
  222. }
  225. BEGIN_MESSAGE_MAP(CRevPlayMDIChildWnd, CMDIChildWnd)
  226. //{{AFX_MSG_MAP(CRevPlayMDIChildWnd)
  227. ON_WM_SIZE()
  228. //}}AFX_MSG_MAP
  229. ON_MESSAGE(WM_USER_PREPARE_TO_CLOSE, OnPrepareToClose)
  230.    
  232. END_MESSAGE_MAP()
  234. /////////////////////////////////////////////////////////////////////////////
  235. // CRevPlayMDIChildWnd message handlers
  237. BOOL CRevPlayMDIChildWnd::Create(LPCTSTR szTitle, const RECT &rect, CMDIFrameWnd *parent)
  238. {
  239.     if (menu.m_hMenu == NULL)
  240. menu.LoadMenu(IDR_REVPLAY);
  241. m_hMenuShared = menu.m_hMenu;
  242. //创建子窗口
  243. if (!CMDIChildWnd::Create(NULL, szTitle, WS_CHILD | WS_VISIBLE | WS_OVERLAPPEDWINDOW, rect, parent))
  244. return FALSE;
  245. //生成UI线程对象
  246. CRevPlayThread* pRevPlayThread = new CRevPlayThread(m_hWnd);
  247. //创建线程
  248. pRevPlayThread->CreateThread();
  250. return TRUE;
  251. }
  253. BOOL CRevPlayMDIChildWnd::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo) 
  254. {
  255. // TODO: Add your specialized code here and/or call the base class
  256. CWnd* pRevPlayWnd = (CRevPlayWnd*)GetDlgItem(IDC_REVPLAY_WND);
  257. if (pRevPlayWnd == NULL)
  258. return FALSE; 
  260. COnCmdMsg oncmdmsg;
  261. oncmdmsg.m_nID =    nID;
  262. oncmdmsg.m_nCode = nCode;
  263. oncmdmsg.m_pExtra = pExtra;
  264. oncmdmsg.m_pHandlerInfo = pHandlerInfo;
  265. return pRevPlayWnd->SendMessage(WM_USER_ONCMDMSG,
  266. 0, (LPARAM)&oncmdmsg);
  268. }
  270. void CRevPlayMDIChildWnd::OnSize(UINT nType, int cx, int cy) 
  271. {
  272. CMDIChildWnd::OnSize(nType, cx, cy);
  274. // TODO: Add your message handler code here
  275. CWnd* pRevPlayWnd = GetDlgItem(IDC_REVPLAY_WND);
  276. if (pRevPlayWnd == NULL)
  277. return; // child CBounceWnd not created yet
  278. CRect rect;
  279. GetClientRect(&rect);
  280. pRevPlayWnd->SetWindowPos(NULL, 0, 0, rect.Width(), rect.Height(),
  281. SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
  283. }
  285. BOOL CRevPlayMDIChildWnd::DestroyWindow() 
  286. {
  287. // TODO: Add your specialized code here and/or call the base class
  288. OnPrepareToClose();
  289. return CMDIChildWnd::DestroyWindow();
  290. }
  293. LRESULT CRevPlayMDIChildWnd::OnPrepareToClose(WPARAM wParam, LPARAM lParam)
  294. {
  295.   CWnd* pRevPlayWnd = (CRevPlayWnd*)GetDlgItem(IDC_REVPLAY_WND);
  296. pRevPlayWnd->SendMessage(WM_USER_PREPARE_TO_CLOSE);
  298. WaitForSingleObject(CRevPlayThread::m_hEventRevPlayThreadKilled, INFINITE);
  299. return 0;
  300. }
  303. /////////////////////////////////////////////////////////////////////////////
  304. // CRevPlayWnd
  307. CRevPlayWnd::CRevPlayWnd()
  308. {
  309. m_LostBlock=0;
  311. m_Receive=FALSE;
  312. m_Save=FALSE;
  313. m_FirstRead=TRUE;
  314. m_RenderOk=FALSE;
  315. m_Stop=FALSE;
  316. rIndex=0;   //pRevMem数组的标记
  317. g_rwIndex=0;
  318. m_pStream=NULL;
  319. m_rdr=NULL;
  321. m_pifg = NULL;
  322. m_pigb = NULL;
  323. m_pimc = NULL;
  324. m_pivw = NULL;
  325. m_ppos = NULL;
  327. hmmioSave = NULL;
  329. }
  331. CRevPlayWnd::~CRevPlayWnd()
  332. {
  333.  
  334. }
  337. BEGIN_MESSAGE_MAP(CRevPlayWnd, CWnd)
  338. //{{AFX_MSG_MAP(CRevPlayWnd)
  339. ON_WM_CREATE()
  340. ON_COMMAND(IDR_SAVE, OnSave)
  341. ON_WM_CONTEXTMENU()
  342. ON_COMMAND(ID_STOP_RECEIVE, OnStopReceive)
  343. ON_COMMAND(IDR_REV_PLAY, OnRevPlay)
  344. ON_UPDATE_COMMAND_UI(IDR_SAVE, OnUpdateSave)
  345. ON_UPDATE_COMMAND_UI(ID_STOP_RECEIVE, OnUpdateStopReceive)
  346. ON_WM_SIZE()
  347. //}}AFX_MSG_MAP
  348. ON_MESSAGE(WM_USER_ONCMDMSG, OnDelegatedCmdMsg)
  349. ON_MESSAGE(WM_USER_PREPARE_TO_CLOSE, OnPrepareToClose)
  350. ON_MESSAGE(WSA_CONNECT,OnConnect)
  351. ON_MESSAGE(WSA_READ,OnRead)
  353. END_MESSAGE_MAP()
  356. /////////////////////////////////////////////////////////////////////////////
  357. // CRevPlayWnd message handlers
  359. LRESULT CRevPlayWnd::OnConnect(WPARAM wParam,LPARAM lParam) 
  360. {
  361. int status;
  362. int SendLen;
  363. int socket;
  364. char szRev[80];
  365. char szBuff[80];
  366. char Msg[]="请发送数据";
  367. u_long block=0;
  368. socket=(SOCKET)wParam; 
  369. if (WSAGETSELECTERROR(lParam))
  370. {//建立连接失败
  372. MessageBox("不能连接服务器", "连接失败", MB_OK);
  373. if(WaitDlg)
  374. WaitDlg.EndDialog(IDCANCEL);
  375. //关闭socket
  376. closesocket(socket); 
  377. return -1;
  378. }
  379. if (WSAGETSELECTEVENT(lParam) == FD_CONNECT)
  380. {//成功建立连接
  382. if(WaitDlg)
  383. WaitDlg.EndDialog(IDCANCEL);
  384. //发送请求发送数据命令给发送端
  385. SendLen=send(socket,Msg,sizeof(Msg),0);
  386. if(SendLen!=sizeof(Msg))
  387. {//请求数据发送失败
  388. MessageBox("请求错误" "Send");
  389. closesocket(socket); 
  390. return -1;
  391. }
  392. if(SendLen==sizeof(Msg))
  393. {
  394. WSAAsyncSelect(socket,m_hWnd, 0, 0 ); 
  395. status=ioctlsocket(socket,FIONBIO,&block);
  396. if(status==SOCKET_ERROR)
  397. {
  398. sprintf(szBuff,"Err: %d",WSAGetLastError());
  399. MessageBox(szBuff);
  400. return -1;
  401. }
  402. //接收数据
  403. status =recv(socket, szRev,sizeof(szRev),0);
  404. if (status) 
  405. {
  406. //得到组播IP地址和端口
  407. sscanf(szRev,"%s%d",strDestAddr,&DestPort);    
  408. sprintf(szBuff,"请加入组:%s,端口:%d",strDestAddr,DestPort);
  409. MessageBox(szBuff,"接收请求");            
  410. sprintf(szBuff,"接收播放:组:%s,端口:%d",strDestAddr,DestPort);
  411. ::SetWindowText(GetParent()->m_hWnd,szBuff);
  412. //关闭socket
  413. closesocket(socket);
  414. }
  415. if(status==0)
  416. {
  417. MessageBox("对方关闭连接");
  418. closesocket(socket);
  419. return -1;
  420. }  
  421. }
  422. }
  423. return 0;
  424. }
  427. LRESULT CRevPlayWnd::OnRead(WPARAM wParam,LPARAM lParam) 
  428. {
  429. DWORD dwRet;
  430. REFTIME fTime;
  431. REFERENCE_TIME llClock; 
  432. HRESULT hr;
  433. RECT rect;
  434. //接收组播数据，存放到缓冲区stWSABuf中
  435. RevLen=ReceiveData();
  436. //将缓冲区stWSABuf中的数据拷贝到存放接收的数据的数组pRevMem中，
  437. //以供DirectShow读取
  438. CopyMemory((PVOID)pRevMem[rIndex],(PVOID)stWSABuf.buf,RevLen);
  439. rIndex=(rIndex+1)%100;
  440. //将接收到的数据保存到文件中
  441. if(hmmioSave)
  442. mmioWrite(hmmioSave,stWSABuf.buf,RevLen);
  444. if(m_FirstRead)   
  445. {//如果是第一次接收到数据，启动DirectShow
  446. fTime = 0.0;
  447. dwRet = Parse ((PBYTE)stWSABuf.buf, stWSABuf.len, &llClock);
  448. fTime = llClock / 90000.0;
  449. if(dwRet == 0)
  450. return -1;
  452. if(InitGraph()==-1)
  453. return -1;
  455. if (abs (dwRet - 2048000) <= 16000) {
  456. RenderFrom ((PBYTE)achInBuf, "2mpal.dat");
  457. } 
  459. if (abs (dwRet - 1152000) <= 16000) {
  460. RenderFrom ((PBYTE)achInBuf, "1mpal.dat");
  461. } 
  463. if (abs (dwRet - 512000)  <= 16000) {
  464. RenderFrom ((PBYTE)achInBuf, "512pal.dat");
  465. }
  467. if (abs (dwRet - 256000)  <= 16000) {
  468. RenderFrom ((PBYTE)achInBuf, "256pal.dat");
  469. }
  471. Block = 0;
  473. //使用智能连接，将Source Filter的输出Pin连出去
  474. if (FAILED(hr = m_pigb -> Render(m_rdr -> GetPin(0)))) 
  475. {
  476. if (hr != VFW_S_AUDIO_NOT_RENDERED && hr != VFW_E_NO_AUDIO_HARDWARE )
  477. {
  478. MessageBox ("Render Error");
  479. WSAAsyncSelect(MultiSock,m_hWnd,WSA_READ,0); 
  480. HELPER_RELEASE(m_pifg);
  481. HELPER_RELEASE(m_pigb);
  482. HELPER_RELEASE(m_pimc);
  483. HELPER_RELEASE(m_pivw);
  484. HELPER_RELEASE(m_ppos);
  485. return -1;
  486. }
  487. }
  489. m_RenderOk = true;
  490. //设置视频窗口属性
  491. m_pivw -> put_Owner((OAHWND)m_hWnd);
  492. m_pivw -> put_WindowStyle(WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
  493. GetClientRect(&rect);
  494. m_pivw -> SetWindowPosition(rect.left, rect.top, rect.right, rect.bottom);
  495. //开始播放
  496. m_pimc -> Run();
  497. m_ppos->put_CurrentPosition(fTime + 0.4);
  498. m_Stop = TRUE;
  499. }
  501. m_FirstRead=FALSE;
  502. return 0;
  503. }
  508. LRESULT CRevPlayWnd::OnDelegatedCmdMsg(WPARAM, LPARAM lParam)
  509. {
  510. COnCmdMsg* pOnCmdMsg = (COnCmdMsg*)lParam;
  511. return CWnd::OnCmdMsg(pOnCmdMsg->m_nID, pOnCmdMsg->m_nCode, pOnCmdMsg->m_pExtra,
  512. pOnCmdMsg->m_pHandlerInfo);
  513. }
  515. LRESULT CRevPlayWnd::OnPrepareToClose(WPARAM, LPARAM)
  516. {
  518.     StopReceive();
  519. if( stWSABuf.buf)
  520. {
  521. delete  stWSABuf.buf;
  522. stWSABuf.buf=NULL;
  523. }
  524. if(achInBuf)
  525. {
  526. delete achInBuf;
  527. achInBuf=NULL;
  528. }
  529. DestroyWindow();
  530. return 0;
  531. }
  533. BOOL CRevPlayWnd::Create(LPCTSTR szTitle, LONG style, const RECT& rect, CWnd* parent)
  534. {
  535. // Register a custom WndClass and create a window.
  536. // This must be done because CBounceWnd has a custom cursor, and
  537. //  no icon.
  538. LPCTSTR lpszRevPlayClass =
  539. AfxRegisterWndClass(CS_HREDRAW | CS_VREDRAW,
  540. LoadCursor(NULL, IDC_UPARROW),
  541. (HBRUSH)(COLOR_WINDOW+1),
  542. NULL);
  544. return CWnd::Create(lpszRevPlayClass, szTitle, style, rect, parent,
  545. IDC_REVPLAY_WND);
  546. }
  549. int CRevPlayWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  550. {
  551. if (CWnd::OnCreate(lpCreateStruct) == -1)
  552. return -1;
  554. // TODO: Add your specialized creation code here
  555. int status;
  556. int sock;
  557. CConnectDlg ConnectDlg;
  559. stWSABuf.buf = new char[BUFSIZE];
  560. stWSABuf.len = BUFSIZE;
  561. achInBuf = new BYTE [BUFSIZE*2];
  563. if(ConnectDlg.DoModal()==IDOK)
  564. {
  565. status=Connect(m_hWnd,AddressIp,LISTEN_PORT,sock);
  566. if(status<0)
  567. return -1;
  568. }
  570. return 0;
  571. }
  573. int CRevPlayWnd::Connect(HWND hwnd, const char *Addr, short Port, int &sock)
  574. {
  575. SOCKADDR_IN send_sin;
  576. int status;
  577. //创建一个socket
  578. sock = socket(AF_INET,SOCK_STREAM,0);
  579. if (sock == INVALID_SOCKET)
  580. {
  581.         MessageBox("Socket Error");
  582.         closesocket(sock);   
  583. return -1;
  584. } 
  585. else
  586. {
  587. send_sin.sin_family=AF_INET;
  588. send_sin.sin_addr.s_addr=inet_addr(Addr);
  589. send_sin.sin_port=htons(Port);
  590. //设置响应的网络事件为FD_CONNECT，即建立连接
  591. //发送WSA_CONNECT消息给窗口
  592. status=WSAAsyncSelect(sock,hwnd,WSA_CONNECT,FD_CONNECT); 
  593. if(status<0)
  594. {//连接建立失败，关闭socket
  595. MessageBox("Error on WSAAsyncSelect()");
  596. WSAAsyncSelect(sock, hwnd, 0, 0);
  597. closesocket(sock);
  598. return -1;
  599. } 
  600. }
  601. //连接发送端
  602. connect(sock,(struct sockaddr FAR *)&send_sin, sizeof(send_sin));
  603. int error=WSAGetLastError();
  604. //有阻塞，弹出等待对话框
  605. if (error==WSAEWOULDBLOCK)
  606. WaitDlg.DoModal(); 
  607. return 0;
  608. }
  612. void CRevPlayWnd::InitMultiSock()
  613. {
  614.     int RevBuf;
  615.     int status;
  616.     BOOL  bFlag;
  617. CString ErrMsg;
  618. SOCKADDR_IN stLocalAddr;
  619. SOCKADDR_IN stDestAddr;
  620. SOCKET hNewSock;
  621.     int RevLen=sizeof(RevBuf);
  622. //创建一个IP组播套接字
  623.     MultiSock = WSASocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP,
  624.   (LPWSAPROTOCOL_INFO)NULL, 0, 
  625.   WSA_FLAG_MULTIPOINT_C_LEAF | WSA_FLAG_MULTIPOINT_D_LEAF);
  626. if (MultiSock == INVALID_SOCKET) 
  627. {
  628. MessageBox("WSASocket() failed");
  629. return;
  630.     } 
  632.     //允许对同一地址bind多次
  633. bFlag = TRUE;
  634. status = setsockopt(
  635. MultiSock, /* socket */
  636.      SOL_SOCKET, /* socket level */
  637. SO_REUSEADDR, /* socket option */
  638.     (char *)&bFlag, /* option value */
  639.   sizeof (bFlag)); /* size of value */
  641. if (status == SOCKET_ERROR) 
  642. {
  643.   ErrMsg.Format ("set SO_REUSEADDR failed, Err: %d",WSAGetLastError());
  644.       MessageBox(ErrMsg);
  645.   return;
  646. }
  647. // 将套接字绑定到用户指定端口
  648. stLocalAddr.sin_family = AF_INET;
  649.   //  stLocalAddr.sin_port = htons (DestPort);
  650.     stLocalAddr.sin_port = htons (201);
  651. stLocalAddr.sin_addr.s_addr = INADDR_ANY;
  652.     status = bind (
  653.         MultiSock, 
  654.         (struct sockaddr FAR *)&stLocalAddr, 
  655.         sizeof(struct sockaddr));
  657.     if (status == SOCKET_ERROR) 
  658. {
  659. ErrMsg.Format ("Bind(socket: %d, port: %d) failed, Err: %d",
  660. MultiSock, DestPort, WSAGetLastError());
  661. MessageBox(ErrMsg);
  663.     }
  664. //设定接收缓冲区为64k
  665.   RevBuf=65536;
  666. status = setsockopt(
  667. MultiSock, /* socket */
  668.      SOL_SOCKET, /* socket level */
  669.     SO_RCVBUF, /* socket option */
  670.     (char *)&RevBuf, /* option value */
  671.     sizeof(RevBuf)); /* size of value */
  672. if (status == SOCKET_ERROR) 
  673. {
  674. MessageBox("set SO_REVBUF error");
  675. return;
  676. }
  677.     
  678. //加入组播组
  679. stDestAddr.sin_family = PF_INET;
  680. stDestAddr.sin_port = htons (201);
  681.     stDestAddr.sin_addr.s_addr = inet_addr("234.5.6.7");
  682.     hNewSock = WSAJoinLeaf (MultiSock, /* socket */
  683.         (PSOCKADDR)&stDestAddr, /* multicast address */
  684.         sizeof (stDestAddr),    /* length of addr struct */
  685.         NULL,                   /* caller data buffer */
  686.         NULL,                   /* callee data buffer */
  687.         NULL,                   /* socket QOS setting */
  688.         NULL,                   /* socket group QOS */
  689.         JL_RECEIVER_ONLY);               /* do both: send *and* receive */
  691.     if (hNewSock == INVALID_SOCKET) 
  692. {
  693.   ErrMsg.Format ("WSAJoinLeaf() failed, Err: %d",WSAGetLastError());
  694.       MessageBox(ErrMsg);
  695. } 
  696. }
  699. int CRevPlayWnd::ReceiveData()
  700. {//接收组播数据
  701.     CString msg;
  702.     int status;
  703.     DWORD cbRet;
  704.     DWORD dFlag;
  705. int iLen;
  706. SOCKADDR_IN stSrcAddr;
  707. cbRet = 0;
  708. iLen = sizeof (stSrcAddr);
  709. dFlag = 0;
  710. //接收组播数据，存放到缓冲区stWSABuf中
  711. status = WSARecvFrom (MultiSock, /* socket */
  712. &stWSABuf,               /* input buffer structure */
  713. 1,                       /* buffer count */
  714. &cbRet,                  /* number of bytes recv'd */
  715. &dFlag,                 /* flags */
  716. (struct sockaddr *)&stSrcAddr,/* source address */
  717. &iLen,                   /* size of addr structure */
  718. NULL,                    /* overlapped structure */
  719. NULL);                   /* overlapped callback function */
  721. if (status == SOCKET_ERROR) 
  722. {
  723. //数据丢失，丢失的块数计数加1
  724. m_LostBlock++;
  725. msg.Format ("WSARecvFrom() failed, Err:%d", WSAGetLastError());
  726. MessageBox (msg);
  727. return -1;
  728. } 
  729. return cbRet;
  730. }
  734. void CRevPlayWnd::OnSave() 
  735. {
  736. // TODO: Add your command handler code here
  737. m_Save=!m_Save;
  738. DWORD dwFlags;
  739. CString SaveFileName;
  740. CString strSave;
  741. TCHAR Driver;
  742.     CFileDialog dlg(TRUE,NULL,"temp.mpg",NULL,"mpeg文件(*.mpg)|*.mpg|AVI文件(*.avi)|*.avi");
  743.     dlg.m_ofn.lpstrTitle="保存到...";
  744.     if(dlg.DoModal()==IDOK)
  745. {
  747. SaveFileName=dlg.GetPathName();
  748.         Driver=SaveFileName.GetAt(0);
  749.         CWnd* pParent = GetOwner();
  750. strSave.Format("保存到：%s",SaveFileName);
  751. CMainFrame* pFrame=(CMainFrame*)pParent->GetOwner();
  752. //   pFrame->m_wndStatusBar.SetPaneText(1,strSave);
  754. }
  755.     dwFlags = MMIO_CREATE | MMIO_WRITE;
  756.     hmmioSave = mmioOpen(SaveFileName.GetBuffer(_MAX_PATH), (LPMMIOINFO)NULL, dwFlags);
  757.     SaveFileName.ReleaseBuffer();
  758. }
  760. void CRevPlayWnd::OnContextMenu(CWnd* pWnd, CPoint point) 
  761. {
  762. // TODO: Add your message handler code here
  763. CMenu menu;
  764. menu.LoadMenu(IDR_POP_MENU);
  765. menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN|TPM_RIGHTBUTTON,point.x,point.y,this);
  766. }
  768. void CRevPlayWnd::OnStopReceive() 
  769. {
  770. // TODO: Add your command handler code here
  771. StopReceive();
  772. m_Save=FALSE;
  773.     m_FirstRead=TRUE;
  774.     m_RenderOk=FALSE;
  775.     m_Stop=FALSE;
  776.     rIndex=0;
  777. }
  779. int  CRevPlayWnd::InitGraph()
  780. {//构建Filter Graph
  781.     HRESULT hr;
  782. hr = S_OK;
  783. //设置媒体类型，为MPEG1数据流
  784.     mt.majortype = MEDIATYPE_Stream;
  785.     mt.subtype = MEDIASUBTYPE_MPEG1System;
  786. //创建Source Filter
  787. m_pStream = new CMemStream(achInBuf, 0x80000000, INFINITE);
  788.     m_pStream->pWnd=this;
  789.     m_rdr = new CMemReader(m_pStream, &mt, &hr);
  791.     if(FAILED(hr) || m_rdr == NULL)
  792. {
  793. MessageBox("CMemReader Error");
  794. return -1;
  795. }
  796.     
  797. m_rdr -> AddRef();
  798. //创建Filter Graph
  799. CHECK_ERROR(CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC, IID_IFilterGraph, (void**)&m_pifg),"CoCreateInstance Error") ;
  800. //将Source Filter加入到Filter Graph中    
  801. CHECK_ERROR(m_pifg -> AddFilter(m_rdr, NULL), "AddFilter Error");
  802. //查询IGraphBuilder接口
  803. CHECK_ERROR(m_pifg -> QueryInterface(IID_IGraphBuilder, (void **)&m_pigb),"QueryInterface(IGraphBuilder) Error");
  804.     m_pigb->AddRef ();
  805. //查询IMediaControl接口
  806. CHECK_ERROR(m_pigb -> QueryInterface(IID_IMediaControl, (void **)&m_pimc),"QueryInterface(IMediaControl) Error");
  807.     m_pimc->AddRef ();
  808. //查询IVideoWindow接口
  809.     CHECK_ERROR(m_pigb -> QueryInterface(IID_IVideoWindow, (void **)&m_pivw),"QueryInterface(IVideoWindow) Error");
  810.     m_pivw->AddRef ();
  811.     //查询IMediaPosition接口
  812.     CHECK_ERROR(m_pigb -> QueryInterface(IID_IMediaPosition, (void **)&m_ppos),"QueryInterface(IMediaPosition) Error");
  813.     m_ppos->AddRef ();
  814. return 0;
  815. }
  817. void CRevPlayWnd::OnRevPlay() 
  818. {
  819. // TODO: Add your command handler code here
  820. int status;
  821. //建立组播socket，加入组播组
  822.    InitMultiSock();
  823. //设置响应的网络事件为FD_READ，即读数据
  824. //发送WSA_READ消息给窗口
  825. status=WSAAsyncSelect(MultiSock,m_hWnd,WSA_READ,FD_READ);
  826. if(status<0)
  827. {
  828.        MessageBox("Error on WSAAsyncSelect()");
  829.        closesocket(MultiSock);
  830.    return;
  831. }
  832. //初始化存放接收数据的缓冲区
  833. for (int i = 0; i< 100; i++ )
  834. pRevMem[i] =new BYTE[BUFSIZE]; //32k
  835. m_Receive=TRUE;
  837. }
  839. BOOL CMemStream::PeekAndPump()
  840. {
  841. static MSG msg;
  843. while (::PeekMessage(&msg,NULL,0,0,PM_NOREMOVE)) {
  844. if (!AfxGetApp()->PumpMessage()) {
  845. ::PostQuitMessage(0);
  846. return FALSE;
  847. }
  848. }
  850. return TRUE;
  851. }
  853. void CRevPlayWnd::RenderFrom(PBYTE Buf, LPCTSTR File)
  854. {
  855.     CFile f;
  856. CString MyPath;
  857. char path[MAX_PATH];
  859. GetModuleFileName (AfxGetInstanceHandle(), path, _MAX_PATH);
  860. MyPath = path;
  861. int index = MyPath.ReverseFind ('\');
  862. MyPath = MyPath.Left (index+1);
  863. MyPath += File;
  865. int r = f.Open (MyPath, CFile::modeRead);
  866.     if(r>0)    
  867. r = f.Read (Buf, BUFSIZE*2);
  868.     else
  869. return;
  870. f.Close ();
  871. }
  873. DWORD CRevPlayWnd::Parse(PBYTE Ptr, DWORD dwSize, LONGLONG *llTime)
  874. {
  875. DWORD RetV;
  876. DWORD LeftBytes = dwSize;
  877. while ((LONGLONG)LeftBytes >= 4 ) {
  878. if (!NextStartCode ((const BYTE **)&Ptr, &LeftBytes))
  879. break;
  880. DWORD Code = DWORD_SWAP(*(UNALIGNED DWORD *)Ptr);
  882. if (VALID_PACKET(Code)) {
  883. PBYTE PcktPtr;
  884. DWORD  Remain;
  885. DWORD PtsPos;
  886. RetV = ParseMPEG1Packet(Ptr, LeftBytes, &PacketData, &PtsPos);
  888. PcktPtr = Ptr+4;
  889. Remain = RetV;
  890. while ((LONG)Remain > 4) {
  891. if (!NextStartCode ((const BYTE **)&PcktPtr, &Remain))
  892. break;
  893. DWORD PcktCode = DWORD_SWAP(*(UNALIGNED DWORD *)PcktPtr);
  894. switch (PcktCode) {
  895. case SEQUENCE_HEADER_CODE:
  896. ParseSequenceHeader(PcktPtr, 0, &SeqInfo);
  897. return (SeqInfo.dwBitRate);
  898. }
  899. PcktPtr += 4;
  900. Remain -=4 ;
  901. }
  903. } else {
  904. switch (Code) {
  905. case PACK_START_CODE:
  906. GetClock (Ptr+4, llTime);
  907. RetV = PACK_HEADER_LENGTH;
  908. break;
  909. case SYSTEM_HEADER_START_CODE:
  910. RetV = ParseSystemHeader(Ptr, LeftBytes);
  911. break;
  912. default:
  913. RetV = 4;
  914. break;
  915. }
  916. }
  918. Ptr += RetV;
  919. LeftBytes -= RetV;
  920. if (RetV <=0)
  921. break;
  922. } 
  923. return 0;
  924. }
  926. void CRevPlayWnd::OnUpdateSave(CCmdUI* pCmdUI) 
  927. {
  928. // TODO: Add your command update UI handler code here
  929. pCmdUI->Enable (!m_Stop);
  930. pCmdUI->SetCheck (m_Save);
  931. }
  933. void CRevPlayWnd::OnUpdateStopReceive(CCmdUI* pCmdUI) 
  934. {
  935. // TODO: Add your command update UI handler code here
  936. pCmdUI->Enable (m_Stop);
  937. }
  939. void CRevPlayWnd::StopReceive()
  940. {
  941.     WSAAsyncSelect(MultiSock,m_hWnd,WSA_READ,0);
  942. closesocket(MultiSock);
  943. if (hmmioSave)
  944. {
  945. mmioClose(hmmioSave, NULL);
  946. hmmioSave = NULL;
  947. }
  948. if(m_pimc)
  949. {
  950. m_pimc -> Pause ();
  951. m_pimc ->StopWhenReady();
  952. m_pimc -> Stop();
  953. }
  954. if(m_pivw)
  955. {
  956. m_pivw -> put_Visible(OAFALSE);
  957. m_pivw -> put_Owner(NULL);
  958. }
  959. HELPER_RELEASE(m_pifg);
  960. HELPER_RELEASE(m_pigb);
  961. HELPER_RELEASE(m_pimc);
  962. HELPER_RELEASE(m_pivw);
  963. HELPER_RELEASE(m_ppos);
  965. if(m_pStream)
  966. {
  967. delete m_pStream;
  968. m_pStream = NULL;
  969. }
  971. if(m_rdr)
  972. {
  973. delete m_rdr;
  974. m_rdr = NULL;
  975. }
  976. for (int i = 0; i< 100; i++) 
  977. {
  979. if (m_Receive) //表示按了Receive菜单
  980. if(pRevMem[i])
  981. delete pRevMem[i];
  982. pRevMem[i] = NULL;
  983. }
  984. }
  986. void CRevPlayWnd::OnSize(UINT nType, int cx, int cy) 
  987. {
  988. CWnd::OnSize(nType, cx, cy);
  990. // TODO: Add your message handler code here
  991. CRect rect;
  992. GetClientRect(&rect);
  993. if(m_pivw)
  994. m_pivw -> SetWindowPosition(rect.left, rect.top, rect.right, rect.bottom);
  996. }