?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Increase ParseScript cache from 30 to 90 seconds
[xy_vsfilter.git] / src / subpic / MemSubPic.cpp
blob8635aaed157009d468aafa8fab8865f79980d030
1 /*
2 * Copyright (C) 2003-2006 Gabest
3 * http://www.gabest.org
4 *
5 * This Program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2, or (at your option)
8 * any later version.
9 *
10 * This Program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with GNU Make; see the file COPYING. If not, write to
17 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
18 * http://www.gnu.org/copyleft/gpl.html
19 *
20 */
21
22 #include "stdafx.h"
23 #include "MemSubPic.h"
24 #include "color_conv_table.h"
25
26 #if 0
27 #include <fstream>
28 //
29 // debug functions
30 //
31 static void SaveRect2File(const CRect& cRect, const char * filename)
32 {
33 std::ofstream os(filename);
34 os<<cRect.left<<","<<cRect.top<<","<<cRect.right<<","<<cRect.bottom;
35 }
36 static void SaveAxxx2File(SubPicDesc& spd, const CRect& cRect, const char * filename)
37 {
38 std::ofstream axxx(filename);
39 int w = cRect.Width(), h = cRect.Height();
40
41 BYTE* top = (BYTE*)spd.bits + spd.pitch*cRect.top + cRect.left*4;
42 BYTE* bottom = top + spd.pitch*h;
43
44 for(; top < bottom ; top += spd.pitch) {
45 BYTE* s = top;
46 BYTE* e = s + w*4;
47 for(; s < e; s+=4) { // ARGB ARGB -> AxYU AxYV
48 axxx<<(int)s[0]<<","<<(int)s[1]<<","<<(int)s[2]<<","<<(int)s[3];
49 if(s+4>=e)
50 {
51 axxx<<std::endl;
52 }
53 else
54 {
55 axxx<<",";
56 }
57 }
58 }
59 axxx.close();
60 }
61 static void SaveArgb2File(SubPicDesc& spd, const CRect& cRect, const char * filename)
62 {
63 SaveAxxx2File(spd, cRect, filename);
64 }
65 static void SaveAyuv2File(SubPicDesc& spd, const CRect& cRect, const char * filename)
66 {
67 SaveAxxx2File(spd, cRect, filename);
68 }
69 static void SaveNvxx2File(SubPicDesc& spd, const CRect& cRect, const char * filename)
70 {
71 std::ofstream os(filename);
72 int w = cRect.Width(), h = cRect.Height();
73
74 BYTE* top = (BYTE*)spd.bits;
75 BYTE* bottom = top + spd.pitch*h;
76
77 for(; top < bottom ; top += spd.pitch) {
78 BYTE* s = top;
79 BYTE* e = s + w;
80
81 BYTE* sY = s + spd.pitch*spd.h;
82 BYTE* sU = sY + spd.pitch*spd.h;
83 BYTE* sV = sU + 1;
84 for(; s < e; s++, sY++, sU+=2,sV+=2) {
85 os<<(int)s[0]<<","<<(int)sY[0]<<","<<(int)sU[0]<<","<<(int)sV[0];
86 if(s+1>=e)
87 {
88 os<<std::endl;
89 }
90 else
91 {
92 os<<",";
93 }
94 }
95 }
96 os.close();
97 }
98
99 #define ONCER(expr) {\
100 static bool entered=false;\
101 if(!entered)\
102 {\
103 entered=true;\
104 expr;\
105 }\
106 }
107 #else
108 #define ONCER(expr)
109 #endif
110
111 //
112 // alpha blend functions
113 //
114 #include "xy_intrinsics.h"
115 #include "../dsutil/vd.h"
116
117 #ifndef _WIN64
118 static void AlphaBlt_YUY2_MMX(int w, int h, BYTE* d, int dstpitch, PCUINT8 s, int srcpitch)
119 {
120 for(int j = 0; j < h; j++, s += srcpitch, d += dstpitch)
121 {
122 unsigned int ia, c;
123 PCUINT8 s2 = s;
124 PCUINT8 s2end = s2 + w*4;
125 DWORD* d2 = (DWORD*)d;
126 ASSERT(w>0);
127 int last_a = w>0?s2[3]:0;
128 for(; s2 < s2end; s2 += 8, d2++)
129 {
130 ia = (last_a + 2*s2[3] + s2[7])>>2;
131 last_a = s2[7];
132 if(ia < 0xff)
133 {
134 //int y1 = (BYTE)(((((*d2&0xff))*s2[3])>>8) + s2[1]); // + y1;
135 //int u = (BYTE)((((((*d2>>8)&0xff))*ia)>>8) + s2[0]); // + u;
136 //int y2 = (BYTE)((((((*d2>>16)&0xff))*s2[7])>>8) + s2[5]); // + y2;
137 //int v = (BYTE)((((((*d2>>24)&0xff))*ia)>>8) + s2[4]); // + v;
138 //*d2 = (v<<24)|(y2<<16)|(u<<8)|y1;
139
140 ia = (ia<<24)|(s2[7]<<16)|(ia<<8)|s2[3];
141 c = (s2[4]<<24)|(s2[5]<<16)|(s2[0]<<8)|s2[1]; // (v<<24)|(y2<<16)|(u<<8)|y1;
142 __asm
143 {
144 mov edi, d2
145 pxor mm0, mm0
146 movd mm2, c
147 punpcklbw mm2, mm0
148 movd mm3, [edi]
149 punpcklbw mm3, mm0
150 movd mm4, ia
151 punpcklbw mm4, mm0
152 psraw mm4, 1 //or else, overflow because psraw shift in sign bit
153 pmullw mm3, mm4
154 psraw mm3, 7
155 paddsw mm3, mm2
156 packuswb mm3, mm3
157 movd [edi], mm3
158 };
159 }
160 }
161 }
162 _mm_empty();
163 }
164 #endif
165
166 void AlphaBlt_YUY2_C(int w, int h, BYTE* d, int dstpitch, PCUINT8 s, int srcpitch)
167 {
168 for(int j = 0; j < h; j++, s += srcpitch, d += dstpitch)
169 {
170 DWORD ia;
171 PCUINT8 s2 = s;
172 PCUINT8 s2end = s2 + w*4;
173 DWORD* d2 = (DWORD*)d;
174 ASSERT(w>0);
175 int last_a = w>0?s2[3]:0;
176 for(; s2 < s2end; s2 += 8, d2++)
177 {
178 ia = (last_a + 2*s2[3] + s2[7])>>2;
179 last_a = s2[7];
180 if(ia < 0xff)
181 {
182 DWORD y1 = (BYTE)(((((*d2&0xff))*s2[3])>>8) + s2[1]); // + y1;
183 DWORD u = (BYTE)((((((*d2>>8)&0xff))*ia)>>8) + s2[0]); // + u;
184 DWORD y2 = (BYTE)((((((*d2>>16)&0xff))*s2[7])>>8) + s2[5]); // + y2;
185 DWORD v = (BYTE)((((((*d2>>24)&0xff))*ia)>>8) + s2[4]); // + v;
186 *d2 = (v<<24)|(y2<<16)|(u<<8)|y1;
187 }
188 }
189 }
190 }
191
192
193 //
194 // CMemSubPic
195 //
196
197 CMemSubPic::CMemSubPic(SubPicDesc& spd, int alpha_blt_dst_type)
198 : m_spd(spd), m_alpha_blt_dst_type(alpha_blt_dst_type)
199 {
200 m_maxsize.SetSize(spd.w, spd.h);
201 // m_rcDirty.SetRect(0, 0, spd.w, spd.h);
202 CRect allSpd(0,0,spd.w, spd.h);
203 m_rectListDirty.AddTail(allSpd);
204 }
205
206 CMemSubPic::~CMemSubPic()
207 {
208 delete [] m_spd.bits, m_spd.bits = NULL;
209 }
210
211 // ISubPic
212
213 STDMETHODIMP_(void*) CMemSubPic::GetObject() const
214 {
215 return (void*)&m_spd;
216 }
217
218 STDMETHODIMP CMemSubPic::GetDesc(SubPicDesc& spd) const
219 {
220 spd.type = m_spd.type;
221 spd.w = m_size.cx;
222 spd.h = m_size.cy;
223 spd.bpp = m_spd.bpp;
224 spd.pitch = m_spd.pitch;
225 spd.bits = m_spd.bits;
226 spd.bitsU = m_spd.bitsU;
227 spd.bitsV = m_spd.bitsV;
228 spd.vidrect = m_vidrect;
229 return S_OK;
230 }
231
232 STDMETHODIMP CMemSubPic::CopyTo(ISubPicEx* pSubPic)
233 {
234 HRESULT hr;
235 if(FAILED(hr = __super::CopyTo(pSubPic))) {
236 return hr;
237 }
238
239 SubPicDesc src, dst;
240 if(FAILED(GetDesc(src)) || FAILED(pSubPic->GetDesc(dst))) {
241 return E_FAIL;
242 }
243 while(!m_rectListDirty.IsEmpty())
244 {
245 CRect& cRect = m_rectListDirty.GetHead();
246 int w = cRect.Width(), h = cRect.Height();
247 BYTE* s = (BYTE*)src.bits + src.pitch*cRect.top + cRect.left*4;
248 BYTE* d = (BYTE*)dst.bits + dst.pitch*cRect.top + cRect.left*4;
249 for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
250 memcpy(d, s, w*4);
251 }
252 return S_OK;
253 }
254
255 STDMETHODIMP CMemSubPic::ClearDirtyRect(DWORD color)
256 {
257 if(m_rectListDirty.IsEmpty()) {
258 return S_OK;
259 }
260 while(!m_rectListDirty.IsEmpty())
261 {
262 //pDirtyRect = m_rectListDirty.RemoveHead();
263 CRect& dirtyRect = m_rectListDirty.RemoveTail();
264 BYTE* p = (BYTE*)m_spd.bits + m_spd.pitch*(dirtyRect.top) + dirtyRect.left*(m_spd.bpp>>3);
265 int w = dirtyRect.Width();
266 if(m_spd.type!=MSP_AYUV_PLANAR)
267 {
268 for(int j = 0, h = dirtyRect.Height(); j < h; j++, p += m_spd.pitch)
269 {
270 #ifdef _WIN64
271 memsetd(p, color, w*4); // nya
272 #else
273 __asm
274 {
275 mov eax, color
276 mov ecx, w
277 mov edi, p
278 cld
279 rep stosd
280 }
281
282 #endif
283 }
284 }
285 else
286 {
287 ///TODO:
288 ///FIX ME
289 for(int j = 0, h = dirtyRect.Height(); j < h; j++, p += m_spd.pitch)
290 {
291 // memsetd(p, 0, m_rcDirty.Width());
292 //DbgLog((LOG_TRACE, 3, "w:%d", w));
293 //w = pDirtyRect->Width();
294 memset(p, 0xFF, w);
295 memset(p+m_spd.h*m_spd.pitch, 0, w);
296 memset(p+m_spd.h*m_spd.pitch*2, 0, w);
297 memset(p+m_spd.h*m_spd.pitch*3, 0, w);
298 }
299 }
300 }
301 m_rectListDirty.RemoveAll();
302 return S_OK;
303 }
304
305 STDMETHODIMP CMemSubPic::Lock(SubPicDesc& spd)
306 {
307 return GetDesc(spd);
308 }
309
310 STDMETHODIMP CMemSubPic::Unlock( CAtlList<CRect>* dirtyRectList )
311 {
312 int src_type = m_spd.type;
313 int dst_type = m_alpha_blt_dst_type;
314 if( (src_type==MSP_RGBA && (dst_type == MSP_RGB32 ||
315 dst_type == MSP_RGB24 ||
316 dst_type == MSP_RGB16 ||
317 dst_type == MSP_RGB15))
318 ||
319 (src_type==MSP_XY_AUYV && dst_type == MSP_YUY2)//ToDo: fix me MSP_AYUV
320 ||
321 (src_type==MSP_AYUV && dst_type == MSP_AYUV)
322 ||
323 (src_type==MSP_AYUV_PLANAR && (dst_type == MSP_IYUV ||
324 dst_type == MSP_YV12 ||
325 dst_type == MSP_P010 ||
326 dst_type == MSP_P016 ||
327 dst_type == MSP_NV12 ||
328 dst_type == MSP_NV21)))
329 {
330 return UnlockOther(dirtyRectList);
331 }
332 else if(src_type==MSP_RGBA && (dst_type == MSP_YUY2 ||
333 dst_type == MSP_AYUV || //ToDo: fix me MSP_AYUV
334 dst_type == MSP_IYUV ||
335 dst_type == MSP_YV12 ||
336 dst_type == MSP_NV12 ||
337 dst_type == MSP_NV21 ||
338 dst_type == MSP_P010 ||
339 dst_type == MSP_P016))
340 {
341 return UnlockRGBA_YUV(dirtyRectList);
342 }
343 return E_NOTIMPL;
344 }
345
346 HRESULT CMemSubPic::UnlockOther(CAtlList<CRect>* dirtyRectList)
347 {
348 SetDirtyRectEx(dirtyRectList);
349 if(m_rectListDirty.IsEmpty()) {
350 return S_OK;
351 }
352
353 POSITION pos = m_rectListDirty.GetHeadPosition();
354 while(pos!=NULL)
355 {
356 const CRect& cRect = m_rectListDirty.GetNext(pos);
357 int w = cRect.Width(), h = cRect.Height();
358 if (w<=0 || h<=0)
359 {
360 continue;
361 }
362
363 BYTE* top = (BYTE*)m_spd.bits + m_spd.pitch*(cRect.top) + cRect.left*4;
364 BYTE* bottom = top + m_spd.pitch*h;
365 if(m_alpha_blt_dst_type == MSP_RGB16)
366 {
367 for(; top < bottom ; top += m_spd.pitch)
368 {
369 DWORD* s = (DWORD*)top;
370 DWORD* e = s + w;
371 for(; s < e; s++)
372 {
373 *s = ((*s>>3)&0x1f000000)|((*s>>8)&0xf800)|((*s>>5)&0x07e0)|((*s>>3)&0x001f);
374 // *s = (*s&0xff000000)|((*s>>8)&0xf800)|((*s>>5)&0x07e0)|((*s>>3)&0x001f);
375 }
376 }
377 }
378 else if(m_alpha_blt_dst_type == MSP_RGB15)
379 {
380 for(; top < bottom; top += m_spd.pitch)
381 {
382 DWORD* s = (DWORD*)top;
383 DWORD* e = s + w;
384 for(; s < e; s++)
385 {
386 *s = ((*s>>3)&0x1f000000)|((*s>>9)&0x7c00)|((*s>>6)&0x03e0)|((*s>>3)&0x001f);
387 // *s = (*s&0xff000000)|((*s>>9)&0x7c00)|((*s>>6)&0x03e0)|((*s>>3)&0x001f);
388 }
389 }
390 }
391 else if(m_alpha_blt_dst_type == MSP_YUY2)
392 {
393 XY_DO_ONCE( xy_logger::write_file("G:\\b1_ul", top, m_spd.pitch*(h-1)) );
394
395 for(BYTE* tempTop=top; tempTop < bottom ; tempTop += m_spd.pitch)
396 {
397 BYTE* s = tempTop;
398 BYTE* e = s + w*4;
399 BYTE last_v = s[0], last_u=s[2];
400 for(; s < e; s+=8) // AUYV AUYV -> AxYU AxYV
401 {
402 BYTE tmp = s[4];
403 s[4] = (last_v + 2*s[0] + s[4] + 2)>>2;
404 last_v = tmp;
405
406 s[0] = (last_u + 2*s[2] + s[6] + 2)>>2;
407 last_u = s[6];
408 }
409 }
410
411 XY_DO_ONCE( xy_logger::write_file("G:\\a1_ul", top, m_spd.pitch*(h-1)) );
412 }
413 else if(m_alpha_blt_dst_type == MSP_YV12 || m_alpha_blt_dst_type == MSP_IYUV
414 || m_alpha_blt_dst_type == MSP_AYUV)
415 {
416 //nothing to do
417 }
418 else if ( m_alpha_blt_dst_type == MSP_P010 || m_alpha_blt_dst_type == MSP_P016
419 || m_alpha_blt_dst_type == MSP_NV12 )
420 {
421 SubsampleAndInterlace(cRect, true);
422 }
423 else if( m_alpha_blt_dst_type == MSP_NV21 )
424 {
425 SubsampleAndInterlace(cRect, false);
426 }
427 }
428 return S_OK;
429 }
430
431 HRESULT CMemSubPic::UnlockRGBA_YUV(CAtlList<CRect>* dirtyRectList)
432 {
433 //debug
434 ONCER( SaveRect2File(dirtyRectList->GetHead(), "F:/mplayer_MinGW_full/MinGW/home/Administrator/xy_vsfilter/debug.rect") );
435 ONCER( SaveArgb2File(m_spd, CRect(CPoint(0,0), m_size), "F:/mplayer_MinGW_full/MinGW/home/Administrator/xy_vsfilter/debug.argb") );
436
437 SetDirtyRectEx(dirtyRectList);
438
439 ONCER( SaveRect2File(dirtyRectList->GetHead(), "F:/mplayer_MinGW_full/MinGW/home/Administrator/xy_vsfilter/debug.rect2") );
440 if(m_rectListDirty.IsEmpty()) {
441 return S_OK;
442 }
443
444 POSITION pos = m_rectListDirty.GetHeadPosition();
445 while(pos!=NULL)
446 {
447 const CRect& cRect = m_rectListDirty.GetNext(pos);
448 int w = cRect.Width(), h = cRect.Height();
449 if(w<=0 || h<=0)
450 {
451 continue;
452 }
453
454 BYTE* top = (BYTE*)m_spd.bits + m_spd.pitch*cRect.top + cRect.left*4;
455 BYTE* bottom = top + m_spd.pitch*h;
456
457 if( m_alpha_blt_dst_type == MSP_YUY2 ||
458 m_alpha_blt_dst_type == MSP_YV12 ||
459 m_alpha_blt_dst_type == MSP_IYUV ||
460 m_alpha_blt_dst_type == MSP_P010 ||
461 m_alpha_blt_dst_type == MSP_P016 ||
462 m_alpha_blt_dst_type == MSP_NV12 ||
463 m_alpha_blt_dst_type == MSP_NV21) {
464 for(; top < bottom ; top += m_spd.pitch) {
465 BYTE* s = top;
466 BYTE* e = s + w*4;
467 DWORD last_yuv = ColorConvTable::PreMulArgb2Ayuv(s[3], s[2], s[1], s[0]);
468 for(; s < e; s+=8) { // ARGB ARGB -> AxYU AxYV
469 if((s[3]+s[7]+(last_yuv>>24)) < 0xff*3) {
470 DWORD tmp1 = ColorConvTable::PreMulArgb2Ayuv(s[3], s[2], s[1], s[0]);
471 DWORD tmp2 = ColorConvTable::PreMulArgb2Ayuv(s[7], s[6], s[5], s[4]);
472
473 s[1] = (tmp1>>16)&0xff;
474 s[5] = (tmp2>>16)&0xff;
475
476 s[0] = (((last_yuv>>8)&0xff) + 2*((tmp1>>8)&0xff) + ((tmp2>>8)&0xff) + 2)/4;
477 s[4] = ((last_yuv&0xff) + 2*(tmp1&0xff) + (tmp2&0xff) + 2)/4;
478 last_yuv = tmp2;
479 } else {
480 last_yuv = ColorConvTable::PreMulArgb2Ayuv(s[7], s[6], s[5], s[4]);
481
482 s[1] = s[5] = 0;
483 s[0] = s[4] = 0;
484 }
485 }
486 }
487 }
488 else if(m_alpha_blt_dst_type == MSP_AYUV) {
489 for(; top < bottom ; top += m_spd.pitch) {
490 BYTE* s = top;
491 BYTE* e = s + w*4;
492 for(; s < e; s+=4) { // ARGB -> AYUV
493 if(s[3] < 0xff) {
494 *((DWORD*)s) = ColorConvTable::PreMulArgb2Ayuv(s[3], s[2], s[1], s[0]);
495 } else {
496 s[0] = s[1] = 0;
497 s[2] = 0;
498 }
499 }
500 }
501 }
502 }
503
504 ONCER( SaveAxxx2File(m_spd, CRect(CPoint(0,0), m_size), "F:/mplayer_MinGW_full/MinGW/home/Administrator/xy_vsfilter/debug.axuv") );
505 return S_OK;
506 }
507
508 void CMemSubPic::SubsampleAndInterlace( const CRect& cRect, bool u_first )
509 {
510 //fix me: check alignment and log error
511 int w = cRect.Width(), h = cRect.Height();
512 BYTE* u_plan = reinterpret_cast<BYTE*>(m_spd.bits) + m_spd.pitch*m_spd.h*2;
513 BYTE* u_start = u_plan + m_spd.pitch*(cRect.top)+ cRect.left;
514 BYTE* v_start = u_start + m_spd.pitch*m_spd.h;
515 BYTE* dst = u_start;
516 if(!u_first)
517 {
518 BYTE* tmp = v_start;
519 v_start = u_start;
520 u_start = tmp;
521 }
522
523 //Todo: fix me.
524 //Walkarround for alignment
525 if ( ((m_spd.pitch|w) &15) == 0 && (g_cpuid.m_flags & CCpuID::sse2) )
526 {
527 ASSERT(w%16==0);
528 SubsampleAndInterlace(dst, u_start, v_start, h, w, m_spd.pitch);
529 }
530 else
531 {
532 SubsampleAndInterlaceC(dst, u_start, v_start, h, w, m_spd.pitch);
533 }
534 }
535
536 STDMETHODIMP CMemSubPic::AlphaBlt( const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget )
537 {
538 if(!pSrc || !pDst || !pTarget) {
539 return E_POINTER;
540 }
541 int src_type = m_spd.type;
542 int dst_type = pTarget->type;
543
544 if( (src_type==MSP_RGBA && (dst_type == MSP_RGB32 ||
545 dst_type == MSP_RGB24 ||
546 dst_type == MSP_RGB16 ||
547 dst_type == MSP_RGB15 ||
548 dst_type == MSP_RGBA ||
549 dst_type == MSP_YUY2 ||//ToDo: fix me MSP_RGBA changed into AxYU AxYV after unlock, may be confusing
550 dst_type == MSP_AYUV ))
551 ||
552 (src_type==MSP_XY_AUYV && dst_type == MSP_YUY2)//ToDo: fix me MSP_AYUV
553 ||
554 (src_type==MSP_AYUV && dst_type == MSP_AYUV)
555 ||
556 (src_type==MSP_AYUV_PLANAR && (dst_type == MSP_IYUV ||
557 dst_type == MSP_YV12)) )
558 {
559 return AlphaBltOther(pSrc, pDst, pTarget);
560 }
561 else if ( src_type==MSP_AYUV_PLANAR && (dst_type == MSP_NV12 ||
562 dst_type == MSP_NV21 ) )
563 {
564 return AlphaBltAnv12_Nv12(pSrc, pDst, pTarget);
565 }
566
567 else if( src_type==MSP_AYUV_PLANAR && (dst_type == MSP_P010 ||
568 dst_type == MSP_P016 ) )
569 {
570 return AlphaBltAnv12_P010(pSrc, pDst, pTarget);
571 }
572 else if( src_type==MSP_RGBA && (dst_type == MSP_IYUV ||
573 dst_type == MSP_YV12))
574 {
575 return AlphaBltAxyuAxyv_Yv12(pSrc, pDst, pTarget);
576 }
577 else if( src_type==MSP_RGBA && (dst_type == MSP_NV12||
578 dst_type == MSP_NV21))
579 {
580 return AlphaBltAxyuAxyv_Nv12(pSrc, pDst, pTarget);
581 }
582 else if( src_type==MSP_RGBA && (dst_type == MSP_P010 ||
583 dst_type == MSP_P016))
584 {
585 return AlphaBltAxyuAxyv_P010(pSrc, pDst, pTarget);
586 }
587 return E_NOTIMPL;
588 }
589
590 HRESULT CMemSubPic::AlphaBltOther(const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget)
591 {
592 const SubPicDesc& src = m_spd;
593 SubPicDesc dst = *pTarget; // copy, because we might modify it
594
595 CRect rs(*pSrc), rd(*pDst);
596 if(dst.h < 0)
597 {
598 dst.h = -dst.h;
599 rd.bottom = dst.h - rd.bottom;
600 rd.top = dst.h - rd.top;
601 }
602 if(rs.Width() != rd.Width() || rs.Height() != abs(rd.Height())) {
603 return E_INVALIDARG;
604 }
605 int w = rs.Width(), h = rs.Height();
606 BYTE* s = (BYTE*)src.bits + src.pitch*rs.top + ((rs.left*src.bpp)>>3);//rs.left*4
607 BYTE* d = (BYTE*)dst.bits + dst.pitch*rd.top + ((rd.left*dst.bpp)>>3);
608 if(rd.top > rd.bottom)
609 {
610 if(dst.type == MSP_RGB32 || dst.type == MSP_RGB24
611 || dst.type == MSP_RGB16 || dst.type == MSP_RGB15
612 || dst.type == MSP_YUY2 || dst.type == MSP_AYUV)
613 {
614 d = (BYTE*)dst.bits + dst.pitch*(rd.top-1) + (rd.left*dst.bpp>>3);
615 }
616 else if(dst.type == MSP_YV12 || dst.type == MSP_IYUV)
617 {
618 d = (BYTE*)dst.bits + dst.pitch*(rd.top-1) + (rd.left*8>>3);
619 }
620 else
621 {
622 return E_NOTIMPL;
623 }
624 dst.pitch = -dst.pitch;
625 }
626 DbgLog((LOG_TRACE, 5, TEXT("w=%d h=%d"), w, h));
627 switch(dst.type)
628 {
629 case MSP_RGBA:
630 for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
631 {
632 BYTE* s2 = s;
633 BYTE* s2end = s2 + w*4;
634 DWORD* d2 = (DWORD*)d;
635 for(; s2 < s2end; s2 += 4, d2++)
636 {
637 if(s2[3] < 0xff)
638 {
639 DWORD bd =0x00000100 -( (DWORD) s2[3]);
640 DWORD B = ((*((DWORD*)s2)&0x000000ff)<<8)/bd;
641 DWORD V = ((*((DWORD*)s2)&0x0000ff00)/bd)<<8;
642 DWORD R = (((*((DWORD*)s2)&0x00ff0000)>>8)/bd)<<16;
643 *d2 = B | V | R
644 | (0xff000000-(*((DWORD*)s2)&0xff000000))&0xff000000;
645 }
646 }
647 }
648 break;
649 case MSP_RGB32:
650 for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
651 {
652 BYTE* s2 = s;
653 BYTE* s2end = s2 + w*4;
654 DWORD* d2 = (DWORD*)d;
655 for(; s2 < s2end; s2 += 4, d2++)
656 {
657 if(s2[3] < 0xff)
658 {
659 *d2 = (((((*d2&0x00ff00ff)*s2[3])>>8) + (*((DWORD*)s2)&0x00ff00ff))&0x00ff00ff)
660 | (((((*d2&0x0000ff00)*s2[3])>>8) + (*((DWORD*)s2)&0x0000ff00))&0x0000ff00);
661 }
662 }
663 }
664 break;
665 case MSP_AYUV:
666 for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
667 {
668 BYTE* s2 = s;
669 BYTE* s2end = s2 + w*4;
670 DWORD* d2 = (DWORD*)d;
671 for(; s2 < s2end; s2 += 4, d2++)
672 {
673 if(s2[3] < 0xff)
674 {
675 *d2 = (((((*d2&0x00ff00ff)*s2[3])>>8) + (*((DWORD*)s2)&0x00ff00ff))&0x00ff00ff)
676 | (((((*d2&0x0000ff00)*s2[3])>>8) + (*((DWORD*)s2)&0x0000ff00))&0x0000ff00)
677 | (*d2&0xff000000);
678 }
679 }
680 }
681 break;
682 case MSP_RGB24:
683 for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
684 {
685 BYTE* s2 = s;
686 BYTE* s2end = s2 + w*4;
687 BYTE* d2 = d;
688 for(; s2 < s2end; s2 += 4, d2 += 3)
689 {
690 if(s2[3] < 0xff)
691 {
692 d2[0] = ((d2[0]*s2[3])>>8) + s2[0];
693 d2[1] = ((d2[1]*s2[3])>>8) + s2[1];
694 d2[2] = ((d2[2]*s2[3])>>8) + s2[2];
695 }
696 }
697 }
698 break;
699 case MSP_RGB16:
700 for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
701 {
702 BYTE* s2 = s;
703 BYTE* s2end = s2 + w*4;
704 WORD* d2 = (WORD*)d;
705 for(; s2 < s2end; s2 += 4, d2++)
706 {
707 if(s2[3] < 0x1f)
708 {
709 *d2 = (WORD)((((((*d2&0xf81f)*s2[3])>>5) + (*(DWORD*)s2&0xf81f))&0xf81f)
710 | (((((*d2&0x07e0)*s2[3])>>5) + (*(DWORD*)s2&0x07e0))&0x07e0));
711 /* *d2 = (WORD)((((((*d2&0xf800)*s2[3])>>8) + (*(DWORD*)s2&0xf800))&0xf800)
712 | (((((*d2&0x07e0)*s2[3])>>8) + (*(DWORD*)s2&0x07e0))&0x07e0)
713 | (((((*d2&0x001f)*s2[3])>>8) + (*(DWORD*)s2&0x001f))&0x001f));
714 */
715 }
716 }
717 }
718 break;
719 case MSP_RGB15:
720 for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
721 {
722 BYTE* s2 = s;
723 BYTE* s2end = s2 + w*4;
724 WORD* d2 = (WORD*)d;
725 for(; s2 < s2end; s2 += 4, d2++)
726 {
727 if(s2[3] < 0x1f)
728 {
729 *d2 = (WORD)((((((*d2&0x7c1f)*s2[3])>>5) + (*(DWORD*)s2&0x7c1f))&0x7c1f)
730 | (((((*d2&0x03e0)*s2[3])>>5) + (*(DWORD*)s2&0x03e0))&0x03e0));
731 /* *d2 = (WORD)((((((*d2&0x7c00)*s2[3])>>8) + (*(DWORD*)s2&0x7c00))&0x7c00)
732 | (((((*d2&0x03e0)*s2[3])>>8) + (*(DWORD*)s2&0x03e0))&0x03e0)
733 | (((((*d2&0x001f)*s2[3])>>8) + (*(DWORD*)s2&0x001f))&0x001f));
734 */
735 }
736 }
737 }
738 break;
739 case MSP_YUY2:
740 AlphaBlt_YUY2(w, h, d, dst.pitch, s, src.pitch);
741 break;
742 case MSP_YV12:
743 case MSP_IYUV:
744 {
745 //dst.pitch = abs(dst.pitch);
746 int h2 = h/2;
747 if(!dst.pitchUV)
748 {
749 dst.pitchUV = abs(dst.pitch)/2;
750 }
751 if(!dst.bitsU || !dst.bitsV)
752 {
753 dst.bitsU = (BYTE*)dst.bits + abs(dst.pitch)*dst.h;
754 dst.bitsV = dst.bitsU + dst.pitchUV*dst.h/2;
755 if(dst.type == MSP_YV12)
756 {
757 BYTE* p = dst.bitsU;
758 dst.bitsU = dst.bitsV;
759 dst.bitsV = p;
760 }
761 }
762 BYTE* dd[2];
763 dd[0] = dst.bitsU + dst.pitchUV*rd.top/2 + rd.left/2;
764 dd[1] = dst.bitsV + dst.pitchUV*rd.top/2 + rd.left/2;
765 if(rd.top > rd.bottom)
766 {
767 dd[0] = dst.bitsU + dst.pitchUV*(rd.top/2-1) + rd.left/2;
768 dd[1] = dst.bitsV + dst.pitchUV*(rd.top/2-1) + rd.left/2;
769 dst.pitchUV = -dst.pitchUV;
770 }
771
772 BYTE* src_origin= (BYTE*)src.bits + src.pitch*rs.top + rs.left;
773
774 BYTE* ss[2];
775 ss[0] = src_origin + src.pitch*src.h*2;//U
776 ss[1] = src_origin + src.pitch*src.h*3;//V
777
778 AlphaBltYv12Luma( d, dst.pitch, w, h, src_origin + src.pitch*src.h, src_origin, src.pitch );
779
780 AlphaBltYv12Chroma( dd[0], dst.pitchUV, w, h2, ss[0], src_origin, src.pitch);
781 AlphaBltYv12Chroma( dd[1], dst.pitchUV, w, h2, ss[1], src_origin, src.pitch);
782 #ifndef _WIN64
783 // TODOX64 : fixme!
784 _mm_empty();
785 #endif
786 }
787 break;
788 default:
789 return E_NOTIMPL;
790 break;
791 }
792
793 //emmsÒª40¸öcpuÖÜÆÚ
794 //__asm emms;
795 return S_OK;
796 }
797
798 HRESULT CMemSubPic::AlphaBltAxyuAxyv_P010(const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget)
799 {
800 const SubPicDesc& src = m_spd;
801 SubPicDesc dst = *pTarget; // copy, because we might modify it
802
803 CRect rs(*pSrc), rd(*pDst);
804
805 if(dst.h < 0) {
806 dst.h = -dst.h;
807 rd.bottom = dst.h - rd.bottom;
808 rd.top = dst.h - rd.top;
809 }
810
811 if(rs.Width() != rd.Width() || rs.Height() != abs(rd.Height())) {
812 return E_INVALIDARG;
813 }
814
815 int w = rs.Width(), h = rs.Height();
816
817 //Y
818 BYTE* s = static_cast<BYTE*>(src.bits) + src.pitch*rs.top + ((rs.left*src.bpp)>>3);
819 BYTE* d = static_cast<BYTE*>(dst.bits) + dst.pitch*rd.top + rd.left*2;
820
821 if(rd.top > rd.bottom) {
822 d = (BYTE*)dst.bits + dst.pitch*(rd.top-1) + rd.left;
823
824 dst.pitch = -dst.pitch;
825 }
826
827 for(ptrdiff_t i=0; i<h; i++, s += src.pitch, d += dst.pitch)
828 {
829 BYTE* s2 = s;
830 BYTE* s2end = s2 + w*4;
831 WORD* d2 = reinterpret_cast<WORD*>(d);
832 for(; s2 < s2end; s2 += 4, d2++)
833 {
834 if(s2[3] < 0xff) {
835 d2[0] = ((d2[0]*s2[3])>>8) + (s2[1]<<8);
836 }
837 }
838 }
839
840 //UV
841 int h2 = h/2;
842 if(!dst.pitchUV)
843 {
844 dst.pitchUV = abs(dst.pitch);
845 }
846 if(!dst.bitsU || !dst.bitsV)
847 {
848 dst.bitsU = static_cast<BYTE*>(dst.bits) + abs(dst.pitch)*dst.h;
849 dst.bitsV = dst.bitsU + 2;
850 }
851 BYTE* ddUV = dst.bitsU + dst.pitchUV*rd.top/2 + rd.left*2;
852 if(rd.top > rd.bottom)
853 {
854 ddUV = dst.bitsU + dst.pitchUV*(rd.top/2-1) + rd.left*2;
855 dst.pitchUV = -dst.pitchUV;
856 }
857
858 s = static_cast<BYTE*>(src.bits) + src.pitch*rs.top + ((rs.left*src.bpp)>>3);
859
860 d = ddUV;
861 int pitch = src.pitch;
862 for(int j = 0; j < h2; j++, s += 2*src.pitch, d += dst.pitchUV )
863 {
864 BYTE* s2 = s;
865 WORD* d2=reinterpret_cast<WORD*>(d);
866 WORD* d2_end = reinterpret_cast<WORD*>(d+2*w);
867 DWORD last_alpha = s2[3]+s2[3+src.pitch];
868 for( ; d2<d2_end; s2+=8, d2+=2)
869 {
870 unsigned int ia = (
871 last_alpha +
872 (s2[3] + s2[3+src.pitch])*2 +
873 s2[3+4]+ s2[3+4+src.pitch]);
874 last_alpha = s2[3+4]+ s2[3+4+src.pitch];
875 if( ia!=0xFF*8 )
876 {
877 d2[0] = (((d2[0])*ia)>>11) + ((s2[0] + s2[0+src.pitch])<<7);
878 d2[1] = (((d2[1])*ia)>>11) + ((s2[4] + s2[4+src.pitch])<<7);
879 }
880 }
881 }
882
883 return S_OK;
884 }
885
886 HRESULT CMemSubPic::AlphaBltAxyuAxyv_Yv12(const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget)
887 {
888 const SubPicDesc& src = m_spd;
889 SubPicDesc dst = *pTarget; // copy, because we might modify it
890
891 CRect rs(*pSrc), rd(*pDst);
892
893 if(dst.h < 0) {
894 dst.h = -dst.h;
895 rd.bottom = dst.h - rd.bottom;
896 rd.top = dst.h - rd.top;
897 }
898
899 if(rs.Width() != rd.Width() || rs.Height() != abs(rd.Height())) {
900 return E_INVALIDARG;
901 }
902
903 int w = rs.Width(), h = rs.Height();
904
905 BYTE* s = (BYTE*)src.bits + src.pitch*rs.top + ((rs.left*src.bpp)>>3);
906 BYTE* d = (BYTE*)dst.bits + dst.pitch*rd.top + rd.left;
907
908 if(rd.top > rd.bottom) {
909 d = (BYTE*)dst.bits + dst.pitch*(rd.top-1) + rd.left;
910
911 dst.pitch = -dst.pitch;
912 }
913
914 for(ptrdiff_t j = 0; j < h; j++, s += src.pitch, d += dst.pitch) {
915 BYTE* s2 = s;
916 BYTE* s2end = s2 + w*4;
917 BYTE* d2 = d;
918 for(; s2 < s2end; s2 += 4, d2++) {
919 if(s2[3] < 0xff) {
920 d2[0] = ((d2[0]*s2[3])>>8) + s2[1];
921 }
922 }
923 }
924 dst.pitch = abs(dst.pitch);
925
926 int h2 = h/2;
927
928 if(!dst.pitchUV) {
929 dst.pitchUV = dst.pitch/2;
930 }
931
932 BYTE* ss[2];
933 ss[0] = (BYTE*)src.bits + src.pitch*rs.top + rs.left*4;
934 ss[1] = ss[0] + 4;
935
936 if(!dst.bitsU || !dst.bitsV) {
937 dst.bitsU = (BYTE*)dst.bits + dst.pitch*dst.h;
938 dst.bitsV = dst.bitsU + dst.pitchUV*dst.h/2;
939
940 if(dst.type == MSP_YV12) {
941 BYTE* p = dst.bitsU;
942 dst.bitsU = dst.bitsV;
943 dst.bitsV = p;
944 }
945 }
946
947 BYTE* dd[2];
948 dd[0] = dst.bitsU + dst.pitchUV*rd.top/2 + rd.left/2;
949 dd[1] = dst.bitsV + dst.pitchUV*rd.top/2 + rd.left/2;
950
951 if(rd.top > rd.bottom) {
952 dd[0] = dst.bitsU + dst.pitchUV*(rd.top/2-1) + rd.left/2;
953 dd[1] = dst.bitsV + dst.pitchUV*(rd.top/2-1) + rd.left/2;
954 dst.pitchUV = -dst.pitchUV;
955 }
956
957 for(ptrdiff_t i = 0; i < 2; i++) {
958 s = ss[i];
959 d = dd[i];
960 BYTE* a = ss[0]+3;
961 for(ptrdiff_t j = 0; j < h2; j++, s += src.pitch*2, d += dst.pitchUV, a += src.pitch*2) {
962 BYTE* s2 = s;
963 BYTE* s2end = s2 + w*4;
964 BYTE* d2 = d;
965 BYTE* a2 = a;
966
967 DWORD last_alpha = a2[0]+a2[0+src.pitch];
968 for(; s2 < s2end; s2 += 8, d2++, a2 += 8) {
969 unsigned int ia = (last_alpha + 2*(a2[0]+a2[0+src.pitch]) + a2[4] + a2[4+src.pitch] + 4 )>>3;
970 last_alpha = a2[4] + a2[4+src.pitch];
971 if(ia < 0xff) {
972 *d2 = ((*d2*ia)>>8) + ((s2[0]+s2[src.pitch])>>1);
973 }
974 }
975 }
976 }
977
978 return S_OK;
979 }
980
981 HRESULT CMemSubPic::AlphaBltAxyuAxyv_Nv12(const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget)
982 {
983 ONCER( SaveArgb2File(*pTarget, CRect(CPoint(0,0), m_size), "F:/mplayer_MinGW_full/MinGW/home/Administrator/xy_vsfilter/debug.nv12") );
984 const SubPicDesc& src = m_spd;
985 SubPicDesc dst = *pTarget; // copy, because we might modify it
986
987 CRect rs(*pSrc), rd(*pDst);
988
989 if(dst.h < 0) {
990 dst.h = -dst.h;
991 rd.bottom = dst.h - rd.bottom;
992 rd.top = dst.h - rd.top;
993 }
994
995 if(rs.Width() != rd.Width() || rs.Height() != abs(rd.Height())) {
996 return E_INVALIDARG;
997 }
998
999 int w = rs.Width(), h = rs.Height();
1000
1001 BYTE* s = (BYTE*)src.bits + src.pitch*rs.top + ((rs.left*src.bpp)>>3);
1002 BYTE* d = (BYTE*)dst.bits + dst.pitch*rd.top + rd.left;
1003
1004 if(rd.top > rd.bottom) {
1005 d = (BYTE*)dst.bits + dst.pitch*(rd.top-1) + rd.left;
1006
1007 dst.pitch = -dst.pitch;
1008 }
1009
1010 for(ptrdiff_t j = 0; j < h; j++, s += src.pitch, d += dst.pitch) {
1011 BYTE* s2 = s;
1012 BYTE* s2end = s2 + w*4;
1013 BYTE* d2 = d;
1014 for(; s2 < s2end; s2 += 4, d2++) {
1015 if(s2[3] < 0xff) {
1016 d2[0] = ((d2[0]*s2[3])>>8) + s2[1];
1017 }
1018 }
1019 }
1020 dst.pitch = abs(dst.pitch);
1021
1022 int h2 = h/2;
1023
1024 if(!dst.pitchUV) {
1025 dst.pitchUV = dst.pitch;
1026 }
1027
1028 BYTE* ss[2];
1029 ss[0] = (BYTE*)src.bits + src.pitch*rs.top + rs.left*4;
1030 ss[1] = ss[0] + 4;
1031
1032 if(!dst.bitsU || !dst.bitsV) {
1033 dst.bitsU = (BYTE*)dst.bits + dst.pitch*dst.h;
1034 dst.bitsV = dst.bitsU + 1;
1035
1036 if(dst.type == MSP_NV21) {
1037 BYTE* p = dst.bitsU;
1038 dst.bitsU = dst.bitsV;
1039 dst.bitsV = p;
1040 }
1041 }
1042
1043 BYTE* dd[2];
1044 dd[0] = dst.bitsU + dst.pitchUV*rd.top/2 + rd.left;
1045 dd[1] = dd[0]+1;
1046
1047 if(rd.top > rd.bottom) {
1048 dd[0] = dst.bitsU + dst.pitchUV*(rd.top/2-1) + rd.left;
1049 dd[1] = dd[0]+1;
1050 dst.pitchUV = -dst.pitchUV;
1051 }
1052
1053 for(ptrdiff_t i = 0; i < 2; i++) {
1054 s = ss[i];
1055 d = dd[i];
1056 BYTE* a = ss[0]+3;
1057 for(ptrdiff_t j = 0; j < h2; j++, s += src.pitch*2, d += dst.pitchUV, a += src.pitch*2) {
1058 BYTE* s2 = s;
1059 BYTE* s2end = s2 + w*4;
1060 BYTE* d2 = d;
1061 BYTE* a2 = a;
1062 DWORD last_alpha = a2[0]+a2[0+src.pitch];
1063 for(; s2 < s2end; s2 += 8, d2+=2, a2 += 8) {
1064 unsigned int ia = (last_alpha+2*(a2[0]+a2[0+src.pitch])+a2[4]+a2[4+src.pitch]+4)>>3;
1065 last_alpha = a2[4]+a2[4+src.pitch];
1066 if(ia < 0xff) {
1067 *d2 = ((*d2*ia)>>8) + ((s2[0]+s2[src.pitch])>>1);
1068 }
1069 }
1070 }
1071 }
1072
1073 ONCER( SaveArgb2File(*pTarget, CRect(CPoint(0,0), m_size), "F:/mplayer_MinGW_full/MinGW/home/Administrator/xy_vsfilter/debug.nv12_2") );
1074 return S_OK;
1075 }
1076
1077 HRESULT CMemSubPic::AlphaBltAnv12_P010( const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget )
1078 {
1079 //fix me: check colorspace and log error
1080 const SubPicDesc& src = m_spd;
1081 SubPicDesc dst = *pTarget; // copy, because we might modify it
1082
1083 CRect rs(*pSrc), rd(*pDst);
1084 if(dst.h < 0)
1085 {
1086 dst.h = -dst.h;
1087 rd.bottom = dst.h - rd.bottom;
1088 rd.top = dst.h - rd.top;
1089 }
1090 if(rs.Width() != rd.Width() || rs.Height() != abs(rd.Height())) {
1091 return E_INVALIDARG;
1092 }
1093 int w = rs.Width(), h = rs.Height();
1094 bool bottom_down = rd.top > rd.bottom;
1095
1096 BYTE* d = NULL;
1097 BYTE* dUV = NULL;
1098 if(!bottom_down)
1099 {
1100 d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*rd.top + rd.left*2;
1101 dUV = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*dst.h + dst.pitch*rd.top/2 + rd.left*2;
1102 }
1103 else
1104 {
1105 d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*(rd.top-1) + rd.left*2;
1106 dUV = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*dst.h + dst.pitch*(rd.top/2-1) + rd.left*2;
1107 dst.pitch = -dst.pitch;
1108 }
1109 ASSERT(dst.pitchUV==0 || dst.pitchUV==abs(dst.pitch));
1110
1111 const BYTE* sa = reinterpret_cast<const BYTE*>(src.bits) + src.pitch*rs.top + rs.left;
1112 const BYTE* sy = sa + src.pitch*src.h;
1113 const BYTE* s_uv = sy + src.pitch*src.h;//UV
1114 return AlphaBltAnv12_P010(sa, sy, s_uv, src.pitch, d, dUV, dst.pitch, w, h);
1115 }
1116
1117 HRESULT CMemSubPic::AlphaBltAnv12_Nv12( const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget )
1118 {
1119 //fix me: check colorspace and log error
1120 const SubPicDesc& src = m_spd;
1121 SubPicDesc dst = *pTarget; // copy, because we might modify it
1122
1123 CRect rs(*pSrc), rd(*pDst);
1124 if(dst.h < 0)
1125 {
1126 dst.h = -dst.h;
1127 rd.bottom = dst.h - rd.bottom;
1128 rd.top = dst.h - rd.top;
1129 }
1130 if(rs.Width() != rd.Width() || rs.Height() != abs(rd.Height())) {
1131 return E_INVALIDARG;
1132 }
1133 int w = rs.Width(), h = rs.Height();
1134 bool bottom_down = rd.top > rd.bottom;
1135
1136 BYTE* d = NULL;
1137 BYTE* dUV = NULL;
1138 if (!bottom_down)
1139 {
1140 d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*rd.top + rd.left;
1141 dUV = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*dst.h + dst.pitch*rd.top/2 + rd.left;
1142 }
1143 else
1144 {
1145 d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*(rd.top-1) + rd.left;
1146 dUV = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*dst.h + dst.pitch*(rd.top/2-1) + rd.left;
1147 dst.pitch = -dst.pitch;
1148 }
1149 ASSERT(dst.pitchUV==0 || dst.pitchUV==abs(dst.pitch));
1150
1151 const BYTE* sa = reinterpret_cast<const BYTE*>(src.bits) + src.pitch*rs.top + rs.left;
1152 const BYTE* sy = sa + src.pitch*src.h;
1153 const BYTE* s_uv = sy + src.pitch*src.h;//UV
1154
1155 return AlphaBltAnv12_Nv12(sa, sy, s_uv, src.pitch, d, dUV, dst.pitch, w, h);
1156 }
1157
1158 STDMETHODIMP CMemSubPic::SetDirtyRectEx(CAtlList<CRect>* dirtyRectList )
1159 {
1160 //if(m_spd.type == MSP_YUY2 || m_spd.type == MSP_YV12 || m_spd.type == MSP_IYUV || m_spd.type == MSP_AYUV)
1161 if(dirtyRectList!=NULL)
1162 {
1163 POSITION pos = dirtyRectList->GetHeadPosition();
1164 if(m_spd.type == MSP_AYUV_PLANAR || m_alpha_blt_dst_type==MSP_IYUV || m_alpha_blt_dst_type==MSP_YV12
1165 || m_alpha_blt_dst_type==MSP_P010 || m_alpha_blt_dst_type==MSP_P016
1166 || m_alpha_blt_dst_type==MSP_NV12 || m_alpha_blt_dst_type==MSP_NV21 )
1167 {
1168 while(pos!=NULL)
1169 {
1170 CRect& cRectSrc = dirtyRectList->GetNext(pos);
1171 cRectSrc.left &= ~15;
1172 cRectSrc.right = (cRectSrc.right+15)&~15;
1173 if(cRectSrc.right>m_spd.w)
1174 {
1175 cRectSrc.right = m_spd.w;
1176 }
1177 cRectSrc.top &= ~1;
1178 cRectSrc.bottom = (cRectSrc.bottom+1)&~1;
1179 ASSERT(cRectSrc.bottom<=m_spd.h);
1180 }
1181 }
1182 else if(m_spd.type == MSP_XY_AUYV || m_alpha_blt_dst_type==MSP_YUY2)
1183 {
1184 while(pos!=NULL)
1185 {
1186 CRect& cRectSrc = dirtyRectList->GetNext(pos);
1187 cRectSrc.left &= ~3;
1188 cRectSrc.right = (cRectSrc.right+3)&~3;
1189 cRectSrc.right = cRectSrc.right < m_spd.w ? cRectSrc.right : m_spd.w;
1190 ASSERT((cRectSrc.right & 3)==0);
1191 }
1192 }
1193 }
1194 return __super::SetDirtyRectEx(dirtyRectList);
1195 }
1196
1197 //
1198 // static
1199 //
1200
1201 void CMemSubPic::AlphaBltYv12Luma(byte* dst, int dst_pitch,
1202 int w, int h,
1203 const byte* sub, const byte* alpha, int sub_pitch)
1204 {
1205 if( (
1206 ((reinterpret_cast<intptr_t>(alpha) ^ reinterpret_cast<intptr_t>(sub))
1207 |(reinterpret_cast<intptr_t>(alpha) ^ reinterpret_cast<intptr_t>(dst))
1208 | static_cast<intptr_t>(sub_pitch)
1209 | static_cast<intptr_t>(dst_pitch) ) & 15 )==0
1210 && w > 32 && (g_cpuid.m_flags & CCpuID::sse2))
1211 {
1212 int head = (16 - (reinterpret_cast<intptr_t>(alpha)&15))&15;
1213 int tail = (w-head) & 15;
1214 int w1 = w - head - tail;
1215 for(int i=0; i<h; i++, dst += dst_pitch, alpha += sub_pitch, sub += sub_pitch)
1216 {
1217 const BYTE* sa = alpha;
1218 const BYTE* s2 = sub;
1219 const BYTE* s2end_mod16 = s2 + w1;
1220 const BYTE* s2end = s2 + w;
1221 BYTE* d2 = dst;
1222
1223 for( ; (reinterpret_cast<intptr_t>(s2)&15) != 0; s2++, sa++, d2++)
1224 {
1225 if(sa[0] < 0xff)
1226 {
1227 d2[0] = ((d2[0]*sa[0])>>8) + s2[0];
1228 }
1229 }
1230 for(; s2 < s2end_mod16; s2+=16, sa+=16, d2+=16)
1231 {
1232 pix_alpha_blend_yv12_luma_sse2(d2, sa, s2);
1233 }
1234 for(; s2 < s2end; s2++, sa++, d2++)
1235 {
1236 if(sa[0] < 0xff)
1237 {
1238 d2[0] = ((d2[0]*sa[0])>>8) + s2[0];
1239 }
1240 }
1241 }
1242 }
1243 else //fix me: only a workaround for non-mod-16 size video
1244 {
1245 CMemSubPic::AlphaBltYv12LumaC(dst, dst_pitch, w, h, sub, alpha, sub_pitch);
1246 }
1247 }
1248
1249 void CMemSubPic::AlphaBltYv12LumaC( byte* dst, int dst_pitch, int w, int h, const byte* sub, const byte* alpha, int sub_pitch )
1250 {
1251 for(int i=0; i<h; i++, dst += dst_pitch, alpha += sub_pitch, sub += sub_pitch)
1252 {
1253 const BYTE* sa = alpha;
1254 const BYTE* s2 = sub;
1255 const BYTE* s2end = s2 + w;
1256 BYTE* d2 = dst;
1257 for(; s2 < s2end; s2+=1, sa+=1, d2+=1)
1258 {
1259 if(sa[0] < 0xff)
1260 {
1261 // d2[0] = (((d2[0]-0x10)*s2[3])>>8) + s2[1];
1262 d2[0] = ((d2[0]*sa[0])>>8) + s2[0];
1263 }
1264 }
1265 }
1266 }
1267
1268 void CMemSubPic::AlphaBltYv12Chroma(byte* dst_uv, int dst_pitch,
1269 int w, int chroma_h,
1270 const byte* src_uv, const byte* src_a, int src_pitch)
1271 {
1272 if( (
1273 ((reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(src_uv))
1274 |(reinterpret_cast<intptr_t>(src_a) ^ (2*reinterpret_cast<intptr_t>(dst_uv)))
1275 | static_cast<intptr_t>(src_pitch)
1276 | (2*static_cast<intptr_t>(dst_pitch)) ) & 15) ==0 &&
1277 w > 16 && (g_cpuid.m_flags & CCpuID::sse2))
1278 {
1279 int head = (16 - (reinterpret_cast<intptr_t>(src_a)&15))&15;
1280 int tail = (w-head) & 15;
1281 int w00 = w - head - tail;
1282
1283 int pitch = src_pitch;
1284 for(int j = 0; j < chroma_h; j++, src_uv += src_pitch*2, src_a += src_pitch*2, dst_uv += dst_pitch)
1285 {
1286 hleft_vmid_mix_uv_yv12_c2(dst_uv, head, src_uv, src_a, src_pitch);
1287 hleft_vmid_mix_uv_yv12_sse2(dst_uv+(head>>1), w00, src_uv+head, src_a+head, src_pitch, head>0 ? -1 : 0);
1288 hleft_vmid_mix_uv_yv12_c2(dst_uv+((head+w00)>>1), tail, src_uv+head+w00, src_a+head+w00, src_pitch, (w00+head)>0 ? -1 : 0);
1289 }
1290 }
1291 else//fix me: only a workaround for non-mod-16 size video
1292 {
1293 AlphaBltYv12ChromaC(dst_uv, dst_pitch, w, chroma_h, src_uv, src_a, src_pitch);
1294 }
1295 }
1296
1297 void CMemSubPic::AlphaBltYv12ChromaC( byte* dst, int dst_pitch, int w, int chroma_h, const byte* sub_chroma, const byte* alpha, int sub_pitch )
1298 {
1299 for(int j = 0; j < chroma_h; j++, sub_chroma += sub_pitch*2, alpha += sub_pitch*2, dst += dst_pitch)
1300 {
1301 hleft_vmid_mix_uv_yv12_c(dst, w, sub_chroma, alpha, sub_pitch);
1302 }
1303 }
1304
1305 HRESULT CMemSubPic::AlphaBltAnv12_P010( const BYTE* src_a, const BYTE* src_y, const BYTE* src_uv, int src_pitch,
1306 BYTE* dst_y, BYTE* dst_uv, int dst_pitch, int w, int h )
1307 {
1308 if ( g_cpuid.m_flags & CCpuID::sse2 )
1309 {
1310 const BYTE* sa = src_a;
1311 if( (
1312 ((reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(src_y))
1313 |(reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(dst_y))
1314 | static_cast<intptr_t>(src_pitch)
1315 | static_cast<intptr_t>(dst_pitch) ) & 15 )==0 &&
1316 w > 32 )
1317 {
1318 int head = (16 - reinterpret_cast<intptr_t>(src_a)&15)&15;
1319 int tail = (w - head) & 15;
1320
1321 for(int i=0; i<h; i++, sa += src_pitch, src_y += src_pitch, dst_y += dst_pitch)
1322 {
1323 const BYTE* sa2 = sa;
1324 const BYTE* s2 = src_y;
1325 const BYTE* s2end_mod16 = s2 + (w&~15);
1326 BYTE* d2 = dst_y;
1327 WORD* d_w=reinterpret_cast<WORD*>(dst_y);
1328
1329 switch( head )//important: it is safe since w > 16
1330 {
1331 case 15:
1332 #define _XY_MIX_ONE if(sa2[0] < 0xff) { d_w[0] = ((d_w[0]*sa2[0])>>8) + (s2[0]<<8); } sa2++;d_w++;s2++;
1333 _XY_MIX_ONE
1334 case 14:
1335 _XY_MIX_ONE
1336 case 13:
1337 _XY_MIX_ONE
1338 case 12:
1339 _XY_MIX_ONE
1340 case 11:
1341 _XY_MIX_ONE
1342 case 10:
1343 _XY_MIX_ONE
1344 case 9:
1345 _XY_MIX_ONE
1346 case 8:
1347 _XY_MIX_ONE
1348 case 7:
1349 _XY_MIX_ONE
1350 case 6:
1351 _XY_MIX_ONE
1352 case 5:
1353 _XY_MIX_ONE
1354 case 4:
1355 _XY_MIX_ONE
1356 case 3:
1357 _XY_MIX_ONE
1358 case 2:
1359 _XY_MIX_ONE
1360 case 1://fall through on purpose
1361 _XY_MIX_ONE
1362 }
1363 for(; s2 < s2end_mod16; s2+=16, sa2+=16, d_w+=16)
1364 {
1365 mix_16_y_p010_sse2( reinterpret_cast<BYTE*>(d_w), s2, sa2);
1366 }
1367 switch( tail )//important: it is safe since w > 16
1368 {
1369 case 15:
1370 _XY_MIX_ONE
1371 case 14:
1372 _XY_MIX_ONE
1373 case 13:
1374 _XY_MIX_ONE
1375 case 12:
1376 _XY_MIX_ONE
1377 case 11:
1378 _XY_MIX_ONE
1379 case 10:
1380 _XY_MIX_ONE
1381 case 9:
1382 _XY_MIX_ONE
1383 case 8:
1384 _XY_MIX_ONE
1385 case 7:
1386 _XY_MIX_ONE
1387 case 6:
1388 _XY_MIX_ONE
1389 case 5:
1390 _XY_MIX_ONE
1391 case 4:
1392 _XY_MIX_ONE
1393 case 3:
1394 _XY_MIX_ONE
1395 case 2:
1396 _XY_MIX_ONE
1397 case 1://fall through on purpose
1398 _XY_MIX_ONE
1399 }
1400 }
1401 }
1402 else //fix me: only a workaround for non-mod-16 size video
1403 {
1404 for(int i=0; i<h; i++, sa += src_pitch, src_y += src_pitch, dst_y += dst_pitch)
1405 {
1406 const BYTE* sa2 = sa;
1407 const BYTE* s2 = src_y;
1408 const BYTE* s2end = s2 + w;
1409 WORD* d_w = reinterpret_cast<WORD*>(dst_y);
1410 for(; s2 < s2end; s2+=1, sa2+=1, d_w+=1)
1411 {
1412 if(sa2[0] < 0xff)
1413 {
1414 d_w[0] = ((d_w[0]*sa2[0])>>8) + (s2[0]<<8);
1415 }
1416 }
1417 }
1418 }
1419 //UV
1420 int h2 = h/2;
1421 BYTE* d = dst_uv;
1422 if( (
1423 ((reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(src_uv))
1424 |(reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(dst_uv))
1425 | static_cast<intptr_t>(src_pitch)
1426 | static_cast<intptr_t>(dst_pitch) ) & 15) ==0 &&
1427 w > 16 )
1428 {
1429 int head = (16-(reinterpret_cast<intptr_t>(src_a)&15))&15;
1430 int tail = (w-head) & 15;
1431 int w00 = w - head - tail;
1432
1433 ASSERT(w>0);//the calls to mix may failed if w==0
1434 for(int j = 0; j < h2; j++, src_uv += src_pitch, src_a += src_pitch*2, d += dst_pitch)
1435 {
1436 hleft_vmid_mix_uv_p010_c2(d, head, src_uv, src_a, src_pitch);
1437 hleft_vmid_mix_uv_p010_sse2(d+2*head, w00, src_uv+head, src_a+head, src_pitch, head>0 ? -1 : 0);
1438 hleft_vmid_mix_uv_p010_c2(d+2*(head+w00), tail, src_uv+head+w00, src_a+head+w00, src_pitch, (w00+head)>0 ? -1 : 0);
1439 }
1440 }
1441 else
1442 {
1443 for(int j = 0; j < h2; j++, src_uv += src_pitch, src_a += src_pitch*2, d += dst_pitch)
1444 {
1445 hleft_vmid_mix_uv_p010_c(d, w, src_uv, src_a, src_pitch);
1446 }
1447 }
1448 #ifndef _WIN64
1449 // TODOX64 : fixme!
1450 _mm_empty();
1451 #endif
1452 return S_OK;
1453 }
1454 else
1455 {
1456 return AlphaBltAnv12_P010_C(src_a, src_y, src_uv, src_pitch, dst_y, dst_uv, dst_pitch, w, h);
1457 }
1458 }
1459
1460 HRESULT CMemSubPic::AlphaBltAnv12_P010_C( const BYTE* src_a, const BYTE* src_y, const BYTE* src_uv, int src_pitch, BYTE* dst_y, BYTE* dst_uv, int dst_pitch, int w, int h )
1461 {
1462 const BYTE* sa = src_a;
1463 for(int i=0; i<h; i++, sa += src_pitch, src_y += src_pitch, dst_y += dst_pitch)
1464 {
1465 const BYTE* sa2 = sa;
1466 const BYTE* s2 = src_y;
1467 const BYTE* s2end = s2 + w;
1468 WORD* d2 = reinterpret_cast<WORD*>(dst_y);
1469 for(; s2 < s2end; s2+=1, sa2+=1, d2+=1)
1470 {
1471 if(sa2[0] < 0xff)
1472 {
1473 d2[0] = ((d2[0]*sa2[0])>>8) + (s2[0]<<8);
1474 }
1475 }
1476 }
1477 //UV
1478 int h2 = h/2;
1479 BYTE* d = dst_uv;
1480 for(int j = 0; j < h2; j++, src_uv += src_pitch, src_a += src_pitch*2, d += dst_pitch)
1481 {
1482 hleft_vmid_mix_uv_p010_c(d, w, src_uv, src_a, src_pitch);
1483 }
1484 return S_OK;
1485 }
1486
1487 HRESULT CMemSubPic::AlphaBltAnv12_Nv12( const BYTE* src_a, const BYTE* src_y, const BYTE* src_uv, int src_pitch,
1488 BYTE* dst_y, BYTE* dst_uv, int dst_pitch, int w, int h )
1489 {
1490 AlphaBltYv12Luma( dst_y, dst_pitch, w, h, src_y, src_a, src_pitch );
1491
1492 int h2 = h/2;
1493 if( (
1494 ((reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(src_uv))
1495 |(reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(dst_uv))
1496 | static_cast<intptr_t>(src_pitch)
1497 | static_cast<intptr_t>(dst_pitch) ) & 15) ==0 &&
1498 w > 16 && (g_cpuid.m_flags & CCpuID::sse2) )
1499 {
1500 BYTE* d = dst_uv;
1501
1502 int head = (16-(reinterpret_cast<intptr_t>(src_a)&15))&15;
1503 int tail = (w-head) & 15;
1504 int w00 = w - head - tail;
1505
1506 ASSERT(w>0);//the calls to mix may failed if w==0
1507 for(int j = 0; j < h2; j++, src_uv += src_pitch, src_a += src_pitch*2, d += dst_pitch)
1508 {
1509 hleft_vmid_mix_uv_nv12_c2(d, head, src_uv, src_a, src_pitch);
1510 hleft_vmid_mix_uv_nv12_sse2(d+head, w00, src_uv+head, src_a+head, src_pitch, head>0 ? -1 : 0);
1511 hleft_vmid_mix_uv_nv12_c2(d+head+w00, tail, src_uv+head+w00, src_a+head+w00, src_pitch, (w00+head)>0 ? -1 : 0);
1512 }
1513 #ifndef _WIN64
1514 // TODOX64 : fixme!
1515 _mm_empty();
1516 #endif
1517 }
1518 else
1519 {
1520 BYTE* d = dst_uv;
1521 for(int j = 0; j < h2; j++, src_uv += src_pitch, src_a += src_pitch*2, d += dst_pitch)
1522 {
1523 hleft_vmid_mix_uv_nv12_c(d, w, src_uv, src_a, src_pitch);
1524 }
1525 }
1526 return S_OK;
1527 }
1528
1529 HRESULT CMemSubPic::AlphaBltAnv12_Nv12_C( const BYTE* src_a, const BYTE* src_y, const BYTE* src_uv, int src_pitch, BYTE* dst_y, BYTE* dst_uv, int dst_pitch, int w, int h )
1530 {
1531 AlphaBltYv12LumaC( dst_y, dst_pitch, w, h, src_y, src_a, src_pitch );
1532 int h2 = h/2;
1533 BYTE* d = dst_uv;
1534 for(int j = 0; j < h2; j++, src_uv += src_pitch, src_a += src_pitch*2, d += dst_pitch)
1535 {
1536 hleft_vmid_mix_uv_nv12_c(d, w, src_uv, src_a, src_pitch);
1537 }
1538 return S_OK;
1539 }
1540
1541 void CMemSubPic::SubsampleAndInterlace( BYTE* dst, const BYTE* u, const BYTE* v, int h, int w, int pitch )
1542 {
1543 for (int i=0;i<h;i+=2)
1544 {
1545 hleft_vmid_subsample_and_interlace_2_line_sse2(dst, u, v, w, pitch);
1546 u += 2*pitch;
1547 v += 2*pitch;
1548 dst += pitch;
1549 }
1550 }
1551
1552 void CMemSubPic::SubsampleAndInterlaceC( BYTE* dst, const BYTE* u, const BYTE* v, int h, int w, int pitch )
1553 {
1554 for (int i=0;i<h;i+=2)
1555 {
1556 hleft_vmid_subsample_and_interlace_2_line_c(dst, u, v, w, pitch);
1557 u += 2*pitch;
1558 v += 2*pitch;
1559 dst += pitch;
1560 }
1561 }
1562
1563 void CMemSubPic::AlphaBlt_YUY2(int w, int h, BYTE* d, int dstpitch, PCUINT8 s, int srcpitch)
1564 {
1565 #ifdef _WIN64
1566 AlphaBlt_YUY2_C(w, h, d, dstpitch, s, srcpitch);
1567 #else
1568 AlphaBlt_YUY2_MMX(w, h, d, dstpitch, s, srcpitch);
1569 #endif
1570 }
1571
1572 //
1573 // CMemSubPicAllocator
1574 //
1575
1576 CMemSubPicAllocator::CMemSubPicAllocator(int alpha_blt_dst_type, SIZE maxsize, int type/*=-1*/)
1577 : CSubPicExAllocatorImpl(maxsize, false, false)
1578 , m_alpha_blt_dst_type(alpha_blt_dst_type)
1579 , m_maxsize(maxsize)
1580 , m_type(type)
1581 {
1582 if(m_type==-1)
1583 {
1584 switch(alpha_blt_dst_type)
1585 {
1586 case MSP_YUY2:
1587 m_type = MSP_XY_AUYV;
1588 break;
1589 case MSP_AYUV:
1590 m_type = MSP_AYUV;
1591 break;
1592 case MSP_IYUV:
1593 case MSP_YV12:
1594 case MSP_P010:
1595 case MSP_P016:
1596 case MSP_NV12:
1597 case MSP_NV21:
1598 m_type = MSP_AYUV_PLANAR;
1599 break;
1600 default:
1601 m_type = MSP_RGBA;
1602 break;
1603 }
1604 }
1605 }
1606
1607 // ISubPicAllocatorImpl
1608
1609 bool CMemSubPicAllocator::AllocEx(bool fStatic, ISubPicEx** ppSubPic)
1610 {
1611 if(!ppSubPic) {
1612 return false;
1613 }
1614 SubPicDesc spd;
1615 spd.w = m_maxsize.cx;
1616 spd.h = m_maxsize.cy;
1617 spd.bpp = 32;
1618 spd.pitch = (spd.w*spd.bpp)>>3;
1619 spd.type = m_type;
1620 spd.bits = DEBUG_NEW BYTE[spd.pitch*spd.h];
1621 if(!spd.bits) {
1622 return false;
1623 }
1624 *ppSubPic = DEBUG_NEW CMemSubPic(spd, m_alpha_blt_dst_type);
1625 if(!(*ppSubPic)) {
1626 return false;
1627 }
1628 (*ppSubPic)->AddRef();
1629 return true;
1630 }
vsfilter mod based on vsfilter 2.39