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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
Copy.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：13k
源码类别：

多媒体编程

开发平台：

Visual C++

Copy.cpp：源码内容
  1. // Copyright 2003-2005 Gabest
  2. // http://www.gabest.org
  3. //
  4. // This program is free software; you can redistribute it and/or modify
  5. // it under the terms of the GNU General Public License as published by
  6. // the Free Software Foundation; either version 2 of the License, or
  7. // (at your option) any later version.
  8. //
  9. // This program is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. // GNU General Public License for more details.
  13. //
  14. // You should have received a copy of the GNU General Public License
  15. // along with this program; if not, write to the Free Software
  16. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA, or visit
  17. // http://www.gnu.org/copyleft/gpl.html
  19. #include "stdafx.h"
  20. #include <math.h>
  21. #include "DirectVobSubFilter.h"
  22. #include "......DSUtilDSUtil.h"
  23. #include "......DSUtilMediaTypes.h"
  25. #include <initguid.h>
  26. #include "........includemoreuuids.h"
  28. extern int c2y_yb[256];
  29. extern int c2y_yg[256];
  30. extern int c2y_yr[256];
  31. extern void ColorConvInit();
  33. void BltLineRGB32(DWORD* d, BYTE* sub, int w, const GUID& subtype)
  34. {
  35. if(subtype == MEDIASUBTYPE_YV12 || subtype == MEDIASUBTYPE_I420 || subtype == MEDIASUBTYPE_IYUV)
  36. {
  37. BYTE* db = (BYTE*)d;
  38. BYTE* dbtend = db + w;
  40. for(; db < dbtend; sub+=4, db++)
  41. {
  42. if(sub[3] < 0xff)
  43. {
  44. int y = (c2y_yb[sub[0]] + c2y_yg[sub[1]] + c2y_yr[sub[2]] + 0x108000) >> 16; 
  45. *db = y; // w/o colors 
  46. }
  47. }
  48. }
  49. else if(subtype == MEDIASUBTYPE_YUY2)
  50. {
  51. WORD* ds = (WORD*)d;
  52. WORD* dstend = ds + w;
  54. for(; ds < dstend; sub+=4, ds++)
  55. {
  56. if(sub[3] < 0xff)
  57. {
  58. int y = (c2y_yb[sub[0]] + c2y_yg[sub[1]] + c2y_yr[sub[2]] + 0x108000) >> 16; 
  59. *ds = 0x8000|y; // w/o colors 
  60. }
  61. }
  62. }
  63. else if(subtype == MEDIASUBTYPE_RGB555)
  64. {
  65. WORD* ds = (WORD*)d;
  66. WORD* dstend = ds + w;
  68. for(; ds < dstend; sub+=4, ds++)
  69. {
  70. if(sub[3] < 0xff)
  71. {
  72. *ds = ((*((DWORD*)sub)>>9)&0x7c00)|((*((DWORD*)sub)>>6)&0x03e0)|((*((DWORD*)sub)>>3)&0x001f);
  73. }
  74. }
  75. }
  76. else if(subtype == MEDIASUBTYPE_RGB565)
  77. {
  78. WORD* ds = (WORD*)d;
  79. WORD* dstend = ds + w;
  81. for(; ds < dstend; sub+=4, ds++)
  82. {
  83. if(sub[3] < 0xff)
  84. {
  85. *ds = ((*((DWORD*)sub)>>8)&0xf800)|((*((DWORD*)sub)>>5)&0x07e0)|((*((DWORD*)sub)>>3)&0x001f);
  86. }
  87. }
  88. }
  89. else if(subtype == MEDIASUBTYPE_RGB24)
  90. {
  91. BYTE* dt = (BYTE*)d;
  92. BYTE* dstend = dt + w*3;
  94. for(; dt < dstend; sub+=4, dt+=3)
  95. {
  96. if(sub[3] < 0xff)
  97. {
  98. dt[0] = sub[0];
  99. dt[1] = sub[1];
  100. dt[2] = sub[2];
  101. }
  102. }
  103. }
  104. else if(subtype == MEDIASUBTYPE_RGB32 || subtype == MEDIASUBTYPE_ARGB32)
  105. {
  106. DWORD* dstend = d + w;
  108. for(; d < dstend; sub+=4, d++)
  109. {
  110. if(sub[3] < 0xff) *d = *((DWORD*)sub)&0xffffff;
  111. }
  112. }
  113. }
  115. /* ResX2 */
  116. void Scale2x(const GUID& subtype, BYTE* d, int dpitch, BYTE* s, int spitch, int w, int h)
  117. {
  118. if(subtype == MEDIASUBTYPE_YV12 || subtype == MEDIASUBTYPE_I420 || subtype == MEDIASUBTYPE_IYUV)
  119. {
  120. BYTE* s1;
  121. BYTE* s2;
  122. BYTE* d1;
  124. for(s1 = s, s2 = s + h*spitch, d1 = d; s1 < s2; d1 += dpitch) // TODO: replace this mess with mmx code
  125. {
  126. BYTE* stmp = s1 + spitch;
  127. BYTE* dtmp = d1 + dpitch;
  129. for(BYTE* s3 = s1 + (w-1); s1 < s3; s1 += 1, d1 += 2)
  130. {
  131. d1[0] = s1[0]; 
  132. d1[1] = (s1[0]+s1[1])>>1;
  133. }
  135. d1[0] = d1[1] = s1[0]; 
  137. s1 += 1;
  138. d1 += 2;
  140. s1 = stmp;
  141. d1 = dtmp;
  142. }
  144. AvgLines8(d, h*2, dpitch);
  145. }
  146. else if(subtype == MEDIASUBTYPE_YUY2)
  147. {
  148. unsigned __int64 __0xffffffff00000000 = 0xffffffff00000000;
  149. unsigned __int64 __0x00000000ffffffff = 0x00000000ffffffff;
  150. unsigned __int64 __0x00ff00ff00ff00ff = 0x00ff00ff00ff00ff;
  152. BYTE* s1;
  153. BYTE* s2;
  154. BYTE* d1;
  156. for(s1 = s, s2 = s + h*spitch, d1 = d; s1 < s2; d1 += dpitch)
  157. {
  158. BYTE* stmp = s1 + spitch;
  159. BYTE* dtmp = d1 + dpitch;
  161. // row0, 4 pixels: y1|u1|y2|v1|y3|u2|y4|v2
  162. // ->
  163. // row0, 8 pixels: y1|u1|(y1+y2)/2|v1|y2|(u1+u2)/2|(y2+y3)/2|(v1+v2)/2
  165. __asm
  166. {
  167. mov esi, s1
  168. mov edi, d1
  170. mov ecx, w
  171. shr ecx, 1
  172. dec ecx
  174. movq mm4, __0x00ff00ff00ff00ff
  175. movq mm5, __0x00000000ffffffff
  176. movq mm6, __0xffffffff00000000
  177. row_loop1:
  178. movq mm0, [esi]
  179. movq mm2, mm0
  181. pand mm0, mm4 // mm0 = 00y400y300y200y1
  182. psrlw mm2, 8 // mm2 = 00u200v200u100v1
  185. movq mm1, mm0
  187. pand mm0, mm5 // mm0 = 0000000000y200y1
  189. psllq mm1, 16
  190. pand mm1, mm6 // mm1 = 00y300y200000000
  192. por mm1, mm0 // mm1 = 00y300y200y200y1
  194. punpcklwd mm0, mm0 // mm0 = 00y200y200y100y1
  196. paddw mm0, mm1
  197. psrlw mm0, 1 // mm0 = (mm0 + mm1) / 2
  200. movq mm1, mm2
  201. punpckldq mm1, mm1 // mm1 = 00u100v100u100v1
  203. paddw mm1, mm2
  204. psrlw mm1, 1 // mm1 = (mm1 + mm2) / 2
  207. psllw mm1, 8
  208. por mm0, mm1 // mm0 = (v1+v2)/2|(y2+y3)/2|(u1+u2)/2|y2|v1|(y1+y2)/2|u1|y1
  210. movq [edi], mm0
  212. lea esi, [esi+4]
  213. lea edi, [edi+8]
  215. dec ecx
  216. jnz row_loop1
  218. mov s1, esi
  219. mov d1, edi
  220. };
  222. *d1++ = s1[0];
  223. *d1++ = s1[1];
  224. *d1++ =(s1[0]+s1[2])>>1;
  225. *d1++ = s1[3];
  227. *d1++ = s1[2];
  228. *d1++ = s1[1];
  229. *d1++ = s1[2];
  230. *d1++ = s1[3];
  232. s1 += 4;
  234. s1 = stmp;
  235. d1 = dtmp;
  236. }
  238. AvgLines8(d, h*2, dpitch);
  239. }
  240. else if(subtype == MEDIASUBTYPE_RGB555)
  241. {
  242. BYTE* s1;
  243. BYTE* s2;
  244. BYTE* d1;
  246. for(s1 = s, s2 = s + h*spitch, d1 = d; s1 < s2; d1 += dpitch) // TODO: replace this mess with mmx code
  247. {
  248. BYTE* stmp = s1 + spitch;
  249. BYTE* dtmp = d1 + dpitch;
  251. for(BYTE* s3 = s1 + (w-1)*2; s1 < s3; s1 += 2, d1 += 4)
  252. {
  253. *((WORD*)d1) = *((WORD*)s1);
  254. *((WORD*)d1+1) = 
  255. ((((*((WORD*)s1)&0x7c00) + (*((WORD*)s1+1)&0x7c00)) >> 1)&0x7c00)|
  256. ((((*((WORD*)s1)&0x03e0) + (*((WORD*)s1+1)&0x03e0)) >> 1)&0x03e0)|
  257. ((((*((WORD*)s1)&0x001f) + (*((WORD*)s1+1)&0x001f)) >> 1)&0x001f);
  258. }
  260. *((WORD*)d1) = *((WORD*)s1);
  261. *((WORD*)d1+1) = *((WORD*)s1);
  263. s1 += 2;
  264. d1 += 4;
  266. s1 = stmp;
  267. d1 = dtmp;
  268. }
  270. AvgLines555(d, h*2, dpitch);
  271. }
  272. else if(subtype == MEDIASUBTYPE_RGB565)
  273. {
  274. BYTE* s1;
  275. BYTE* s2;
  276. BYTE* d1;
  278. for(s1 = s, s2 = s + h*spitch, d1 = d; s1 < s2; d1 += dpitch) // TODO: replace this mess with mmx code
  279. {
  280. BYTE* stmp = s1 + spitch;
  281. BYTE* dtmp = d1 + dpitch;
  283. for(BYTE* s3 = s1 + (w-1)*2; s1 < s3; s1 += 2, d1 += 4)
  284. {
  285. *((WORD*)d1) = *((WORD*)s1);
  286. *((WORD*)d1+1) = 
  287. ((((*((WORD*)s1)&0xf800) + (*((WORD*)s1+1)&0xf800)) >> 1)&0xf800)|
  288. ((((*((WORD*)s1)&0x07e0) + (*((WORD*)s1+1)&0x07e0)) >> 1)&0x07e0)|
  289. ((((*((WORD*)s1)&0x001f) + (*((WORD*)s1+1)&0x001f)) >> 1)&0x001f);
  290. }
  292. *((WORD*)d1) = *((WORD*)s1);
  293. *((WORD*)d1+1) = *((WORD*)s1);
  295. s1 += 2;
  296. d1 += 4;
  298. s1 = stmp;
  299. d1 = dtmp;
  300. }
  302. AvgLines565(d, h*2, dpitch);
  303. }
  304. else if(subtype == MEDIASUBTYPE_RGB24)
  305. {
  306. BYTE* s1;
  307. BYTE* s2;
  308. BYTE* d1;
  310. for(s1 = s, s2 = s + h*spitch, d1 = d; s1 < s2; d1 += dpitch) // TODO: replace this mess with mmx code
  311. {
  312. BYTE* stmp = s1 + spitch;
  313. BYTE* dtmp = d1 + dpitch;
  315. for(BYTE* s3 = s1 + (w-1)*3; s1 < s3; s1 += 3, d1 += 6)
  316. {
  317. d1[0] = s1[0]; 
  318. d1[1] = s1[1]; 
  319. d1[2] = s1[2];
  320. d1[3] = (s1[0]+s1[3])>>1;
  321. d1[4] = (s1[1]+s1[4])>>1;
  322. d1[5] = (s1[2]+s1[5])>>1;
  323. }
  325. d1[0] = d1[3] = s1[0]; 
  326. d1[1] = d1[4] = s1[1]; 
  327. d1[2] = d1[5] = s1[2];
  329. s1 += 3;
  330. d1 += 6;
  332. s1 = stmp;
  333. d1 = dtmp;
  334. }
  336. AvgLines8(d, h*2, dpitch);
  337. }
  338. else if(subtype == MEDIASUBTYPE_RGB32 || subtype == MEDIASUBTYPE_ARGB32)
  339. {
  340. BYTE* s1;
  341. BYTE* s2;
  342. BYTE* d1;
  344. for(s1 = s, s2 = s + h*spitch, d1 = d; s1 < s2; d1 += dpitch)
  345. {
  346. BYTE* stmp = s1 + spitch;
  347. BYTE* dtmp = d1 + dpitch;
  349. __asm
  350. {
  351. mov esi, s1
  352. mov edi, d1
  354. mov ecx, w
  355. dec ecx
  357. pxor mm0, mm0
  358. row_loop3:
  359. movq mm1, [esi]
  360. movq mm2, mm1
  362. punpcklbw mm1, mm0 // mm1 = 00xx00r100g100b1
  363. punpckhbw mm2, mm0 // mm2 = 00xx00r200g200b2
  365. paddw mm2, mm1
  366. psrlw mm2, 1 // mm2 = (mm1 + mm2) / 2
  368. packuswb mm1, mm2
  370. movq [edi], mm1
  372. lea esi, [esi+4]
  373. lea edi, [edi+8]
  375. dec ecx
  376. jnz row_loop3
  378. mov s1, esi
  379. mov d1, edi
  380. };
  382. *((DWORD*)d1) = *((DWORD*)s1);
  383. *((DWORD*)d1+1) = *((DWORD*)s1);
  385. s1 += 4;
  386. d1 += 8;
  388. s1 = stmp;
  389. d1 = dtmp;
  390. }
  392. AvgLines8(d, h*2, dpitch);
  393. }
  395. __asm emms;
  396. }
  398. HRESULT CDirectVobSubFilter::Copy(BYTE* pSub, BYTE* pIn, CSize sub, CSize in, int bpp, const GUID& subtype, DWORD black)
  399. {
  400. int wIn = in.cx, hIn = in.cy, pitchIn = ((wIn*bpp>>3)+3)&~3;
  401. int wSub = sub.cx, hSub = sub.cy, pitchSub = ((wSub*bpp>>3)+3)&~3;
  402. bool fScale2x = wIn*2 <= wSub;
  404. if(fScale2x) wIn <<= 1, hIn <<= 1;
  406. int left = ((wSub - wIn)>>1)&~1;
  407. int mid = wIn;
  408. int right = left + ((wSub - wIn)&1);
  410. int dpLeft = left*bpp>>3;
  411. int dpMid = mid*bpp>>3;
  412. int dpRight = right*bpp>>3;
  414. ASSERT(wSub >= wIn);
  416. {
  417. int i = 0, j = 0;
  419. j += (hSub - hIn) >> 1;
  421. for(; i < j; i++, pSub += pitchSub)
  422. {
  423. memsetd(pSub, black, dpLeft+dpMid+dpRight);
  424. }
  426. j += hIn;
  428. if(hIn > hSub)
  429. pIn += pitchIn * ((hIn - hSub) >> (fScale2x?2:1));
  431. if(fScale2x)
  432. {
  433. Scale2x(subtype, 
  434. pSub + dpLeft, pitchSub, pIn, pitchIn, 
  435. in.cx, (min(j, hSub) - i) >> 1);
  436.             
  437. for(int k = min(j, hSub); i < k; i++, pIn += pitchIn, pSub += pitchSub)
  438. {
  439. memsetd(pSub, black, dpLeft);
  440. memsetd(pSub + dpLeft+dpMid, black, dpRight);
  441. }
  442. }
  443. else
  444. {
  445. for(int k = min(j, hSub); i < k; i++, pIn += pitchIn, pSub += pitchSub)
  446. {
  447. memsetd(pSub, black, dpLeft);
  448. memcpy(pSub + dpLeft, pIn, dpMid);
  449. memsetd(pSub + dpLeft+dpMid, black, dpRight);
  450. }
  451. }
  453. j = hSub;
  455. for(; i < j; i++, pSub += pitchSub)
  456. {
  457. memsetd(pSub, black, dpLeft+dpMid+dpRight);
  458. }
  459. }
  461. return NOERROR;
  462. }
  464. void CDirectVobSubFilter::PrintMessages(BYTE* pOut)
  465. {
  466. if(!m_hdc || !m_hbm)
  467. return;
  469. ColorConvInit();
  471. const GUID& subtype = m_pOutput->CurrentMediaType().subtype;
  473. BITMAPINFOHEADER bihOut;
  474. ExtractBIH(&m_pOutput->CurrentMediaType(), &bihOut);
  476. CString msg, tmp;
  478. if(m_fOSD)
  479. {
  480. tmp.Format(_T("in: %dx%d %snout: %dx%d %sn"), 
  481. m_w, m_h, 
  482. Subtype2String(m_pInput->CurrentMediaType().subtype),
  483. bihOut.biWidth, bihOut.biHeight, 
  484. Subtype2String(m_pOutput->CurrentMediaType().subtype));
  485. msg += tmp;
  487. tmp.Format(_T("real fps: %.3f, current fps: %.3fnmedia time: %d, subtitle time: %d [ms]nframe number: %d (calculated)nrate: %.4fn"), 
  488. m_fps, m_fMediaFPSEnabled?m_MediaFPS:fabs(m_fps),
  489. (int)m_tPrev.Millisecs(), (int)(CalcCurrentTime()/10000),
  490. (int)(m_tPrev.m_time * m_fps / 10000000),
  491. m_pInput->CurrentRate());
  492. msg += tmp;
  494. CAutoLock cAutoLock(&m_csQueueLock);
  496. if(m_pSubPicQueue)
  497. {
  498. int nSubPics = -1;
  499. REFERENCE_TIME rtNow = -1, rtStart = -1, rtStop = -1;
  500. m_pSubPicQueue->GetStats(nSubPics, rtNow, rtStart, rtStop);
  501. tmp.Format(_T("queue stats: %I64d - %I64d [ms]n"), rtStart/10000, rtStop/10000);
  502. msg += tmp;
  504. for(int i = 0; i < nSubPics; i++)
  505. {
  506. m_pSubPicQueue->GetStats(i, rtStart, rtStop);
  507. tmp.Format(_T("%d: %I64d - %I64d [ms]n"), i, rtStart/10000, rtStop/10000);
  508. msg += tmp;
  509. }
  511. }
  512. }
  514. if(msg.IsEmpty()) return;
  516. HANDLE hOldBitmap = SelectObject(m_hdc, m_hbm);
  517. HANDLE hOldFont = SelectObject(m_hdc, m_hfont);
  519. SetTextColor(m_hdc, 0xffffff);
  520. SetBkMode(m_hdc, TRANSPARENT);
  521. SetMapMode(m_hdc, MM_TEXT);
  523. BITMAP bm;
  524. GetObject(m_hbm, sizeof(BITMAP), &bm);
  526. CRect r(0, 0, bm.bmWidth, bm.bmHeight);
  527. DrawText(m_hdc, msg, _tcslen(msg), &r, DT_CALCRECT|DT_EXTERNALLEADING|DT_NOPREFIX|DT_WORDBREAK);
  529. r += CPoint(10, 10);
  530. r &= CRect(0, 0, bm.bmWidth, bm.bmHeight);
  532. DrawText(m_hdc, msg, _tcslen(msg), &r, DT_LEFT|DT_TOP|DT_NOPREFIX|DT_WORDBREAK);
  534. BYTE* pIn = (BYTE*)bm.bmBits;
  535. int pitchIn = bm.bmWidthBytes;
  536. int pitchOut = bihOut.biWidth * bihOut.biBitCount >> 3;
  538. if(subtype == MEDIASUBTYPE_YV12 || subtype == MEDIASUBTYPE_I420 || subtype == MEDIASUBTYPE_IYUV)
  539. pitchOut = bihOut.biWidth;
  541. pitchIn = (pitchIn+3)&~3;
  542. pitchOut = (pitchOut+3)&~3;
  544. if(bihOut.biHeight > 0 && bihOut.biCompression <= 3) // flip if the dst bitmap is flipped rgb (m_hbm is a top-down bitmap, not like the subpictures)
  545. {
  546. pOut += pitchOut * (abs(bihOut.biHeight)-1);
  547. pitchOut = -pitchOut;
  548. }
  550. pIn += pitchIn * r.top;
  551. pOut += pitchOut * r.top;
  553. for(int w = min(r.right, m_w), h = r.Height(); h--; pIn += pitchIn, pOut += pitchOut)
  554. {
  555. BltLineRGB32((DWORD*)pOut, pIn, w, subtype);
  556. memsetd(pIn, 0xff000000, r.right*4);
  557. }
  559. SelectObject(m_hdc, hOldBitmap);
  560. SelectObject(m_hdc, hOldFont);
  561. }