src/video/symbian/dsa.cpp

   1 #include "dsa.h"
   2 #include "sdlepocapi.h"
   3 #include <cdsb.h>
   4 #include <basched.h>
   5
   6 LOCAL_C int BytesPerPixel(TDisplayMode aMode)
   7 {
   8         return ((TDisplayModeUtils::NumDisplayModeBitsPerPixel(aMode) - 1) >> 3) + 1;
   9 }
  10
  11 template<class T>
  12 NONSHARABLE_CLASS(CBitmapSurface) : public T
  13 {
  14         public:
  15                 CBitmapSurface(RWsSession& aSession);
  16
  17         private:
  18                 void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);
  19                 ~CBitmapSurface();
  20                 TUint8* LockSurface();
  21                 void UnlockHwSurface();
  22                 void CreateSurfaceL();
  23                 void Free();
  24                 void Update(CFbsBitmap& aBmp);
  25                 CFbsBitmap* iBmp;
  26 };
  27
  28 template<class T>
  29 void CBitmapSurface<T>::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
  30 {
  31         T::ConstructL(aWindow, aDevice);
  32 }
  33
  34 template<class T>
  35 CBitmapSurface<T>::CBitmapSurface(RWsSession& aSession) : T(aSession)
  36 {
  37 }
  38
  39 template<class T>
  40 void CBitmapSurface<T>::Free()
  41 {
  42         delete iBmp;
  43         iBmp = NULL;
  44         T::Free();
  45 }
  46
  47 template<class T>
  48 CBitmapSurface<T>::~CBitmapSurface()
  49 {
  50         __ASSERT_DEBUG(iBmp == NULL, PANIC(KErrNotReady));
  51 }
  52
  53 template<class T>
  54 TUint8* CBitmapSurface<T>::LockSurface()
  55 {
  56         iBmp->LockHeap();
  57         return reinterpret_cast<TUint8*>(iBmp->DataAddress());
  58 }
  59
  60 template<class T>
  61 void CBitmapSurface<T>::UnlockHwSurface()
  62 {
  63         iBmp->UnlockHeap();
  64         T::SetUpdating(EFalse);
  65         Update(*iBmp);
  66 }
  67
  68 template<class T>
  69 void CBitmapSurface<T>::Update(CFbsBitmap& aBmp)
  70 {
  71         T::DoBlt(aBmp);
  72         T::CompleteUpdate();
  73 }
  74
  75 template<class T>
  76 void CBitmapSurface<T>::CreateSurfaceL()
  77 {
  78         Free();
  79         iBmp  = new (ELeave) CFbsBitmap();
  80         User::LeaveIfError(iBmp->Create(T::SwSize(), T::DisplayMode()));
  81         T::CreateSurfaceL(*iBmp);
  82 }
  83
  84 //////////////////////////////////////////////////////////////////////
  85
  86 NONSHARABLE_CLASS(CDsaGles) : public CDsa
  87 {
  88         public:
  89                 CDsaGles(RWsSession& aSession) : CDsa(aSession) {}
  90
  91         private:
  92                 TUint8* LockSurface() { return NULL; }
  93                 void UnlockHwSurface() {}
  94                 void Resume() {}
  95                 void CreateSurfaceL() {}
  96 };
  97
  98 //////////////////////////////////////////////////////////////////////
  99
 100 NONSHARABLE_CLASS(CDsaBase) : public CDsa, public MDirectScreenAccess
 101 {
 102         protected:
 103                 CDsaBase(RWsSession& aSession) : CDsa(aSession) { m_updateWholeScreen = false; }
 104                 ~CDsaBase();
 105                 void ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice);
 106                 void Stop();
 107                 void Resume();
 108                 void CompleteUpdate();
 109                 void DoBlt(CFbsBitmap& aBmp);
 110                 void CreateSurfaceL(CFbsBitmap& aBmp) {};
 111
 112                 CDirectScreenAccess*  iDsa;
 113
 114         private:
 115                 void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);
 116                 void Restart(RDirectScreenAccess::TTerminationReasons aReason);
 117                 void RestartL();
 118 };
 119
 120 void CDsaBase::ConstructL(RWindow& aWindow, CWsScreenDevice& aDevice)
 121 {
 122         CDsa::ConstructL(aWindow, aDevice);
 123         if(iDsa != NULL)
 124         {
 125                 iDsa->Cancel();
 126                 delete iDsa;
 127                 iDsa = NULL;
 128         }
 129
 130         iDsa = CDirectScreenAccess::NewL(Session(), aDevice, aWindow, *this);
 131         RestartL();
 132 }
 133
 134 void CDsaBase::Resume()
 135 {
 136         if(Stopped())
 137                 Restart(RDirectScreenAccess::ETerminateRegion);
 138 }
 139
 140 void CDsaBase::CompleteUpdate()
 141 {
 142         iDsa->ScreenDevice()->Update();
 143 }
 144
 145 void CDsaBase::DoBlt(CFbsBitmap& aBmp)
 146 {
 147         if(SwSize() == HwRect().Size())
 148                 iDsa->Gc()->BitBlt(HwRect().iTl, &aBmp);
 149         else
 150                 iDsa->Gc()->DrawBitmap(HwRect(), &aBmp);
 151 }
 152
 153 CDsaBase::~CDsaBase()
 154 {
 155         if(iDsa != NULL)
 156         {
 157                 iDsa->Cancel();
 158         }
 159         delete iDsa;
 160 }
 161
 162 void CDsaBase::RestartL()
 163 {
 164         iDsa->StartL();
 165         iDsa->Gc()->SetClippingRegion(iDsa->DrawingRegion());
 166
 167         SetTargetRect();
 168
 169         Start();
 170 }
 171
 172 void CDsaBase::AbortNow(RDirectScreenAccess::TTerminationReasons /*aReason*/)
 173 {
 174         Stop();
 175 }
 176
 177 void CDsaBase::Restart(RDirectScreenAccess::TTerminationReasons /*aReason*/)
 178 {
 179         TRAPD(err, RestartL());
 180         if(err == KLeaveExit)
 181         {
 182                 Stop();
 183         }
 184         else
 185         {
 186                 PANIC_IF_ERROR(err);
 187         }
 188 }
 189
 190 void CDsaBase::Stop()
 191 {
 192         CDsa::Stop();
 193         iDsa->Cancel();
 194 }
 195
 196 ///////////////////////////////////////////////////////////////////////
 197
 198 NONSHARABLE_CLASS(TDsa)
 199 {
 200         public:
 201                 inline TDsa(const CDsa& aDsa) : iDsa(aDsa) {}
 202                 inline const TSize& SwSize() const { return iDsa.SwSize(); }
 203                 inline void Copy(TUint32* aTarget, const TUint8* aSrc, int aBytes, int aHeight) const;
 204         private:
 205                 const CDsa& iDsa;
 206 };
 207
 208 inline void TDsa::Copy(TUint32* aTarget, const TUint8* aSrc, int aBytes, int aHeight) const
 209 {
 210         iDsa.iCopyFunction(iDsa, aTarget, aSrc, aBytes, aHeight);
 211 }
 212
 213 template<class T, class S>
 214 void ClipCopy(const TDsa& iDsa, TUint8* aTarget,
 215                 const TUint8* aSource,
 216                 const TRect& aUpdateRect,
 217                 const TRect& aSourceRect)
 218 {
 219         const S* source = reinterpret_cast<const S*>(aSource);
 220         const int lineWidth = aSourceRect.Width();
 221
 222         source += (aUpdateRect.iTl.iY * lineWidth);
 223         const int sourceStartOffset = aUpdateRect.iTl.iX;
 224         source += sourceStartOffset;
 225
 226         T* targetPtr = reinterpret_cast<T*>(aTarget);
 227
 228         const int scanLineWidth = iDsa.SwSize().iWidth;
 229
 230         targetPtr += (aSourceRect.iTl.iY + aUpdateRect.iTl.iY ) * scanLineWidth;
 231         const int targetStartOffset = (aUpdateRect.iTl.iX + aSourceRect.iTl.iX);
 232
 233         targetPtr += targetStartOffset;
 234
 235
 236         const int height = aUpdateRect.Height();
 237
 238         const int lineMove = lineWidth;
 239         const int copyLen = aUpdateRect.Width();
 240
 241
 242         for(int i = 0; i < height; i++) //source is always smaller
 243         {
 244                 iDsa.Copy(reinterpret_cast<TUint32*>(targetPtr), reinterpret_cast<const TUint8*>(source), copyLen, height);
 245                 source += lineMove;
 246                 targetPtr += scanLineWidth; // >> 2;
 247         }
 248 }
 249
 250 /////////////////////////////////////////////////////////////////////////////////////////////////////
 251
 252 CDsa* CDsa::CreateL(RWsSession& aSession)
 253 {
 254         return new (ELeave) CBitmapSurface<CDsaBase>(aSession);
 255 }
 256
 257 void CDsa::Free()
 258 {
 259 }
 260
 261 TSize CDsa::WindowSize() const
 262 {
 263         return iSwSize;
 264 }
 265
 266 void CDsa::SetSuspend()
 267 {
 268         iStateFlags |= ESdlThreadSuspend;
 269 }
 270
 271
 272 void CDsa::SetUpdating(TBool aUpdate)
 273 {
 274         if(aUpdate)
 275                 iStateFlags |= EUpdating;
 276         else
 277                 iStateFlags &= ~EUpdating;
 278 }
 279
 280 TBool CDsa::Stopped() const
 281 {
 282         return (iStateFlags & ESdlThreadExplicitStop);
 283 }
 284
 285 CDsa::~CDsa()
 286 {
 287         delete[] iLut256;
 288 }
 289
 290 void CDsa::ConstructL(RWindow& aWindow, CWsScreenDevice& /*aDevice*/)
 291 {
 292         if(iLut256 == NULL)
 293                 iLut256 = new TUint32[256];
 294         iTargetMode = aWindow.DisplayMode();
 295         iTargetBpp = BytesPerPixel(DisplayMode());
 296         iScreenRect = TRect(aWindow.Position(), aWindow.Size());
 297         SetTargetRect();
 298         iWindow = &aWindow;
 299 }
 300
 301 void CDsa::DoBlt(CFbsBitmap& /*aBmp*/)
 302 {
 303 }
 304
 305 void CDsa::LockPalette(TBool aLock)
 306 {
 307         if(aLock)
 308                 iStateFlags |= EPaletteLocked;
 309         else
 310                 iStateFlags &= ~EPaletteLocked;
 311 }
 312
 313 int CDsa::SetPalette(int aFirst, int aCount, TUint32* aPalette)
 314 {
 315         if(iLut256 == NULL)
 316                 return KErrNotFound;
 317         if(iStateFlags & EPaletteLocked)
 318                 return KErrNone;
 319         for(int i = aFirst; i < aFirst + aCount; i++)
 320         {
 321                 iLut256[i] = aPalette[i];
 322         }
 323         return KErrNone;
 324 }
 325
 326 CDsa::CDsa(RWsSession& aSession) :
 327         iStateFlags(0),
 328         iSession(aSession)
 329
 330 {
 331         iCFTable[0] = CopyMem;
 332         iCFTable[1] = Copy256;
 333         iCFTable[2] = CopySlow;
 334 }
 335
 336 RWsSession& CDsa::Session()
 337 {
 338         return iSession;
 339 }
 340
 341 TUint8* CDsa::LockHwSurface()
 342 {
 343         if((iStateFlags & EUpdating) == 0) //else frame is skipped
 344         {
 345                 return LockSurface();
 346         }
 347         return NULL;
 348 }
 349
 350 int CDsa::AllocSurface(const TSize& aSize, TDisplayMode aMode)
 351 {
 352         iSourceMode = aMode;
 353
 354         iSourceBpp = BytesPerPixel(aMode);
 355
 356         const TSize size = WindowSize();
 357         if(aSize.iWidth > size.iWidth)
 358                 return KErrTooBig;
 359         if(aSize.iHeight > size.iHeight)
 360                 return KErrTooBig;
 361
 362         TRAPD(err, CreateSurfaceL());
 363         if(err != KErrNone)
 364                 return err;
 365
 366         SetCopyFunction();
 367
 368         return KErrNone;
 369 }
 370
 371 void CDsa::ClipCopy(TUint8* aTarget,
 372                 const TUint8* aSource,
 373                 const TRect& aUpdateRect,
 374                 const TRect& aSourceRect) const
 375 {
 376         const TDsa dsa(*this);
 377         switch(iSourceBpp)
 378         {
 379                 case 1:
 380                         ::ClipCopy<TUint32, TUint8>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);
 381                         break;
 382                 case 2:
 383                         ::ClipCopy<TUint32, TUint16>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);
 384                         break;
 385                 case 4:
 386                         ::ClipCopy<TUint32, TUint32>(dsa, aTarget, aSource, aUpdateRect, aSourceRect);
 387                         break;
 388         }
 389 }
 390
 391 void CDsa::SetCopyFunction()
 392 {
 393         //calculate offset to correct function in iCFTable according to given parameters
 394         int function = 0;
 395         const int KCopyFunctions = 1;
 396         const int KOffsetToNative = 0;
 397         const int KOffsetTo256 = KOffsetToNative + KCopyFunctions;
 398         const int KOffsetToOtherModes = KOffsetTo256 + KCopyFunctions;
 399
 400         if(iSourceMode == DisplayMode())
 401                 function = KOffsetToNative;
 402         else if(iSourceMode == EColor256)
 403                 function = KOffsetTo256;
 404         else
 405                 function = KOffsetToOtherModes;
 406
 407         iCopyFunction = iCFTable[function];
 408 }
 409
 410 inline void Rotate(TRect& aRect)
 411 {
 412         const int dx = aRect.iBr.iX - aRect.iTl.iX;
 413         const int dy = aRect.iBr.iY - aRect.iTl.iY;
 414
 415         aRect.iBr.iX = aRect.iTl.iX + dy;
 416         aRect.iBr.iY = aRect.iTl.iY + dx;
 417
 418         const int tmp = aRect.iTl.iX;
 419         aRect.iTl.iX = aRect.iTl.iY;
 420         aRect.iTl.iY = tmp;
 421 }
 422
 423 TBool CDsa::AddUpdateRect(const TUint8* aBits, const TRect& aUpdateRect, const TRect& aRect)
 424 {
 425         if(iTargetAddr == NULL)
 426         {
 427                 iTargetAddr = LockHwSurface();
 428         }
 429
 430         TUint8* target = iTargetAddr;
 431         if(target == NULL)
 432                 return EFalse;
 433
 434
 435         TRect targetRect = TRect(TPoint(0, 0), SwSize());
 436
 437         TRect sourceRect = aRect;
 438         TRect updateRect = aUpdateRect;
 439
 440         if(iSourceMode != DisplayMode() || targetRect != sourceRect || targetRect != updateRect)
 441         {
 442                 sourceRect.Intersection(targetRect); //so source always smaller or equal than target
 443                 ClipCopy(target, aBits, updateRect, sourceRect);
 444         }
 445         else
 446         {
 447                 const int byteCount = aRect.Width() * aRect.Height() * iSourceBpp; //this could be stored
 448                 Mem::Copy(target, aBits, byteCount);
 449         }
 450
 451         return ETrue;
 452 }
 453
 454 void CDsa::UpdateSwSurface()
 455 {
 456         iTargetAddr = NULL;
 457         UnlockHwSurface();      //could be faster if does not use AO, but only check status before redraw, then no context switch needed
 458 }
 459
 460 void CDsa::DoStop()
 461 {
 462         if(IsDsaAvailable())
 463                 iStateFlags |= ESdlThreadExplicitStop;
 464         Stop();
 465 }
 466
 467 void CDsa::Stop()
 468 {
 469         iStateFlags &= ~ERunning;
 470 }
 471
 472 void CDsa::Start()
 473 {
 474         iStateFlags |= ERunning;
 475
 476         iStateFlags &= ~ESdlThreadExplicitStop;
 477
 478         if(iStateFlags & ESdlThreadSuspend)
 479         {
 480                 EpocSdlEnv::Resume();
 481                 iStateFlags &= ~ ESdlThreadSuspend;
 482         }
 483         EpocSdlEnv::ObserverEvent(MSDLObserver::EEventWindowReserved);
 484 }
 485
 486 void CDsa::SetTargetRect()
 487 {
 488         iTargetRect = iScreenRect;
 489         iSwSize = iScreenRect.Size();
 490 }
 491
 492 RWindow* CDsa::Window()
 493 {
 494         return iWindow;
 495 }
 496
 497 CDsa* CDsa::CreateGlesDsaL()
 498 {
 499         CDsa* dsa = new (ELeave) CDsaGles(Session());
 500         CWsScreenDevice* dummy = NULL;
 501         dsa->ConstructL(*Window(), *dummy);
 502         Free();
 503         delete this;
 504         return dsa;
 505 }
 506
 507 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 508
 509 void CDsa::Copy256(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, int aBytes, int)
 510 {
 511         TUint32* target = aTarget;
 512         const TUint32* endt = target + aBytes;
 513         const TUint8* source = aSource;
 514         while(target < endt)
 515         {
 516                 *target++ = aDsa.iLut256[*source++];
 517         }
 518 }
 519
 520 void CDsa::CopyMem(const CDsa& /*aDsa*/, TUint32* aTarget, const TUint8* aSource, int aBytes, int)
 521 {
 522         const TUint32* src = reinterpret_cast<const TUint32*>(aSource);
 523         Mem::Copy(aTarget, src, aBytes << 2);
 524 }
 525
 526 NONSHARABLE_CLASS(MRgbCopy)
 527 {
 528         public:
 529                 virtual void Copy(TUint32* aTarget, const TUint8* aSource, int aBytes, TBool aReversed) = 0;
 530                 virtual void FlipCopy(TUint32* aTarget, const TUint8* aSource, int aBytes, int aLineLen, TBool aReversed) = 0;
 531 };
 532
 533 template <class T>
 534 NONSHARABLE_CLASS(TRgbCopy) : public MRgbCopy
 535 {
 536         public:
 537                 TRgbCopy(TDisplayMode aMode);
 538                 void* operator new(TUint aBytes, TAny* aMem);
 539                 void Copy(TUint32* aTarget, const TUint8* aSource, int aBytes, TBool aReversed);
 540                 void FlipCopy(TUint32* aTarget, const TUint8* aSource, int aBytes, int aLineLen, TBool aReversed);
 541                 static TUint32 Gray256(const TUint8& aPixel);
 542                 static TUint32 Color256(const TUint8& aPixel);
 543                 static TUint32 Color4K(const TUint16& aPixel);
 544                 static TUint32 Color64K(const TUint16& aPixel);
 545                 static TUint32 Color16M(const TUint32& aPixel);
 546                 static TUint32 Color16MU(const TUint32& aPixel);
 547                 static TUint32 Color16MA(const TUint32& aPixel);
 548         private:
 549                 typedef TUint32 (*TRgbFunc) (const T& aValue);
 550                 TRgbFunc iFunc;
 551 };
 552
 553 template <class T>
 554 void* TRgbCopy<T>::operator new(TUint /*aBytes*/, TAny* aMem)
 555 {
 556         return aMem;
 557 }
 558
 559 template <class T>
 560 TRgbCopy<T>::TRgbCopy(TDisplayMode aMode)
 561 {
 562         switch(aMode)
 563         {
 564                 case EGray256 : iFunc = (TRgbFunc) Gray256; break;
 565                 case EColor256 : iFunc =  (TRgbFunc) Color256; break;
 566                 case EColor4K : iFunc =  (TRgbFunc) Color4K; break;
 567                 case EColor64K : iFunc =  (TRgbFunc) Color64K; break;
 568                 case EColor16M : iFunc =  (TRgbFunc) Color16M; break;
 569                 case EColor16MU : iFunc =  (TRgbFunc) Color16MU; break;
 570                 case EColor16MA : iFunc =  (TRgbFunc) Color16MA; break;
 571                 default:
 572                                   PANIC(KErrNotSupported);
 573         }
 574 }
 575
 576 template <class T>
 577 void TRgbCopy<T>::Copy(TUint32* aTarget, const TUint8* aSource, int aBytes, TBool aReversed)
 578 {
 579         const T* source = reinterpret_cast<const T*>(aSource);
 580         TUint32* target = aTarget;
 581         TUint32* endt = target + aBytes;
 582
 583         if(aReversed)
 584         {
 585                 while(target < endt)
 586                 {
 587                         const T value = *source++;
 588                         *(--endt) = iFunc(value);
 589                 }
 590         }
 591         else
 592         {
 593                 while(target < endt)
 594                 {
 595                         const T value = *source++;
 596                         *target++ = iFunc(value);
 597                 }
 598         }
 599 }
 600
 601 template <class T>
 602 void TRgbCopy<T>::FlipCopy(TUint32* aTarget, const TUint8* aSource, int aBytes, int aLineLen, TBool aReversed)
 603 {
 604         const T* column = reinterpret_cast<const T*>(aSource);
 605         TUint32* target = aTarget;
 606         TUint32* endt = target + aBytes;
 607
 608         if(aReversed)
 609         {
 610                 while(target < endt)
 611                 {
 612                         *(--endt) = iFunc(*column);
 613                         column += aLineLen;
 614                 }
 615         }
 616         else
 617         {
 618                 while(target < endt)
 619                 {
 620                         *target++ = iFunc(*column);
 621                         column += aLineLen;
 622                 }
 623         }
 624 }
 625
 626 template <class T>
 627 TUint32 TRgbCopy<T>::Gray256(const TUint8& aPixel)
 628 {
 629         const TUint32 px = aPixel << 16 | aPixel << 8 | aPixel;
 630         return px;
 631 }
 632
 633 template <class T>
 634 TUint32 TRgbCopy<T>::Color256(const TUint8& aPixel)
 635 {
 636         return TRgb::Color256(aPixel).Value();
 637 }
 638
 639 template <class T>
 640 TUint32 TRgbCopy<T>::Color4K(const TUint16& aPixel)
 641 {
 642         TUint32 col = (aPixel & 0xF00) << 12;
 643         col |= (aPixel & 0xF00) << 8;
 644
 645         col |= (aPixel & 0x0F0) << 8;
 646         col |= (aPixel & 0x0F0);
 647
 648         col |= (aPixel & 0x00F) << 4;
 649         col |= (aPixel & 0x00F);
 650
 651         return col;
 652 }
 653
 654 template <class T>
 655 TUint32 TRgbCopy<T>::Color64K(const TUint16& aPixel)
 656 {
 657         TUint32 col = (aPixel & 0xF800)<< 8;
 658         col |= (aPixel & 0xE000) << 3;
 659
 660         col |= (aPixel & 0x07E0) << 5;
 661         col |= (aPixel & 0xC0) >> 1;
 662
 663         col |= (aPixel & 0x07E0) << 3;
 664         col |= (aPixel & 0x1C) >> 2;
 665
 666         return col;
 667 }
 668
 669 template <class T>
 670 TUint32 TRgbCopy<T>::Color16M(const TUint32& aPixel)
 671 {
 672         return TRgb::Color16M(aPixel).Value();
 673 }
 674
 675 template <class T>
 676 TUint32 TRgbCopy<T>::Color16MU(const TUint32& aPixel)
 677 {
 678         return TRgb::Color16MU(aPixel).Value();
 679 }
 680
 681 template <class T>
 682 TUint32 TRgbCopy<T>::Color16MA(const TUint32& aPixel)
 683 {
 684         return TRgb::Color16MA(aPixel).Value();
 685 }
 686
 687 typedef TUint64 TStackMem;
 688
 689 LOCAL_C MRgbCopy* GetCopy(TAny* mem, TDisplayMode aMode)
 690 {
 691         if(aMode == EColor256 || aMode == EGray256)
 692         {
 693                 return new (mem) TRgbCopy<TUint8>(aMode);
 694         }
 695         if(aMode == EColor4K || aMode == EColor64K)
 696         {
 697                 return new (mem) TRgbCopy<TUint16>(aMode);
 698         }
 699         if(aMode == EColor16M || aMode == EColor16MU || aMode == EColor16MA)
 700         {
 701                 return new (mem) TRgbCopy<TUint32>(aMode);
 702         }
 703         PANIC(KErrNotSupported);
 704         return NULL;
 705 }
 706
 707 void CDsa::CopySlow(const CDsa& aDsa, TUint32* aTarget, const TUint8* aSource, int aBytes, int)
 708 {
 709         TStackMem mem = 0;
 710         GetCopy(&mem, aDsa.iSourceMode)->Copy(aTarget, aSource, aBytes, EFalse);
 711 }