gfx/gl/SurfaceStream.cpp

   1 /* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40; -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "SurfaceStream.h"
   7
   8 #include "gfxPoint.h"
   9 #include "SharedSurface.h"
  10 #include "SharedSurfaceGL.h"
  11 #include "GeckoProfiler.h"
  12 #include "mozilla/Move.h"
  13
  14 namespace mozilla {
  15 namespace gl {
  16
  17 SurfaceStreamType
  18 SurfaceStream::ChooseGLStreamType(SurfaceStream::OMTC omtc,
  19                                   bool preserveBuffer)
  20 {
  21     if (omtc == SurfaceStream::OffMainThread) {
  22         if (preserveBuffer)
  23             return SurfaceStreamType::TripleBuffer_Copy;
  24         else
  25             return SurfaceStreamType::TripleBuffer_Async;
  26     } else {
  27         if (preserveBuffer)
  28             return SurfaceStreamType::SingleBuffer;
  29         else
  30             return SurfaceStreamType::TripleBuffer;
  31     }
  32 }
  33
  34 TemporaryRef<SurfaceStream>
  35 SurfaceStream::CreateForType(SurfaceStreamType type, mozilla::gl::GLContext* glContext, SurfaceStream* prevStream)
  36 {
  37     RefPtr<SurfaceStream> result;
  38
  39     switch (type) {
  40         case SurfaceStreamType::SingleBuffer:
  41             result = new SurfaceStream_SingleBuffer(prevStream);
  42             break;
  43         case SurfaceStreamType::TripleBuffer_Copy:
  44             result = new SurfaceStream_TripleBuffer_Copy(prevStream);
  45             break;
  46         case SurfaceStreamType::TripleBuffer_Async:
  47             result = new SurfaceStream_TripleBuffer_Async(prevStream);
  48             break;
  49         case SurfaceStreamType::TripleBuffer:
  50             result = new SurfaceStream_TripleBuffer(prevStream);
  51             break;
  52         default:
  53             MOZ_CRASH("Invalid Type.");
  54     }
  55
  56     result->mGLContext = glContext;
  57
  58     return result.forget();
  59 }
  60
  61 bool
  62 SurfaceStream_TripleBuffer::CopySurfaceToProducer(SharedSurface* src, SurfaceFactory* factory)
  63 {
  64     if (!mProducer) {
  65         New(factory, src->mSize, &mProducer);
  66         if (!mProducer) {
  67             return false;
  68         }
  69     }
  70
  71     MOZ_ASSERT(src->mSize == mProducer->mSize, "Size mismatch");
  72
  73     SharedSurface::ProdCopy(src, mProducer.get(), factory);
  74     return true;
  75 }
  76
  77 void
  78 SurfaceStream::New(SurfaceFactory* factory, const gfx::IntSize& size,
  79                    UniquePtr<SharedSurface>* surfSlot)
  80 {
  81     MOZ_ASSERT(surfSlot);
  82     UniquePtr<SharedSurface>& surf = *surfSlot;
  83
  84     MOZ_ASSERT(!surf);
  85     surf = factory->NewSharedSurface(size);
  86
  87     if (surf) {
  88         // Before next use, wait until SharedSurface's buffer
  89         // is no longer being used.
  90         surf->WaitForBufferOwnership();
  91 #ifdef DEBUG
  92         mSurfaces.insert(surf.get());
  93 #endif
  94     }
  95 }
  96
  97 void
  98 SurfaceStream::MoveTo(UniquePtr<SharedSurface>* slotFrom,
  99                       UniquePtr<SharedSurface>* slotTo)
 100 {
 101     MOZ_ASSERT(slotFrom);
 102     UniquePtr<SharedSurface>& from = *slotFrom;
 103
 104     MOZ_ASSERT(slotTo);
 105     UniquePtr<SharedSurface>& to = *slotTo;
 106
 107     MOZ_ASSERT(!to);
 108     to = Move(from);
 109     MOZ_ASSERT(!from);
 110 }
 111
 112 void
 113 SurfaceStream::Recycle(SurfaceFactory* factory, UniquePtr<SharedSurface>* surfSlot)
 114 {
 115     MOZ_ASSERT(surfSlot);
 116     UniquePtr<SharedSurface>& surf = *surfSlot;
 117
 118     if (surf) {
 119 #ifdef DEBUG
 120         mSurfaces.erase(surf.get());
 121 #endif
 122         factory->Recycle(Move(surf));
 123     }
 124     MOZ_ASSERT(!surf);
 125 }
 126
 127 void
 128 SurfaceStream::Delete(UniquePtr<SharedSurface>* surfSlot)
 129 {
 130     MOZ_ASSERT(surfSlot);
 131     UniquePtr<SharedSurface>& surf = *surfSlot;
 132
 133     if (surf) {
 134 #ifdef DEBUG
 135         mSurfaces.erase(surf.get());
 136 #endif
 137         surf = nullptr;
 138     }
 139     MOZ_ASSERT(!surf);
 140 }
 141
 142 UniquePtr<SharedSurface>
 143 SurfaceStream::Surrender(UniquePtr<SharedSurface>* surfSlot)
 144 {
 145     MOZ_ASSERT(surfSlot);
 146     UniquePtr<SharedSurface>& surf = *surfSlot;
 147
 148 #ifdef DEBUG
 149     if (surf) {
 150         mSurfaces.erase(surf.get());
 151     }
 152 #endif
 153
 154     UniquePtr<SharedSurface> ret = Move(surf);
 155     MOZ_ASSERT(!surf);
 156
 157     return Move(ret);
 158 }
 159
 160 // Move `surfSlot` to `return`, but record that the surf is now part of
 161 // this stream.
 162 UniquePtr<SharedSurface>
 163 SurfaceStream::Absorb(UniquePtr<SharedSurface>* surfSlot)
 164 {
 165     MOZ_ASSERT(surfSlot);
 166     UniquePtr<SharedSurface>& surf = *surfSlot;
 167
 168 #ifdef DEBUG
 169     if (surf) {
 170         mSurfaces.insert(surf.get());
 171     }
 172 #endif
 173
 174     UniquePtr<SharedSurface> ret = Move(surf);
 175     MOZ_ASSERT(!surf);
 176
 177     return Move(ret);
 178 }
 179
 180 void
 181 SurfaceStream::Scrap(UniquePtr<SharedSurface>* surfSlot)
 182 {
 183     MOZ_ASSERT(surfSlot);
 184     UniquePtr<SharedSurface>& surf = *surfSlot;
 185
 186     if (surf) {
 187         mScraps.Push(Move(surf));
 188     }
 189     MOZ_ASSERT(!surf);
 190
 191 }
 192
 193 void
 194 SurfaceStream::RecycleScraps(SurfaceFactory* factory)
 195 {
 196     while (!mScraps.Empty()) {
 197         UniquePtr<SharedSurface> cur = mScraps.Pop();
 198
 199         Recycle(factory, &cur);
 200     }
 201 }
 202
 203 ////////////////////////////////////////////////////////////////////////
 204 // SurfaceStream
 205
 206 SurfaceStream::SurfaceStream(SurfaceStreamType type,
 207                              SurfaceStream* prevStream)
 208     : mType(type)
 209     , mProducer(nullptr)
 210     , mMonitor("SurfaceStream monitor")
 211     , mIsAlive(true)
 212 {
 213     MOZ_ASSERT(!prevStream || mType != prevStream->mType,
 214                "We should not need to create a SurfaceStream from another "
 215                "of the same type.");
 216 }
 217
 218 SurfaceStream::~SurfaceStream()
 219 {
 220     Delete(&mProducer);
 221
 222     while (!mScraps.Empty()) {
 223         UniquePtr<SharedSurface> cur = mScraps.Pop();
 224
 225         Delete(&cur);
 226     }
 227
 228     MOZ_ASSERT(mSurfaces.empty());
 229 }
 230
 231 SharedSurface*
 232 SurfaceStream::SwapConsumer()
 233 {
 234     MOZ_ASSERT(mIsAlive);
 235
 236     SharedSurface* ret = SwapConsumer_NoWait();
 237     if (!ret)
 238         return nullptr;
 239
 240     if (!ret->WaitSync()) {
 241         return nullptr;
 242     }
 243
 244     return ret;
 245 }
 246
 247 SharedSurface*
 248 SurfaceStream::Resize(SurfaceFactory* factory, const gfx::IntSize& size)
 249 {
 250     MonitorAutoLock lock(mMonitor);
 251
 252     if (mProducer) {
 253         Scrap(&mProducer);
 254     }
 255
 256     New(factory, size, &mProducer);
 257     return mProducer.get();
 258 }
 259
 260 ////////////////////////////////////////////////////////////////////////
 261 // SurfaceStream_SingleBuffer
 262
 263 SurfaceStream_SingleBuffer::SurfaceStream_SingleBuffer(SurfaceStream* prevStream)
 264     : SurfaceStream(SurfaceStreamType::SingleBuffer, prevStream)
 265     , mConsumer(nullptr)
 266 {
 267     if (!prevStream)
 268         return;
 269
 270     UniquePtr<SharedSurface> prevProducer;
 271     UniquePtr<SharedSurface> prevConsumer;
 272     prevStream->SurrenderSurfaces(&prevProducer, &prevConsumer);
 273
 274     mProducer = Absorb(&prevProducer);
 275     mConsumer = Absorb(&prevConsumer);
 276 }
 277
 278 SurfaceStream_SingleBuffer::~SurfaceStream_SingleBuffer()
 279 {
 280     Delete(&mConsumer);
 281 }
 282
 283 void
 284 SurfaceStream_SingleBuffer::SurrenderSurfaces(UniquePtr<SharedSurface>* out_producer,
 285                                               UniquePtr<SharedSurface>* out_consumer)
 286 {
 287     MOZ_ASSERT(out_producer);
 288     MOZ_ASSERT(out_consumer);
 289
 290     mIsAlive = false;
 291
 292     *out_producer = Surrender(&mProducer);
 293     *out_consumer = Surrender(&mConsumer);
 294 }
 295
 296 SharedSurface*
 297 SurfaceStream_SingleBuffer::SwapProducer(SurfaceFactory* factory,
 298                                          const gfx::IntSize& size)
 299 {
 300     MonitorAutoLock lock(mMonitor);
 301     if (mConsumer) {
 302         Recycle(factory, &mConsumer);
 303     }
 304
 305     if (mProducer) {
 306         // Fence now, before we start (maybe) juggling Prod around.
 307         mProducer->Fence();
 308
 309         // Size mismatch means we need to squirrel the current Prod
 310         // into Cons, and leave Prod empty, so it gets a new surface below.
 311         bool needsNewBuffer = mProducer->mSize != size;
 312
 313         // Even if we're the right size, if the type has changed, and we don't
 314         // need to preserve, we should switch out for (presumedly) better perf.
 315         if (mProducer->mType != factory->mType &&
 316             !factory->mCaps.preserve)
 317         {
 318             needsNewBuffer = true;
 319         }
 320
 321         if (needsNewBuffer) {
 322             MoveTo(&mProducer, &mConsumer);
 323         }
 324     }
 325
 326     // The old Prod (if there every was one) was invalid,
 327     // so we need a new one.
 328     if (!mProducer) {
 329         New(factory, size, &mProducer);
 330     }
 331
 332     return mProducer.get();
 333 }
 334
 335 SharedSurface*
 336 SurfaceStream_SingleBuffer::SwapConsumer_NoWait()
 337 {
 338     MonitorAutoLock lock(mMonitor);
 339
 340     // Use Cons, if present.
 341     // Otherwise, just use Prod directly.
 342     SharedSurface* toConsume = mConsumer.get();
 343     if (!toConsume)
 344         toConsume = mProducer.get();
 345
 346     return toConsume;
 347 }
 348
 349 ////////////////////////////////////////////////////////////////////////
 350 // SurfaceStream_TripleBuffer_Copy
 351
 352 SurfaceStream_TripleBuffer_Copy::SurfaceStream_TripleBuffer_Copy(SurfaceStream* prevStream)
 353     : SurfaceStream(SurfaceStreamType::TripleBuffer_Copy, prevStream)
 354     , mStaging(nullptr)
 355     , mConsumer(nullptr)
 356 {
 357     if (!prevStream)
 358         return;
 359
 360     UniquePtr<SharedSurface> prevProducer;
 361     UniquePtr<SharedSurface> prevConsumer;
 362     prevStream->SurrenderSurfaces(&prevProducer, &prevConsumer);
 363
 364     mProducer = Absorb(&prevProducer);
 365     mConsumer = Absorb(&prevConsumer);
 366 }
 367
 368 SurfaceStream_TripleBuffer_Copy::~SurfaceStream_TripleBuffer_Copy()
 369 {
 370     Delete(&mStaging);
 371     Delete(&mConsumer);
 372 }
 373
 374 void
 375 SurfaceStream_TripleBuffer_Copy::SurrenderSurfaces(UniquePtr<SharedSurface>* out_producer,
 376                                                    UniquePtr<SharedSurface>* out_consumer)
 377 {
 378     MOZ_ASSERT(out_producer);
 379     MOZ_ASSERT(out_consumer);
 380
 381     mIsAlive = false;
 382
 383     *out_producer = Surrender(&mProducer);
 384     *out_consumer = Surrender(&mConsumer);
 385
 386     if (!*out_consumer)
 387         *out_consumer = Surrender(&mStaging);
 388 }
 389
 390 SharedSurface*
 391 SurfaceStream_TripleBuffer_Copy::SwapProducer(SurfaceFactory* factory,
 392                                               const gfx::IntSize& size)
 393 {
 394     MonitorAutoLock lock(mMonitor);
 395
 396     RecycleScraps(factory);
 397     if (mProducer) {
 398         if (mStaging) {
 399             // We'll re-use this for a new mProducer later on if
 400             // the size remains the same
 401             Recycle(factory, &mStaging);
 402         }
 403
 404         MoveTo(&mProducer, &mStaging);
 405         mStaging->Fence();
 406
 407         New(factory, size, &mProducer);
 408
 409         if (mProducer &&
 410             mStaging->mSize == mProducer->mSize)
 411         {
 412             SharedSurface::ProdCopy(mStaging.get(), mProducer.get(), factory);
 413         }
 414     } else {
 415         New(factory, size, &mProducer);
 416     }
 417
 418     return mProducer.get();
 419 }
 420
 421 SharedSurface*
 422 SurfaceStream_TripleBuffer_Copy::SwapConsumer_NoWait()
 423 {
 424     MonitorAutoLock lock(mMonitor);
 425
 426     if (mStaging) {
 427         Scrap(&mConsumer);
 428         MoveTo(&mStaging, &mConsumer);
 429     }
 430
 431     return mConsumer.get();
 432 }
 433
 434 ////////////////////////////////////////////////////////////////////////
 435 // SurfaceStream_TripleBuffer
 436
 437 void SurfaceStream_TripleBuffer::Init(SurfaceStream* prevStream)
 438 {
 439     if (!prevStream)
 440         return;
 441
 442     UniquePtr<SharedSurface> prevProducer;
 443     UniquePtr<SharedSurface> prevConsumer;
 444     prevStream->SurrenderSurfaces(&prevProducer, &prevConsumer);
 445
 446     mProducer = Absorb(&prevProducer);
 447     mConsumer = Absorb(&prevConsumer);
 448 }
 449
 450 SurfaceStream_TripleBuffer::SurfaceStream_TripleBuffer(SurfaceStreamType type,
 451                                                        SurfaceStream* prevStream)
 452     : SurfaceStream(type, prevStream)
 453     , mStaging(nullptr)
 454     , mConsumer(nullptr)
 455 {
 456     SurfaceStream_TripleBuffer::Init(prevStream);
 457 }
 458
 459 SurfaceStream_TripleBuffer::SurfaceStream_TripleBuffer(SurfaceStream* prevStream)
 460     : SurfaceStream(SurfaceStreamType::TripleBuffer, prevStream)
 461     , mStaging(nullptr)
 462     , mConsumer(nullptr)
 463 {
 464     SurfaceStream_TripleBuffer::Init(prevStream);
 465 }
 466
 467 SurfaceStream_TripleBuffer::~SurfaceStream_TripleBuffer()
 468 {
 469     Delete(&mStaging);
 470     Delete(&mConsumer);
 471 }
 472
 473 void
 474 SurfaceStream_TripleBuffer::SurrenderSurfaces(UniquePtr<SharedSurface>* out_producer,
 475                                               UniquePtr<SharedSurface>* out_consumer)
 476 {
 477     MOZ_ASSERT(out_producer);
 478     MOZ_ASSERT(out_consumer);
 479
 480     mIsAlive = false;
 481
 482     *out_producer = Surrender(&mProducer);
 483     *out_consumer = Surrender(&mConsumer);
 484
 485     if (!*out_consumer)
 486         *out_consumer = Surrender(&mStaging);
 487 }
 488
 489 SharedSurface*
 490 SurfaceStream_TripleBuffer::SwapProducer(SurfaceFactory* factory,
 491                                          const gfx::IntSize& size)
 492 {
 493     PROFILER_LABEL("SurfaceStream_TripleBuffer", "SwapProducer",
 494                    js::ProfileEntry::Category::GRAPHICS);
 495
 496     MonitorAutoLock lock(mMonitor);
 497     if (mProducer) {
 498         RecycleScraps(factory);
 499
 500         // If WaitForCompositor succeeds, mStaging has moved to mConsumer.
 501         // If it failed, we might have to scrap it.
 502         if (mStaging) {
 503             WaitForCompositor();
 504         }
 505         if (mStaging) {
 506             Scrap(&mStaging);
 507         }
 508
 509         MoveTo(&mProducer, &mStaging);
 510         mStaging->Fence();
 511     }
 512
 513     MOZ_ASSERT(!mProducer);
 514     New(factory, size, &mProducer);
 515
 516     return mProducer.get();
 517 }
 518
 519 SharedSurface*
 520 SurfaceStream_TripleBuffer::SwapConsumer_NoWait()
 521 {
 522     MonitorAutoLock lock(mMonitor);
 523     if (mStaging) {
 524         Scrap(&mConsumer);
 525         MoveTo(&mStaging, &mConsumer);
 526         mMonitor.NotifyAll();
 527     }
 528
 529     return mConsumer.get();
 530 }
 531
 532 ////////////////////////////////////////////////////////////////////////
 533 // SurfaceStream_TripleBuffer_Async
 534
 535 SurfaceStream_TripleBuffer_Async::SurfaceStream_TripleBuffer_Async(SurfaceStream* prevStream)
 536     : SurfaceStream_TripleBuffer(SurfaceStreamType::TripleBuffer_Async,
 537                                  prevStream)
 538 {
 539 }
 540
 541 SurfaceStream_TripleBuffer_Async::~SurfaceStream_TripleBuffer_Async()
 542 {
 543 }
 544
 545 void
 546 SurfaceStream_TripleBuffer_Async::WaitForCompositor()
 547 {
 548     PROFILER_LABEL("SurfaceStream_TripleBuffer_Async",
 549                    "WaitForCompositor",
 550                    js::ProfileEntry::Category::GRAPHICS);
 551
 552     // If we haven't be notified within 100ms, then
 553     // something must have happened and it will never arrive.
 554     // Bail out to avoid deadlocking.
 555     mMonitor.Wait(PR_MillisecondsToInterval(100));
 556 }
 557
 558 } /* namespace gfx */
 559 } /* namespace mozilla */