src/subpic/SimpleSubpicImpl.cpp

   1 #include "stdafx.h"
   2 #include "SimpleSubpicImpl.h"
   3 #include "ISimpleSubPic.h"
   4 #include "xy_intrinsics.h"
   5 #include "../subtitles/xy_malloc.h"
   6 #include "MemSubPic.h"
   7
   8 //////////////////////////////////////////////////////////////////////////
   9 //
  10 // SimpleSubpic
  11 //
  12
  13 SimpleSubpic::SimpleSubpic( IXySubRenderFrame*sub_render_frame, int alpha_blt_dst_type )
  14     : CUnknown(NAME("SimpleSubpic"), NULL)
  15     , m_sub_render_frame(sub_render_frame)
  16     , m_alpha_blt_dst_type(alpha_blt_dst_type)
  17 {
  18     ConvertColorSpace();
  19 }
  20
  21 SimpleSubpic::~SimpleSubpic()
  22 {
  23     for(unsigned i=0;i<m_buffers.GetCount();i++)
  24         xy_free(m_buffers.GetAt(i));
  25 }
  26
  27 STDMETHODIMP SimpleSubpic::NonDelegatingQueryInterface( REFIID riid, void** ppv )
  28 {
  29     return
  30         QI(ISimpleSubPic)
  31         __super::NonDelegatingQueryInterface(riid, ppv);
  32 }
  33
  34 STDMETHODIMP SimpleSubpic::AlphaBlt( SubPicDesc* target )
  35 {
  36     ASSERT(target!=NULL);
  37     HRESULT hr = S_FALSE;
  38     int count = m_bitmap.GetCount();
  39     for(int i=0;i<count;i++)
  40     {
  41         switch(target->type)
  42         {
  43         case MSP_NV12:
  44         case MSP_NV21:
  45             hr = AlphaBltAnv12_Nv12(target, m_bitmap.GetAt(i));
  46             break;
  47         case MSP_P010:
  48         case MSP_P016:
  49             hr = AlphaBltAnv12_P010(target, m_bitmap.GetAt(i));
  50             break;
  51         default:
  52             hr = AlphaBlt(target, m_bitmap.GetAt(i));
  53             break;
  54         }
  55
  56         if (FAILED(hr))
  57         {
  58             return hr;
  59         }
  60     }
  61
  62     return hr;
  63 }
  64
  65 HRESULT SimpleSubpic::AlphaBltAnv12_P010( SubPicDesc* target, const Bitmap& src )
  66 {
  67     //fix me: check colorspace and log error
  68     SubPicDesc dst = *target; // copy, because we might modify it
  69
  70     CRect rd(src.pos, src.size);
  71     if(dst.h < 0)
  72     {
  73         dst.h = -dst.h;
  74         rd.bottom = dst.h - rd.bottom;
  75         rd.top = dst.h - rd.top;
  76     }
  77
  78     int w = src.size.cx, h = src.size.cy;
  79     bool bottom_down = rd.top > rd.bottom;
  80
  81     BYTE* d = NULL;
  82     BYTE* dUV = NULL;
  83     if(!bottom_down)
  84     {
  85         d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*rd.top + rd.left*2;
  86         dUV = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*dst.h + dst.pitch*rd.top/2 + rd.left*2;
  87     }
  88     else
  89     {
  90         d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*(rd.top-1) + rd.left*2;
  91         dUV = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*dst.h + dst.pitch*(rd.top/2-1) + rd.left*2;
  92         dst.pitch = -dst.pitch;
  93     }
  94     ASSERT(dst.pitchUV==0 || dst.pitchUV==abs(dst.pitch));
  95
  96     enum PLANS{A=0,Y,UV};
  97     const BYTE* sa = reinterpret_cast<const BYTE*>(src.extra.plans[A]);
  98     const BYTE* sy = reinterpret_cast<const BYTE*>(src.extra.plans[Y]);
  99     const BYTE* s_uv = reinterpret_cast<const BYTE*>(src.extra.plans[UV]);
 100     return CMemSubPic::AlphaBltAnv12_P010(sa, sy, s_uv, src.pitch, d, dUV, dst.pitch, w, h);
 101 }
 102
 103 HRESULT SimpleSubpic::AlphaBltAnv12_Nv12( SubPicDesc* target, const Bitmap& src )
 104 {
 105     //fix me: check colorspace and log error
 106     SubPicDesc dst = *target; // copy, because we might modify it
 107
 108     CRect rd(src.pos, src.size);
 109     if(dst.h < 0)
 110     {
 111         dst.h = -dst.h;
 112         rd.bottom = dst.h - rd.bottom;
 113         rd.top = dst.h - rd.top;
 114     }
 115
 116     int w = src.size.cx, h = src.size.cy;
 117     bool bottom_down = rd.top > rd.bottom;
 118
 119     BYTE* d = NULL;
 120     BYTE* dUV = NULL;
 121     if (!bottom_down)
 122     {
 123         d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*rd.top + rd.left;
 124         dUV = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*dst.h + dst.pitch*rd.top/2 + rd.left;
 125     }
 126     else
 127     {
 128         d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*(rd.top-1) + rd.left;
 129         dUV = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*dst.h + dst.pitch*(rd.top/2-1) + rd.left;
 130         dst.pitch = -dst.pitch;
 131     }
 132     ASSERT(dst.pitchUV==0 || dst.pitchUV==abs(dst.pitch));
 133
 134     enum PLANS{A=0,Y,UV};
 135     const BYTE* sa = reinterpret_cast<const BYTE*>(src.extra.plans[A]);
 136     const BYTE* sy = reinterpret_cast<const BYTE*>(src.extra.plans[Y]);
 137     const BYTE* s_uv = reinterpret_cast<const BYTE*>(src.extra.plans[UV]);
 138     return CMemSubPic::AlphaBltAnv12_Nv12(sa, sy, s_uv, src.pitch, d, dUV, dst.pitch, w, h);
 139 }
 140
 141 HRESULT SimpleSubpic::AlphaBlt( SubPicDesc* target, const Bitmap& src )
 142 {
 143     SubPicDesc dst = *target; // copy, because we might modify it
 144
 145     CRect rd(src.pos, src.size);
 146     if(dst.h < 0)
 147     {
 148         dst.h = -dst.h;
 149         rd.bottom = dst.h - rd.bottom;
 150         rd.top = dst.h - rd.top;
 151     }
 152
 153     int w = src.size.cx, h = src.size.cy;
 154     const BYTE* s = reinterpret_cast<const BYTE*>(src.pixels);
 155     BYTE* d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*rd.top + ((rd.left*dst.bpp)>>3);
 156
 157     if(rd.top > rd.bottom)
 158     {
 159         if(dst.type == MSP_RGB32 || dst.type == MSP_RGB24
 160             || dst.type == MSP_RGB16 || dst.type == MSP_RGB15
 161             || dst.type == MSP_YUY2 || dst.type == MSP_AYUV)
 162         {
 163             d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*(rd.top-1) + (rd.left*dst.bpp>>3);
 164         }
 165         else if(dst.type == MSP_YV12 || dst.type == MSP_IYUV)
 166         {
 167             d = reinterpret_cast<BYTE*>(dst.bits) + dst.pitch*(rd.top-1) + (rd.left*8>>3);
 168         }
 169         else
 170         {
 171             return E_NOTIMPL;
 172         }
 173         dst.pitch = -dst.pitch;
 174     }
 175     DbgLog((LOG_TRACE, 5, TEXT("w=%d h=%d"), w, h));
 176     switch(dst.type)
 177     {
 178     case MSP_RGBA:
 179         for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
 180         {
 181             const BYTE* s2 = s;
 182             const BYTE* s2end = s2 + w*4;
 183             DWORD* d2 = reinterpret_cast<DWORD*>(d);
 184             for(; s2 < s2end; s2 += 4, d2++)
 185             {
 186                 if(s2[3] < 0xff)
 187                 {
 188                     DWORD bd =0x00000100 -( (DWORD) s2[3]);
 189                     DWORD B = ((*((DWORD*)s2)&0x000000ff)<<8)/bd;
 190                     DWORD V = ((*((DWORD*)s2)&0x0000ff00)/bd)<<8;
 191                     DWORD R = (((*((DWORD*)s2)&0x00ff0000)>>8)/bd)<<16;
 192                     *d2 = B | V | R
 193                         | (0xff000000-(*((DWORD*)s2)&0xff000000))&0xff000000;
 194                 }
 195             }
 196         }
 197         break;
 198     case MSP_RGB32:
 199         for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
 200         {
 201             const BYTE* s2 = s;
 202             const BYTE* s2end = s2 + w*4;
 203             DWORD* d2 = (DWORD*)d;
 204             for(; s2 < s2end; s2 += 4, d2++)
 205             {
 206                 if(s2[3] < 0xff)
 207                 {
 208                     *d2 = (((((*d2&0x00ff00ff)*s2[3])>>8) + (*((DWORD*)s2)&0x00ff00ff))&0x00ff00ff)
 209                         | (((((*d2&0x0000ff00)*s2[3])>>8) + (*((DWORD*)s2)&0x0000ff00))&0x0000ff00);
 210                 }
 211             }
 212         }
 213         break;
 214     case MSP_AYUV:
 215         for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
 216         {
 217             const BYTE* s2 = s;
 218             const BYTE* s2end = s2 + w*4;
 219             DWORD* d2 = (DWORD*)d;
 220             for(; s2 < s2end; s2 += 4, d2++)
 221             {
 222                 if(s2[3] < 0xff)
 223                 {
 224                     *d2 = (((((*d2&0x00ff00ff)*s2[3])>>8) + (*((DWORD*)s2)&0x00ff00ff))&0x00ff00ff)
 225                         | (((((*d2&0x0000ff00)*s2[3])>>8) + (*((DWORD*)s2)&0x0000ff00))&0x0000ff00)
 226                         | (*d2&0xff000000);
 227                 }
 228             }
 229         }
 230         break;
 231     case MSP_RGB24:
 232         for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
 233         {
 234             const BYTE* s2 = s;
 235             const BYTE* s2end = s2 + w*4;
 236             BYTE* d2 = d;
 237             for(; s2 < s2end; s2 += 4, d2 += 3)
 238             {
 239                 if(s2[3] < 0xff)
 240                 {
 241                     d2[0] = ((d2[0]*s2[3])>>8) + s2[0];
 242                     d2[1] = ((d2[1]*s2[3])>>8) + s2[1];
 243                     d2[2] = ((d2[2]*s2[3])>>8) + s2[2];
 244                 }
 245             }
 246         }
 247         break;
 248     case MSP_RGB16:
 249         for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
 250         {
 251             const BYTE* s2 = s;
 252             const BYTE* s2end = s2 + w*4;
 253             WORD* d2 = reinterpret_cast<WORD*>(d);
 254             for(; s2 < s2end; s2 += 4, d2++)
 255             {
 256                 if(s2[3] < 0x1f)
 257                 {
 258                     *d2 = (WORD)((((((*d2&0xf81f)*s2[3])>>5) + (*(DWORD*)s2&0xf81f))&0xf81f)
 259                         | (((((*d2&0x07e0)*s2[3])>>5) + (*(DWORD*)s2&0x07e0))&0x07e0));
 260                     /*                                  *d2 = (WORD)((((((*d2&0xf800)*s2[3])>>8) + (*(DWORD*)s2&0xf800))&0xf800)
 261                     | (((((*d2&0x07e0)*s2[3])>>8) + (*(DWORD*)s2&0x07e0))&0x07e0)
 262                     | (((((*d2&0x001f)*s2[3])>>8) + (*(DWORD*)s2&0x001f))&0x001f));
 263                     */
 264                 }
 265             }
 266         }
 267         break;
 268     case MSP_RGB15:
 269         for(int j = 0; j < h; j++, s += src.pitch, d += dst.pitch)
 270         {
 271             const BYTE* s2 = s;
 272             const BYTE* s2end = s2 + w*4;
 273             WORD* d2 = reinterpret_cast<WORD*>(d);
 274             for(; s2 < s2end; s2 += 4, d2++)
 275             {
 276                 if(s2[3] < 0x1f)
 277                 {
 278                     *d2 = (WORD)((((((*d2&0x7c1f)*s2[3])>>5) + (*(DWORD*)s2&0x7c1f))&0x7c1f)
 279                         | (((((*d2&0x03e0)*s2[3])>>5) + (*(DWORD*)s2&0x03e0))&0x03e0));
 280                     /*                                  *d2 = (WORD)((((((*d2&0x7c00)*s2[3])>>8) + (*(DWORD*)s2&0x7c00))&0x7c00)
 281                     | (((((*d2&0x03e0)*s2[3])>>8) + (*(DWORD*)s2&0x03e0))&0x03e0)
 282                     | (((((*d2&0x001f)*s2[3])>>8) + (*(DWORD*)s2&0x001f))&0x001f));
 283                     */
 284                 }
 285             }
 286         }
 287         break;
 288     case MSP_YUY2:
 289         CMemSubPic::AlphaBlt_YUY2(w,h,d,dst.pitch,s, src.pitch);
 290         break;
 291     case MSP_YV12:
 292     case MSP_IYUV:
 293         {
 294             //dst.pitch = abs(dst.pitch);
 295             int h2 = h/2;
 296             if(!dst.pitchUV)
 297             {
 298                 dst.pitchUV = abs(dst.pitch)/2;
 299             }
 300             if(!dst.bitsU || !dst.bitsV)
 301             {
 302                 dst.bitsU = reinterpret_cast<BYTE*>(dst.bits) + abs(dst.pitch)*dst.h;
 303                 dst.bitsV = dst.bitsU + dst.pitchUV*dst.h/2;
 304                 if(dst.type == MSP_YV12)
 305                 {
 306                     BYTE* p = dst.bitsU;
 307                     dst.bitsU = dst.bitsV;
 308                     dst.bitsV = p;
 309                 }
 310             }
 311             BYTE* dd[2];
 312             dd[0] = dst.bitsU + dst.pitchUV*rd.top/2 + rd.left/2;
 313             dd[1] = dst.bitsV + dst.pitchUV*rd.top/2 + rd.left/2;
 314             if(rd.top > rd.bottom)
 315             {
 316                 dd[0] = dst.bitsU + dst.pitchUV*(rd.top/2-1) + rd.left/2;
 317                 dd[1] = dst.bitsV + dst.pitchUV*(rd.top/2-1) + rd.left/2;
 318                 dst.pitchUV = -dst.pitchUV;
 319             }
 320
 321             enum PLANS{A=0,Y,U,V};
 322             const BYTE* sa = reinterpret_cast<const BYTE*>(src.extra.plans[A]);
 323             const BYTE* sy = reinterpret_cast<const BYTE*>(src.extra.plans[Y]);
 324             const BYTE* su = reinterpret_cast<const BYTE*>(src.extra.plans[U]);
 325             const BYTE* sv = reinterpret_cast<const BYTE*>(src.extra.plans[V]);
 326             CMemSubPic::AlphaBltYv12Luma( d, dst.pitch, w, h, sy, sa, src.pitch );
 327             CMemSubPic::AlphaBltYv12Chroma( dd[0], dst.pitchUV, w, h2, su, sa, src.pitch);
 328             CMemSubPic::AlphaBltYv12Chroma( dd[1], dst.pitchUV, w, h2, sv, sa, src.pitch);
 329 #ifndef _WIN64
 330             // TODOX64 : fixme!
 331             _mm_empty();
 332 #endif
 333         }
 334         break;
 335     default:
 336         return E_NOTIMPL;
 337         break;
 338     }
 339
 340     //emmsÒª40¸öcpuÖÜÆÚ
 341     //__asm emms;
 342     return S_OK;
 343 }
 344
 345 HRESULT SimpleSubpic::ConvertColorSpace()
 346 {
 347     int count = 0;
 348     HRESULT hr = m_sub_render_frame->GetBitmapCount(&count);
 349     if (FAILED(hr) || count==0)
 350     {
 351         return hr;
 352     }
 353     int xy_color_space = 0;
 354     hr = m_sub_render_frame->GetXyColorSpace(&xy_color_space);
 355     if (FAILED(hr))
 356     {
 357         return hr;
 358     }
 359     m_bitmap.SetCount(count);
 360     m_buffers.SetCount(count);
 361     for (int i=0;i<count;i++)
 362     {
 363         m_buffers.GetAt(i) = NULL;//safe
 364
 365         Bitmap &bitmap = m_bitmap.GetAt(i);
 366         hr = m_sub_render_frame->GetBitmap(i, &bitmap.id, &bitmap.pos, &bitmap.size, &bitmap.pixels, &bitmap.pitch);
 367         if (FAILED(hr))
 368         {
 369             return hr;
 370         }
 371         if (xy_color_space==XY_CS_AYUV_PLANAR)
 372         {
 373             hr = m_sub_render_frame->GetBitmapExtra(i, &bitmap.extra);
 374             if (FAILED(hr))
 375             {
 376                 return hr;
 377             }
 378         }
 379
 380         int w = bitmap.size.cx, h = bitmap.size.cy;
 381         if (w<=0 || h<=0)
 382         {
 383             continue;
 384         }
 385
 386         const BYTE* top = reinterpret_cast<const BYTE*>(bitmap.pixels);
 387         const BYTE* bottom = top + bitmap.pitch*h;
 388         if(m_alpha_blt_dst_type == MSP_RGB16)
 389         {
 390             ASSERT(xy_color_space==XY_CS_ARGB);
 391
 392             BYTE* dst = reinterpret_cast<BYTE*>(xy_malloc(bitmap.pitch*h, (bitmap.pos.x*4)&15));
 393             m_buffers.GetAt(i) = dst;
 394             bitmap.pixels = dst;
 395             for(; top < bottom ; top += bitmap.pitch, dst += bitmap.pitch)
 396             {
 397                 const DWORD* s = reinterpret_cast<const DWORD*>(top);
 398                 const DWORD* e = s + w;
 399                 DWORD* dst2 = reinterpret_cast<DWORD*>(dst);
 400                 for(; s < e; s++, dst2++)
 401                 {
 402                     *dst2 = ((*s>>3)&0x1f000000)|((*s>>8)&0xf800)|((*s>>5)&0x07e0)|((*s>>3)&0x001f);
 403                     //                          *s = (*s&0xff000000)|((*s>>8)&0xf800)|((*s>>5)&0x07e0)|((*s>>3)&0x001f);
 404                 }
 405             }
 406         }
 407         else if(m_alpha_blt_dst_type == MSP_RGB15)
 408         {
 409             ASSERT(xy_color_space==XY_CS_ARGB);
 410
 411             BYTE* dst = reinterpret_cast<BYTE*>(xy_malloc(bitmap.pitch*h, (bitmap.pos.x*4)&15));
 412             m_buffers.GetAt(i) = dst;
 413             bitmap.pixels = dst;
 414             for(; top < bottom; top += bitmap.pitch, dst += bitmap.pitch)
 415             {
 416                 const DWORD* s = reinterpret_cast<const DWORD*>(top);
 417                 const DWORD* e = s + w;
 418                 DWORD* dst2 = reinterpret_cast<DWORD*>(dst);
 419                 for(; s < e; s++, dst2++)
 420                 {
 421                     *dst2 = ((*s>>3)&0x1f000000)|((*s>>9)&0x7c00)|((*s>>6)&0x03e0)|((*s>>3)&0x001f);
 422                     //                          *s = (*s&0xff000000)|((*s>>9)&0x7c00)|((*s>>6)&0x03e0)|((*s>>3)&0x001f);
 423                 }
 424             }
 425         }
 426         else if(m_alpha_blt_dst_type == MSP_YUY2)
 427         {
 428             ASSERT(xy_color_space==XY_CS_AUYV);
 429             XY_DO_ONCE( xy_logger::write_file("G:\\b1_ul", top, bitmap.pitch*(h-1)) );
 430
 431             BYTE* dst = reinterpret_cast<BYTE*>(xy_malloc(bitmap.pitch*h, (bitmap.pos.x*4)&15));
 432             m_buffers.GetAt(i) = dst;
 433             memcpy(dst, bitmap.pixels, bitmap.pitch*h);
 434             bitmap.pixels = dst;
 435             for(BYTE* tempTop=dst; tempTop < dst+bitmap.pitch*h ; tempTop += bitmap.pitch)
 436             {
 437                 BYTE* s = tempTop;
 438                 BYTE* e = s + w*4;
 439                 BYTE last_v = s[0], last_u=s[2];
 440                 for(; s < e; s+=8) // AUYV AUYV -> AxYU AxYV
 441                 {
 442                     BYTE tmp = s[4];
 443                     s[4] = (last_v + 2*s[0] + s[4] + 2)>>2;
 444                     last_v = tmp;
 445
 446                     s[0] = (last_u + 2*s[2] + s[6] + 2)>>2;
 447                     last_u = s[6];
 448                 }
 449             }
 450             XY_DO_ONCE( xy_logger::write_file("G:\\a1_ul", dst, bitmap.pitch*(h-1)) );
 451         }
 452         else if(m_alpha_blt_dst_type == MSP_YV12 || m_alpha_blt_dst_type == MSP_IYUV )
 453         {
 454             ASSERT(xy_color_space==XY_CS_AYUV_PLANAR);
 455             //nothing to do
 456         }
 457         else if ( m_alpha_blt_dst_type == MSP_P010 || m_alpha_blt_dst_type == MSP_P016
 458             || m_alpha_blt_dst_type == MSP_NV12 )
 459         {
 460             ASSERT(xy_color_space==XY_CS_AYUV_PLANAR);
 461             SubsampleAndInterlace(i, &bitmap, true);
 462         }
 463         else if( m_alpha_blt_dst_type == MSP_NV21 )
 464         {
 465             ASSERT(xy_color_space==XY_CS_AYUV_PLANAR);
 466             SubsampleAndInterlace(i, &bitmap, false);
 467         }
 468     }
 469     return S_OK;
 470 }
 471
 472 void SimpleSubpic::SubsampleAndInterlace( int index, Bitmap*bitmap, bool u_first )
 473 {
 474     ASSERT(bitmap!=NULL);
 475     //fix me: check alignment and log error
 476     int w = bitmap->size.cx, h = bitmap->size.cy;
 477     ASSERT(h%2==0);
 478     const BYTE* u_start = reinterpret_cast<const BYTE*>(bitmap->extra.plans[2]);
 479     const BYTE* v_start = reinterpret_cast<const BYTE*>(bitmap->extra.plans[3]);
 480
 481     BYTE* dst = reinterpret_cast<BYTE*>(xy_malloc(bitmap->pitch*h/2, bitmap->pos.x&15));
 482     m_buffers.GetAt(index) = dst;
 483     bitmap->extra.plans[2] = dst;
 484
 485     if(!u_first)
 486     {
 487         const BYTE* tmp = v_start;
 488         v_start = u_start;
 489         u_start = tmp;
 490     }
 491
 492     //Todo: fix me.
 493     //Walkarround for alignment
 494     if ( ((bitmap->pitch | (int)u_start | (int)v_start)&15) == 0 && (g_cpuid.m_flags & CCpuID::sse2) )
 495     {
 496         for (int i=0;i<h;i+=2)
 497         {
 498             int w16 = w&~15;
 499             hleft_vmid_subsample_and_interlace_2_line_sse2(dst, u_start, v_start, w16, bitmap->pitch);
 500             ASSERT(w>0);
 501             hleft_vmid_subsample_and_interlace_2_line_c(dst+w16, u_start+w16, v_start+w16, w&15, bitmap->pitch, -1);
 502             u_start += 2*bitmap->pitch;
 503             v_start += 2*bitmap->pitch;
 504             dst += bitmap->pitch;
 505         }
 506     }
 507     else
 508     {
 509         for (int i=0;i<h;i+=2)
 510         {
 511             hleft_vmid_subsample_and_interlace_2_line_c(dst, u_start, v_start, w, bitmap->pitch);
 512             u_start += 2*bitmap->pitch;
 513             v_start += 2*bitmap->pitch;
 514             dst += bitmap->pitch;
 515         }
 516     }
 517 }