diff --git a/components/VideoFramePool.cpp b/components/VideoFramePool.cpp
index c2f68fc..acda536 100644
--- a/components/VideoFramePool.cpp
+++ b/components/VideoFramePool.cpp
@@ -12,6 +12,7 @@
 
 #include <android/hardware/graphics/common/1.0/types.h>
 #include <base/bind.h>
+#include <base/memory/ptr_util.h>
 #include <base/time/time.h>
 #include <log/log.h>
 
@@ -21,10 +22,21 @@
 
 namespace android {
 namespace {
+// The number of times and timeout used between subsequent calls when fetching graphic blocks.
 constexpr size_t kAllocateBufferMaxRetries = 32;
-constexpr size_t kFetchRetryDelayUs = 500;
+constexpr size_t kFetchRetryDelayUs = 1000;
 }  // namespace
 
+// static
+std::unique_ptr<VideoFramePool> VideoFramePool::Create(
+        std::shared_ptr<C2BlockPool> blockPool, const media::Size& size, HalPixelFormat pixelFormat,
+        bool isSecure, scoped_refptr<::base::SequencedTaskRunner> taskRunner) {
+    std::unique_ptr<VideoFramePool> pool = ::base::WrapUnique(new VideoFramePool(
+            std::move(blockPool), size, pixelFormat, isSecure, std::move(taskRunner)));
+    if (!pool->initialize()) return nullptr;
+    return pool;
+}
+
 VideoFramePool::VideoFramePool(std::shared_ptr<C2BlockPool> blockPool, const media::Size& size,
                                HalPixelFormat pixelFormat, bool isSecure,
                                scoped_refptr<::base::SequencedTaskRunner> taskRunner)
@@ -33,72 +45,110 @@
         mPixelFormat(pixelFormat),
         mMemoryUsage(isSecure ? C2MemoryUsage::READ_PROTECTED : C2MemoryUsage::CPU_READ,
                      static_cast<uint64_t>(BufferUsage::VIDEO_DECODER)),
-        mTaskRunner(std::move(taskRunner)) {
+        mClientTaskRunner(std::move(taskRunner)) {
     ALOGV("%s()", __func__);
-    ALOG_ASSERT(mTaskRunner->RunsTasksInCurrentSequence());
+    ALOG_ASSERT(mClientTaskRunner->RunsTasksInCurrentSequence());
     DCHECK(mBlockPool);
-    DCHECK(mTaskRunner);
+    DCHECK(mClientTaskRunner);
+}
 
-    mWeakThis = mWeakThisFactory.GetWeakPtr();
+bool VideoFramePool::initialize() {
+    if (!mFetchThread.Start()) {
+        ALOGE("Fetch thread failed to start.");
+        return false;
+    }
+    mFetchTaskRunner = mFetchThread.task_runner();
+
+    mClientWeakThis = mClientWeakThisFactory.GetWeakPtr();
+    mFetchWeakThis = mFetchWeakThisFactory.GetWeakPtr();
+
+    return true;
 }
 
 VideoFramePool::~VideoFramePool() {
     ALOGV("%s()", __func__);
-    ALOG_ASSERT(mTaskRunner->RunsTasksInCurrentSequence());
+    ALOG_ASSERT(mClientTaskRunner->RunsTasksInCurrentSequence());
 
-    mWeakThisFactory.InvalidateWeakPtrs();
+    mClientWeakThisFactory.InvalidateWeakPtrs();
+
+    if (mFetchThread.IsRunning()) {
+        mFetchTaskRunner->PostTask(FROM_HERE,
+                                   ::base::BindOnce(&VideoFramePool::destroyTask, mFetchWeakThis));
+        mFetchThread.Stop();
+    }
+}
+
+void VideoFramePool::destroyTask() {
+    ALOGV("%s()", __func__);
+    ALOG_ASSERT(mFetchTaskRunner->RunsTasksInCurrentSequence());
+
+    mFetchWeakThisFactory.InvalidateWeakPtrs();
 }
 
 void VideoFramePool::getVideoFrame(GetVideoFrameCB cb) {
     ALOGV("%s()", __func__);
-    ALOG_ASSERT(mTaskRunner->RunsTasksInCurrentSequence());
+    ALOG_ASSERT(mClientTaskRunner->RunsTasksInCurrentSequence());
 
-    bool isRunning = !mCbQueue.empty();
-    mCbQueue.push(std::move(cb));
-    if (!isRunning) tryFetchGraphicBlock();
+    ++mNumPendingRequests;
+    mFetchTaskRunner->PostTask(FROM_HERE, ::base::BindOnce(&VideoFramePool::getVideoFrameTask,
+                                                           mFetchWeakThis, std::move(cb)));
 }
 
 bool VideoFramePool::hasPendingRequests() const {
-    return !mCbQueue.empty();
+    ALOGV("%s()", __func__);
+    ALOG_ASSERT(mClientTaskRunner->RunsTasksInCurrentSequence());
+
+    return mNumPendingRequests > 0;
 }
 
-void VideoFramePool::tryFetchGraphicBlock() {
+void VideoFramePool::getVideoFrameTask(GetVideoFrameCB cb) {
     ALOGV("%s()", __func__);
-    ALOG_ASSERT(mTaskRunner->RunsTasksInCurrentSequence());
+    ALOG_ASSERT(mFetchTaskRunner->RunsTasksInCurrentSequence());
 
-    if (mCbQueue.empty()) return;
+    std::unique_ptr<VideoFrame> frame = nullptr;
 
-    std::shared_ptr<C2GraphicBlock> block;
-    auto err = mBlockPool->fetchGraphicBlock(mSize.width(), mSize.height(),
-                                             static_cast<uint32_t>(mPixelFormat), mMemoryUsage,
-                                             &block);
+    size_t numRetries = 0;
+    while (numRetries < kAllocateBufferMaxRetries) {
+        std::shared_ptr<C2GraphicBlock> block;
+        c2_status_t err = mBlockPool->fetchGraphicBlock(mSize.width(), mSize.height(),
+                                                        static_cast<uint32_t>(mPixelFormat),
+                                                        mMemoryUsage, &block);
 
-    if ((err == C2_TIMED_OUT || err == C2_BLOCKING) && mNumRetries++ < kAllocateBufferMaxRetries) {
-        ALOGD("fetchGraphicBlock() timeout. retry %zu times", mNumRetries);
-        mTaskRunner->PostDelayedTask(
-                FROM_HERE, ::base::BindOnce(&VideoFramePool::tryFetchGraphicBlock, mWeakThis),
-                ::base::TimeDelta::FromMicroseconds(kFetchRetryDelayUs));
-    } else if (err != C2_OK) {
-        ALOGE("Failed to fetch block, err=%d, retry %zu times", err, mNumRetries);
-        sendVideoFrame(nullptr);
-    } else {
-        mNumRetries = 0;
-        sendVideoFrame(VideoFrame::Create(std::move(block)));
-
-        if (!mCbQueue.empty()) {
-            mTaskRunner->PostTask(
-                    FROM_HERE, ::base::BindOnce(&VideoFramePool::tryFetchGraphicBlock, mWeakThis));
+        if (err == C2_OK) {
+            frame = VideoFrame::Create(std::move(block));
+            break;
+        } else if (err != C2_TIMED_OUT && err != C2_BLOCKING) {
+            ALOGE("Failed to fetch block, err=%d, retry %zu times", err, numRetries);
+            break;
+        } else {
+            ++numRetries;
+            ALOGD("fetchGraphicBlock() timeout. retry %zu times", numRetries);
+            usleep(kFetchRetryDelayUs);
         }
     }
+    if (numRetries == kAllocateBufferMaxRetries) {
+        ALOGE("Timeout to fetch block, retry %zu times", numRetries);
+    }
+
+    mClientTaskRunner->PostTask(
+            FROM_HERE, ::base::BindOnce(&VideoFramePool::onVideoFrameReady, mClientWeakThis,
+                                        std::move(cb), std::move(frame)));
 }
 
-void VideoFramePool::sendVideoFrame(std::unique_ptr<VideoFrame> frame) {
+void VideoFramePool::onVideoFrameReady(GetVideoFrameCB cb, std::unique_ptr<VideoFrame> frame) {
     ALOGV("%s()", __func__);
-    ALOG_ASSERT(mTaskRunner->RunsTasksInCurrentSequence());
-    ALOG_ASSERT(!mCbQueue.empty());
+    ALOG_ASSERT(mClientTaskRunner->RunsTasksInCurrentSequence());
 
-    auto cb = std::move(mCbQueue.front());
-    mCbQueue.pop();
+    --mNumPendingRequests;
+
+    if (!frame) {
+        ALOGE("Failed to get GraphicBlock, abandoning all pending requests.");
+        mClientWeakThisFactory.InvalidateWeakPtrs();
+        mClientWeakThis = mClientWeakThisFactory.GetWeakPtr();
+
+        mNumPendingRequests = 0;
+    }
+
     std::move(cb).Run(std::move(frame));
 }