src/apps/mplayerc/RealMediaWindowlessSite.cpp

   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 "mplayerc.h"
  24 #include <math.h>
  25 #include <atlbase.h>
  26 #include <atlcoll.h>
  27 #include "realmediawindowlesssite.h"
  28 #include "..\..\DSUtil\DSUtil.h"
  29
  30 void DSObjects::ExtractRects(REGION* pRegion)
  31 {
  32         LPRGNDATA lpRgnData;
  33
  34         DWORD sizeNeeed = GetRegionData((HRGN)pRegion->pOSRegion, 0, NULL);
  35
  36         lpRgnData = (LPRGNDATA)new char[sizeNeeed];
  37         DWORD returnValue = GetRegionData((HRGN)pRegion->pOSRegion, sizeNeeed, lpRgnData);
  38
  39         PN_VECTOR_DELETE(pRegion->rects);
  40
  41         pRegion->numRects               = lpRgnData->rdh.nCount;
  42         pRegion->extents.left   = lpRgnData->rdh.rcBound.left;
  43         pRegion->extents.top    = lpRgnData->rdh.rcBound.top;
  44         pRegion->extents.right  = lpRgnData->rdh.rcBound.right;
  45         pRegion->extents.bottom = lpRgnData->rdh.rcBound.bottom;
  46
  47         if(lpRgnData->rdh.nCount)
  48         {
  49                 pRegion->rects = new PNxRect[lpRgnData->rdh.nCount];
  50
  51                 // now extract the information.
  52
  53                 for(int j = 0; j < (int) lpRgnData->rdh.nCount;j++)
  54                 {
  55                         RECT* pRect = (RECT*)lpRgnData->Buffer;
  56                         pRegion->rects[j].left = pRect[j].left;
  57                         pRegion->rects[j].top = pRect[j].top;
  58                         pRegion->rects[j].right = pRect[j].right;
  59                         pRegion->rects[j].bottom = pRect[j].bottom;
  60                 }
  61         }
  62
  63         PN_VECTOR_DELETE(lpRgnData);
  64 }
  65 REGION* DSObjects::RMACreateRectRegion(int left, int top, int right, int bottom)
  66 {
  67         REGION* retVal = new REGION;
  68         retVal->pOSRegion = (void*)CreateRectRgn(left, top, right, bottom);
  69         ExtractRects(retVal);
  70         return retVal;
  71 }
  72 void DSObjects::RMASubtractRegion(REGION* regM, REGION* regS, REGION* regD)
  73 {
  74         CombineRgn((HRGN)regD->pOSRegion, (HRGN)regM->pOSRegion, (HRGN)regS->pOSRegion, RGN_DIFF);
  75         ExtractRects(regD);
  76 }
  77 void DSObjects::RMAUnionRegion(REGION* reg1, REGION* reg2, REGION* regD)
  78 {
  79         CombineRgn((HRGN)regD->pOSRegion, (HRGN)reg1->pOSRegion, (HRGN)reg2->pOSRegion, RGN_OR);
  80         ExtractRects(regD);
  81 }
  82 void DSObjects::RMAIntersectRegion(REGION* reg1, REGION* reg2, REGION* regD)
  83 {
  84         CombineRgn((HRGN)regD->pOSRegion, (HRGN)reg1->pOSRegion, (HRGN)reg2->pOSRegion, RGN_AND);
  85         ExtractRects(regD);
  86 }
  87 BOOL DSObjects::RMAEqualRegion(REGION* reg1, REGION* reg2)
  88 {
  89         return EqualRgn((HRGN)reg1->pOSRegion, (HRGN)reg2->pOSRegion)
  90                 && !memcmp(&reg1->extents, &reg2->extents, sizeof(PNxRect)) ? TRUE : FALSE;
  91 }
  92 void DSObjects::RMADestroyRegion(REGION* reg)
  93 {
  94         if(reg) DeleteObject((HRGN)reg->pOSRegion),
  95         PN_VECTOR_DELETE(reg->rects);
  96         PN_DELETE(reg);
  97 }
  98 REGION* DSObjects::RMACreateRegion()
  99 {
 100         return RMACreateRectRegion(0,0,0,0);
 101 }
 102
 103 //
 104 // CRealMediaWindowlessSite
 105 //
 106
 107 CRealMediaWindowlessSite::CRealMediaWindowlessSite(HRESULT& hr, IUnknown* pContext, CRealMediaWindowlessSite* pParentSite, IUnknown* pUnkOuter)
 108         : CUnknown(NAME("CRealMediaWindowlessSite"), pUnkOuter, &hr)
 109         , m_pContext(pContext)
 110         , m_pParentSite(pParentSite)
 111         , m_pCCF(pContext)
 112         , m_fDamaged(false), m_fInRedraw(false), m_fIsVisible(true)
 113         , m_lZOrder(0)
 114         , m_pRegion(NULL), m_pRegionWithoutChildren(NULL)
 115 {
 116         m_size.cx = m_size.cy = 0;
 117         m_position.x = m_position.y = 0;
 118
 119         memset(&m_lastBitmapInfo, 0, sizeof(m_lastBitmapInfo));
 120
 121         hr = S_OK;
 122
 123         if(!m_pContext || !m_pCCF)
 124         {
 125                 hr = E_POINTER;
 126                 return;
 127         }
 128
 129         m_pCCF->CreateInstance(CLSID_IRMAValues, (void**)&m_pValues);
 130 }
 131
 132 CRealMediaWindowlessSite::~CRealMediaWindowlessSite()
 133 {
 134         POSITION pos = m_pChildren.GetHeadPosition();
 135         while(pos) DestroyChild(m_pChildren.GetNext(pos));
 136
 137         RMADestroyRegion(m_pRegion);
 138         RMADestroyRegion(m_pRegionWithoutChildren);
 139 }
 140
 141 STDMETHODIMP CRealMediaWindowlessSite::NonDelegatingQueryInterface(REFIID riid, void** ppv)
 142 {
 143         return
 144                 QI2(IRMASite)
 145                 QI2(IRMASite2)
 146                 QI2(IRMASiteWindowless)
 147                 QI2(IRMAVideoSurface)
 148                 (m_pValues && m_pValues->QueryInterface(riid, ppv) == PNR_OK) ? PNR_OK :
 149                 CUnknown::NonDelegatingQueryInterface(riid, ppv);
 150 }
 151
 152 // public
 153
 154 void CRealMediaWindowlessSite::GetTopLeft(PNxPoint* pPoint)
 155 {
 156         pPoint->x += m_position.x;
 157         pPoint->y += m_position.y;
 158
 159         if(m_pParentSite)
 160                 m_pParentSite->GetTopLeft(pPoint);
 161 }
 162
 163 REGION* CRealMediaWindowlessSite::GetRegion()
 164 {
 165         return m_pRegion;
 166 }
 167
 168 // private
 169
 170 void CRealMediaWindowlessSite::RecomputeRegion()
 171 {
 172         if(m_pParentSite) m_pParentSite->RecomputeRegion();
 173         else InternalRecomputeRegion();
 174 }
 175
 176 void CRealMediaWindowlessSite::InternalRecomputeRegion()
 177 {
 178         ComputeRegion();
 179
 180         POSITION pos = m_pChildren.GetHeadPosition();
 181         while(pos)
 182         {
 183                 CRealMediaWindowlessSite* pSite = (CRealMediaWindowlessSite*)(IRMASite*)m_pChildren.GetNext(pos);
 184                 if(pSite) pSite->InternalRecomputeRegion();
 185         }
 186 }
 187
 188 void CRealMediaWindowlessSite::ComputeRegion()
 189 {
 190         REGION* pTempRegion = NULL;
 191
 192         if(m_pRegion)
 193         {
 194                 pTempRegion = RMACreateRegion();
 195                 RMAUnionRegion(pTempRegion, m_pRegion, pTempRegion);
 196                 RMADestroyRegion(m_pRegion);
 197         }
 198
 199         if(m_pRegionWithoutChildren)
 200         {
 201                 RMADestroyRegion(m_pRegionWithoutChildren);
 202         }
 203
 204         PNxPoint topleft = {0,0};
 205         GetTopLeft(&topleft);
 206
 207         if(IsSiteVisible())
 208         {
 209                 m_pRegionWithoutChildren = RMACreateRectRegion(topleft.x, topleft.y, topleft.x + m_size.cx, topleft.y + m_size.cy);
 210
 211                 if(m_pParentSite)
 212                 {
 213                         RMAIntersectRegion(m_pRegionWithoutChildren, m_pParentSite->m_pRegionWithoutChildren, m_pRegionWithoutChildren);
 214
 215                         POSITION pos = m_pParentSite->m_pChildren.GetHeadPosition();
 216             while(pos)
 217                         {
 218                                 CRealMediaWindowlessSite* pSiblingSite = (CRealMediaWindowlessSite*)(IRMASite*)m_pParentSite->m_pChildren.GetNext(pos);
 219                                 if(pSiblingSite != this)
 220                                 {
 221                                         INT32 zOrder;
 222                                         pSiblingSite->GetZOrder(zOrder);
 223
 224                                         if(zOrder > m_lZOrder && pSiblingSite->IsSiteVisible())
 225                                         {
 226                                                 pSiblingSite->SubtractSite(m_pRegionWithoutChildren);
 227                                         }
 228                                 }
 229                         }
 230                 }
 231
 232                 m_pRegion = RMACreateRegion();
 233                 RMAUnionRegion(m_pRegion, m_pRegionWithoutChildren, m_pRegion);
 234
 235                 POSITION pos = m_pChildren.GetHeadPosition();
 236                 while(pos)
 237                 {
 238                         CRealMediaWindowlessSite* pChildSite = (CRealMediaWindowlessSite*)(IRMASite*)m_pChildren.GetNext(pos);
 239                         if(pChildSite->IsSiteVisible()) pChildSite->SubtractSite(m_pRegion);
 240                 }
 241         }
 242         else
 243         {
 244                 m_pRegionWithoutChildren = RMACreateRectRegion(0,0,0,0);
 245                 m_pRegion = RMACreateRectRegion(0,0,0,0);
 246         }
 247
 248         if(pTempRegion && !RMAEqualRegion(m_pRegion, pTempRegion))
 249         {
 250                 ForceRedraw();
 251         }
 252
 253         RMADestroyRegion(pTempRegion);
 254 }
 255
 256 void CRealMediaWindowlessSite::SubtractSite(REGION* pRegion)
 257 {
 258         PNxPoint topLeft;
 259         memset(&topLeft, 0, sizeof(PNxPoint));
 260         GetTopLeft(&topLeft);
 261
 262         REGION* pTempRegion = RMACreateRectRegion(topLeft.x, topLeft.y, topLeft.x + m_size.cx, topLeft.y + m_size.cy);
 263
 264         RMASubtractRegion(pRegion, pTempRegion, pRegion);
 265         RMADestroyRegion(pTempRegion);
 266 }
 267
 268 void CRealMediaWindowlessSite::UpdateZOrder(CRealMediaWindowlessSite* pUpdatedChildSite, INT32 lOldZOrder, INT32 lNewZOrder)
 269 {
 270         POSITION pos = m_pChildren.GetHeadPosition();
 271         while(pos)
 272         {
 273                 CRealMediaWindowlessSite* pSite = (CRealMediaWindowlessSite*)(IRMASite*)m_pChildren.GetNext(pos);
 274
 275                 INT32 lItsOldZOrder;
 276                 pSite->GetZOrder(lItsOldZOrder);
 277
 278                 if(pSite != pUpdatedChildSite)
 279                 {
 280                         if(lOldZOrder < lNewZOrder)
 281                         {
 282                                 if(lItsOldZOrder >= lOldZOrder && lItsOldZOrder < lNewZOrder)
 283                                 {
 284                                         pSite->SetInternalZOrder(lItsOldZOrder-1);
 285                                 }
 286                         }
 287                         else
 288                         {
 289                                 if(lItsOldZOrder >= lNewZOrder && lItsOldZOrder < lOldZOrder)
 290                                 {
 291                                         pSite->SetInternalZOrder(lItsOldZOrder+1);
 292                                 }
 293                         }
 294                 }
 295                 else
 296                 {
 297                         pSite->SetInternalZOrder(lNewZOrder);
 298                 }
 299         }
 300 }
 301
 302 void CRealMediaWindowlessSite::SetInternalZOrder(INT32 lZOrder)
 303 {
 304         m_lZOrder = lZOrder;
 305 }
 306
 307 // IRMASiteWindowless
 308
 309 STDMETHODIMP CRealMediaWindowlessSite::EventOccurred(PNxEvent* /*IN*/ pEvent)
 310 {
 311         return PNR_NOTIMPL;  /* not necessary within our implementation */
 312 }
 313
 314 STDMETHODIMP_(PNxWindow*) CRealMediaWindowlessSite::GetParentWindow()
 315 {
 316         return NULL;
 317 }
 318
 319 // IRMASite
 320
 321 STDMETHODIMP CRealMediaWindowlessSite::AttachUser(IRMASiteUser* /*IN*/ pUser)
 322 {
 323         HRESULT hr = PNR_FAIL;
 324
 325         if(m_pUser) return PNR_UNEXPECTED;
 326
 327         if(CComQIPtr<IRMASite, &IID_IRMASite> pOuterSite = GetOwner())
 328                 hr = pUser->AttachSite(pOuterSite);
 329
 330         if(PNR_OK == hr)
 331                 m_pUser = pUser;
 332
 333         return hr;
 334 }
 335
 336 STDMETHODIMP CRealMediaWindowlessSite::DetachUser()
 337 {
 338         HRESULT hr = PNR_OK;
 339
 340         if(!m_pUser) return PNR_UNEXPECTED;
 341
 342         hr = m_pUser->DetachSite();
 343
 344         if(PNR_OK == hr)
 345                 m_pUser = NULL;
 346
 347         return hr;
 348 }
 349
 350 STDMETHODIMP CRealMediaWindowlessSite::GetUser(REF(IRMASiteUser*) /*OUT*/ pUser)
 351 {
 352         HRESULT hr = PNR_OK;
 353
 354         if(!m_pUser) return PNR_UNEXPECTED;
 355
 356         (pUser = m_pUser)->AddRef();
 357
 358         return hr;
 359 }
 360
 361 STDMETHODIMP CRealMediaWindowlessSite::CreateChild(REF(IRMASite*) /*OUT*/ pChildSite)
 362 {
 363         HRESULT hr = PNR_OK;
 364
 365         CComPtr<IRMASite> pSite =
 366                 (IRMASite*)new CRealMediaWindowlessSite(hr, m_pContext, this);
 367
 368         if(FAILED(hr) || !pSite)
 369                 return E_FAIL;
 370
 371         pChildSite = pSite.Detach();
 372
 373         m_pChildren.AddTail(pChildSite);
 374
 375         return hr;
 376 }
 377
 378 STDMETHODIMP CRealMediaWindowlessSite::DestroyChild(IRMASite* /*IN*/ pChildSite)
 379 {
 380         if(POSITION pos = m_pChildren.Find(pChildSite))
 381         {
 382                 m_pChildren.RemoveAt(pos);
 383                 return PNR_OK;
 384         }
 385
 386         return PNR_UNEXPECTED;
 387 }
 388
 389 STDMETHODIMP CRealMediaWindowlessSite::AttachWatcher(IRMASiteWatcher* /*IN*/ pWatcher)
 390 {
 391         if(m_pWatcher) return PNR_UNEXPECTED;
 392
 393         if(m_pWatcher = pWatcher)
 394                 m_pWatcher->AttachSite((IRMASite*)this);
 395
 396         return PNR_OK;
 397 }
 398
 399 STDMETHODIMP CRealMediaWindowlessSite::DetachWatcher()
 400 {
 401         if(!m_pWatcher) return PNR_UNEXPECTED;
 402
 403         m_pWatcher->DetachSite();
 404         m_pWatcher = NULL;
 405
 406         return PNR_OK;
 407 }
 408
 409 STDMETHODIMP CRealMediaWindowlessSite::SetPosition(PNxPoint position)
 410 {
 411         HRESULT hr = PNR_OK;
 412
 413         if(m_pWatcher)
 414         {
 415                 hr = m_pWatcher->ChangingPosition(m_position, position);
 416         }
 417
 418         if(PNR_OK == hr)
 419         {
 420                 m_position = position;
 421
 422                 POSITION pos = m_pPassiveWatchers.GetHeadPosition();
 423                 while(pos) m_pPassiveWatchers.GetNext(pos)->PositionChanged(&position);
 424
 425                 RecomputeRegion();
 426         }
 427
 428         return hr;
 429 }
 430
 431 STDMETHODIMP CRealMediaWindowlessSite::GetPosition(REF(PNxPoint) position)
 432 {
 433         position = m_position;
 434         return PNR_OK;
 435 }
 436
 437 STDMETHODIMP CRealMediaWindowlessSite::SetSize(PNxSize size)
 438 {
 439         HRESULT hr = PNR_OK;
 440
 441         if(m_pWatcher)
 442         {
 443                 hr = m_pWatcher->ChangingSize(m_size, size);
 444         }
 445
 446         if(PNR_OK == hr && size.cx != 0 && size.cy != 0)
 447         {
 448                 m_size = size;
 449
 450                 POSITION pos = m_pPassiveWatchers.GetHeadPosition();
 451                 while(pos) m_pPassiveWatchers.GetNext(pos)->SizeChanged(&size);
 452
 453                 RecomputeRegion();
 454         }
 455
 456         return hr;
 457 }
 458
 459 STDMETHODIMP CRealMediaWindowlessSite::GetSize(REF(PNxSize) size)
 460 {
 461         size = m_size;
 462         return PNR_OK;
 463 }
 464
 465 STDMETHODIMP CRealMediaWindowlessSite::DamageRect(PNxRect rect)
 466 {
 467         m_fDamaged = TRUE;
 468         return PNR_OK;
 469 }
 470
 471 STDMETHODIMP CRealMediaWindowlessSite::DamageRegion(PNxRegion region)
 472 {
 473         m_fDamaged = TRUE;
 474         return PNR_OK;
 475 }
 476
 477 STDMETHODIMP CRealMediaWindowlessSite::ForceRedraw()
 478 {
 479         // make sure we have a visible window and are not re-enterering and we have damage
 480         if(!m_fInRedraw && m_fDamaged && m_fIsVisible)
 481         {
 482                 m_fInRedraw = TRUE;
 483
 484                 PNxEvent event = {RMA_SURFACE_UPDATE, NULL, (IRMAVideoSurface*)this, NULL, 0, 0};
 485                 m_pUser->HandleEvent(&event);
 486
 487                 m_fInRedraw = FALSE;
 488                 m_fDamaged = FALSE;
 489         }
 490
 491         return PNR_OK;
 492 }
 493
 494 // IRMASite2
 495
 496 STDMETHODIMP CRealMediaWindowlessSite::UpdateSiteWindow(PNxWindow* /*IN*/ pWindow)
 497 {
 498         return PNR_OK;
 499 }
 500
 501 STDMETHODIMP CRealMediaWindowlessSite::ShowSite(BOOL bShow)
 502 {
 503         m_fIsVisible = !!bShow;
 504         RecomputeRegion();
 505         return PNR_OK;
 506 }
 507
 508 STDMETHODIMP_(BOOL) CRealMediaWindowlessSite::IsSiteVisible()
 509 {
 510         BOOL fIsVisible = m_fIsVisible;
 511         if(m_pParentSite) fIsVisible = fIsVisible && m_pParentSite->IsSiteVisible();
 512         return fIsVisible;
 513 }
 514
 515 STDMETHODIMP CRealMediaWindowlessSite::SetZOrder(INT32 lZOrder)
 516 {
 517         if(!m_pParentSite) return PNR_UNEXPECTED;
 518
 519         if(lZOrder == -1 || lZOrder >= (INT32)m_pParentSite->GetNumberOfChildSites())
 520                 lZOrder = m_pParentSite->GetNumberOfChildSites() - 1;
 521
 522         if(m_lZOrder != lZOrder)
 523                 m_pParentSite->UpdateZOrder(this, m_lZOrder, lZOrder);
 524
 525         m_lZOrder = lZOrder;
 526
 527         return PNR_OK;
 528 }
 529
 530 STDMETHODIMP CRealMediaWindowlessSite::GetZOrder(REF(INT32) lZOrder)
 531 {
 532         if(!m_pParentSite) return PNR_UNEXPECTED;
 533         lZOrder = m_lZOrder;
 534         return PNR_OK;
 535 }
 536
 537 STDMETHODIMP CRealMediaWindowlessSite::MoveSiteToTop()
 538 {
 539         if(!m_pParentSite) return PNR_UNEXPECTED;
 540         return PNR_NOTIMPL;
 541 }
 542
 543 STDMETHODIMP CRealMediaWindowlessSite::GetVideoSurface(REF(IRMAVideoSurface*) pSurface)
 544 {
 545         (pSurface = (IRMAVideoSurface*)this)->AddRef();
 546         return PNR_OK;
 547 }
 548
 549 STDMETHODIMP_(UINT32) CRealMediaWindowlessSite::GetNumberOfChildSites()
 550 {
 551         return (UINT32)m_pChildren.GetCount();
 552 }
 553
 554 STDMETHODIMP CRealMediaWindowlessSite::AddPassiveSiteWatcher(IRMAPassiveSiteWatcher* pWatcher)
 555 {
 556         m_pPassiveWatchers.AddTail(pWatcher);
 557         return PNR_OK;
 558 }
 559
 560 STDMETHODIMP CRealMediaWindowlessSite::RemovePassiveSiteWatcher(IRMAPassiveSiteWatcher* pWatcher)
 561 {
 562         if(POSITION pos = m_pPassiveWatchers.Find(pWatcher))
 563         {
 564                 m_pPassiveWatchers.RemoveAt(pos);
 565                 return PNR_OK;
 566         }
 567
 568         return PNR_UNEXPECTED;
 569 }
 570
 571 STDMETHODIMP CRealMediaWindowlessSite::SetCursor(PNxCursor cursor, REF(PNxCursor) oldCursor)
 572 {
 573         return PNR_NOTIMPL;
 574 }
 575
 576 // private
 577
 578 void CRealMediaWindowlessSite::IntersectRect(PNxRect* pRect, PNxRect* pBox, PNxRect* pRetVal)
 579 {
 580         pRetVal->left   = max(pRect->left, pBox->left);
 581         pRetVal->top    = max(pRect->top, pBox->top);
 582         pRetVal->right  = min(pRect->right, pBox->right);
 583         pRetVal->bottom = min(pRect->bottom, pBox->bottom);
 584 }
 585
 586 // protected
 587
 588 bool CRealMediaWindowlessSite::GetBltService(IRMAVideoSurface** ppBltService)
 589 {
 590         bool fRet = false;
 591
 592         if(ppBltService)
 593         {
 594                 if(m_pParentSite)
 595                 {
 596                         fRet = m_pParentSite->GetBltService(ppBltService);
 597             }
 598             else if(m_pBltService)
 599                 {
 600                         (*ppBltService = m_pBltService)->AddRef();
 601                         fRet = true;
 602                 }
 603         }
 604
 605         return(fRet);
 606 }
 607
 608 void CRealMediaWindowlessSite::SetBltService(IRMAVideoSurface* pBltService)
 609 {
 610         m_pBltService = pBltService;
 611 }
 612
 613 // IRMAVideoSurface
 614
 615 STDMETHODIMP CRealMediaWindowlessSite::Blt(UCHAR*       /*IN*/ pImageData, RMABitmapInfoHeader* /*IN*/ pBitmapInfo, REF(PNxRect) /*IN*/ inDestRect, REF(PNxRect) /*IN*/ inSrcRect)
 616 {
 617         BeginOptimizedBlt(pBitmapInfo);
 618         return OptimizedBlt(pImageData, inDestRect, inSrcRect);
 619 }
 620
 621 STDMETHODIMP CRealMediaWindowlessSite::BeginOptimizedBlt(RMABitmapInfoHeader* /*IN*/ pBitmapInfo)
 622 {
 623         if(memcmp(&m_bitmapInfo, pBitmapInfo, sizeof(RMABitmapInfoHeader)))
 624         {
 625                 memcpy(&m_bitmapInfo, pBitmapInfo, sizeof(RMABitmapInfoHeader));
 626
 627         // format of image has changed somehow.
 628                 // do something here if this affects you.
 629         }
 630
 631 /*
 632         CComPtr<IRMAVideoSurface> pBltService;
 633         GetBltService(&pBltService);
 634         if(!pBltService)
 635                 return PNR_UNEXPECTED;
 636
 637         RMA_COMPRESSION_TYPE ulType = (RMA_COMPRESSION_TYPE)-1;
 638         pBltService->GetPreferredFormat(ulType);
 639
 640         if(pBitmapInfo->biCompression != ulType)
 641                 return PNR_UNEXPECTED;
 642 */
 643         return PNR_OK;
 644 }
 645
 646 STDMETHODIMP CRealMediaWindowlessSite::OptimizedBlt(UCHAR* /*IN*/ pImageBits, REF(PNxRect) /*IN*/ rDestRect, REF(PNxRect) /*IN*/ rSrcRect)
 647 {
 648         CComPtr<IRMAVideoSurface> pBltService;
 649         GetBltService(&pBltService);
 650
 651         REGION* pRegion = GetRegion();
 652
 653         if(!pBltService || !pRegion)
 654                 return PNR_UNEXPECTED;
 655
 656         PNxPoint origin;
 657         memset(&origin, 0, sizeof(PNxPoint));
 658         GetTopLeft(&origin);
 659         PNxRect adjustedDestRect;
 660         adjustedDestRect.left   = rDestRect.left + origin.x;
 661         adjustedDestRect.top    = rDestRect.top + origin.y;
 662         adjustedDestRect.right  = rDestRect.right + origin.x;
 663         adjustedDestRect.bottom = rDestRect.bottom + origin.y;
 664
 665         for(int i = 0; i < pRegion->numRects; i++)
 666         {
 667                 PNxRect* pRect = pRegion->rects+i;
 668
 669                 // intersect the dest rect with the rect from the
 670                 // region to get the final dest rect.
 671                 PNxRect finalDestRect;
 672                 IntersectRect(&adjustedDestRect, pRect, &finalDestRect);
 673
 674         // now compute the src rect for this blt.
 675                 double xStretch = (double) (rDestRect.right - rDestRect.left) / (double) (rSrcRect.right - rSrcRect.left);
 676                 double yStretch = (double) (rDestRect.bottom - rDestRect.top) / (double) (rSrcRect.bottom - rSrcRect.top);
 677
 678                 PNxRect finalSrcRect;
 679                 finalSrcRect.left   = (INT32)((double)(finalDestRect.left-origin.x) / xStretch + 0.5);
 680                 finalSrcRect.top    = (INT32)((double)(finalDestRect.top-origin.y)      / yStretch + 0.5);
 681                 finalSrcRect.right  = (INT32)((double)(finalDestRect.right-origin.x) / xStretch + 0.5);
 682                 finalSrcRect.bottom = (INT32)((double)(finalDestRect.bottom-origin.y) / yStretch + 0.5);
 683
 684                 pBltService->Blt(pImageBits, &m_bitmapInfo, finalDestRect, finalSrcRect);
 685         }
 686
 687         return PNR_OK;
 688 }
 689
 690 STDMETHODIMP CRealMediaWindowlessSite::EndOptimizedBlt()
 691 {
 692         memset(&m_bitmapInfo, 0, sizeof(m_bitmapInfo));
 693         return PNR_OK;
 694 }
 695
 696 STDMETHODIMP CRealMediaWindowlessSite::GetOptimizedFormat(REF(RMA_COMPRESSION_TYPE) /*OUT*/ ulType)
 697 {
 698         ulType =  m_bitmapInfo.biCompression;
 699         return PNR_OK;
 700 }
 701
 702 STDMETHODIMP CRealMediaWindowlessSite::GetPreferredFormat(REF(RMA_COMPRESSION_TYPE) /*OUT*/ ulType)
 703 {
 704         CComPtr<IRMAVideoSurface> pBltService;
 705         GetBltService(&pBltService);
 706         if(!pBltService)
 707                 return PNR_UNEXPECTED;
 708
 709         return pBltService->GetPreferredFormat(ulType);
 710 }