diff --git a/codec2/hidl/1.0/utils/Component.cpp b/codec2/hidl/1.0/utils/Component.cpp
index f109d44..8f04e55 100644
--- a/codec2/hidl/1.0/utils/Component.cpp
+++ b/codec2/hidl/1.0/utils/Component.cpp
@@ -162,9 +162,9 @@
             Return<void> transStatus = listener->onWorkDone(workBundle);
             if (!transStatus.isOk()) {
                 ALOGE("onWorkDone -- transaction failed.");
+                return;
             }
-
-            // Finish buffer transfers: nothing else to do
+            yieldBufferQueueBlocks(c2workItems, true);
         }
     }
 
@@ -220,11 +220,11 @@
 
     Status res = static_cast<Status>(c2res);
     if (c2res == C2_OK) {
-        // TODO: Connect with bufferpool API for buffer transfers
         ALOGV("flush -- converting output");
         res = objcpy(&flushedWorkBundle, c2flushedWorks, &mBufferPoolSender);
     }
     _hidl_cb(res, flushedWorkBundle);
+    yieldBufferQueueBlocks(c2flushedWorks, true);
     return Void();
 }
 
diff --git a/codec2/hidl/1.0/utils/include/codec2/hidl/1.0/Component.h b/codec2/hidl/1.0/utils/include/codec2/hidl/1.0/Component.h
index 534d342..a6e4333 100644
--- a/codec2/hidl/1.0/utils/include/codec2/hidl/1.0/Component.h
+++ b/codec2/hidl/1.0/utils/include/codec2/hidl/1.0/Component.h
@@ -78,7 +78,7 @@
     typedef ::android::hardware::graphics::bufferqueue::V1_0::
             IGraphicBufferProducer HGraphicBufferProducer;
 
-    // Methods from gIComponent follow.
+    // Methods from IComponent follow.
     virtual Return<Status> queue(const WorkBundle& workBundle) override;
     virtual Return<void> flush(flush_cb _hidl_cb) override;
     virtual Return<Status> drain(bool withEos) override;
diff --git a/codec2/hidl/1.0/utils/include/codec2/hidl/1.0/types.h b/codec2/hidl/1.0/utils/include/codec2/hidl/1.0/types.h
index 72c991e..46dee38 100644
--- a/codec2/hidl/1.0/utils/include/codec2/hidl/1.0/types.h
+++ b/codec2/hidl/1.0/utils/include/codec2/hidl/1.0/types.h
@@ -22,6 +22,7 @@
 #include <android/hardware/media/bufferpool/1.0/types.h>
 #include <hardware/google/media/c2/1.0/IComponentStore.h>
 #include <hardware/google/media/c2/1.0/types.h>
+#include <gui/IGraphicBufferProducer.h>
 
 #include <C2Component.h>
 #include <C2Param.h>
@@ -39,9 +40,11 @@
 using ::android::hardware::hidl_handle;
 using ::android::hardware::hidl_string;
 using ::android::hardware::hidl_vec;
+using ::android::status_t;
 using ::android::sp;
 using ::android::hardware::media::bufferpool::V1_0::implementation::
         ConnectionId;
+using ::android::IGraphicBufferProducer;
 
 // Types of metadata for Blocks.
 struct C2Hidl_Range {
@@ -262,6 +265,82 @@
 c2_status_t toC2Status(::android::hardware::media::bufferpool::V1_0::
         ResultStatus rs);
 
+// BufferQueue-Based Block Operations
+// ==================================
+
+// Create a GraphicBuffer object from a graphic block and attach it to an
+// IGraphicBufferProducer.
+status_t attachToBufferQueue(const C2ConstGraphicBlock& block,
+                             const sp<IGraphicBufferProducer>& igbp,
+                             uint32_t generation,
+                             int32_t* bqSlot);
+
+// Return false if block does not come from a bufferqueue-based blockpool.
+// Otherwise, extract bqId and bqSlot and return true.
+bool getBufferQueueAssignment(const C2ConstGraphicBlock& block,
+                              uint64_t* bqId,
+                              int32_t* bqSlot);
+
+// Disassociate the given block with its designated bufferqueue so that
+// cancelBuffer() will not be called when the block is destroyed. If the block
+// does not have a designated bufferqueue, the function returns false.
+// Otherwise, it returns true.
+//
+// Note: This function should be called after attachBuffer() or queueBuffer() is
+// called manually.
+bool yieldBufferQueueBlock(const C2ConstGraphicBlock& block);
+
+// Call yieldBufferQueueBlock() on blocks in the given workList. processInput
+// determines whether input blocks are yielded. processOutput works similarly on
+// output blocks. (The default value of processInput is false while the default
+// value of processOutput is true. This implies that in most cases, only output
+// buffers contain bufferqueue-based blocks.)
+//
+// Note: This function should be called after WorkBundle has been successfully
+// sent over the Treble boundary to another process.
+void yieldBufferQueueBlocks(const std::list<std::unique_ptr<C2Work>>& workList,
+                            bool processInput = false,
+                            bool processOutput = true);
+
+// Assign the given block to a bufferqueue so that when the block is destroyed,
+// cancelBuffer() will be called.
+//
+// If the block does not come from a bufferqueue-based blockpool, this function
+// returns false.
+//
+// If the block already has a bufferqueue assignment that matches the given one,
+// the function returns true.
+//
+// If the block already has a bufferqueue assignment that does not match the
+// given one, the block will be reassigned to the given bufferqueue. This
+// will call attachBuffer() on the given igbp. The function then returns true on
+// success or false on any failure during the operation.
+//
+// Note: This function should be called after detachBuffer() or dequeueBuffer()
+// is called manually.
+bool holdBufferQueueBlock(const C2ConstGraphicBlock& block,
+                          const sp<IGraphicBufferProducer>& igbp,
+                          uint64_t bqId,
+                          uint32_t generation);
+
+// Call holdBufferQueueBlock() on input or output blocks in the given workList.
+// Since the bufferqueue assignment for input and output buffers can be
+// different, this function takes forInput to determine whether the given
+// bufferqueue is for input buffers or output buffers. (The default value of
+// forInput is false.)
+//
+// In the (rare) case that both input and output buffers are bufferqueue-based,
+// this function must be called twice, once for the input buffers and once for
+// the output buffers.
+//
+// Note: This function should be called after WorkBundle has been received from
+// another process.
+void holdBufferQueueBlocks(const std::list<std::unique_ptr<C2Work>>& workList,
+                           const sp<IGraphicBufferProducer>& igbp,
+                           uint64_t bqId,
+                           uint32_t generation,
+                           bool forInput = false);
+
 }  // namespace utils
 }  // namespace V1_0
 }  // namespace c2
diff --git a/codec2/hidl/1.0/utils/types.cpp b/codec2/hidl/1.0/utils/types.cpp
index dd05056..cad7605 100644
--- a/codec2/hidl/1.0/utils/types.cpp
+++ b/codec2/hidl/1.0/utils/types.cpp
@@ -20,6 +20,8 @@
 
 #include <codec2/hidl/1.0/types.h>
 
+#include <media/stagefright/bqhelper/WGraphicBufferProducer.h>
+
 #include <C2AllocatorIon.h>
 #include <C2AllocatorGralloc.h>
 #include <C2BlockInternal.h>
@@ -31,8 +33,9 @@
 #include <C2Work.h>
 #include <util/C2ParamUtils.h>
 
-#include <unordered_map>
 #include <algorithm>
+#include <functional>
+#include <unordered_map>
 
 #include <media/stagefright/foundation/AUtils.h>
 
@@ -52,6 +55,7 @@
         ClientManager;
 using ::android::hardware::media::bufferpool::V1_0::implementation::
         TransactionId;
+using ::android::TWGraphicBufferProducer;
 
 namespace /* unnamed */ {
 
@@ -926,7 +930,9 @@
 }
 
 // std::list<std::unique_ptr<C2Work>> -> WorkBundle
-Status objcpy(WorkBundle* d, const std::list<std::unique_ptr<C2Work>>& s,
+Status objcpy(
+        WorkBundle* d,
+        const std::list<std::unique_ptr<C2Work>>& s,
         BufferPoolSender* bufferPoolSender) {
     Status status = Status::OK;
 
@@ -1573,6 +1579,201 @@
     }
 }
 
+namespace /* unnamed */ {
+
+// Create a GraphicBuffer object from a graphic block.
+sp<GraphicBuffer> createGraphicBuffer(const C2ConstGraphicBlock& block) {
+    uint32_t width;
+    uint32_t height;
+    uint32_t format;
+    uint64_t usage;
+    uint32_t stride;
+    uint64_t bqId;
+    int32_t bqSlot;
+    _UnwrapNativeCodec2GrallocMetadata(
+            block.handle(), &width, &height, &format, &usage,
+            &stride, &bqId, reinterpret_cast<uint32_t*>(&bqSlot));
+    native_handle_t *grallocHandle =
+            UnwrapNativeCodec2GrallocHandle(block.handle());
+    sp<GraphicBuffer> graphicBuffer =
+            new GraphicBuffer(grallocHandle,
+                              GraphicBuffer::CLONE_HANDLE,
+                              width, height, format,
+                              1, usage, stride);
+    native_handle_delete(grallocHandle);
+    return graphicBuffer;
+}
+
+template <typename BlockProcessor>
+void forEachBlock(C2FrameData& frameData,
+                  BlockProcessor process) {
+    for (const std::shared_ptr<C2Buffer>& buffer : frameData.buffers) {
+        if (buffer) {
+            for (const C2ConstGraphicBlock& block :
+                    buffer->data().graphicBlocks()) {
+                process(block);
+            }
+        }
+    }
+}
+
+template <typename BlockProcessor>
+void forEachBlock(const std::list<std::unique_ptr<C2Work>>& workList,
+                  BlockProcessor process,
+                  bool processInput, bool processOutput) {
+    for (const std::unique_ptr<C2Work>& work : workList) {
+        if (!work) {
+            continue;
+        }
+        if (processInput) {
+            forEachBlock(work->input, process);
+        }
+        if (processOutput) {
+            for (const std::unique_ptr<C2Worklet>& worklet : work->worklets) {
+                if (worklet) {
+                    forEachBlock(worklet->output,
+                                 process);
+                }
+            }
+        }
+    }
+}
+
+sp<HGraphicBufferProducer> getHgbp(const sp<IGraphicBufferProducer>& igbp) {
+    sp<HGraphicBufferProducer> hgbp = igbp->getHalInterface();
+    return hgbp ? hgbp :
+            new TWGraphicBufferProducer<HGraphicBufferProducer>(igbp);
+}
+
+} // unnamed namespace
+
+status_t attachToBufferQueue(const C2ConstGraphicBlock& block,
+                             const sp<IGraphicBufferProducer>& igbp,
+                             uint32_t generation,
+                             int32_t* bqSlot) {
+    if (!igbp) {
+        ALOGW("attachToBufferQueue -- null producer.");
+        return NO_INIT;
+    }
+
+    sp<GraphicBuffer> graphicBuffer = createGraphicBuffer(block);
+    graphicBuffer->setGenerationNumber(generation);
+
+    ALOGV("attachToBufferQueue -- attaching buffer: "
+            "block dimension %ux%u, "
+            "graphicBuffer dimension %ux%u, "
+            "format %#x, usage %#llx, stride %u, generation %u.",
+            static_cast<unsigned>(block.width()),
+            static_cast<unsigned>(block.height()),
+            static_cast<unsigned>(graphicBuffer->getWidth()),
+            static_cast<unsigned>(graphicBuffer->getHeight()),
+            static_cast<unsigned>(graphicBuffer->getPixelFormat()),
+            static_cast<unsigned long long>(graphicBuffer->getUsage()),
+            static_cast<unsigned>(graphicBuffer->getStride()),
+            static_cast<unsigned>(graphicBuffer->getGenerationNumber()));
+
+    status_t result = igbp->attachBuffer(bqSlot, graphicBuffer);
+    if (result != OK) {
+        ALOGW("attachToBufferQueue -- attachBuffer failed. Error code = %d",
+                static_cast<int>(result));
+        return false;
+    }
+    ALOGV("attachToBufferQueue -- attachBuffer returned slot %d",
+            static_cast<int>(*bqSlot));
+    return true;
+}
+
+bool getBufferQueueAssignment(const C2ConstGraphicBlock& block,
+                              uint64_t* bqId,
+                              int32_t* bqSlot) {
+    return _C2BlockFactory::GetBufferQueueData(
+            _C2BlockFactory::GetGraphicBlockPoolData(block),
+            bqId, bqSlot);
+}
+
+bool yieldBufferQueueBlock(const C2ConstGraphicBlock& block) {
+    std::shared_ptr<_C2BlockPoolData> data =
+            _C2BlockFactory::GetGraphicBlockPoolData(block);
+    if (data && _C2BlockFactory::GetBufferQueueData(data)) {
+        _C2BlockFactory::YieldBlockToBufferQueue(data);
+        return true;
+    }
+    return false;
+}
+
+void yieldBufferQueueBlocks(
+        const std::list<std::unique_ptr<C2Work>>& workList,
+        bool processInput, bool processOutput) {
+    forEachBlock(workList, yieldBufferQueueBlock, processInput, processOutput);
+}
+
+bool holdBufferQueueBlock(const C2ConstGraphicBlock& block,
+                            const sp<IGraphicBufferProducer>& igbp,
+                            uint64_t bqId,
+                            uint32_t generation) {
+    std::shared_ptr<_C2BlockPoolData> data =
+            _C2BlockFactory::GetGraphicBlockPoolData(block);
+    if (!data) {
+        return false;
+    }
+
+    uint64_t oldId;
+    int32_t oldSlot;
+    // If the block is not bufferqueue-based, do nothing.
+    if (!_C2BlockFactory::GetBufferQueueData(data, &oldId, &oldSlot) ||
+            (oldId == 0)) {
+        return false;
+    }
+
+    // If the block's bqId is the same as the desired bqId, just hold.
+    if (oldId == bqId) {
+        ALOGV("holdBufferQueueBlock -- import without attaching: "
+                "bqId %llu, bqSlot %d, generation %u.",
+                static_cast<long long unsigned>(oldId),
+                static_cast<int>(oldSlot),
+                static_cast<unsigned>(generation));
+        _C2BlockFactory::HoldBlockFromBufferQueue(data, getHgbp(igbp));
+        return true;
+    }
+
+    // Otherwise, attach to the given igbp, which must not be null.
+    if (!igbp) {
+        return false;
+    }
+
+    int32_t bqSlot;
+    status_t result = attachToBufferQueue(block, igbp, generation, &bqSlot);
+
+    if (result != OK) {
+        ALOGE("holdBufferQueueBlock -- fail to attach: "
+                "target bqId %llu, generation %u.",
+                static_cast<long long unsigned>(bqId),
+                static_cast<unsigned>(generation));
+
+        return false;
+    }
+
+    ALOGV("holdBufferQueueBlock -- attached: "
+            "bqId %llu, bqSlot %d, generation %u.",
+            static_cast<long long unsigned>(bqId),
+            static_cast<int>(bqSlot),
+            static_cast<unsigned>(generation));
+    _C2BlockFactory::AssignBlockToBufferQueue(
+            data, getHgbp(igbp), bqId, bqSlot, true);
+    return true;
+}
+
+void holdBufferQueueBlocks(const std::list<std::unique_ptr<C2Work>>& workList,
+                           const sp<IGraphicBufferProducer>& igbp,
+                           uint64_t bqId,
+                           uint32_t generation,
+                           bool forInput) {
+    forEachBlock(workList,
+                 std::bind(holdBufferQueueBlock,
+                           std::placeholders::_1, igbp, bqId, generation),
+                 forInput, !forInput);
+}
+
 }  // namespace utils
 }  // namespace V1_0
 }  // namespace c2
diff --git a/codec2/hidl/client/Android.bp b/codec2/hidl/client/Android.bp
index c98de21..0819055 100644
--- a/codec2/hidl/client/Android.bp
+++ b/codec2/hidl/client/Android.bp
@@ -6,8 +6,10 @@
     ],
 
     shared_libs: [
+        "android.hardware.graphics.bufferqueue@1.0",
         "android.hardware.media.bufferpool@1.0",
         "hardware.google.media.c2@1.0",
+        "libbase",
         "libbinder",
         "libcodec2_hidl_utils@1.0",
         "libcutils",
@@ -16,8 +18,10 @@
         "libhidltransport",
         "liblog",
         "libstagefright_bufferpool@1.0",
+        "libstagefright_bufferqueue_helper",
         "libstagefright_codec2",
         "libstagefright_codec2_vndk",
+        "libui",
         "libutils",
     ],
 
diff --git a/codec2/hidl/client/client.cpp b/codec2/hidl/client/client.cpp
index 7164916..8751601 100644
--- a/codec2/hidl/client/client.cpp
+++ b/codec2/hidl/client/client.cpp
@@ -20,33 +20,37 @@
 
 #include <codec2/hidl/client.h>
 
-#include <hardware/google/media/c2/1.0/IComponentListener.h>
-#include <hardware/google/media/c2/1.0/IConfigurable.h>
-#include <hardware/google/media/c2/1.0/IComponentInterface.h>
-#include <hardware/google/media/c2/1.0/IComponent.h>
-#include <hardware/google/media/c2/1.0/IComponentStore.h>
-#include <android/hardware/media/bufferpool/1.0/IClientManager.h>
-
-#include <C2PlatformSupport.h>
-#include <C2BufferPriv.h>
-#include <C2Debug.h>
-#include <bufferpool/ClientManager.h>
-#include <gui/bufferqueue/1.0/H2BGraphicBufferProducer.h>
-#include <hidl/HidlSupport.h>
-#include <cutils/properties.h>
-
 #include <deque>
 #include <limits>
 #include <map>
 #include <type_traits>
 #include <vector>
 
+#include <bufferpool/ClientManager.h>
+#include <cutils/properties.h>
+#include <gui/bufferqueue/1.0/H2BGraphicBufferProducer.h>
+#include <hidl/HidlSupport.h>
+#include <media/stagefright/bqhelper/WGraphicBufferProducer.h>
+#undef LOG
+
+#include <android/hardware/media/bufferpool/1.0/IClientManager.h>
+#include <hardware/google/media/c2/1.0/IComponent.h>
+#include <hardware/google/media/c2/1.0/IComponentInterface.h>
+#include <hardware/google/media/c2/1.0/IComponentListener.h>
+#include <hardware/google/media/c2/1.0/IComponentStore.h>
+#include <hardware/google/media/c2/1.0/IConfigurable.h>
+
+#include <C2Debug.h>
+#include <C2BufferPriv.h>
+#include <C2PlatformSupport.h>
+
 namespace android {
 
 using ::android::hardware::hidl_vec;
 using ::android::hardware::hidl_string;
 using ::android::hardware::Return;
 using ::android::hardware::Void;
+using ::android::TWGraphicBufferProducer;
 
 using namespace ::hardware::google::media::c2::V1_0;
 using namespace ::hardware::google::media::c2::V1_0::utils;
@@ -364,13 +368,7 @@
             // release input buffers potentially held by the component from queue
             std::shared_ptr<Codec2Client::Component> strongComponent = component.lock();
             if (strongComponent) {
-                std::vector<uint64_t> inputDone;
-                for (const std::unique_ptr<C2Work> &work : workItems) {
-                    if (work) {
-                        inputDone.emplace_back(work->input.ordinal.frameIndex.peeku());
-                    }
-                }
-                strongComponent->handleOnWorkDone(inputDone);
+                strongComponent->handleOnWorkDone(workItems);
             }
             if (std::shared_ptr<Codec2Client::Listener> listener = base.lock()) {
                 listener->onWorkDone(component, workItems);
@@ -802,18 +800,40 @@
     return static_cast<c2_status_t>(static_cast<Status>(transResult));
 }
 
-void Codec2Client::Component::handleOnWorkDone(const std::vector<uint64_t> &inputDone) {
-    std::lock_guard<std::mutex> lock(mInputBuffersMutex);
-    for (uint64_t inputIndex : inputDone) {
-        auto it = mInputBuffers.find(inputIndex);
-        if (it == mInputBuffers.end()) {
-            ALOGI("unknown input index %llu in onWorkDone", (long long)inputIndex);
-        } else {
-            ALOGV("done with input index %llu with %zu buffers",
-                    (long long)inputIndex, it->second.size());
-            mInputBuffers.erase(it);
+void Codec2Client::Component::handleOnWorkDone(
+        const std::list<std::unique_ptr<C2Work>> &workItems) {
+    // Input buffers' lifetime management
+    std::vector<uint64_t> inputDone;
+    for (const std::unique_ptr<C2Work> &work : workItems) {
+        if (work) {
+            inputDone.emplace_back(work->input.ordinal.frameIndex.peeku());
         }
     }
+
+    {
+        std::lock_guard<std::mutex> lock(mInputBuffersMutex);
+        for (uint64_t inputIndex : inputDone) {
+            auto it = mInputBuffers.find(inputIndex);
+            if (it == mInputBuffers.end()) {
+                ALOGI("unknown input index %llu in onWorkDone", (long long)inputIndex);
+            } else {
+                ALOGV("done with input index %llu with %zu buffers",
+                        (long long)inputIndex, it->second.size());
+                mInputBuffers.erase(it);
+            }
+        }
+    }
+
+    // Output bufferqueue-based blocks' lifetime management
+    mOutputBufferQueueMutex.lock();
+    sp<IGraphicBufferProducer> igbp = mOutputIgbp;
+    uint64_t bqId = mOutputBqId;
+    uint32_t generation = mOutputGeneration;
+    mOutputBufferQueueMutex.unlock();
+
+    if (igbp) {
+        holdBufferQueueBlocks(workItems, igbp, bqId, generation);
+    }
 }
 
 c2_status_t Codec2Client::Component::queue(
@@ -886,6 +906,8 @@
             flushedIndices.emplace_back(work->input.ordinal.frameIndex.peeku());
         }
     }
+
+    // Input buffers' lifetime management
     for (uint64_t flushedIndex : flushedIndices) {
         std::lock_guard<std::mutex> lock(mInputBuffersMutex);
         auto it = mInputBuffers.find(flushedIndex);
@@ -898,6 +920,17 @@
         }
     }
 
+    // Output bufferqueue-based blocks' lifetime management
+    mOutputBufferQueueMutex.lock();
+    sp<IGraphicBufferProducer> igbp = mOutputIgbp;
+    uint64_t bqId = mOutputBqId;
+    uint32_t generation = mOutputGeneration;
+    mOutputBufferQueueMutex.unlock();
+
+    if (igbp) {
+        holdBufferQueueBlocks(*flushedWork, igbp, bqId, generation);
+    }
+
     return status;
 }
 
@@ -988,9 +1021,15 @@
 
 c2_status_t Codec2Client::Component::setOutputSurface(
         C2BlockPool::local_id_t blockPoolId,
-        const sp<IGraphicBufferProducer>& surface) {
+        const sp<IGraphicBufferProducer>& surface,
+        uint32_t generation) {
+    sp<HGraphicBufferProducer> igbp = surface->getHalInterface();
+    if (!igbp) {
+        igbp = new TWGraphicBufferProducer<HGraphicBufferProducer>(surface);
+    }
+
     Return<Status> transStatus = base()->setOutputSurface(
-            static_cast<uint64_t>(blockPoolId), surface);
+            static_cast<uint64_t>(blockPoolId), igbp);
     if (!transStatus.isOk()) {
         ALOGE("setOutputSurface -- transaction failed.");
         return C2_TRANSACTION_FAILED;
@@ -1000,13 +1039,91 @@
     if (status != C2_OK) {
         ALOGE("setOutputSurface -- call failed. "
                 "Error code = %d", static_cast<int>(status));
+    } else {
+        std::lock_guard<std::mutex> lock(mOutputBufferQueueMutex);
+        if (mOutputIgbp != surface) {
+            mOutputIgbp = surface;
+            if (!surface) {
+                mOutputBqId = 0;
+            } else if (surface->getUniqueId(&mOutputBqId) != OK) {
+                ALOGE("setOutputSurface -- cannot obtain bufferqueue id.");
+            }
+        }
+        mOutputGeneration = generation;
     }
     return status;
 }
 
+status_t Codec2Client::Component::queueToOutputSurface(
+        const C2ConstGraphicBlock& block,
+        const QueueBufferInput& input,
+        QueueBufferOutput* output) {
+    uint64_t bqId;
+    int32_t bqSlot;
+    if (!getBufferQueueAssignment(block, &bqId, &bqSlot) || bqId == 0) {
+        // Block not from bufferqueue -- it must be attached before queuing.
+
+        mOutputBufferQueueMutex.lock();
+        sp<IGraphicBufferProducer> outputIgbp = mOutputIgbp;
+        uint32_t outputGeneration = mOutputGeneration;
+        mOutputBufferQueueMutex.unlock();
+
+        status_t status = !attachToBufferQueue(block,
+                                               outputIgbp,
+                                               outputGeneration,
+                                               &bqSlot);
+        if (status != OK) {
+            ALOGW("queueToOutputSurface -- attaching failed.");
+            return INVALID_OPERATION;
+        }
+
+        status = outputIgbp->queueBuffer(static_cast<int>(bqSlot),
+                                         input, output);
+        if (status != OK) {
+            ALOGE("queueToOutputSurface -- queueBuffer() failed "
+                    "on non-bufferqueue-based block. "
+                    "Error code = %d.",
+                    static_cast<int>(status));
+            return status;
+        }
+        return OK;
+    }
+
+    mOutputBufferQueueMutex.lock();
+    sp<IGraphicBufferProducer> outputIgbp = mOutputIgbp;
+    uint64_t outputBqId = mOutputBqId;
+    mOutputBufferQueueMutex.unlock();
+
+    if (!outputIgbp) {
+        ALOGE("queueToOutputSurface -- output surface is null.");
+        return NO_INIT;
+    }
+
+    if (bqId != outputBqId) {
+        ALOGE("queueToOutputSurface -- bufferqueue ids mismatch.");
+        return DEAD_OBJECT;
+    }
+
+    status_t status = outputIgbp->queueBuffer(static_cast<int>(bqSlot),
+                                              input, output);
+    if (status != OK) {
+        ALOGE("queueToOutputSurface -- queueBuffer() failed "
+                "on bufferqueue-based block. "
+                "Error code = %d.",
+                static_cast<int>(status));
+        return status;
+    }
+    if (!yieldBufferQueueBlock(block)) {
+        ALOGE("queueToOutputSurface -- cannot yield bufferqueue-based block "
+                "to the bufferqueue.");
+        return UNKNOWN_ERROR;
+    }
+    return OK;
+}
+
 c2_status_t Codec2Client::Component::connectToOmxInputSurface(
-        const sp<IGraphicBufferProducer>& producer,
-        const sp<IGraphicBufferSource>& source) {
+        const sp<HGraphicBufferProducer>& producer,
+        const sp<HGraphicBufferSource>& source) {
     Return<Status> transStatus = base()->connectToOmxInputSurface(
             producer, source);
     if (!transStatus.isOk()) {
diff --git a/codec2/hidl/client/include/codec2/hidl/client.h b/codec2/hidl/client/include/codec2/hidl/client.h
index 0433921..24b6f7e 100644
--- a/codec2/hidl/client/include/codec2/hidl/client.h
+++ b/codec2/hidl/client/include/codec2/hidl/client.h
@@ -17,6 +17,7 @@
 #ifndef CODEC2_HIDL_CLIENT_H_
 #define CODEC2_HIDL_CLIENT_H_
 
+#include <gui/IGraphicBufferProducer.h>
 #include <codec2/hidl/1.0/types.h>
 
 #include <C2PlatformSupport.h>
@@ -94,7 +95,6 @@
 
 // Forward declarations of other classes
 namespace android {
-class IGraphicBufferProducer;
 namespace hardware {
 namespace graphics {
 namespace bufferqueue {
@@ -298,24 +298,53 @@
 
     c2_status_t release();
 
-    typedef ::android::hardware::graphics::bufferqueue::V1_0::
+    typedef ::android::
             IGraphicBufferProducer IGraphicBufferProducer;
-    typedef ::android::hardware::media::omx::V1_0::
-            IGraphicBufferSource IGraphicBufferSource;
+    typedef IGraphicBufferProducer::
+            QueueBufferInput QueueBufferInput;
+    typedef IGraphicBufferProducer::
+            QueueBufferOutput QueueBufferOutput;
 
-    // Output surface
+    typedef ::android::hardware::graphics::bufferqueue::V1_0::
+            IGraphicBufferProducer HGraphicBufferProducer;
+    typedef ::android::hardware::media::omx::V1_0::
+            IGraphicBufferSource HGraphicBufferSource;
+
+    // Set the output surface to be used with a blockpool previously created by
+    // createBlockPool().
     c2_status_t setOutputSurface(
             C2BlockPool::local_id_t blockPoolId,
-            const sp<IGraphicBufferProducer>& surface);
+            const sp<IGraphicBufferProducer>& surface,
+            uint32_t generation);
+
+    // Extract a slot number from of the block, then call
+    // IGraphicBufferProducer::queueBuffer().
+    //
+    // If the output surface has not been set, NO_INIT will be returned.
+    //
+    // If the block does not come from a bufferqueue-based blockpool,
+    // attachBuffer() will be called, followed by queueBuffer().
+    //
+    // If the block has a bqId that does not match the id of the output surface,
+    // DEAD_OBJECT will be returned.
+    //
+    // If the call to queueBuffer() is successful but the block cannot be
+    // associated to the output surface for automatic cancellation upon
+    // destruction, UNKNOWN_ERROR will be returned.
+    //
+    // Otherwise, the return value from queueBuffer() will be returned.
+    status_t queueToOutputSurface(
+            const C2ConstGraphicBlock& block,
+            const QueueBufferInput& input,
+            QueueBufferOutput* output);
 
     c2_status_t connectToOmxInputSurface(
-            const sp<IGraphicBufferProducer>& producer,
-            const sp<IGraphicBufferSource>& source);
+            const sp<HGraphicBufferProducer>& producer,
+            const sp<HGraphicBufferSource>& source);
 
     c2_status_t disconnectFromInputSurface();
 
-    // Input buffer lifetime management
-    void handleOnWorkDone(const std::vector<uint64_t> &inputDone);
+    void handleOnWorkDone(const std::list<std::unique_ptr<C2Work>> &workItems);
 
     // base cannot be null.
     Component(const sp<Base>& base);
@@ -332,6 +361,11 @@
     ::hardware::google::media::c2::V1_0::utils::DefaultBufferPoolSender
             mBufferPoolSender;
 
+    std::mutex mOutputBufferQueueMutex;
+    sp<IGraphicBufferProducer> mOutputIgbp;
+    uint64_t mOutputBqId;
+    uint32_t mOutputGeneration;
+
     static c2_status_t setDeathListener(
             const std::shared_ptr<Component>& component,
             const std::shared_ptr<Listener>& listener);
diff --git a/codec2/vndk/C2Buffer.cpp b/codec2/vndk/C2Buffer.cpp
index 6288777..47366ca 100644
--- a/codec2/vndk/C2Buffer.cpp
+++ b/codec2/vndk/C2Buffer.cpp
@@ -129,8 +129,8 @@
           mAllocation(other.mAllocation),
           mPoolData(other.mPoolData) { }
 
-    /** returns const pool data  */
-    std::shared_ptr<const _C2BlockPoolData> poolData() const {
+    /** returns pool data  */
+    std::shared_ptr<_C2BlockPoolData> poolData() const {
         return mPoolData;
     }
 
@@ -382,7 +382,7 @@
     return std::shared_ptr<C2LinearBlock>(new C2LinearBlock(impl, *impl));
 }
 
-std::shared_ptr<const _C2BlockPoolData> _C2BlockFactory::GetLinearBlockPoolData(
+std::shared_ptr<_C2BlockPoolData> _C2BlockFactory::GetLinearBlockPoolData(
         const C2Block1D &block) {
     if (block.mImpl) {
         return block.mImpl->poolData();
@@ -804,8 +804,8 @@
 
     virtual ~_C2Block2DImpl() = default;
 
-    /** returns const pool data  */
-    std::shared_ptr<const _C2BlockPoolData> poolData() const {
+    /** returns pool data  */
+    std::shared_ptr<_C2BlockPoolData> poolData() const {
         return mPoolData;
     }
 
@@ -1101,7 +1101,7 @@
     return std::shared_ptr<C2GraphicBlock>(new C2GraphicBlock(impl, *impl));
 }
 
-std::shared_ptr<const _C2BlockPoolData> _C2BlockFactory::GetGraphicBlockPoolData(
+std::shared_ptr<_C2BlockPoolData> _C2BlockFactory::GetGraphicBlockPoolData(
         const C2Block2D &block) {
     if (block.mImpl) {
         return block.mImpl->poolData();
diff --git a/codec2/vndk/include/C2BqBufferPriv.h b/codec2/vndk/include/C2BqBufferPriv.h
index d666e59..e1baad4 100644
--- a/codec2/vndk/include/C2BqBufferPriv.h
+++ b/codec2/vndk/include/C2BqBufferPriv.h
@@ -64,12 +64,14 @@
      */
     virtual void configureProducer(const android::sp<android::HGraphicBufferProducer> &producer);
 
-    class Impl;
 private:
     const std::shared_ptr<C2Allocator> mAllocator;
     const local_id_t mLocalId;
 
+    class Impl;
     std::shared_ptr<Impl> mImpl;
+
+    friend struct C2BufferQueueBlockPoolData;
 };
 
 #endif // STAGEFRIGHT_CODEC2_BUFFER_PRIV_H_
diff --git a/codec2/vndk/internal/C2BlockInternal.h b/codec2/vndk/internal/C2BlockInternal.h
index 812bcea..7c1e0e7 100644
--- a/codec2/vndk/internal/C2BlockInternal.h
+++ b/codec2/vndk/internal/C2BlockInternal.h
@@ -17,6 +17,8 @@
 #ifndef ANDROID_STAGEFRIGHT_C2BLOCK_INTERNAL_H_
 #define ANDROID_STAGEFRIGHT_C2BLOCK_INTERNAL_H_
 
+#include <android/hardware/graphics/bufferqueue/1.0/IGraphicBufferProducer.h>
+
 #include <C2Buffer.h>
 
 namespace android {
@@ -48,6 +50,8 @@
     virtual ~_C2BlockPoolData() = default;
 };
 
+struct C2BufferQueueBlockPoolData;
+
 /**
  * Internal only interface for creating blocks by block pool/buffer passing implementations.
  *
@@ -57,12 +61,12 @@
     /**
      * Create a linear block from an allocation for an allotted range.
      *
-     * @param alloc parent allocation
-     * @param data  blockpool data
-     * @param offset allotted range offset
-     * @param size  allotted size
+     * \param alloc parent allocation
+     * \param data  blockpool data
+     * \param offset allotted range offset
+     * \param size  allotted size
      *
-     * @return shared pointer to the linear block. nullptr if there was not enough memory to
+     * \return shared pointer to the linear block. nullptr if there was not enough memory to
      *         create this block.
      */
     static
@@ -75,11 +79,11 @@
     /**
      * Create a graphic block from an allocation for an allotted section.
      *
-     * @param alloc parent allocation
-     * @param data  blockpool data
-     * @param crop  allotted crop region
+     * \param alloc parent allocation
+     * \param data  blockpool data
+     * \param crop  allotted crop region
      *
-     * @return shared pointer to the graphic block. nullptr if there was not enough memory to
+     * \return shared pointer to the graphic block. nullptr if there was not enough memory to
      *         create this block.
      */
     static
@@ -91,27 +95,27 @@
     /**
      * Return a block pool data from 1D block.
      *
-     * @param shared pointer to the 1D block which is already created.
+     * \param shared pointer to the 1D block which is already created.
      */
     static
-    std::shared_ptr<const _C2BlockPoolData> GetLinearBlockPoolData(
+    std::shared_ptr<_C2BlockPoolData> GetLinearBlockPoolData(
             const C2Block1D& block);
 
     /**
      * Return a block pool data from 2D block.
      *
-     * @param shared pointer to the 2D block which is already created.
+     * \param shared pointer to the 2D block which is already created.
      */
     static
-    std::shared_ptr<const _C2BlockPoolData> GetGraphicBlockPoolData(
+    std::shared_ptr<_C2BlockPoolData> GetGraphicBlockPoolData(
             const C2Block2D& block);
 
     /**
      * Create a linear block from the received native handle.
      *
-     * @param handle    native handle to a linear block
+     * \param handle    native handle to a linear block
      *
-     * @return shared pointer to the linear block. nullptr if there was not enough memory to
+     * \return shared pointer to the linear block. nullptr if there was not enough memory to
      *         create this block.
      */
     static
@@ -121,9 +125,9 @@
     /**
      * Create a graphic block from the received native handle.
      *
-     * @param handle    native handle to a graphic block
+     * \param handle    native handle to a graphic block
      *
-     * @return shared pointer to the graphic block. nullptr if there was not enough memory to
+     * \return shared pointer to the graphic block. nullptr if there was not enough memory to
      *         create this block.
      */
     static
@@ -133,9 +137,9 @@
     /**
      * Create a linear block from the received bufferpool data.
      *
-     * @param data  bufferpool data to a linear block
+     * \param data  bufferpool data to a linear block
      *
-     * @return shared pointer to the linear block. nullptr if there was not enough memory to
+     * \return shared pointer to the linear block. nullptr if there was not enough memory to
      *         create this block.
      */
     static
@@ -146,9 +150,9 @@
     /**
      * Create a graphic block from the received bufferpool data.
      *
-     * @param data  bufferpool data to a graphic block
+     * \param data  bufferpool data to a graphic block
      *
-     * @return shared pointer to the graphic block. nullptr if there was not enough memory to
+     * \return shared pointer to the graphic block. nullptr if there was not enough memory to
      *         create this block.
      */
     static
@@ -159,31 +163,165 @@
     /**
      * Get bufferpool data from the blockpool data.
      *
-     * @param poolData          blockpool data
-     * @param bufferPoolData    pointer to bufferpool data where the bufferpool
+     * \param poolData          blockpool data
+     * \param bufferPoolData    pointer to bufferpool data where the bufferpool
      *                          data is stored.
      *
-     * @return {@code true} when there is valid bufferpool data, {@code false} otherwise.
+     * \return {\code true} when there is valid bufferpool data, {\code false} otherwise.
      */
     static
     bool GetBufferPoolData(
             const std::shared_ptr<const _C2BlockPoolData> &poolData,
             std::shared_ptr<android::hardware::media::bufferpool::BufferPoolData> *bufferPoolData);
 
+    /*
+     * Life Cycle Management of BufferQueue-Based Blocks
+     * =================================================
+     *
+     * A block that is created by a bufferqueue-based blockpool requires some
+     * special treatment when it is destroyed. In particular, if the block
+     * corresponds to a held (dequeued/attached) GraphicBuffer in a slot of a
+     * bufferqueue, its destruction should trigger a call to
+     * IGraphicBufferProducer::cancelBuffer(). On the other hand, if the
+     * GraphicBuffer is not held, i.e., if it has been queued or detached,
+     * cancelBuffer() should not be called upon the destruction of the block.
+     *
+     * _C2BlockPoolData created by a bufferqueue-based blockpool includes two
+     * main pieces of information:
+     *   - "held" status: Whether cancelBuffer() should be called upon
+     *     destruction of the block.
+     *   - bufferqueue assignment: The triple (igbp, bqId, bqSlot), where igbp
+     *     is the IGraphicBufferProducer instance of the bufferqueue, bqId is
+     *     the globally unique id of the bufferqueue, and bqSlot is the slot in
+     *     the bufferqueue.
+     *
+     * igbp is the instance of IGraphicBufferProducer on which cancelBuffer()
+     * will be called if "held" status is true when the block is destroyed.
+     * (bqSlot is an input to cancelBuffer().) However, only bqId and bqSlot
+     * are retained when a block is transferred from one process to another. It
+     * is the responsibility of both the sending and receiving processes to
+     * maintain consistency of "held" status and igbp. Below are functions
+     * provided for this purpose:
+     *
+     *   - GetBufferQueueData(): Returns bqId and bqSlot.
+     *   - HoldBlockFromBufferQueue(): Sets "held" status to true.
+     *   - YieldBlockToBufferQueue(): Sets "held" status to false.
+     *   - AssignBlockToBufferQueue(): Sets the bufferqueue assignment and
+     *     "held" status.
+     *
+     * All these functions operate on _C2BlockPoolData, which can be obtained by
+     * calling GetGraphicBlockPoolData().
+     *
+     * HoldBlockFromBufferQueue() will mark the block as held, while
+     * YieldBlockToBufferQueue() will do the opposite. These two functions do
+     * not modify the bufferqueue assignment, so it is not wrong to call
+     * HoldBlockFromBufferQueue() after YieldBlockToBufferQueue() if it can be
+     * guaranteed that the block is not destroyed during the period between the
+     * two calls.
+     *
+     * AssingBlockToBufferQueue() has a "held" status as an optional argument.
+     * The default value is true.
+     *
+     * Maintaining Consistency with IGraphicBufferProducer Operations
+     * ==============================================================
+     *
+     * dequeueBuffer()
+     *   - This function is called by the blockpool. It should not be called
+     *     manually. The blockpool will automatically generate the correct
+     *     information for _C2BlockPoolData, with "held" status set to true.
+     *
+     * queueBuffer()
+     *   - After queueBuffer() is called, YieldBlockToBufferQueue() should be
+     *     called.
+     *
+     * attachBuffer()
+     *   - After attachBuffer() is called, AssignBlockToBufferQueue() should be
+     *     called with "held" status set to true.
+     *
+     * detachBuffer()
+     *   - After detachBuffer() is called, HoldBlockFromBufferQueue() should be
+     *     called.
+     */
+
     /**
      * Get bufferqueue data from the blockpool data.
      *
-     * @param poolData  blockpool data
-     * @param igbp_id   pointer to id of igbp to be stored
-     * @param igbp_slot pointer to slot of igbp to be stored
+     * Calling this function with \p bpId set to nullptr will return whether the
+     * block comes from a bufferqueue-based blockpool.
      *
-     * @return {@code true} when there is valid bufferqueue data, {@code false} otherwise.
+     * \param[in]  poolData blockpool data
+     * \param[out] bqId     Id of the bufferqueue owning the buffer (block)
+     * \param[out] bqSlot   Slot number of the buffer
+     *
+     * \return {\code true} when there is valid bufferqueue data;
+     *         {\code false} otherwise.
      */
     static
     bool GetBufferQueueData(
-            const std::shared_ptr<const _C2BlockPoolData> &poolData,
-            uint64_t *igbp_id,
-            int32_t *igbp_slot);
+            const std::shared_ptr<_C2BlockPoolData>& poolData,
+            uint64_t* bqId = nullptr, int32_t* bqSlot = nullptr);
+
+    /**
+     * Set bufferqueue assignment and "held" status to a block created by a
+     * bufferqueue-based blockpool.
+     *
+     * \param poolData blockpool data associated to the block.
+     * \param igbp     \c IGraphicBufferProducer instance from the designated
+     *                 bufferqueue.
+     * \param bqId     Id of the bufferqueue that will own the buffer (block).
+     * \param bqSlot   Slot number of the buffer.
+     * \param held     Whether the block is held. This "held" status can be
+     *                 changed later by calling YieldBlockToBufferQueue() or
+     *                 HoldBlockFromBufferQueue().
+     *
+     * \return \c true if \p poolData is valid bufferqueue data;
+     *         \c false otherwise.
+     *
+     * Note: bqId should match the unique id obtained from igbp->getUniqueId().
+     */
+    static
+    bool AssignBlockToBufferQueue(
+            const std::shared_ptr<_C2BlockPoolData>& poolData,
+            const ::android::sp<::android::hardware::graphics::bufferqueue::
+                                V1_0::IGraphicBufferProducer>& igbp,
+            uint64_t bqId,
+            int32_t bqSlot,
+            bool held = true);
+
+    /**
+     * Hold a block from the designated bufferqueue. This causes the destruction
+     * of the block to trigger a call to cancelBuffer().
+     *
+     * This function assumes that \p poolData comes from a bufferqueue-based
+     * block. It does not check if that is the case.
+     *
+     * \param poolData blockpool data associated to the block.
+     * \param igbp     \c IGraphicBufferProducer instance to be assigned to the
+     *                 block. This is not needed when the block is local.
+     *
+     * \return The previous held status.
+     */
+    static
+    bool HoldBlockFromBufferQueue(
+            const std::shared_ptr<_C2BlockPoolData>& poolData,
+            const ::android::sp<::android::hardware::graphics::bufferqueue::
+                                V1_0::IGraphicBufferProducer>& igbp = nullptr);
+
+    /**
+     * Yield a block to the designated bufferqueue. This causes the destruction
+     * of the block not to trigger a call to cancelBuffer();
+     *
+     * This function assumes that \p poolData comes from a bufferqueue-based
+     * block. It does not check if that is the case.
+     *
+     * \param poolData blockpool data associated to the block.
+     *
+     * \return The previous held status.
+     */
+    static
+    bool YieldBlockToBufferQueue(
+            const std::shared_ptr<_C2BlockPoolData>& poolData);
+
 };
 
 #endif // ANDROID_STAGEFRIGHT_C2BLOCK_INTERNAL_H_
diff --git a/codec2/vndk/platform/C2BqBuffer.cpp b/codec2/vndk/platform/C2BqBuffer.cpp
index a1788ed..3d13e85 100644
--- a/codec2/vndk/platform/C2BqBuffer.cpp
+++ b/codec2/vndk/platform/C2BqBuffer.cpp
@@ -41,75 +41,96 @@
 using ::android::status_t;
 using ::android::wp;
 
-struct C2_HIDE C2BufferQueueBlockPoolData : public _C2BlockPoolData {
+struct C2BufferQueueBlockPoolData : public _C2BlockPoolData {
+
+    bool held;
+    bool local;
+    uint64_t bqId;
+    int32_t bqSlot;
+    sp<HGraphicBufferProducer> igbp;
+    std::shared_ptr<C2BufferQueueBlockPool::Impl> localPool;
 
     virtual type_t getType() const override {
         return TYPE_BUFFERQUEUE;
     }
 
-    void getBufferQueueData(uint64_t *igbp_id, int32_t *igbp_slot) const {
-        *igbp_id = mIgbpId;
-        *igbp_slot = mIgbpSlot;
-    }
-
-    void remove() {
-        mConnected = false;
-    }
-
+    // Create a remote BlockPoolData.
     C2BufferQueueBlockPoolData(
-            uint64_t igbp_id, int32_t igbp_slot)
-            : mLocal(false), mConnected(true), mIgbpId(igbp_id), mIgbpSlot(igbp_slot) {
+            uint64_t bqId, int32_t bqSlot,
+            const sp<HGraphicBufferProducer>& producer = nullptr);
 
-    }
-
-    // in case of connect without attaching from remote side
-    void setOwner(sp<HGraphicBufferProducer> producer) {
-        if (!mLocal && producer) {
-            mProducer = producer;
-        }
-    }
-
-    // in case of attach and connnect from remote side
-    void setNewOwner(sp<HGraphicBufferProducer> producer, uint64_t igbp_id, int32_t igbp_slot) {
-        if (!mLocal && producer) {
-            mProducer = producer;
-            mIgbpId = igbp_id;
-            mIgbpSlot = igbp_slot;
-        }
-    }
-
+    // Create a local BlockPoolData.
     C2BufferQueueBlockPoolData(
-            uint64_t igbp_id, int32_t igbp_slot,
-            std::shared_ptr<C2BufferQueueBlockPool::Impl> pool)
-            : mLocal(true), mConnected(true), mIgbpId(igbp_id), mIgbpSlot(igbp_slot), mPool(pool) {
-        // TODO: use remove when a block is being disconnected. And remove
-        // clearing mConnected.
-        mConnected = false;
-    }
+            uint64_t bqId, int32_t bqSlot,
+            const std::shared_ptr<C2BufferQueueBlockPool::Impl>& pool);
 
     virtual ~C2BufferQueueBlockPoolData() override;
 
-private:
-    bool mLocal;
-    bool mConnected;
-    uint64_t mIgbpId;
-    int32_t mIgbpSlot;
-    std::weak_ptr<C2BufferQueueBlockPool::Impl> mPool;
-    wp<HGraphicBufferProducer> mProducer;
 };
 
 bool _C2BlockFactory::GetBufferQueueData(
-        const std::shared_ptr<const _C2BlockPoolData> &data,
-        uint64_t *igbp_id, int32_t *igbp_slot) {
+        const std::shared_ptr<_C2BlockPoolData>& data,
+        uint64_t* bqId, int32_t* bqSlot) {
     if (data && data->getType() == _C2BlockPoolData::TYPE_BUFFERQUEUE) {
-        const std::shared_ptr<const C2BufferQueueBlockPoolData> poolData =
-                std::static_pointer_cast<const C2BufferQueueBlockPoolData>(data);
-        poolData->getBufferQueueData(igbp_id, igbp_slot);
+        if (bqId) {
+            const std::shared_ptr<C2BufferQueueBlockPoolData> poolData =
+                    std::static_pointer_cast<C2BufferQueueBlockPoolData>(data);
+            *bqId = poolData->bqId;
+            if (bqSlot) {
+                *bqSlot = poolData->bqSlot;
+            }
+        }
         return true;
     }
     return false;
 }
 
+bool _C2BlockFactory::AssignBlockToBufferQueue(
+        const std::shared_ptr<_C2BlockPoolData>& data,
+        const sp<HGraphicBufferProducer>& igbp,
+        uint64_t bqId,
+        int32_t bqSlot,
+        bool held) {
+    if (data && data->getType() == _C2BlockPoolData::TYPE_BUFFERQUEUE) {
+        const std::shared_ptr<C2BufferQueueBlockPoolData> poolData =
+                std::static_pointer_cast<C2BufferQueueBlockPoolData>(data);
+        poolData->igbp = igbp;
+        poolData->bqId = bqId;
+        poolData->bqSlot = bqSlot;
+        poolData->held = held;
+        return true;
+    }
+    return false;
+}
+
+bool _C2BlockFactory::HoldBlockFromBufferQueue(
+        const std::shared_ptr<_C2BlockPoolData>& data,
+        const sp<HGraphicBufferProducer>& igbp) {
+    const std::shared_ptr<C2BufferQueueBlockPoolData> poolData =
+            std::static_pointer_cast<C2BufferQueueBlockPoolData>(data);
+    if (!poolData->local) {
+        poolData->igbp = igbp;
+    }
+    if (poolData->held) {
+        poolData->held = true;
+        return false;
+    }
+    poolData->held = true;
+    return true;
+}
+
+bool _C2BlockFactory::YieldBlockToBufferQueue(
+        const std::shared_ptr<_C2BlockPoolData>& data) {
+    const std::shared_ptr<C2BufferQueueBlockPoolData> poolData =
+            std::static_pointer_cast<C2BufferQueueBlockPoolData>(data);
+    if (!poolData->held) {
+        poolData->held = false;
+        return false;
+    }
+    poolData->held = false;
+    return true;
+}
+
 std::shared_ptr<C2GraphicBlock> _C2BlockFactory::CreateGraphicBlock(
         const C2Handle *handle) {
     // TODO: get proper allocator? and mutex?
@@ -393,23 +414,34 @@
     sp<GraphicBuffer> mBuffers[NUM_BUFFER_SLOTS];
 };
 
-C2BufferQueueBlockPoolData::~C2BufferQueueBlockPoolData() {
-    if (mIgbpId == 0 || mConnected == false) {
-        return;
-    }
-    if (mLocal) {
-        auto lockedPool = mPool.lock();
-        if (lockedPool) {
-            lockedPool->cancel(mIgbpId, mIgbpSlot);
-        }
-    } else {
-        sp<HGraphicBufferProducer> producer = mProducer.promote();
-        if (producer) {
-            producer->cancelBuffer(mIgbpSlot, nullptr);
-        }
-    }
+C2BufferQueueBlockPoolData::C2BufferQueueBlockPoolData(
+        uint64_t bqId, int32_t bqSlot,
+        const sp<HGraphicBufferProducer>& producer) :
+        held(producer && bqId != 0), local(false),
+        bqId(bqId), bqSlot(bqSlot),
+        igbp(producer),
+        localPool() {
 }
 
+C2BufferQueueBlockPoolData::C2BufferQueueBlockPoolData(
+        uint64_t bqId, int32_t bqSlot,
+        const std::shared_ptr<C2BufferQueueBlockPool::Impl>& pool) :
+        held(true), local(true),
+        bqId(bqId), bqSlot(bqSlot),
+        igbp(pool ? pool->mProducer : nullptr),
+        localPool(pool) {
+}
+
+C2BufferQueueBlockPoolData::~C2BufferQueueBlockPoolData() {
+    if (!held || bqId == 0) {
+        return;
+    }
+    if (local && localPool) {
+        localPool->cancel(bqId, bqSlot);
+    } else if (igbp) {
+        igbp->cancelBuffer(bqSlot, nullptr);
+    }
+}
 
 C2BufferQueueBlockPool::C2BufferQueueBlockPool(
         const std::shared_ptr<C2Allocator> &allocator, const local_id_t localId)
diff --git a/media/sfplugin/CCodecBufferChannel.cpp b/media/sfplugin/CCodecBufferChannel.cpp
index af02bd7..d2510e5 100644
--- a/media/sfplugin/CCodecBufferChannel.cpp
+++ b/media/sfplugin/CCodecBufferChannel.cpp
@@ -252,26 +252,6 @@
     DISALLOW_EVIL_CONSTRUCTORS(OutputBuffers);
 };
 
-class CCodecBufferChannel::OutputBufferQueue {
-public:
-    OutputBufferQueue() : mIgbp(nullptr), mIgbpId(0) {}
-    bool isNewIgbp(sp<IGraphicBufferProducer> igbp) {
-        if (!igbp || igbp == mIgbp) return false;
-        mIgbp = igbp;
-        mIgbp->getUniqueId(&mIgbpId);
-        mIgbp->setMaxDequeuedBufferCount(16); // TODO: tune
-        return true;
-    }
-
-    bool isNewIgbpId(uint64_t igbpId) {
-        return igbpId != mIgbpId;
-    }
-
-private:
-    sp<IGraphicBufferProducer> mIgbp;
-    uint64_t mIgbpId;
-};
-
 namespace {
 
 // TODO: get this info from component
@@ -1206,7 +1186,6 @@
       mCCodecCallback(callback),
       mFrameIndex(0u),
       mFirstValidFrameIndex(0u),
-      mOutputBufferQueue(new OutputBufferQueue()),
       mMetaMode(MODE_NONE),
       mPendingFeed(0) {
 }
@@ -1562,23 +1541,11 @@
         std::static_pointer_cast<const C2StreamHdrStaticInfo::output>(
                 c2Buffer->getInfo(C2StreamHdrStaticInfo::output::PARAM_TYPE));
 
-    Mutexed<OutputSurface>::Locked output(mOutputSurface);
-    if (output->surface == nullptr) {
-        ALOGE("no surface");
-        return OK;
-    }
-    sp<IGraphicBufferProducer> igbp = output->surface->getIGraphicBufferProducer();
-    if (mOutputBufferQueue->isNewIgbp(igbp)) {
-        sp<HGraphicBufferProducer> higbp = igbp->getHalInterface();
-        if (!higbp) {
-            higbp = new TWGraphicBufferProducer<HGraphicBufferProducer>(igbp);
-        }
-        Mutexed<BlockPools>::Locked pools(mBlockPools);
-        // set output surface for managed pools (other than ion or gralloc-backed pool)
-        if (pools->outputPoolId >= C2BlockPool::PLATFORM_START
-                && pools->outputAllocatorId != C2PlatformAllocatorStore::GRALLOC
-                && pools->outputAllocatorId != C2PlatformAllocatorStore::ION) {
-            mComponent->setOutputSurface(pools->outputPoolId, higbp);
+    {
+        Mutexed<OutputSurface>::Locked output(mOutputSurface);
+        if (output->surface == nullptr) {
+            ALOGE("no surface");
+            return OK;
         }
     }
 
@@ -1589,42 +1556,6 @@
     }
     const C2ConstGraphicBlock &block = blocks.front();
 
-    native_handle_t *grallocHandle = UnwrapNativeCodec2GrallocHandle(block.handle());
-    uint32_t width;
-    uint32_t height;
-    uint32_t format;
-    uint64_t usage;
-    uint32_t stride;
-    uint64_t igbp_id;
-    int32_t igbp_slot;
-    _UnwrapNativeCodec2GrallocMetadata(
-            block.handle(), &width, &height, &format, &usage, &stride,
-            &igbp_id, (uint32_t *)&igbp_slot);
-    ALOGV("attaching buffer (%u*%u): (%u*%u, fmt %#x, usage %#llx, stride %u)",
-            block.width(),
-            block.height(),
-            width, height, format, (long long)usage, stride);
-
-    status_t result = OK;
-    if (mOutputBufferQueue->isNewIgbpId(igbp_id)) {
-        sp<GraphicBuffer> graphicBuffer(new GraphicBuffer(
-                grallocHandle,
-                GraphicBuffer::CLONE_HANDLE,
-                width, height, format, 1, usage, stride));
-        // TODO: detach?
-        graphicBuffer->setGenerationNumber(output->generation);
-        result = igbp->attachBuffer(&igbp_slot, graphicBuffer);
-        if (result != OK) {
-            native_handle_delete(grallocHandle);
-            ALOGI("attachBuffer failed: %d", result);
-            return result;
-        }
-        ALOGV("attach buffer from %" PRIu64 " : %d", igbp_id, igbp_slot);
-    } else {
-        ALOGV("dequeued buffer arrived %" PRIu64 " %d", igbp_id, igbp_slot);
-    }
-    native_handle_delete(grallocHandle);
-
     // TODO: revisit this after C2Fence implementation.
     android::IGraphicBufferProducer::QueueBufferInput qbi(
             timestampNs,
@@ -1667,7 +1598,7 @@
         qbi.setHdrMetadata(hdr);
     }
     android::IGraphicBufferProducer::QueueBufferOutput qbo;
-    result = igbp->queueBuffer(igbp_slot, qbi, &qbo);
+    status_t result = mComponent->queueToOutputSurface(block, qbi, &qbo);
     if (result != OK) {
         ALOGE("queueBuffer failed: %d", result);
         return result;
@@ -1848,14 +1779,18 @@
     }
 
     if (outputFormat != nullptr) {
-        bool hasOutputSurface = false;
+        sp<IGraphicBufferProducer> outputSurface;
+        uint32_t outputGeneration;
         {
             Mutexed<OutputSurface>::Locked output(mOutputSurface);
-            hasOutputSurface = (output->surface != nullptr);
+            outputSurface = output->surface ?
+                    output->surface->getIGraphicBufferProducer() : nullptr;
+            outputGeneration = output->generation;
         }
 
         bool graphic = (oStreamFormat.value == C2FormatVideo);
         C2BlockPool::local_id_t outputPoolId_;
+
         {
             Mutexed<BlockPools>::Locked pools(mBlockPools);
 
@@ -1891,7 +1826,7 @@
 
             // use bufferqueue if outputting to a surface
             if (pools->outputAllocatorId == C2PlatformAllocatorStore::GRALLOC
-                    && hasOutputSurface
+                    && outputSurface
                     && ((poolMask >> C2PlatformAllocatorStore::BUFFERQUEUE) & 1)) {
                 pools->outputAllocatorId = C2PlatformAllocatorStore::BUFFERQUEUE;
             }
@@ -1927,7 +1862,7 @@
         Mutexed<std::unique_ptr<OutputBuffers>>::Locked buffers(mOutputBuffers);
 
         if (graphic) {
-            if (hasOutputSurface) {
+            if (outputSurface) {
                 buffers->reset(new GraphicOutputBuffers);
             } else {
                 buffers->reset(new RawGraphicOutputBuffers);
@@ -1939,16 +1874,11 @@
 
 
         // Try to set output surface to created block pool if given.
-        if (hasOutputSurface) {
-            Mutexed<OutputSurface>::Locked output(mOutputSurface);
-            sp<IGraphicBufferProducer> igbp = output->surface->getIGraphicBufferProducer();
-            if (mOutputBufferQueue->isNewIgbp(igbp)) {
-                sp<HGraphicBufferProducer> higbp = igbp->getHalInterface();
-                if (!higbp) {
-                    higbp = new TWGraphicBufferProducer<HGraphicBufferProducer>(igbp);
-                }
-                mComponent->setOutputSurface(outputPoolId_, higbp);
-            }
+        if (outputSurface) {
+            mComponent->setOutputSurface(
+                    outputPoolId_,
+                    outputSurface,
+                    outputGeneration);
         }
 
         if (oStreamFormat.value == C2FormatAudio) {
@@ -2167,7 +2097,6 @@
         newSurface->setMaxDequeuedBufferCount(kMinOutputBufferArraySize);
     }
 
-    Mutexed<OutputSurface>::Locked output(mOutputSurface);
 //    if (newSurface == nullptr) {
 //        if (*surface != nullptr) {
 //            ALOGW("cannot unset a surface");
@@ -2181,15 +2110,41 @@
 //        return INVALID_OPERATION;
 //    }
 
-    output->surface = newSurface;
+    uint32_t generation;
+
     ANativeWindowBuffer *buf;
-    ANativeWindow *window = output->surface.get();
+    ANativeWindow *window = newSurface.get();
     int fenceFd;
     window->dequeueBuffer(window, &buf, &fenceFd);
     sp<GraphicBuffer> gbuf = GraphicBuffer::from(buf);
-    output->generation = gbuf->getGenerationNumber();
+    generation = gbuf->getGenerationNumber();
     window->cancelBuffer(window, buf, fenceFd);
 
+    std::shared_ptr<Codec2Client::Configurable> outputPoolIntf;
+    C2BlockPool::local_id_t outputPoolId;
+    {
+        Mutexed<BlockPools>::Locked pools(mBlockPools);
+        outputPoolId = pools->outputPoolId;
+        outputPoolIntf = pools->outputPoolIntf;
+    }
+
+    if (outputPoolIntf) {
+        if (mComponent->setOutputSurface(
+                outputPoolId,
+                newSurface->getIGraphicBufferProducer(),
+                generation) != C2_OK) {
+            ALOGW("setSurface -- setOutputSurface() failed to configure "
+                    "new surface to the component's output block pool.");
+            return INVALID_OPERATION;
+        }
+    }
+
+    {
+        Mutexed<OutputSurface>::Locked output(mOutputSurface);
+        output->surface = newSurface;
+        output->generation = generation = gbuf->getGenerationNumber();
+    }
+
     return OK;
 }
 
diff --git a/media/sfplugin/CCodecBufferChannel.h b/media/sfplugin/CCodecBufferChannel.h
index 4762c33..2127e2b 100644
--- a/media/sfplugin/CCodecBufferChannel.h
+++ b/media/sfplugin/CCodecBufferChannel.h
@@ -130,7 +130,6 @@
     class Buffers;
     class InputBuffers;
     class OutputBuffers;
-    class OutputBufferQueue;
 
 private:
     class QueueGuard;
@@ -213,7 +212,6 @@
         uint32_t generation;
     };
     Mutexed<OutputSurface> mOutputSurface;
-    std::unique_ptr<OutputBufferQueue> mOutputBufferQueue;
 
     struct BlockPools {
         C2Allocator::id_t inputAllocatorId;