?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
X64 transport [Part 2](we do not(?) need _mm_empty in x64 build)
[xy_vsfilter.git] / src / subpic / MemSubPic.cpp
blob2c6e27f0e92a02db8a529019bd06789369181405
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 {
415 //nothing to do
416 }
417 else if ( m_alpha_blt_dst_type == MSP_P010 || m_alpha_blt_dst_type == MSP_P016
418 || m_alpha_blt_dst_type == MSP_NV12 )
419 {
420 SubsampleAndInterlace(cRect, true);
421 }
422 else if( m_alpha_blt_dst_type == MSP_NV21 )
423 {
424 SubsampleAndInterlace(cRect, false);
425 }
426 }
427 return S_OK;
428 }
429
430 HRESULT CMemSubPic::UnlockRGBA_YUV(CAtlList<CRect>* dirtyRectList)
431 {
432 //debug
433 ONCER( SaveRect2File(dirtyRectList->GetHead(), "F:/mplayer_MinGW_full/MinGW/home/Administrator/xy_vsfilter/debug.rect") );
434 ONCER( SaveArgb2File(m_spd, CRect(CPoint(0,0), m_size), "F:/mplayer_MinGW_full/MinGW/home/Administrator/xy_vsfilter/debug.argb") );
435
436 SetDirtyRectEx(dirtyRectList);
437
438 ONCER( SaveRect2File(dirtyRectList->GetHead(), "F:/mplayer_MinGW_full/MinGW/home/Administrator/xy_vsfilter/debug.rect2") );
439 if(m_rectListDirty.IsEmpty()) {
440 return S_OK;
441 }
442
443 POSITION pos = m_rectListDirty.GetHeadPosition();
444 while(pos!=NULL)
445 {
446 const CRect& cRect = m_rectListDirty.GetNext(pos);
447 int w = cRect.Width(), h = cRect.Height();
448 if(w<=0 || h<=0)
449 {
450 continue;
451 }
452
453 BYTE* top = (BYTE*)m_spd.bits + m_spd.pitch*cRect.top + cRect.left*4;
454 BYTE* bottom = top + m_spd.pitch*h;
455
456 if( m_alpha_blt_dst_type == MSP_YUY2 ||
457 m_alpha_blt_dst_type == MSP_YV12 ||
458 m_alpha_blt_dst_type == MSP_IYUV ||
459 m_alpha_blt_dst_type == MSP_P010 ||
460 m_alpha_blt_dst_type == MSP_P016 ||
461 m_alpha_blt_dst_type == MSP_NV12 ||
462 m_alpha_blt_dst_type == MSP_NV21) {
463 for(; top < bottom ; top += m_spd.pitch) {
464 BYTE* s = top;
465 BYTE* e = s + w*4;
466 DWORD last_yuv = ColorConvTable::PreMulArgb2Ayuv(s[3], s[2], s[1], s[0]);
467 for(; s < e; s+=8) { // ARGB ARGB -> AxYU AxYV
468 if((s[3]+s[7]+(last_yuv>>24)) < 0xff*3) {
469 DWORD tmp1 = ColorConvTable::PreMulArgb2Ayuv(s[3], s[2], s[1], s[0]);
470 DWORD tmp2 = ColorConvTable::PreMulArgb2Ayuv(s[7], s[6], s[5], s[4]);
471
472 s[1] = (tmp1>>16)&0xff;
473 s[5] = (tmp2>>16)&0xff;
474
475 s[0] = (((last_yuv>>8)&0xff) + 2*((tmp1>>8)&0xff) + ((tmp2>>8)&0xff) + 2)/4;
476 s[4] = ((last_yuv&0xff) + 2*(tmp1&0xff) + (tmp2&0xff) + 2)/4;
477 last_yuv = tmp2;
478 } else {
479 last_yuv = ColorConvTable::PreMulArgb2Ayuv(s[7], s[6], s[5], s[4]);
480
481 s[1] = s[5] = 0;
482 s[0] = s[4] = 0;
483 }
484 }
485 }
486 }
487 else if(m_alpha_blt_dst_type == MSP_AYUV) {
488 for(; top < bottom ; top += m_spd.pitch) {
489 BYTE* s = top;
490 BYTE* e = s + w*4;
491 for(; s < e; s+=4) { // ARGB -> AYUV
492 if(s[3] < 0xff) {
493 *((DWORD*)s) = ColorConvTable::PreMulArgb2Ayuv(s[3], s[2], s[1], s[0]);
494 } else {
495 s[0] = s[1] = 0;
496 s[2] = 0;
497 }
498 }
499 }
500 }
501 }
502
503 ONCER( SaveAxxx2File(m_spd, CRect(CPoint(0,0), m_size), "F:/mplayer_MinGW_full/MinGW/home/Administrator/xy_vsfilter/debug.axuv") );
504 return S_OK;
505 }
506
507 void CMemSubPic::SubsampleAndInterlace( const CRect& cRect, bool u_first )
508 {
509 //fix me: check alignment and log error
510 int w = cRect.Width(), h = cRect.Height();
511 BYTE* u_plan = reinterpret_cast<BYTE*>(m_spd.bits) + m_spd.pitch*m_spd.h*2;
512 BYTE* u_start = u_plan + m_spd.pitch*(cRect.top)+ cRect.left;
513 BYTE* v_start = u_start + m_spd.pitch*m_spd.h;
514 BYTE* dst = u_start;
515 if(!u_first)
516 {
517 BYTE* tmp = v_start;
518 v_start = u_start;
519 u_start = tmp;
520 }
521
522 //Todo: fix me.
523 //Walkarround for alignment
524 if ( ((m_spd.pitch|w) &15) == 0 && (g_cpuid.m_flags & CCpuID::sse2) )
525 {
526 ASSERT(w%16==0);
527 SubsampleAndInterlace(dst, u_start, v_start, h, w, m_spd.pitch);
528 }
529 else
530 {
531 SubsampleAndInterlaceC(dst, u_start, v_start, h, w, m_spd.pitch);
532 }
533 }
534
535 STDMETHODIMP CMemSubPic::AlphaBlt( const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget )
536 {
537 if(!pSrc || !pDst || !pTarget) {
538 return E_POINTER;
539 }
540 int src_type = m_spd.type;
541 int dst_type = pTarget->type;
542
543 if( (src_type==MSP_RGBA && (dst_type == MSP_RGB32 ||
544 dst_type == MSP_RGB24 ||
545 dst_type == MSP_RGB16 ||
546 dst_type == MSP_RGB15 ||
547 dst_type == MSP_RGBA ||
548 dst_type == MSP_YUY2 ||//ToDo: fix me MSP_RGBA changed into AxYU AxYV after unlock, may be confusing
549 dst_type == MSP_AYUV ))
550 ||
551 (src_type==MSP_XY_AUYV && dst_type == MSP_YUY2)//ToDo: fix me MSP_AYUV
552 ||
553 (src_type==MSP_AYUV && dst_type == MSP_AYUV)
554 ||
555 (src_type==MSP_AYUV_PLANAR && (dst_type == MSP_IYUV ||
556 dst_type == MSP_YV12)) )
557 {
558 return AlphaBltOther(pSrc, pDst, pTarget);
559 }
560 else if ( src_type==MSP_AYUV_PLANAR && (dst_type == MSP_NV12 ||
561 dst_type == MSP_NV21 ) )
562 {
563 return AlphaBltAnv12_Nv12(pSrc, pDst, pTarget);
564 }
565
566 else if( src_type==MSP_AYUV_PLANAR && (dst_type == MSP_P010 ||
567 dst_type == MSP_P016 ) )
568 {
569 return AlphaBltAnv12_P010(pSrc, pDst, pTarget);
570 }
571 else if( src_type==MSP_RGBA && (dst_type == MSP_IYUV ||
572 dst_type == MSP_YV12))
573 {
574 return AlphaBltAxyuAxyv_Yv12(pSrc, pDst, pTarget);
575 }
576 else if( src_type==MSP_RGBA && (dst_type == MSP_NV12||
577 dst_type == MSP_NV21))
578 {
579 return AlphaBltAxyuAxyv_Nv12(pSrc, pDst, pTarget);
580 }
581 else if( src_type==MSP_RGBA && (dst_type == MSP_P010 ||
582 dst_type == MSP_P016))
583 {
584 return AlphaBltAxyuAxyv_P010(pSrc, pDst, pTarget);
585 }
586 return E_NOTIMPL;
587 }
588
589 HRESULT CMemSubPic::AlphaBltOther(const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget)
590 {
591 const SubPicDesc& src = m_spd;
592 SubPicDesc dst = *pTarget; // copy, because we might modify it
593
594 CRect rs(*pSrc), rd(*pDst);
595 if(dst.h < 0)
596 {
597 dst.h = -dst.h;
598 rd.bottom = dst.h - rd.bottom;
599 rd.top = dst.h - rd.top;
600 }
601 if(rs.Width() != rd.Width() || rs.Height() != abs(rd.Height())) {
602 return E_INVALIDARG;
603 }
604 int w = rs.Width(), h = rs.Height();
605 BYTE* s = (BYTE*)src.bits + src.pitch*rs.top + ((rs.left*src.bpp)>>3);//rs.left*4
606 BYTE* d = (BYTE*)dst.bits + dst.pitch*rd.top + ((rd.left*dst.bpp)>>3);
607 if(rd.top > rd.bottom)
608 {
609 if(dst.type == MSP_RGB32 || dst.type == MSP_RGB24
610 || dst.type == MSP_RGB16 || dst.type == MSP_RGB15
611 || dst.type == MSP_YUY2 || dst.type == MSP_AYUV)
612 {
613 d = (BYTE*)dst.bits + dst.pitch*(rd.top-1) + (rd.left*dst.bpp>>3);
614 }
615 else if(dst.type == MSP_YV12 || dst.type == MSP_IYUV)
616 {
617 d = (BYTE*)dst.bits + dst.pitch*(rd.top-1) + (rd.left*8>>3);
618 }
619 else
620 {
621 return E_NOTIMPL;
622 }
623 dst.pitch = -dst.pitch;
624 }
625 DbgLog((LOG_TRACE, 5, TEXT("w=%d h=%d"), w, h));
626 switch(dst.type)
627 {
628 case MSP_RGBA:
629 for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
630 {
631 BYTE* s2 = s;
632 BYTE* s2end = s2 + w*4;
633 DWORD* d2 = (DWORD*)d;
634 for(; s2 < s2end; s2 += 4, d2++)
635 {
636 if(s2[3] < 0xff)
637 {
638 DWORD bd =0x00000100 -( (DWORD) s2[3]);
639 DWORD B = ((*((DWORD*)s2)&0x000000ff)<<8)/bd;
640 DWORD V = ((*((DWORD*)s2)&0x0000ff00)/bd)<<8;
641 DWORD R = (((*((DWORD*)s2)&0x00ff0000)>>8)/bd)<<16;
642 *d2 = B | V | R
643 | (0xff000000-(*((DWORD*)s2)&0xff000000))&0xff000000;
644 }
645 }
646 }
647 break;
648 case MSP_RGB32:
649 case MSP_AYUV: //ToDo: fix me MSP_VUYA indeed?
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 #ifdef _WIN64
658 DWORD ia = 256-s2[3];
659 if(s2[3] < 0xff) {
660 *d2 = ((((*d2&0x00ff00ff)*s2[3])>>8) + (((*((DWORD*)s2)&0x00ff00ff)*ia)>>8)&0x00ff00ff)
661 | ((((*d2&0x0000ff00)*s2[3])>>8) + (((*((DWORD*)s2)&0x0000ff00)*ia)>>8)&0x0000ff00);
662 }
663 #else
664 if(s2[3] < 0xff)
665 {
666 *d2 = (((((*d2&0x00ff00ff)*s2[3])>>8) + (*((DWORD*)s2)&0x00ff00ff))&0x00ff00ff)
667 | (((((*d2&0x0000ff00)*s2[3])>>8) + (*((DWORD*)s2)&0x0000ff00))&0x0000ff00);
668 }
669 #endif
670 }
671 }
672 break;
673 case MSP_RGB24:
674 for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
675 {
676 BYTE* s2 = s;
677 BYTE* s2end = s2 + w*4;
678 BYTE* d2 = d;
679 for(; s2 < s2end; s2 += 4, d2 += 3)
680 {
681 if(s2[3] < 0xff)
682 {
683 d2[0] = ((d2[0]*s2[3])>>8) + s2[0];
684 d2[1] = ((d2[1]*s2[3])>>8) + s2[1];
685 d2[2] = ((d2[2]*s2[3])>>8) + s2[2];
686 }
687 }
688 }
689 break;
690 case MSP_RGB16:
691 for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
692 {
693 BYTE* s2 = s;
694 BYTE* s2end = s2 + w*4;
695 WORD* d2 = (WORD*)d;
696 for(; s2 < s2end; s2 += 4, d2++)
697 {
698 if(s2[3] < 0x1f)
699 {
700 *d2 = (WORD)((((((*d2&0xf81f)*s2[3])>>5) + (*(DWORD*)s2&0xf81f))&0xf81f)
701 | (((((*d2&0x07e0)*s2[3])>>5) + (*(DWORD*)s2&0x07e0))&0x07e0));
702 /* *d2 = (WORD)((((((*d2&0xf800)*s2[3])>>8) + (*(DWORD*)s2&0xf800))&0xf800)
703 | (((((*d2&0x07e0)*s2[3])>>8) + (*(DWORD*)s2&0x07e0))&0x07e0)
704 | (((((*d2&0x001f)*s2[3])>>8) + (*(DWORD*)s2&0x001f))&0x001f));
705 */
706 }
707 }
708 }
709 break;
710 case MSP_RGB15:
711 for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
712 {
713 BYTE* s2 = s;
714 BYTE* s2end = s2 + w*4;
715 WORD* d2 = (WORD*)d;
716 for(; s2 < s2end; s2 += 4, d2++)
717 {
718 if(s2[3] < 0x1f)
719 {
720 *d2 = (WORD)((((((*d2&0x7c1f)*s2[3])>>5) + (*(DWORD*)s2&0x7c1f))&0x7c1f)
721 | (((((*d2&0x03e0)*s2[3])>>5) + (*(DWORD*)s2&0x03e0))&0x03e0));
722 /* *d2 = (WORD)((((((*d2&0x7c00)*s2[3])>>8) + (*(DWORD*)s2&0x7c00))&0x7c00)
723 | (((((*d2&0x03e0)*s2[3])>>8) + (*(DWORD*)s2&0x03e0))&0x03e0)
724 | (((((*d2&0x001f)*s2[3])>>8) + (*(DWORD*)s2&0x001f))&0x001f));
725 */
726 }
727 }
728 }
729 break;
730 case MSP_YUY2:
731 AlphaBlt_YUY2(w, h, d, dst.pitch, s, src.pitch);
732 break;
733 case MSP_YV12:
734 case MSP_IYUV:
735 {
736 //dst.pitch = abs(dst.pitch);
737 int h2 = h/2;
738 if(!dst.pitchUV)
739 {
740 dst.pitchUV = abs(dst.pitch)/2;
741 }
742 if(!dst.bitsU || !dst.bitsV)
743 {
744 dst.bitsU = (BYTE*)dst.bits + abs(dst.pitch)*dst.h;
745 dst.bitsV = dst.bitsU + dst.pitchUV*dst.h/2;
746 if(dst.type == MSP_YV12)
747 {
748 BYTE* p = dst.bitsU;
749 dst.bitsU = dst.bitsV;
750 dst.bitsV = p;
751 }
752 }
753 BYTE* dd[2];
754 dd[0] = dst.bitsU + dst.pitchUV*rd.top/2 + rd.left/2;
755 dd[1] = dst.bitsV + dst.pitchUV*rd.top/2 + rd.left/2;
756 if(rd.top > rd.bottom)
757 {
758 dd[0] = dst.bitsU + dst.pitchUV*(rd.top/2-1) + rd.left/2;
759 dd[1] = dst.bitsV + dst.pitchUV*(rd.top/2-1) + rd.left/2;
760 dst.pitchUV = -dst.pitchUV;
761 }
762
763 BYTE* src_origin= (BYTE*)src.bits + src.pitch*rs.top + rs.left;
764
765 BYTE* ss[2];
766 ss[0] = src_origin + src.pitch*src.h*2;//U
767 ss[1] = src_origin + src.pitch*src.h*3;//V
768
769 AlphaBltYv12Luma( d, dst.pitch, w, h, src_origin + src.pitch*src.h, src_origin, src.pitch );
770
771 AlphaBltYv12Chroma( dd[0], dst.pitchUV, w, h2, ss[0], src_origin, src.pitch);
772 AlphaBltYv12Chroma( dd[1], dst.pitchUV, w, h2, ss[1], src_origin, src.pitch);
773 #ifndef _WIN64
774 // TODOX64 : fixme!
775 _mm_empty();
776 #endif
777 }
778 break;
779 default:
780 return E_NOTIMPL;
781 break;
782 }
783
784 //emmsÒª40¸öcpuÖÜÆÚ
785 //__asm emms;
786 return S_OK;
787 }
788
789 HRESULT CMemSubPic::AlphaBltAxyuAxyv_P010(const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget)
790 {
791 const SubPicDesc& src = m_spd;
792 SubPicDesc dst = *pTarget; // copy, because we might modify it
793
794 CRect rs(*pSrc), rd(*pDst);
795
796 if(dst.h < 0) {
797 dst.h = -dst.h;
798 rd.bottom = dst.h - rd.bottom;
799 rd.top = dst.h - rd.top;
800 }
801
802 if(rs.Width() != rd.Width() || rs.Height() != abs(rd.Height())) {
803 return E_INVALIDARG;
804 }
805
806 int w = rs.Width(), h = rs.Height();
807
808 //Y
809 BYTE* s = static_cast<BYTE*>(src.bits) + src.pitch*rs.top + ((rs.left*src.bpp)>>3);
810 BYTE* d = static_cast<BYTE*>(dst.bits) + dst.pitch*rd.top + rd.left*2;
811
812 if(rd.top > rd.bottom) {
813 d = (BYTE*)dst.bits + dst.pitch*(rd.top-1) + rd.left;
814
815 dst.pitch = -dst.pitch;
816 }
817
818 for(ptrdiff_t i=0; i<h; i++, s += src.pitch, d += dst.pitch)
819 {
820 BYTE* s2 = s;
821 BYTE* s2end = s2 + w*4;
822 WORD* d2 = reinterpret_cast<WORD*>(d);
823 for(; s2 < s2end; s2 += 4, d2++)
824 {
825 if(s2[3] < 0xff) {
826 d2[0] = ((d2[0]*s2[3])>>8) + (s2[1]<<8);
827 }
828 }
829 }
830
831 //UV
832 int h2 = h/2;
833 if(!dst.pitchUV)
834 {
835 dst.pitchUV = abs(dst.pitch);
836 }
837 if(!dst.bitsU || !dst.bitsV)
838 {
839 dst.bitsU = static_cast<BYTE*>(dst.bits) + abs(dst.pitch)*dst.h;
840 dst.bitsV = dst.bitsU + 2;
841 }
842 BYTE* ddUV = dst.bitsU + dst.pitchUV*rd.top/2 + rd.left*2;
843 if(rd.top > rd.bottom)
844 {
845 ddUV = dst.bitsU + dst.pitchUV*(rd.top/2-1) + rd.left*2;
846 dst.pitchUV = -dst.pitchUV;
847 }
848
849 s = static_cast<BYTE*>(src.bits) + src.pitch*rs.top + ((rs.left*src.bpp)>>3);
850
851 d = ddUV;
852 int pitch = src.pitch;
853 for(int j = 0; j < h2; j++, s += 2*src.pitch, d += dst.pitchUV )
854 {
855 BYTE* s2 = s;
856 WORD* d2=reinterpret_cast<WORD*>(d);
857 WORD* d2_end = reinterpret_cast<WORD*>(d+2*w);
858 DWORD last_alpha = s2[3]+s2[3+src.pitch];
859 for( ; d2<d2_end; s2+=8, d2+=2)
860 {
861 unsigned int ia = (
862 last_alpha +
863 (s2[3] + s2[3+src.pitch])*2 +
864 s2[3+4]+ s2[3+4+src.pitch]);
865 last_alpha = s2[3+4]+ s2[3+4+src.pitch];
866 if( ia!=0xFF*8 )
867 {
868 d2[0] = (((d2[0])*ia)>>11) + ((s2[0] + s2[0+src.pitch])<<7);
869 d2[1] = (((d2[1])*ia)>>11) + ((s2[4] + s2[4+src.pitch])<<7);
870 }
871 }
872 }
873
874 return S_OK;
875 }
876
877 HRESULT CMemSubPic::AlphaBltAxyuAxyv_Yv12(const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget)
878 {
879 const SubPicDesc& src = m_spd;
880 SubPicDesc dst = *pTarget; // copy, because we might modify it
881
882 CRect rs(*pSrc), rd(*pDst);
883
884 if(dst.h < 0) {
885 dst.h = -dst.h;
886 rd.bottom = dst.h - rd.bottom;
887 rd.top = dst.h - rd.top;
888 }
889
890 if(rs.Width() != rd.Width() || rs.Height() != abs(rd.Height())) {
891 return E_INVALIDARG;
892 }
893
894 int w = rs.Width(), h = rs.Height();
895
896 BYTE* s = (BYTE*)src.bits + src.pitch*rs.top + ((rs.left*src.bpp)>>3);
897 BYTE* d = (BYTE*)dst.bits + dst.pitch*rd.top + rd.left;
898
899 if(rd.top > rd.bottom) {
900 d = (BYTE*)dst.bits + dst.pitch*(rd.top-1) + rd.left;
901
902 dst.pitch = -dst.pitch;
903 }
904
905 for(ptrdiff_t j = 0; j < h; j++, s += src.pitch, d += dst.pitch) {
906 BYTE* s2 = s;
907 BYTE* s2end = s2 + w*4;
908 BYTE* d2 = d;
909 for(; s2 < s2end; s2 += 4, d2++) {
910 if(s2[3] < 0xff) {
911 d2[0] = ((d2[0]*s2[3])>>8) + s2[1];
912 }
913 }
914 }
915 dst.pitch = abs(dst.pitch);
916
917 int h2 = h/2;
918
919 if(!dst.pitchUV) {
920 dst.pitchUV = dst.pitch/2;
921 }
922
923 BYTE* ss[2];
924 ss[0] = (BYTE*)src.bits + src.pitch*rs.top + rs.left*4;
925 ss[1] = ss[0] + 4;
926
927 if(!dst.bitsU || !dst.bitsV) {
928 dst.bitsU = (BYTE*)dst.bits + dst.pitch*dst.h;
929 dst.bitsV = dst.bitsU + dst.pitchUV*dst.h/2;
930
931 if(dst.type == MSP_YV12) {
932 BYTE* p = dst.bitsU;
933 dst.bitsU = dst.bitsV;
934 dst.bitsV = p;
935 }
936 }
937
938 BYTE* dd[2];
939 dd[0] = dst.bitsU + dst.pitchUV*rd.top/2 + rd.left/2;
940 dd[1] = dst.bitsV + dst.pitchUV*rd.top/2 + rd.left/2;
941
942 if(rd.top > rd.bottom) {
943 dd[0] = dst.bitsU + dst.pitchUV*(rd.top/2-1) + rd.left/2;
944 dd[1] = dst.bitsV + dst.pitchUV*(rd.top/2-1) + rd.left/2;
945 dst.pitchUV = -dst.pitchUV;
946 }
947
948 for(ptrdiff_t i = 0; i < 2; i++) {
949 s = ss[i];
950 d = dd[i];
951 BYTE* a = ss[0]+3;
952 for(ptrdiff_t j = 0; j < h2; j++, s += src.pitch*2, d += dst.pitchUV, a += src.pitch*2) {
953 BYTE* s2 = s;
954 BYTE* s2end = s2 + w*4;
955 BYTE* d2 = d;
956 BYTE* a2 = a;
957
958 DWORD last_alpha = a2[0]+a2[0+src.pitch];
959 for(; s2 < s2end; s2 += 8, d2++, a2 += 8) {
960 unsigned int ia = (last_alpha + 2*(a2[0]+a2[0+src.pitch]) + a2[4] + a2[4+src.pitch] + 4 )>>3;
961 last_alpha = a2[4] + a2[4+src.pitch];
962 if(ia < 0xff) {
963 *d2 = ((*d2*ia)>>8) + ((s2[0]+s2[src.pitch])>>1);
964 }
965 }
966 }
967 }
968
969 return S_OK;
970 }
971
972 HRESULT CMemSubPic::AlphaBltAxyuAxyv_Nv12(const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget)
973 {
974 ONCER( SaveArgb2File(*pTarget, CRect(CPoint(0,0), m_size), "F:/mplayer_MinGW_full/MinGW/home/Administrator/xy_vsfilter/debug.nv12") );
975 const SubPicDesc& src = m_spd;
976 SubPicDesc dst = *pTarget; // copy, because we might modify it
977
978 CRect rs(*pSrc), rd(*pDst);
979
980 if(dst.h < 0) {
981 dst.h = -dst.h;
982 rd.bottom = dst.h - rd.bottom;
983 rd.top = dst.h - rd.top;
984 }
985
986 if(rs.Width() != rd.Width() || rs.Height() != abs(rd.Height())) {
987 return E_INVALIDARG;
988 }
989
990 int w = rs.Width(), h = rs.Height();
991
992 BYTE* s = (BYTE*)src.bits + src.pitch*rs.top + ((rs.left*src.bpp)>>3);
993 BYTE* d = (BYTE*)dst.bits + dst.pitch*rd.top + rd.left;
994
995 if(rd.top > rd.bottom) {
996 d = (BYTE*)dst.bits + dst.pitch*(rd.top-1) + rd.left;
997
998 dst.pitch = -dst.pitch;
999 }
1000
1001 for(ptrdiff_t j = 0; j < h; j++, s += src.pitch, d += dst.pitch) {
1002 BYTE* s2 = s;
1003 BYTE* s2end = s2 + w*4;
1004 BYTE* d2 = d;
1005 for(; s2 < s2end; s2 += 4, d2++) {
1006 if(s2[3] < 0xff) {
1007 d2[0] = ((d2[0]*s2[3])>>8) + s2[1];
1008 }
1009 }
1010 }
1011 dst.pitch = abs(dst.pitch);
1012
1013 int h2 = h/2;
1014
1015 if(!dst.pitchUV) {
1016 dst.pitchUV = dst.pitch;
1017 }
1018
1019 BYTE* ss[2];
1020 ss[0] = (BYTE*)src.bits + src.pitch*rs.top + rs.left*4;
1021 ss[1] = ss[0] + 4;
1022
1023 if(!dst.bitsU || !dst.bitsV) {
1024 dst.bitsU = (BYTE*)dst.bits + dst.pitch*dst.h;
1025 dst.bitsV = dst.bitsU + 1;
1026
1027 if(dst.type == MSP_NV21) {
1028 BYTE* p = dst.bitsU;
1029 dst.bitsU = dst.bitsV;
1030 dst.bitsV = p;
1031 }
1032 }
1033
1034 BYTE* dd[2];
1035 dd[0] = dst.bitsU + dst.pitchUV*rd.top/2 + rd.left;
1036 dd[1] = dd[0]+1;
1037
1038 if(rd.top > rd.bottom) {
1039 dd[0] = dst.bitsU + dst.pitchUV*(rd.top/2-1) + rd.left;
1040 dd[1] = dd[0]+1;
1041 dst.pitchUV = -dst.pitchUV;
1042 }
1043
1044 for(ptrdiff_t i = 0; i < 2; i++) {
1045 s = ss[i];
1046 d = dd[i];
1047 BYTE* a = ss[0]+3;
1048 for(ptrdiff_t j = 0; j < h2; j++, s += src.pitch*2, d += dst.pitchUV, a += src.pitch*2) {
1049 BYTE* s2 = s;
1050 BYTE* s2end = s2 + w*4;
1051 BYTE* d2 = d;
1052 BYTE* a2 = a;
1053 DWORD last_alpha = a2[0]+a2[0+src.pitch];
1054 for(; s2 < s2end; s2 += 8, d2+=2, a2 += 8) {
1055 unsigned int ia = (last_alpha+2*(a2[0]+a2[0+src.pitch])+a2[4]+a2[4+src.pitch]+4)>>3;
1056 last_alpha = a2[4]+a2[4+src.pitch];
1057 if(ia < 0xff) {
1058 *d2 = ((*d2*ia)>>8) + ((s2[0]+s2[src.pitch])>>1);
1059 }
1060 }
1061 }
1062 }
1063
1064 ONCER( SaveArgb2File(*pTarget, CRect(CPoint(0,0), m_size), "F:/mplayer_MinGW_full/MinGW/home/Administrator/xy_vsfilter/debug.nv12_2") );
1065 return S_OK;
1066 }
1067
1068 HRESULT CMemSubPic::AlphaBltAnv12_P010( const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget )
1069 {
1070 //fix me: check colorspace and log error
1071 const SubPicDesc& src = m_spd;
1072 SubPicDesc dst = *pTarget; // copy, because we might modify it
1073
1074 CRect rs(*pSrc), rd(*pDst);
1075 if(dst.h < 0)
1076 {
1077 dst.h = -dst.h;
1078 rd.bottom = dst.h - rd.bottom;
1079 rd.top = dst.h - rd.top;
1080 }
1081 if(rs.Width() != rd.Width() || rs.Height() != abs(rd.Height())) {
1082 return E_INVALIDARG;
1083 }
1084 int w = rs.Width(), h = rs.Height();
1085 bool bottom_down = rd.top > rd.bottom;
1086
1087 BYTE* d = NULL;
1088 BYTE* dUV = NULL;
1089 if(!bottom_down)
1090 {
1091 d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*rd.top + rd.left*2;
1092 dUV = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*dst.h + dst.pitch*rd.top/2 + rd.left*2;
1093 }
1094 else
1095 {
1096 d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*(rd.top-1) + rd.left*2;
1097 dUV = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*dst.h + dst.pitch*(rd.top/2-1) + rd.left*2;
1098 dst.pitch = -dst.pitch;
1099 }
1100 ASSERT(dst.pitchUV==0 || dst.pitchUV==abs(dst.pitch));
1101
1102 const BYTE* sa = reinterpret_cast<const BYTE*>(src.bits) + src.pitch*rs.top + rs.left;
1103 const BYTE* sy = sa + src.pitch*src.h;
1104 const BYTE* s_uv = sy + src.pitch*src.h;//UV
1105 return AlphaBltAnv12_P010(sa, sy, s_uv, src.pitch, d, dUV, dst.pitch, w, h);
1106 }
1107
1108 HRESULT CMemSubPic::AlphaBltAnv12_Nv12( const RECT* pSrc, const RECT* pDst, SubPicDesc* pTarget )
1109 {
1110 //fix me: check colorspace and log error
1111 const SubPicDesc& src = m_spd;
1112 SubPicDesc dst = *pTarget; // copy, because we might modify it
1113
1114 CRect rs(*pSrc), rd(*pDst);
1115 if(dst.h < 0)
1116 {
1117 dst.h = -dst.h;
1118 rd.bottom = dst.h - rd.bottom;
1119 rd.top = dst.h - rd.top;
1120 }
1121 if(rs.Width() != rd.Width() || rs.Height() != abs(rd.Height())) {
1122 return E_INVALIDARG;
1123 }
1124 int w = rs.Width(), h = rs.Height();
1125 bool bottom_down = rd.top > rd.bottom;
1126
1127 BYTE* d = NULL;
1128 BYTE* dUV = NULL;
1129 if (!bottom_down)
1130 {
1131 d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*rd.top + rd.left;
1132 dUV = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*dst.h + dst.pitch*rd.top/2 + rd.left;
1133 }
1134 else
1135 {
1136 d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*(rd.top-1) + rd.left;
1137 dUV = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*dst.h + dst.pitch*(rd.top/2-1) + rd.left;
1138 dst.pitch = -dst.pitch;
1139 }
1140 ASSERT(dst.pitchUV==0 || dst.pitchUV==abs(dst.pitch));
1141
1142 const BYTE* sa = reinterpret_cast<const BYTE*>(src.bits) + src.pitch*rs.top + rs.left;
1143 const BYTE* sy = sa + src.pitch*src.h;
1144 const BYTE* s_uv = sy + src.pitch*src.h;//UV
1145
1146 return AlphaBltAnv12_Nv12(sa, sy, s_uv, src.pitch, d, dUV, dst.pitch, w, h);
1147 }
1148
1149 STDMETHODIMP CMemSubPic::SetDirtyRectEx(CAtlList<CRect>* dirtyRectList )
1150 {
1151 //if(m_spd.type == MSP_YUY2 || m_spd.type == MSP_YV12 || m_spd.type == MSP_IYUV || m_spd.type == MSP_AYUV)
1152 if(dirtyRectList!=NULL)
1153 {
1154 POSITION pos = dirtyRectList->GetHeadPosition();
1155 if(m_spd.type == MSP_AYUV_PLANAR || m_alpha_blt_dst_type==MSP_IYUV || m_alpha_blt_dst_type==MSP_YV12
1156 || m_alpha_blt_dst_type==MSP_P010 || m_alpha_blt_dst_type==MSP_P016
1157 || m_alpha_blt_dst_type==MSP_NV12 || m_alpha_blt_dst_type==MSP_NV21 )
1158 {
1159 while(pos!=NULL)
1160 {
1161 CRect& cRectSrc = dirtyRectList->GetNext(pos);
1162 cRectSrc.left &= ~15;
1163 cRectSrc.right = (cRectSrc.right+15)&~15;
1164 if(cRectSrc.right>m_spd.w)
1165 {
1166 cRectSrc.right = m_spd.w;
1167 }
1168 cRectSrc.top &= ~1;
1169 cRectSrc.bottom = (cRectSrc.bottom+1)&~1;
1170 }
1171 }
1172 else if(m_spd.type == MSP_XY_AUYV || m_alpha_blt_dst_type==MSP_YUY2)
1173 {
1174 while(pos!=NULL)
1175 {
1176 CRect& cRectSrc = dirtyRectList->GetNext(pos);
1177 cRectSrc.left &= ~3;
1178 cRectSrc.right = (cRectSrc.right+3)&~3;
1179 }
1180 }
1181 }
1182 return __super::SetDirtyRectEx(dirtyRectList);
1183 }
1184
1185 //
1186 // static
1187 //
1188
1189 void CMemSubPic::AlphaBltYv12Luma(byte* dst, int dst_pitch,
1190 int w, int h,
1191 const byte* sub, const byte* alpha, int sub_pitch)
1192 {
1193 if( (
1194 ((reinterpret_cast<intptr_t>(alpha) ^ reinterpret_cast<intptr_t>(sub))
1195 |(reinterpret_cast<intptr_t>(alpha) ^ reinterpret_cast<intptr_t>(dst))
1196 | static_cast<intptr_t>(sub_pitch)
1197 | static_cast<intptr_t>(dst_pitch) ) & 15 )==0
1198 && w > 32 && (g_cpuid.m_flags & CCpuID::sse2))
1199 {
1200 int head = (16 - (reinterpret_cast<intptr_t>(alpha)&15))&15;
1201 int tail = (w-head) & 15;
1202 int w1 = w - head - tail;
1203 for(int i=0; i<h; i++, dst += dst_pitch, alpha += sub_pitch, sub += sub_pitch)
1204 {
1205 const BYTE* sa = alpha;
1206 const BYTE* s2 = sub;
1207 const BYTE* s2end_mod16 = s2 + w1;
1208 const BYTE* s2end = s2 + w;
1209 BYTE* d2 = dst;
1210
1211 for( ; (reinterpret_cast<intptr_t>(s2)&15) != 0; s2++, sa++, d2++)
1212 {
1213 if(sa[0] < 0xff)
1214 {
1215 d2[0] = ((d2[0]*sa[0])>>8) + s2[0];
1216 }
1217 }
1218 for(; s2 < s2end_mod16; s2+=16, sa+=16, d2+=16)
1219 {
1220 pix_alpha_blend_yv12_luma_sse2(d2, sa, s2);
1221 }
1222 for(; s2 < s2end; s2++, sa++, d2++)
1223 {
1224 if(sa[0] < 0xff)
1225 {
1226 d2[0] = ((d2[0]*sa[0])>>8) + s2[0];
1227 }
1228 }
1229 }
1230 }
1231 else //fix me: only a workaround for non-mod-16 size video
1232 {
1233 CMemSubPic::AlphaBltYv12LumaC(dst, dst_pitch, w, h, sub, alpha, sub_pitch);
1234 }
1235 }
1236
1237 void CMemSubPic::AlphaBltYv12LumaC( byte* dst, int dst_pitch, int w, int h, const byte* sub, const byte* alpha, int sub_pitch )
1238 {
1239 for(int i=0; i<h; i++, dst += dst_pitch, alpha += sub_pitch, sub += sub_pitch)
1240 {
1241 const BYTE* sa = alpha;
1242 const BYTE* s2 = sub;
1243 const BYTE* s2end = s2 + w;
1244 BYTE* d2 = dst;
1245 for(; s2 < s2end; s2+=1, sa+=1, d2+=1)
1246 {
1247 if(sa[0] < 0xff)
1248 {
1249 // d2[0] = (((d2[0]-0x10)*s2[3])>>8) + s2[1];
1250 d2[0] = ((d2[0]*sa[0])>>8) + s2[0];
1251 }
1252 }
1253 }
1254 }
1255
1256 void CMemSubPic::AlphaBltYv12Chroma(byte* dst_uv, int dst_pitch,
1257 int w, int chroma_h,
1258 const byte* src_uv, const byte* src_a, int src_pitch)
1259 {
1260 if( (
1261 ((reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(src_uv))
1262 |(reinterpret_cast<intptr_t>(src_a) ^ (2*reinterpret_cast<intptr_t>(dst_uv)))
1263 | static_cast<intptr_t>(src_pitch)
1264 | (2*static_cast<intptr_t>(dst_pitch)) ) & 15) ==0 &&
1265 w > 16 && (g_cpuid.m_flags & CCpuID::sse2))
1266 {
1267 int head = (16 - (reinterpret_cast<intptr_t>(src_a)&15))&15;
1268 int tail = (w-head) & 15;
1269 int w00 = w - head - tail;
1270
1271 int pitch = src_pitch;
1272 for(int j = 0; j < chroma_h; j++, src_uv += src_pitch*2, src_a += src_pitch*2, dst_uv += dst_pitch)
1273 {
1274 hleft_vmid_mix_uv_yv12_c2(dst_uv, head, src_uv, src_a, src_pitch);
1275 hleft_vmid_mix_uv_yv12_sse2(dst_uv+(head>>1), w00, src_uv+head, src_a+head, src_pitch, head>0 ? -1 : 0);
1276 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);
1277 }
1278 }
1279 else//fix me: only a workaround for non-mod-16 size video
1280 {
1281 AlphaBltYv12ChromaC(dst_uv, dst_pitch, w, chroma_h, src_uv, src_a, src_pitch);
1282 }
1283 }
1284
1285 void CMemSubPic::AlphaBltYv12ChromaC( byte* dst, int dst_pitch, int w, int chroma_h, const byte* sub_chroma, const byte* alpha, int sub_pitch )
1286 {
1287 for(int j = 0; j < chroma_h; j++, sub_chroma += sub_pitch*2, alpha += sub_pitch*2, dst += dst_pitch)
1288 {
1289 hleft_vmid_mix_uv_yv12_c(dst, w, sub_chroma, alpha, sub_pitch);
1290 }
1291 }
1292
1293 HRESULT CMemSubPic::AlphaBltAnv12_P010( const BYTE* src_a, const BYTE* src_y, const BYTE* src_uv, int src_pitch,
1294 BYTE* dst_y, BYTE* dst_uv, int dst_pitch, int w, int h )
1295 {
1296 if ( g_cpuid.m_flags & CCpuID::sse2 )
1297 {
1298 const BYTE* sa = src_a;
1299 if( (
1300 ((reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(src_y))
1301 |(reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(dst_y))
1302 | static_cast<intptr_t>(src_pitch)
1303 | static_cast<intptr_t>(dst_pitch) ) & 15 )==0 &&
1304 w > 32 )
1305 {
1306 int head = (16 - reinterpret_cast<intptr_t>(src_a)&15)&15;
1307 int tail = (w - head) & 15;
1308
1309 for(int i=0; i<h; i++, sa += src_pitch, src_y += src_pitch, dst_y += dst_pitch)
1310 {
1311 const BYTE* sa2 = sa;
1312 const BYTE* s2 = src_y;
1313 const BYTE* s2end_mod16 = s2 + (w&~15);
1314 BYTE* d2 = dst_y;
1315 WORD* d_w=reinterpret_cast<WORD*>(dst_y);
1316
1317 switch( head )//important: it is safe since w > 16
1318 {
1319 case 15:
1320 #define _XY_MIX_ONE if(sa2[0] < 0xff) { d_w[0] = ((d_w[0]*sa2[0])>>8) + (s2[0]<<8); } sa2++;d_w++;s2++;
1321 _XY_MIX_ONE
1322 case 14:
1323 _XY_MIX_ONE
1324 case 13:
1325 _XY_MIX_ONE
1326 case 12:
1327 _XY_MIX_ONE
1328 case 11:
1329 _XY_MIX_ONE
1330 case 10:
1331 _XY_MIX_ONE
1332 case 9:
1333 _XY_MIX_ONE
1334 case 8:
1335 _XY_MIX_ONE
1336 case 7:
1337 _XY_MIX_ONE
1338 case 6:
1339 _XY_MIX_ONE
1340 case 5:
1341 _XY_MIX_ONE
1342 case 4:
1343 _XY_MIX_ONE
1344 case 3:
1345 _XY_MIX_ONE
1346 case 2:
1347 _XY_MIX_ONE
1348 case 1://fall through on purpose
1349 _XY_MIX_ONE
1350 }
1351 for(; s2 < s2end_mod16; s2+=16, sa2+=16, d_w+=16)
1352 {
1353 mix_16_y_p010_sse2( reinterpret_cast<BYTE*>(d_w), s2, sa2);
1354 }
1355 switch( tail )//important: it is safe since w > 16
1356 {
1357 case 15:
1358 _XY_MIX_ONE
1359 case 14:
1360 _XY_MIX_ONE
1361 case 13:
1362 _XY_MIX_ONE
1363 case 12:
1364 _XY_MIX_ONE
1365 case 11:
1366 _XY_MIX_ONE
1367 case 10:
1368 _XY_MIX_ONE
1369 case 9:
1370 _XY_MIX_ONE
1371 case 8:
1372 _XY_MIX_ONE
1373 case 7:
1374 _XY_MIX_ONE
1375 case 6:
1376 _XY_MIX_ONE
1377 case 5:
1378 _XY_MIX_ONE
1379 case 4:
1380 _XY_MIX_ONE
1381 case 3:
1382 _XY_MIX_ONE
1383 case 2:
1384 _XY_MIX_ONE
1385 case 1://fall through on purpose
1386 _XY_MIX_ONE
1387 }
1388 }
1389 }
1390 else //fix me: only a workaround for non-mod-16 size video
1391 {
1392 for(int i=0; i<h; i++, sa += src_pitch, src_y += src_pitch, dst_y += dst_pitch)
1393 {
1394 const BYTE* sa2 = sa;
1395 const BYTE* s2 = src_y;
1396 const BYTE* s2end = s2 + w;
1397 WORD* d_w = reinterpret_cast<WORD*>(dst_y);
1398 for(; s2 < s2end; s2+=1, sa2+=1, d_w+=1)
1399 {
1400 if(sa2[0] < 0xff)
1401 {
1402 d_w[0] = ((d_w[0]*sa2[0])>>8) + (s2[0]<<8);
1403 }
1404 }
1405 }
1406 }
1407 //UV
1408 int h2 = h/2;
1409 BYTE* d = dst_uv;
1410 if( (
1411 ((reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(src_uv))
1412 |(reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(dst_uv))
1413 | static_cast<intptr_t>(src_pitch)
1414 | static_cast<intptr_t>(dst_pitch) ) & 15) ==0 &&
1415 w > 16 )
1416 {
1417 int head = (16-(reinterpret_cast<intptr_t>(src_a)&15))&15;
1418 int tail = (w-head) & 15;
1419 int w00 = w - head - tail;
1420
1421 ASSERT(w>0);//the calls to mix may failed if w==0
1422 for(int j = 0; j < h2; j++, src_uv += src_pitch, src_a += src_pitch*2, d += dst_pitch)
1423 {
1424 hleft_vmid_mix_uv_p010_c2(d, head, src_uv, src_a, src_pitch);
1425 hleft_vmid_mix_uv_p010_sse2(d+2*head, w00, src_uv+head, src_a+head, src_pitch, head>0 ? -1 : 0);
1426 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);
1427 }
1428 }
1429 else
1430 {
1431 for(int j = 0; j < h2; j++, src_uv += src_pitch, src_a += src_pitch*2, d += dst_pitch)
1432 {
1433 hleft_vmid_mix_uv_p010_c(d, w, src_uv, src_a, src_pitch);
1434 }
1435 }
1436 #ifndef _WIN64
1437 // TODOX64 : fixme!
1438 _mm_empty();
1439 #endif
1440 return S_OK;
1441 }
1442 else
1443 {
1444 return AlphaBltAnv12_P010_C(src_a, src_y, src_uv, src_pitch, dst_y, dst_uv, dst_pitch, w, h);
1445 }
1446 }
1447
1448 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 )
1449 {
1450 const BYTE* sa = src_a;
1451 for(int i=0; i<h; i++, sa += src_pitch, src_y += src_pitch, dst_y += dst_pitch)
1452 {
1453 const BYTE* sa2 = sa;
1454 const BYTE* s2 = src_y;
1455 const BYTE* s2end = s2 + w;
1456 WORD* d2 = reinterpret_cast<WORD*>(dst_y);
1457 for(; s2 < s2end; s2+=1, sa2+=1, d2+=1)
1458 {
1459 if(sa2[0] < 0xff)
1460 {
1461 d2[0] = ((d2[0]*sa2[0])>>8) + (s2[0]<<8);
1462 }
1463 }
1464 }
1465 //UV
1466 int h2 = h/2;
1467 BYTE* d = dst_uv;
1468 for(int j = 0; j < h2; j++, src_uv += src_pitch, src_a += src_pitch*2, d += dst_pitch)
1469 {
1470 hleft_vmid_mix_uv_p010_c(d, w, src_uv, src_a, src_pitch);
1471 }
1472 return S_OK;
1473 }
1474
1475 HRESULT CMemSubPic::AlphaBltAnv12_Nv12( const BYTE* src_a, const BYTE* src_y, const BYTE* src_uv, int src_pitch,
1476 BYTE* dst_y, BYTE* dst_uv, int dst_pitch, int w, int h )
1477 {
1478 AlphaBltYv12Luma( dst_y, dst_pitch, w, h, src_y, src_a, src_pitch );
1479
1480 int h2 = h/2;
1481 if( (
1482 ((reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(src_uv))
1483 |(reinterpret_cast<intptr_t>(src_a) ^ reinterpret_cast<intptr_t>(dst_uv))
1484 | static_cast<intptr_t>(src_pitch)
1485 | static_cast<intptr_t>(dst_pitch) ) & 15) ==0 &&
1486 w > 16 && (g_cpuid.m_flags & CCpuID::sse2) )
1487 {
1488 BYTE* d = dst_uv;
1489
1490 int head = (16-(reinterpret_cast<intptr_t>(src_a)&15))&15;
1491 int tail = (w-head) & 15;
1492 int w00 = w - head - tail;
1493
1494 ASSERT(w>0);//the calls to mix may failed if w==0
1495 for(int j = 0; j < h2; j++, src_uv += src_pitch, src_a += src_pitch*2, d += dst_pitch)
1496 {
1497 hleft_vmid_mix_uv_nv12_c2(d, head, src_uv, src_a, src_pitch);
1498 hleft_vmid_mix_uv_nv12_sse2(d+head, w00, src_uv+head, src_a+head, src_pitch, head>0 ? -1 : 0);
1499 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);
1500 }
1501 #ifndef _WIN64
1502 // TODOX64 : fixme!
1503 _mm_empty();
1504 #endif
1505 }
1506 else
1507 {
1508 BYTE* d = dst_uv;
1509 for(int j = 0; j < h2; j++, src_uv += src_pitch, src_a += src_pitch*2, d += dst_pitch)
1510 {
1511 hleft_vmid_mix_uv_nv12_c(d, w, src_uv, src_a, src_pitch);
1512 }
1513 }
1514 return S_OK;
1515 }
1516
1517 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 )
1518 {
1519 AlphaBltYv12LumaC( dst_y, dst_pitch, w, h, src_y, src_a, src_pitch );
1520 int h2 = h/2;
1521 BYTE* d = dst_uv;
1522 for(int j = 0; j < h2; j++, src_uv += src_pitch, src_a += src_pitch*2, d += dst_pitch)
1523 {
1524 hleft_vmid_mix_uv_nv12_c(d, w, src_uv, src_a, src_pitch);
1525 }
1526 return S_OK;
1527 }
1528
1529 void CMemSubPic::SubsampleAndInterlace( BYTE* dst, const BYTE* u, const BYTE* v, int h, int w, int pitch )
1530 {
1531 for (int i=0;i<h;i+=2)
1532 {
1533 hleft_vmid_subsample_and_interlace_2_line_sse2(dst, u, v, w, pitch);
1534 u += 2*pitch;
1535 v += 2*pitch;
1536 dst += pitch;
1537 }
1538 }
1539
1540 void CMemSubPic::SubsampleAndInterlaceC( BYTE* dst, const BYTE* u, const BYTE* v, int h, int w, int pitch )
1541 {
1542 for (int i=0;i<h;i+=2)
1543 {
1544 hleft_vmid_subsample_and_interlace_2_line_c(dst, u, v, w, pitch);
1545 u += 2*pitch;
1546 v += 2*pitch;
1547 dst += pitch;
1548 }
1549 }
1550
1551 void CMemSubPic::AlphaBlt_YUY2(int w, int h, BYTE* d, int dstpitch, PCUINT8 s, int srcpitch)
1552 {
1553 #ifdef _WIN64
1554 AlphaBlt_YUY2_C(w, h, d, dstpitch, s, srcpitch);
1555 #else
1556 AlphaBlt_YUY2_MMX(w, h, d, dstpitch, s, srcpitch);
1557 #endif
1558 }
1559
1560 //
1561 // CMemSubPicAllocator
1562 //
1563
1564 CMemSubPicAllocator::CMemSubPicAllocator(int alpha_blt_dst_type, SIZE maxsize, int type/*=-1*/)
1565 : CSubPicExAllocatorImpl(maxsize, false, false)
1566 , m_alpha_blt_dst_type(alpha_blt_dst_type)
1567 , m_maxsize(maxsize)
1568 , m_type(type)
1569 {
1570 if(m_type==-1)
1571 {
1572 switch(alpha_blt_dst_type)
1573 {
1574 case MSP_YUY2:
1575 m_type = MSP_XY_AUYV;
1576 break;
1577 case MSP_AYUV:
1578 m_type = MSP_AYUV;
1579 break;
1580 case MSP_IYUV:
1581 case MSP_YV12:
1582 case MSP_P010:
1583 case MSP_P016:
1584 case MSP_NV12:
1585 case MSP_NV21:
1586 m_type = MSP_AYUV_PLANAR;
1587 break;
1588 default:
1589 m_type = MSP_RGBA;
1590 break;
1591 }
1592 }
1593 }
1594
1595 // ISubPicAllocatorImpl
1596
1597 bool CMemSubPicAllocator::AllocEx(bool fStatic, ISubPicEx** ppSubPic)
1598 {
1599 if(!ppSubPic) {
1600 return false;
1601 }
1602 SubPicDesc spd;
1603 spd.w = m_maxsize.cx;
1604 spd.h = m_maxsize.cy;
1605 spd.bpp = 32;
1606 spd.pitch = (spd.w*spd.bpp)>>3;
1607 spd.type = m_type;
1608 spd.bits = DNew BYTE[spd.pitch*spd.h];
1609 if(!spd.bits) {
1610 return false;
1611 }
1612 *ppSubPic = DNew CMemSubPic(spd, m_alpha_blt_dst_type);
1613 if(!(*ppSubPic)) {
1614 return false;
1615 }
1616 (*ppSubPic)->AddRef();
1617 return true;
1618 }
vsfilter mod based on vsfilter 2.39