| // Copyright 2019 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include <fake_codec_adapter.h> | |
| #include <fuchsia/media/cpp/fidl.h> | |
| #include <fuchsia/mediacodec/cpp/fidl.h> | |
| #include <fuchsia/sysmem/cpp/fidl.h> | |
| #include <fuchsia/sysmem2/cpp/fidl_test_base.h> | |
| #include <lib/async-loop/cpp/loop.h> | |
| #include <lib/async-loop/default.h> | |
| #include <lib/sync/cpp/completion.h> | |
| #include <atomic> | |
| #include <thread> | |
| #include <gtest/gtest.h> | |
| #include "lib/media/codec_impl/codec_impl.h" | |
| #include "src/lib/testing/loop_fixture/real_loop_fixture.h" | |
| class CodecPacketForTest { | |
| public: | |
| static bool IsQueued(const CodecPacket* packet) { return packet->is_queued(); } | |
| }; | |
| namespace { | |
| constexpr uint32_t kInputMinBufferCountForCamping = 3; | |
| constexpr uint64_t kInputBufferSize = 4096; | |
| constexpr uint32_t kOutputBufferCount = 5; | |
| constexpr uint64_t kOutputBufferSize = 256ULL * 144 * 4; | |
| constexpr uint32_t kTestPacketValidLengthBytes = 16; | |
| constexpr zx::duration kWaitTimeout = zx::sec(30); | |
| void PopulateTestBufferSettings(fuchsia::sysmem2::BufferMemorySettings* buffer_settings, | |
| uint64_t size_bytes) { | |
| buffer_settings->set_size_bytes(size_bytes); | |
| buffer_settings->set_raw_vmo_size(size_bytes); | |
| buffer_settings->set_is_physically_contiguous(false); | |
| buffer_settings->set_is_secure(false); | |
| buffer_settings->set_coherency_domain(fuchsia::sysmem2::CoherencyDomain::CPU); | |
| buffer_settings->mutable_heap()->set_heap_type("fuchsia.sysmem.HeapType.SYSTEM_RAM").set_id(0); | |
| } | |
| auto CreateDecoderParams() { | |
| fuchsia::mediacodec::CreateDecoder_Params params; | |
| params.mutable_input_details()->set_format_details_version_ordinal(0); | |
| return params; | |
| } | |
| auto CreateStreamBufferPartialSettings( | |
| uint64_t buffer_lifetime_ordinal, const fuchsia::media::StreamBufferConstraints& constraints, | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token) { | |
| fuchsia::media::StreamBufferPartialSettings settings; | |
| settings.set_buffer_lifetime_ordinal(buffer_lifetime_ordinal) | |
| .set_buffer_constraints_version_ordinal(constraints.buffer_constraints_version_ordinal()) | |
| .set_sysmem2_token(std::move(token)); | |
| return settings; | |
| } | |
| auto CreateValidInputBufferCollectionConstraints() { | |
| fuchsia_sysmem2::BufferCollectionConstraints result; | |
| result.usage().emplace().cpu() = | |
| fuchsia::sysmem::cpuUsageRead | fuchsia::sysmem::cpuUsageReadOften; | |
| result.min_buffer_count_for_camping() = kInputMinBufferCountForCamping; | |
| // Must emplace the buffer_memory_constraints here, as enforced by CodecImpl. Leaving all | |
| // buffer_memory_constraints fields default is fine. | |
| result.buffer_memory_constraints().emplace(); | |
| return result; | |
| } | |
| auto CreateValidOutputBufferCollectionConstraints() { | |
| fuchsia_sysmem2::BufferCollectionConstraints result; | |
| result.usage().emplace().cpu() = | |
| fuchsia::sysmem::cpuUsageWrite | fuchsia::sysmem::cpuUsageWriteOften; | |
| result.min_buffer_count_for_camping() = kOutputBufferCount; | |
| auto& bmc = result.buffer_memory_constraints().emplace(); | |
| bmc.min_size_bytes() = kOutputBufferSize; | |
| bmc.cpu_domain_supported() = true; | |
| return result; | |
| } | |
| auto CreateInputPacket() { | |
| fuchsia::media::Packet input_packet; | |
| input_packet.mutable_header()->set_buffer_lifetime_ordinal(1).set_packet_index(0); | |
| input_packet.set_buffer_index(0) | |
| .set_stream_lifetime_ordinal(1) | |
| .set_start_offset(0) | |
| .set_valid_length_bytes(kTestPacketValidLengthBytes); | |
| return input_packet; | |
| } | |
| class TestBufferCollection : public fuchsia::sysmem2::testing::BufferCollection_TestBase { | |
| public: | |
| TestBufferCollection() : binding_(this) {} | |
| void Bind(fidl::InterfaceRequest<fuchsia::sysmem2::BufferCollection> request) { | |
| binding_.Bind(std::move(request)); | |
| } | |
| void NotImplemented_(const std::string& name) override {} | |
| void WaitForAllBuffersAllocated(WaitForAllBuffersAllocatedCallback callback) override { | |
| wait_callback_ = std::move(callback); | |
| } | |
| void CheckAllBuffersAllocated(CheckAllBuffersAllocatedCallback callback) override { | |
| fuchsia::sysmem2::BufferCollection_CheckAllBuffersAllocated_Result result; | |
| result.set_response({}); | |
| callback(std::move(result)); | |
| } | |
| void FailAllocation() { | |
| WaitForAllBuffersAllocatedCallback callback; | |
| callback.swap(wait_callback_); | |
| fuchsia::sysmem2::BufferCollection_WaitForAllBuffersAllocated_Result result; | |
| result.set_err(fuchsia::sysmem2::Error::CONSTRAINTS_INTERSECTION_EMPTY); | |
| callback(std::move(result)); | |
| } | |
| void CompleteAllocation(uint32_t buffer_count, uint64_t size_bytes) { | |
| WaitForAllBuffersAllocatedCallback callback; | |
| callback.swap(wait_callback_); | |
| fuchsia::sysmem2::BufferCollectionInfo info; | |
| PopulateTestBufferSettings(info.mutable_settings()->mutable_buffer_settings(), size_bytes); | |
| for (uint32_t i = 0; i < buffer_count; ++i) { | |
| zx::vmo vmo; | |
| ZX_ASSERT(zx::vmo::create(size_bytes, 0, &vmo) == ZX_OK); | |
| fuchsia::sysmem2::VmoBuffer vmo_buffer; | |
| vmo_buffer.set_vmo(std::move(vmo)); | |
| vmo_buffer.set_vmo_usable_start(0); | |
| info.mutable_buffers()->push_back(std::move(vmo_buffer)); | |
| } | |
| fuchsia::sysmem2::BufferCollection_WaitForAllBuffersAllocated_Response response; | |
| response.set_buffer_collection_info(std::move(info)); | |
| fuchsia::sysmem2::BufferCollection_WaitForAllBuffersAllocated_Result result; | |
| result.set_response(std::move(response)); | |
| callback(std::move(result)); | |
| } | |
| bool is_waiting() const { return !!wait_callback_; } | |
| private: | |
| fidl::Binding<fuchsia::sysmem2::BufferCollection> binding_; | |
| WaitForAllBuffersAllocatedCallback wait_callback_; | |
| }; | |
| class TestAllocator : public fuchsia::sysmem2::testing::Allocator_TestBase { | |
| public: | |
| TestAllocator() : binding_(this) {} | |
| void Bind(fidl::InterfaceRequest<fuchsia::sysmem2::Allocator> request) { | |
| binding_.Bind(std::move(request)); | |
| } | |
| void BindSharedCollection( | |
| ::fuchsia::sysmem2::AllocatorBindSharedCollectionRequest request) override { | |
| auto col = std::make_unique<TestBufferCollection>(); | |
| col->Bind(std::move(*request.mutable_buffer_collection_request())); | |
| collections_.push_back(std::move(col)); | |
| } | |
| void SetDebugClientInfo(::fuchsia::sysmem2::AllocatorSetDebugClientInfoRequest request) override { | |
| } | |
| void GetVmoInfo(::fuchsia::sysmem2::AllocatorGetVmoInfoRequest request, | |
| GetVmoInfoCallback callback) override { | |
| uint64_t vmo_size = 0; | |
| ZX_ASSERT(request.vmo().get_size(&vmo_size) == ZX_OK); | |
| fuchsia::sysmem2::Allocator_GetVmoInfo_Response response; | |
| response.set_buffer_collection_id(1); | |
| response.set_buffer_index(0); | |
| response.set_constraints_ok(true); | |
| if (request.has_vmo_settings_to_check()) { | |
| response.set_vmo_settings_match(true); | |
| } | |
| PopulateTestBufferSettings(response.mutable_single_buffer_settings()->mutable_buffer_settings(), | |
| vmo_size); | |
| callback(fuchsia::sysmem2::Allocator_GetVmoInfo_Result::WithResponse(std::move(response))); | |
| } | |
| void NotImplemented_(const std::string& name) override { | |
| // Unexpected. | |
| ZX_PANIC("NotImplemented_(): %s", name.c_str()); | |
| } | |
| TestBufferCollection& collection(size_t index = 0) { return *collections_.at(index); } | |
| size_t collection_count() const { return collections_.size(); } | |
| private: | |
| fidl::Binding<fuchsia::sysmem2::Allocator> binding_; | |
| std::vector<std::unique_ptr<TestBufferCollection>> collections_; | |
| }; | |
| class CodecImplFailures : public gtest::RealLoopFixture { | |
| public: | |
| using StreamProcessorPtr = ::fuchsia::media::StreamProcessorPtr; | |
| void TearDown() override { token_request_ = nullptr; } | |
| virtual std::unique_ptr<FakeCodecAdapter> CreateCodecAdapter() { | |
| auto codec_adapter = std::make_unique<FakeCodecAdapter>(codec_impl_->lock(), codec_impl_.get()); | |
| codec_adapter_ = codec_adapter.get(); | |
| return codec_adapter; | |
| } | |
| void Create(fidl::InterfaceRequest<fuchsia::media::StreamProcessor> request, | |
| fit::function<void(FakeCodecAdapter*)> configure_adapter = nullptr) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::Allocator> sysmem; | |
| sysmem_request_ = sysmem.NewRequest(); | |
| codec_impl_ = std::make_unique<CodecImpl>( | |
| fidl::ClientEnd<fuchsia_sysmem2::Allocator>(sysmem.TakeChannel()), nullptr, dispatcher(), | |
| CreateDecoderParams(), std::move(request)); | |
| auto codec_adapter = CreateCodecAdapter(); | |
| if (configure_adapter) { | |
| configure_adapter(codec_adapter_); | |
| } | |
| codec_impl_->SetCoreCodecAdapter(std::move(codec_adapter)); | |
| codec_impl_->BindAsync([this] { | |
| error_handler_ran_ = true; | |
| codec_adapter_ = nullptr; | |
| codec_impl_ = nullptr; | |
| }); | |
| } | |
| protected: | |
| static bool IsPacketQueued(const CodecPacket* packet) { | |
| return CodecPacketForTest::IsQueued(packet); | |
| } | |
| uint64_t GetSharedFidlForStreamWaitCount() { | |
| return codec_impl_->GetSharedFidlForStreamWaitCountForTesting(); | |
| } | |
| void WaitForSharedFidlForStreamWaitCount(uint64_t expected_count) { | |
| codec_impl_->WaitForSharedFidlForStreamWaitCountForTesting(expected_count); | |
| } | |
| void EmitOutputPacketFromCoreCodecThread(CodecPacket* packet, const CodecBuffer* buffer, | |
| std::atomic<bool>* emitted_flag = nullptr, | |
| zx::vmo* child_vmo_to_reset = nullptr) { | |
| std::thread([this, packet, buffer, emitted_flag, child_vmo_to_reset] { | |
| packet->SetBuffer(buffer); | |
| packet->SetStartOffset(0); | |
| packet->SetValidLengthBytes(kTestPacketValidLengthBytes); | |
| if (emitted_flag) { | |
| *emitted_flag = true; | |
| } | |
| static_cast<CodecAdapterEvents*>(codec_impl_.get()) | |
| ->onCoreCodecOutputPacket(packet, false, false); | |
| if (child_vmo_to_reset) { | |
| child_vmo_to_reset->reset(); | |
| } | |
| }).join(); | |
| } | |
| void WaitForAndCompleteCollectionAllocation(TestAllocator& allocator, size_t collection_index, | |
| uint32_t buffer_count, uint64_t buffer_size) { | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&allocator, collection_index, this] { | |
| return error_handler_ran_ || (allocator.collection_count() > collection_index && | |
| allocator.collection(collection_index).is_waiting()); | |
| }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| allocator.collection(collection_index).CompleteAllocation(buffer_count, buffer_size); | |
| } | |
| // Just cache this request so that we can have a valid sysmem handle | |
| std::optional<fidl::InterfaceRequest<fuchsia::sysmem2::Allocator>> sysmem_request_; | |
| std::optional<fidl::InterfaceRequest<fuchsia::sysmem2::BufferCollectionToken>> token_request_; | |
| bool error_handler_ran_ = false; | |
| std::unique_ptr<CodecImpl> codec_impl_; | |
| FakeCodecAdapter* codec_adapter_; | |
| }; | |
| TEST_F(CodecImplFailures, InputBufferCollectionConstraintsCpuUsage) { | |
| StreamProcessorPtr processor; | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| auto buffer_collection_constraints = CreateValidInputBufferCollectionConstraints(); | |
| // Setting write usage on input buffers is invalid and will result in codec | |
| // failure | |
| buffer_collection_constraints.usage()->cpu() = | |
| fuchsia::sysmem::cpuUsageWrite | fuchsia::sysmem::cpuUsageWriteOften; | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| std::move(buffer_collection_constraints)); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| }; | |
| Create(processor.NewRequest()); | |
| RunLoopUntil([this]() { return error_handler_ran_; }); | |
| ASSERT_TRUE(error_handler_ran_); | |
| } | |
| // TODO(https://fxbug.dev/577201084): Remove once API level 33 is retired and v1 token support is | |
| // removed. | |
| TEST_F(CodecImplFailures, InputBufferCollectionConstraintsCpuUsageV1Token) { | |
| StreamProcessorPtr processor; | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| auto buffer_collection_constraints = CreateValidInputBufferCollectionConstraints(); | |
| // Setting write usage on input buffers is invalid and will result in codec | |
| // failure | |
| buffer_collection_constraints.usage()->cpu() = | |
| fuchsia::sysmem::cpuUsageWrite | fuchsia::sysmem::cpuUsageWriteOften; | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| std::move(buffer_collection_constraints)); | |
| fuchsia::media::StreamBufferPartialSettings settings; | |
| settings.set_buffer_lifetime_ordinal(1) | |
| .set_buffer_constraints_version_ordinal( | |
| input_constraints.buffer_constraints_version_ordinal()) | |
| .set_sysmem_token( | |
| fidl::InterfaceHandle<fuchsia::sysmem::BufferCollectionToken>(token.TakeChannel())); | |
| processor->SetInputBufferPartialSettings(std::move(settings)); | |
| }; | |
| Create(processor.NewRequest()); | |
| RunLoopUntil([this]() { return error_handler_ran_; }); | |
| ASSERT_TRUE(error_handler_ran_); | |
| } | |
| TEST_F(CodecImplFailures, InputBufferCollectionConstraintsMinBufferCount) { | |
| StreamProcessorPtr processor; | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| auto buffer_collection_constraints = CreateValidInputBufferCollectionConstraints(); | |
| // No buffers required for camping would be less than the minimum for the | |
| // server | |
| buffer_collection_constraints.min_buffer_count_for_camping() = 0; | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| std::move(buffer_collection_constraints)); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| }; | |
| Create(processor.NewRequest()); | |
| RunLoopUntil([this]() { return error_handler_ran_; }); | |
| ASSERT_TRUE(error_handler_ran_); | |
| } | |
| TEST_F(CodecImplFailures, InputBufferCollectionSysmemFailure) { | |
| StreamProcessorPtr processor; | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| CreateValidInputBufferCollectionConstraints()); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| }; | |
| Create(processor.NewRequest()); | |
| TestAllocator allocator; | |
| ASSERT_TRUE(sysmem_request_.has_value()); | |
| allocator.Bind(std::move(sysmem_request_.value())); | |
| sysmem_request_ = nullptr; | |
| RunLoopUntil([&allocator] { | |
| return allocator.collection_count() >= 1 && allocator.collection(0).is_waiting(); | |
| }); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_TRUE(allocator.collection(0).is_waiting()); | |
| allocator.collection(0).FailAllocation(); | |
| RunLoopUntil([this] { return error_handler_ran_; }); | |
| ASSERT_TRUE(error_handler_ran_); | |
| } | |
| TEST_F(CodecImplFailures, InputBufferCollectionSysmemFailureDuringDestruction) { | |
| StreamProcessorPtr processor; | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| CreateValidInputBufferCollectionConstraints()); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| }; | |
| Create(processor.NewRequest()); | |
| TestAllocator allocator; | |
| ASSERT_TRUE(sysmem_request_.has_value()); | |
| allocator.Bind(std::move(sysmem_request_.value())); | |
| sysmem_request_ = nullptr; | |
| RunLoopUntil([&allocator] { | |
| return allocator.collection_count() >= 1 && allocator.collection(0).is_waiting(); | |
| }); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_TRUE(allocator.collection(0).is_waiting()); | |
| // Fail allocation and immediately destroy CodecImpl and close processor client. | |
| allocator.collection(0).FailAllocation(); | |
| codec_impl_ = nullptr; | |
| processor = nullptr; | |
| // Run remaining loop tasks to ensure any pending FIDL error handlers on shared_fidl_thread | |
| // execute safely without Use-After-Free or misaligned address crashes. | |
| RunLoopUntilIdle(); | |
| } | |
| TEST_F(CodecImplFailures, OutputPacketOnFirstBufferAddInNonDynamicMode) { | |
| StreamProcessorPtr processor; | |
| std::optional<fidl::InterfaceRequest<fuchsia::sysmem2::BufferCollectionToken>> | |
| output_token_request; | |
| std::atomic<bool> output_packet_emitted = false; | |
| bool client_received_output_packet = false; | |
| CodecPacket* first_recycled_packet = nullptr; | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| CreateValidInputBufferCollectionConstraints()); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| }; | |
| processor.events().OnOutputConstraints = [&](auto output_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| output_token_request = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kOutputPort, | |
| CreateValidOutputBufferCollectionConstraints()); | |
| processor->SetOutputBufferPartialSettings(CreateStreamBufferPartialSettings( | |
| 1, output_constraints.buffer_constraints(), std::move(token))); | |
| }; | |
| processor.events().OnOutputPacket = [&](fuchsia::media::Packet packet, bool error_before, | |
| bool error_during) { | |
| client_received_output_packet = true; | |
| }; | |
| Create(processor.NewRequest(), [&](FakeCodecAdapter* adapter) { | |
| adapter->SetSupportsDynamicBuffers(true); | |
| adapter->SetOnRecycleOutputPacket([&](CodecPacket* packet) { | |
| if (!first_recycled_packet) { | |
| first_recycled_packet = packet; | |
| } | |
| }); | |
| adapter->SetOnAddBuffer([&](CodecPort port, const CodecBuffer* buffer) { | |
| if (port == kOutputPort && buffer->index() == 0) { | |
| ASSERT_NE(first_recycled_packet, nullptr); | |
| // At this point inside ScopedUnlock of buffer 0 (out of 5): | |
| // - is_port_configured_[kOutputPort] is false (current_buffers.size() == 1 < 5) | |
| // - CompleteOutputBufferPartialSettings has not been received yet. | |
| // Emit an output packet from a core codec thread. | |
| EmitOutputPacketFromCoreCodecThread(first_recycled_packet, buffer, &output_packet_emitted); | |
| } | |
| }); | |
| }); | |
| TestAllocator allocator; | |
| ASSERT_TRUE(sysmem_request_.has_value()); | |
| allocator.Bind(std::move(sysmem_request_.value())); | |
| sysmem_request_ = nullptr; | |
| // Complete input buffer allocation. | |
| WaitForAndCompleteCollectionAllocation(allocator, 0, kInputMinBufferCountForCamping, | |
| kInputBufferSize); | |
| // QueueInputPacket starts the stream; since IsCoreCodecRequiringOutputConfigForFormatDetection() | |
| // is true by default, StartNewStream sends OnOutputConstraints (with PausedOutput) and waits for | |
| // output configuration. | |
| processor->QueueInputPacket(CreateInputPacket()); | |
| // Wait for output buffer collection to start waiting, then complete allocation. | |
| WaitForAndCompleteCollectionAllocation(allocator, 1, kOutputBufferCount, kOutputBufferSize); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([&] { return error_handler_ran_ || output_packet_emitted; }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_TRUE(output_packet_emitted); | |
| // Verify PausedOutput holds back the output packet prior to CompleteOutputBufferPartialSettings. | |
| RunLoopUntilIdle(); | |
| ASSERT_FALSE(client_received_output_packet); | |
| // Now send CompleteOutputBufferPartialSettings so PausedOutput unpauses and delivers the packet. | |
| processor->CompleteOutputBufferPartialSettings(1); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { return error_handler_ran_ || client_received_output_packet; }, kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_TRUE(client_received_output_packet); | |
| processor.Unbind(); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([this] { return !codec_impl_; }, kWaitTimeout)); | |
| } | |
| TEST_F(CodecImplFailures, OutputPacketWithOldOrdinalWhenPortDeconfigured) { | |
| StreamProcessorPtr processor; | |
| std::optional<fidl::InterfaceRequest<fuchsia::sysmem2::BufferCollectionToken>> | |
| output_token_request; | |
| CodecPacket* saved_output_packet = nullptr; | |
| const CodecBuffer* saved_output_buffer = nullptr; | |
| zx::vmo retained_child_vmo; | |
| std::atomic<bool> stream_started = false; | |
| std::atomic<bool> remove_buffer_called = false; | |
| bool second_output_constraints_received = false; | |
| std::atomic<bool> old_packet_emitted_after_deconfig = false; | |
| std::atomic<bool> old_packet_recycled_back = false; | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| CreateValidInputBufferCollectionConstraints()); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| }; | |
| // A real client responds to every action-required OnOutputConstraints by configuring new output | |
| // buffers. In this test, we only configure output buffers for the first OnOutputConstraints and | |
| // intentionally ignore the second one so that the output port remains in the deconfigured state | |
| // (is_port_configured_[kOutputPort] == false, buffer_lifetime_ordinal_[kOutputPort] == 2) while | |
| // we verify that a late output packet from ordinal 1 is cleanly recycled back without crashing. | |
| bool sent_output_settings = false; | |
| processor.events().OnOutputConstraints = [&](auto output_constraints) { | |
| if (!sent_output_settings) { | |
| sent_output_settings = true; | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| output_token_request = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints( | |
| kOutputPort, CreateValidOutputBufferCollectionConstraints()); | |
| processor->SetOutputBufferPartialSettings(CreateStreamBufferPartialSettings( | |
| 1, output_constraints.buffer_constraints(), std::move(token))); | |
| } else { | |
| second_output_constraints_received = true; | |
| } | |
| }; | |
| Create(processor.NewRequest(), [&](FakeCodecAdapter* adapter) { | |
| adapter->SetSupportsDynamicBuffers(true); | |
| adapter->SetOnStartStream([&] { stream_started = true; }); | |
| adapter->SetOnRecycleOutputPacket([&](CodecPacket* packet) { | |
| if (!saved_output_packet) { | |
| saved_output_packet = packet; | |
| } else if (old_packet_emitted_after_deconfig && packet == saved_output_packet) { | |
| old_packet_recycled_back = true; | |
| } | |
| }); | |
| adapter->SetOnAddBuffer([&](CodecPort port, const CodecBuffer* buffer) { | |
| if (port == kOutputPort && buffer->index() == 0) { | |
| saved_output_buffer = buffer; | |
| // Hold a child VMO handle obtained during AddBuffer so the old buffer_lifetime_ordinal | |
| // remains active after EnsureBuffersNotConfigured resets until_remove_started_child_vmo_. | |
| retained_child_vmo = buffer->GetChildVmo(); | |
| } | |
| }); | |
| adapter->SetOnRemoveBuffer([&](CodecPort port, const CodecBuffer* buffer) { | |
| if (port == kOutputPort && buffer->index() == 0) { | |
| remove_buffer_called = true; | |
| } | |
| }); | |
| }); | |
| TestAllocator allocator; | |
| ASSERT_TRUE(sysmem_request_.has_value()); | |
| allocator.Bind(std::move(sysmem_request_.value())); | |
| sysmem_request_ = nullptr; | |
| // Complete input buffer allocation. | |
| WaitForAndCompleteCollectionAllocation(allocator, 0, kInputMinBufferCountForCamping, | |
| kInputBufferSize); | |
| processor->QueueInputPacket(CreateInputPacket()); | |
| // Complete output buffer allocation and CompleteOutputBufferPartialSettings(1). | |
| WaitForAndCompleteCollectionAllocation(allocator, 1, kOutputBufferCount, kOutputBufferSize); | |
| processor->CompleteOutputBufferPartialSettings(1); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { return error_handler_ran_ || (saved_output_buffer != nullptr && stream_started); }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| // Trigger a mid-stream output constraints change so EnsureBuffersNotConfigured(kOutputPort) | |
| // sets is_port_configured_[kOutputPort] = false, buffer_lifetime_ordinal_[kOutputPort] = 2, | |
| // and resets buffer.until_remove_started_child_vmo_. | |
| uint64_t version = codec_adapter_->IncrementConstraintsVersion(kOutputPort); | |
| std::thread([this, version] { | |
| static_cast<CodecAdapterEvents*>(codec_impl_.get()) | |
| ->onCoreCodecMidStreamOutputConstraintsChange2(version); | |
| }).join(); | |
| // Wait until EnsureBuffersNotConfigured has completed and the second OnOutputConstraints event | |
| // has been received by the client. | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { | |
| return error_handler_ran_ || (remove_buffer_called && second_output_constraints_received); | |
| }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| // Now that EnsureBuffersNotConfigured has completed (until_remove_started_child_vmo_ is reset, | |
| // is_port_configured_[kOutputPort] is false, buffer_lifetime_ordinal_[kOutputPort] is 2), emit | |
| // an output packet from ordinal 1 and immediately release the adapter's retained_child_vmo so | |
| // that CodecPacket's buffer_keep_alive_ is solely responsible for keeping the buffer alive until | |
| // short_circuit_packet recycles it on shared_fidl_thread_. | |
| EmitOutputPacketFromCoreCodecThread(saved_output_packet, saved_output_buffer, | |
| &old_packet_emitted_after_deconfig, &retained_child_vmo); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { | |
| return error_handler_ran_ || | |
| (old_packet_emitted_after_deconfig && old_packet_recycled_back); | |
| }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_TRUE(old_packet_emitted_after_deconfig); | |
| ASSERT_TRUE(old_packet_recycled_back); | |
| processor.Unbind(); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([this] { return !codec_impl_; }, kWaitTimeout)); | |
| } | |
| TEST_F(CodecImplFailures, RemoveBufferInNonDynamicModeForActiveOrdinalFails) { | |
| StreamProcessorPtr processor; | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| CreateValidInputBufferCollectionConstraints()); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| // Calling RemoveBuffer on the active buffer_lifetime_ordinal (1) when in non-dynamic buffer | |
| // mode must fail the protocol check at RemoveBufferInternal. | |
| fuchsia::media::StreamProcessorRemoveBufferRequest remove_request; | |
| remove_request.set_port(fuchsia::media::Port::INPUT) | |
| .set_buffer_lifetime_ordinal(1) | |
| .set_buffer_index(0); | |
| processor->RemoveBuffer(std::move(remove_request), [](auto) {}); | |
| }; | |
| Create(processor.NewRequest()); | |
| RunLoopUntil([this] { return error_handler_ran_; }); | |
| ASSERT_TRUE(error_handler_ran_); | |
| } | |
| TEST_F(CodecImplFailures, | |
| OutputPacketWithOldOrdinalDeliveredWithEnableOldOutputBuffersAndRemoveBuffer) { | |
| StreamProcessorPtr processor; | |
| std::optional<fidl::InterfaceRequest<fuchsia::sysmem2::BufferCollectionToken>> | |
| output_token_request_1; | |
| std::optional<fidl::InterfaceRequest<fuchsia::sysmem2::BufferCollectionToken>> | |
| output_token_request_2; | |
| CodecPacket* saved_output_packet = nullptr; | |
| const CodecBuffer* saved_output_buffer = nullptr; | |
| zx::vmo retained_child_vmo; | |
| std::atomic<bool> stream_started = false; | |
| std::atomic<bool> remove_buffer_called = false; | |
| bool second_output_constraints_received = false; | |
| fuchsia::media::StreamOutputConstraints second_output_constraints; | |
| std::atomic<bool> old_packet_emitted_after_deconfig = false; | |
| std::atomic<bool> old_packet_recycled_back = false; | |
| bool client_received_old_output_packet = false; | |
| bool remove_buffer_completed = false; | |
| bool remove_buffer_completed_before_output_packet = false; | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| CreateValidInputBufferCollectionConstraints()); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| }; | |
| bool sent_first_output_settings = false; | |
| processor.events().OnOutputConstraints = [&](auto output_constraints) { | |
| if (!sent_first_output_settings) { | |
| sent_first_output_settings = true; | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| output_token_request_1 = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints( | |
| kOutputPort, CreateValidOutputBufferCollectionConstraints()); | |
| processor->SetOutputBufferPartialSettings(CreateStreamBufferPartialSettings( | |
| 1, output_constraints.buffer_constraints(), std::move(token))); | |
| } else { | |
| second_output_constraints = std::move(output_constraints); | |
| second_output_constraints_received = true; | |
| } | |
| }; | |
| processor.events().OnOutputPacket = [&](fuchsia::media::Packet packet, bool error_before, | |
| bool error_during) { | |
| if (packet.header().buffer_lifetime_ordinal() == 1) { | |
| remove_buffer_completed_before_output_packet = remove_buffer_completed; | |
| client_received_old_output_packet = true; | |
| processor->RecycleOutputPacket(std::move(*packet.mutable_header())); | |
| } | |
| }; | |
| Create(processor.NewRequest(), [&](FakeCodecAdapter* adapter) { | |
| adapter->SetSupportsDynamicBuffers(true); | |
| adapter->SetIsCoreCodecHwBased(kInputPort, true); | |
| adapter->SetIsCoreCodecHwBased(kOutputPort, true); | |
| adapter->SetOnStartStream([&] { stream_started = true; }); | |
| adapter->SetOnRecycleOutputPacket([&](CodecPacket* packet) { | |
| if (!saved_output_packet) { | |
| saved_output_packet = packet; | |
| } else if (old_packet_emitted_after_deconfig && packet == saved_output_packet) { | |
| old_packet_recycled_back = true; | |
| } | |
| }); | |
| adapter->SetOnAddBuffer([&](CodecPort port, const CodecBuffer* buffer) { | |
| if (port == kOutputPort && buffer->lifetime_ordinal() == 1 && buffer->index() == 0) { | |
| saved_output_buffer = buffer; | |
| retained_child_vmo = buffer->GetChildVmo(); | |
| } | |
| }); | |
| adapter->SetOnRemoveBuffer([&](CodecPort port, const CodecBuffer* buffer) { | |
| if (port == kOutputPort && buffer->lifetime_ordinal() == 1 && buffer->index() == 0) { | |
| remove_buffer_called = true; | |
| } | |
| }); | |
| }); | |
| TestAllocator allocator; | |
| ASSERT_TRUE(sysmem_request_.has_value()); | |
| allocator.Bind(std::move(sysmem_request_.value())); | |
| sysmem_request_ = nullptr; | |
| processor->EnableOldOutputBuffers(); | |
| // Complete input buffer allocation. | |
| WaitForAndCompleteCollectionAllocation(allocator, 0, kInputMinBufferCountForCamping, | |
| kInputBufferSize); | |
| processor->QueueInputPacket(CreateInputPacket()); | |
| // Complete first output buffer allocation and CompleteOutputBufferPartialSettings(1). | |
| WaitForAndCompleteCollectionAllocation(allocator, 1, kOutputBufferCount, kOutputBufferSize); | |
| processor->CompleteOutputBufferPartialSettings(1); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { return error_handler_ran_ || (saved_output_buffer != nullptr && stream_started); }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| // Trigger a mid-stream output constraints change so EnsureBuffersNotConfigured(kOutputPort) | |
| // sets port_settings_[kOutputPort] = nullptr, is_port_configured_[kOutputPort] = false, | |
| // buffer_lifetime_ordinal_[kOutputPort] = 2, and resets buffer.until_remove_started_child_vmo_, | |
| // while MidStreamOutputConstraintsChange retains PausedOutput until new output buffers are | |
| // configured. | |
| uint64_t version = codec_adapter_->IncrementConstraintsVersion(kOutputPort); | |
| std::thread([this, version] { | |
| static_cast<CodecAdapterEvents*>(codec_impl_.get()) | |
| ->onCoreCodecMidStreamOutputConstraintsChange2(version); | |
| }).join(); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { | |
| return error_handler_ran_ || (remove_buffer_called && second_output_constraints_received); | |
| }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| // Client requests RemoveBuffer on ordinal 1 buffer 0 to be notified when removal completes. | |
| fuchsia::media::StreamProcessorRemoveBufferRequest remove_request; | |
| remove_request.set_port(fuchsia::media::Port::OUTPUT) | |
| .set_buffer_lifetime_ordinal(1) | |
| .set_buffer_index(0); | |
| processor->RemoveBuffer(std::move(remove_request), [&](auto) { remove_buffer_completed = true; }); | |
| RunLoopUntilIdle(); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_FALSE(remove_buffer_completed); | |
| // While output is paused and port_settings_[kOutputPort] is nullptr, emit an output packet from | |
| // ordinal 1 (which goes through the full EnableOldOutputBuffers delivery path including | |
| // CacheFlushAndInvalidate via buffer->coherency_domain() and PostStreamOutputLocked's | |
| // GetKeepAlive()) and immediately drop the adapter's retained_child_vmo. | |
| EmitOutputPacketFromCoreCodecThread(saved_output_packet, saved_output_buffer, | |
| &old_packet_emitted_after_deconfig, &retained_child_vmo); | |
| // While output remains paused (before ordinal 3 is configured), neither OnOutputPacket nor the | |
| // RemoveBuffer completion callback should have fired. | |
| RunLoopUntilIdle(); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_FALSE(client_received_old_output_packet); | |
| ASSERT_FALSE(remove_buffer_completed); | |
| // Now configure ordinal 3 output buffers and CompleteOutputBufferPartialSettings(3) to unpause | |
| // output. | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token_2; | |
| output_token_request_2 = token_2.NewRequest(); | |
| processor->SetOutputBufferPartialSettings(CreateStreamBufferPartialSettings( | |
| 3, second_output_constraints.buffer_constraints(), std::move(token_2))); | |
| WaitForAndCompleteCollectionAllocation(allocator, 2, kOutputBufferCount, kOutputBufferSize); | |
| processor->CompleteOutputBufferPartialSettings(3); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { | |
| return error_handler_ran_ || (client_received_old_output_packet && | |
| old_packet_recycled_back && remove_buffer_completed); | |
| }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_TRUE(client_received_old_output_packet); | |
| ASSERT_FALSE(remove_buffer_completed_before_output_packet); | |
| ASSERT_TRUE(old_packet_recycled_back); | |
| ASSERT_TRUE(remove_buffer_completed); | |
| processor.Unbind(); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([this] { return !codec_impl_; }, kWaitTimeout)); | |
| } | |
| TEST_F(CodecImplFailures, | |
| DynamicRemoveBufferRetainsUntilRemoveStartedChildVmoDuringCoreCodecRemoveBuffer) { | |
| StreamProcessorPtr processor; | |
| CodecPacket* saved_output_packet = nullptr; | |
| const CodecBuffer* saved_output_buffer = nullptr; | |
| zx::vmo retained_child_vmo; | |
| std::atomic<bool> stream_started = false; | |
| std::atomic<bool> remove_buffer_called = false; | |
| std::atomic<bool> packet_emitted_after_remove = false; | |
| std::atomic<bool> packet_recycled_back = false; | |
| bool client_received_output_packet = false; | |
| bool remove_buffer_completed = false; | |
| bool remove_buffer_completed_before_output_packet = false; | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| CreateValidInputBufferCollectionConstraints()); | |
| zx::vmo input_vmo; | |
| ASSERT_EQ(zx::vmo::create(kInputBufferSize, 0, &input_vmo), ZX_OK); | |
| fuchsia::media::StreamProcessorAddBufferRequest add_input; | |
| add_input.set_port(fuchsia::media::Port::INPUT) | |
| .set_buffer_constraints_version_ordinal( | |
| input_constraints.buffer_constraints_version_ordinal()) | |
| .set_buffer_lifetime_ordinal(1) | |
| .set_buffer_index(0) | |
| .set_buffer(std::move(input_vmo)); | |
| processor->AddBuffer(std::move(add_input)); | |
| processor->QueueInputPacket(CreateInputPacket()); | |
| }; | |
| processor.events().OnOutputConstraints = [this, &processor](auto output_constraints) { | |
| codec_adapter_->SetBufferCollectionConstraints(kOutputPort, | |
| CreateValidOutputBufferCollectionConstraints()); | |
| zx::vmo output_vmo; | |
| ASSERT_EQ(zx::vmo::create(kOutputBufferSize, 0, &output_vmo), ZX_OK); | |
| fuchsia::media::StreamProcessorAddBufferRequest add_output; | |
| add_output.set_port(fuchsia::media::Port::OUTPUT) | |
| .set_buffer_constraints_version_ordinal( | |
| output_constraints.buffer_constraints().buffer_constraints_version_ordinal()) | |
| .set_buffer_lifetime_ordinal(1) | |
| .set_buffer_index(0) | |
| .set_buffer(std::move(output_vmo)); | |
| processor->AddBuffer(std::move(add_output)); | |
| }; | |
| processor.events().OnOutputPacket = [&](fuchsia::media::Packet packet, bool error_before, | |
| bool error_during) { | |
| remove_buffer_completed_before_output_packet = remove_buffer_completed; | |
| client_received_output_packet = true; | |
| processor->RecycleOutputPacket(std::move(*packet.mutable_header())); | |
| }; | |
| Create(processor.NewRequest(), [&](FakeCodecAdapter* adapter) { | |
| adapter->SetSupportsDynamicBuffers(true); | |
| adapter->SetOnStartStream([&] { stream_started = true; }); | |
| adapter->SetOnRecycleOutputPacket([&](CodecPacket* packet) { | |
| if (!saved_output_packet) { | |
| saved_output_packet = packet; | |
| } else if (packet_emitted_after_remove && packet == saved_output_packet) { | |
| packet_recycled_back = true; | |
| } | |
| }); | |
| adapter->SetOnAddBuffer([&](CodecPort port, const CodecBuffer* buffer) { | |
| if (port == kOutputPort && buffer->index() == 0) { | |
| saved_output_buffer = buffer; | |
| } | |
| }); | |
| adapter->SetOnRemoveBuffer([&](CodecPort port, const CodecBuffer* buffer) { | |
| if (port == kOutputPort && buffer->index() == 0) { | |
| // Obtain a child VMO handle during CoreCodecRemoveBuffer (while | |
| // until_remove_started_child_vmo_ is still populated in RemoveBufferInternal). | |
| retained_child_vmo = buffer->GetChildVmo(); | |
| ASSERT_TRUE(retained_child_vmo.is_valid()); | |
| remove_buffer_called = true; | |
| } | |
| }); | |
| }); | |
| TestAllocator allocator; | |
| ASSERT_TRUE(sysmem_request_.has_value()); | |
| allocator.Bind(std::move(sysmem_request_.value())); | |
| sysmem_request_ = nullptr; | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { return error_handler_ran_ || (saved_output_buffer != nullptr && stream_started); }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| // Remove the active output buffer via StreamProcessor.RemoveBuffer. | |
| fuchsia::media::StreamProcessorRemoveBufferRequest remove_request; | |
| remove_request.set_port(fuchsia::media::Port::OUTPUT) | |
| .set_buffer_lifetime_ordinal(1) | |
| .set_buffer_index(0); | |
| processor->RemoveBuffer(std::move(remove_request), [&](auto) { remove_buffer_completed = true; }); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([&] { return error_handler_ran_ || remove_buffer_called; }, | |
| kWaitTimeout)); | |
| RunLoopUntilIdle(); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_FALSE(remove_buffer_completed); | |
| // Now that RemoveBufferInternal has reset until_remove_started_child_vmo_, emit an output packet | |
| // referencing the buffer (exercising the GetKeepAlive() -> CreateChildVmoFromParent() -> | |
| // create_child() fallback) and immediately release retained_child_vmo. | |
| EmitOutputPacketFromCoreCodecThread(saved_output_packet, saved_output_buffer, | |
| &packet_emitted_after_remove, &retained_child_vmo); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { | |
| return error_handler_ran_ || | |
| (client_received_output_packet && packet_recycled_back && remove_buffer_completed); | |
| }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_TRUE(client_received_output_packet); | |
| ASSERT_FALSE(remove_buffer_completed_before_output_packet); | |
| ASSERT_TRUE(packet_recycled_back); | |
| ASSERT_TRUE(remove_buffer_completed); | |
| processor.Unbind(); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([this] { return !codec_impl_; }, kWaitTimeout)); | |
| } | |
| TEST_F(CodecImplFailures, OutputPacketQueuedDuringPausedOutputShortCircuitedOnOutputReconfig) { | |
| StreamProcessorPtr processor; | |
| std::optional<fidl::InterfaceRequest<fuchsia::sysmem2::BufferCollectionToken>> | |
| output_token_request_1; | |
| std::optional<fidl::InterfaceRequest<fuchsia::sysmem2::BufferCollectionToken>> | |
| output_token_request_2; | |
| CodecPacket* saved_output_packet_1 = nullptr; | |
| const CodecBuffer* saved_output_buffer_1 = nullptr; | |
| CodecPacket* saved_output_packet_3 = nullptr; | |
| const CodecBuffer* saved_output_buffer_3 = nullptr; | |
| std::atomic<bool> packet_1_emitted = false; | |
| std::atomic<uint32_t> packet_1_recycle_count = 0; | |
| bool client_received_ordinal_1_packet = false; | |
| bool client_received_ordinal_3_packet = false; | |
| fuchsia::media::StreamOutputConstraints initial_output_constraints; | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| CreateValidInputBufferCollectionConstraints()); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| }; | |
| processor.events().OnOutputConstraints = [&](auto output_constraints) { | |
| initial_output_constraints = std::move(output_constraints); | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| output_token_request_1 = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kOutputPort, | |
| CreateValidOutputBufferCollectionConstraints()); | |
| processor->SetOutputBufferPartialSettings(CreateStreamBufferPartialSettings( | |
| 1, initial_output_constraints.buffer_constraints(), std::move(token))); | |
| }; | |
| processor.events().OnOutputPacket = [&](fuchsia::media::Packet packet, bool error_before, | |
| bool error_during) { | |
| if (packet.header().buffer_lifetime_ordinal() == 1) { | |
| client_received_ordinal_1_packet = true; | |
| } else if (packet.header().buffer_lifetime_ordinal() == 3) { | |
| client_received_ordinal_3_packet = true; | |
| processor->RecycleOutputPacket(std::move(*packet.mutable_header())); | |
| } | |
| }; | |
| Create(processor.NewRequest(), [&](FakeCodecAdapter* adapter) { | |
| adapter->SetSupportsDynamicBuffers(true); | |
| adapter->SetOnRecycleOutputPacket([&](CodecPacket* packet) { | |
| if (packet->buffer_lifetime_ordinal() == 1) { | |
| if (!saved_output_packet_1) { | |
| saved_output_packet_1 = packet; | |
| } else if (packet == saved_output_packet_1) { | |
| ++packet_1_recycle_count; | |
| } | |
| } else if (packet->buffer_lifetime_ordinal() == 3 && !saved_output_packet_3) { | |
| saved_output_packet_3 = packet; | |
| } | |
| }); | |
| adapter->SetOnAddBuffer([&](CodecPort port, const CodecBuffer* buffer) { | |
| if (port == kOutputPort && buffer->lifetime_ordinal() == 1 && buffer->index() == 0) { | |
| saved_output_buffer_1 = buffer; | |
| ASSERT_NE(saved_output_packet_1, nullptr); | |
| // Emit an output packet from ordinal 1 while StartNewStream's PausedOutput is still active | |
| // (before CompleteOutputBufferPartialSettings(1) is ever sent). | |
| EmitOutputPacketFromCoreCodecThread(saved_output_packet_1, saved_output_buffer_1, | |
| &packet_1_emitted); | |
| } else if (port == kOutputPort && buffer->lifetime_ordinal() == 3 && buffer->index() == 0) { | |
| saved_output_buffer_3 = buffer; | |
| } | |
| }); | |
| }); | |
| TestAllocator allocator; | |
| ASSERT_TRUE(sysmem_request_.has_value()); | |
| allocator.Bind(std::move(sysmem_request_.value())); | |
| sysmem_request_ = nullptr; | |
| WaitForAndCompleteCollectionAllocation(allocator, 0, kInputMinBufferCountForCamping, | |
| kInputBufferSize); | |
| processor->QueueInputPacket(CreateInputPacket()); | |
| WaitForAndCompleteCollectionAllocation(allocator, 1, kOutputBufferCount, kOutputBufferSize); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { return error_handler_ran_ || packet_1_emitted.load(); }, kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| RunLoopUntilIdle(); | |
| ASSERT_FALSE(client_received_ordinal_1_packet); | |
| ASSERT_EQ(packet_1_recycle_count.load(), 0u); | |
| // Without calling EnableOldOutputBuffers() and before CompleteOutputBufferPartialSettings(1), | |
| // supersede ordinal 1 with SetOutputBufferPartialSettings(3), which runs | |
| // EnsureBuffersNotConfigured(kOutputPort) while ordinal 1's packet is still queued in | |
| // output_queue_. EnsureBuffersNotConfigured must skip recycling the queued packet (`is_queued()` | |
| // is true), and when CompleteOutputBufferPartialSettings(3) unpauses output_queue_, the queued | |
| // closure must short-circuit and recycle ordinal 1's packet exactly once without delivering | |
| // OnOutputPacket for ordinal 1 to the client. | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token_2; | |
| output_token_request_2 = token_2.NewRequest(); | |
| processor->SetOutputBufferPartialSettings(CreateStreamBufferPartialSettings( | |
| 3, initial_output_constraints.buffer_constraints(), std::move(token_2))); | |
| WaitForAndCompleteCollectionAllocation(allocator, 2, kOutputBufferCount, kOutputBufferSize); | |
| processor->CompleteOutputBufferPartialSettings(3); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { | |
| return error_handler_ran_ || | |
| (packet_1_recycle_count.load() == 1u && saved_output_buffer_3 != nullptr && | |
| saved_output_packet_3 != nullptr); | |
| }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_EQ(packet_1_recycle_count.load(), 1u); | |
| ASSERT_FALSE(client_received_ordinal_1_packet); | |
| // Emit an output packet from ordinal 3 to verify normal output delivery after the short-circuited | |
| // ordinal 1 packet. | |
| EmitOutputPacketFromCoreCodecThread(saved_output_packet_3, saved_output_buffer_3); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { return error_handler_ran_ || client_received_ordinal_3_packet; }, kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_FALSE(client_received_ordinal_1_packet); | |
| ASSERT_TRUE(client_received_ordinal_3_packet); | |
| ASSERT_EQ(packet_1_recycle_count.load(), 1u); | |
| processor.Unbind(); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([this] { return !codec_impl_; }, kWaitTimeout)); | |
| } | |
| TEST_F(CodecImplFailures, OutputPacketQueuedDuringMidStreamFormatChangeNonDynamicBuffers) { | |
| StreamProcessorPtr processor; | |
| std::optional<fidl::InterfaceRequest<fuchsia::sysmem2::BufferCollectionToken>> | |
| output_token_request_1; | |
| std::optional<fidl::InterfaceRequest<fuchsia::sysmem2::BufferCollectionToken>> | |
| output_token_request_2; | |
| CodecPacket* saved_output_packet_1 = nullptr; | |
| const CodecBuffer* saved_output_buffer_1 = nullptr; | |
| CodecPacket* saved_output_packet_3 = nullptr; | |
| const CodecBuffer* saved_output_buffer_3 = nullptr; | |
| std::atomic<bool> packet_1_emitted = false; | |
| std::atomic<uint32_t> packet_1_post_emit_recycle_count = 0; | |
| bool client_received_ordinal_1_packet = false; | |
| bool client_received_ordinal_3_packet = false; | |
| fuchsia::media::StreamOutputConstraints initial_output_constraints; | |
| std::atomic<bool> stream_started = false; | |
| std::atomic<bool> re_config_prepare_entered = false; | |
| libsync::Completion allow_re_config_prepare_to_finish; | |
| bool ensure_output_buffers_not_configured_checked_queued = false; | |
| std::atomic<bool> closed_buffer_lifetime_ordinal_1 = false; | |
| uint32_t output_constraints_count = 0; | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| CreateValidInputBufferCollectionConstraints()); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| }; | |
| processor.events().OnOutputConstraints = [&](auto output_constraints) { | |
| ++output_constraints_count; | |
| initial_output_constraints = std::move(output_constraints); | |
| if (output_constraints_count == 1) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| output_token_request_1 = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints( | |
| kOutputPort, CreateValidOutputBufferCollectionConstraints()); | |
| processor->SetOutputBufferPartialSettings(CreateStreamBufferPartialSettings( | |
| 1, initial_output_constraints.buffer_constraints(), std::move(token))); | |
| } | |
| }; | |
| processor.events().OnOutputPacket = [&](fuchsia::media::Packet packet, bool error_before, | |
| bool error_during) { | |
| if (packet.header().buffer_lifetime_ordinal() == 1) { | |
| client_received_ordinal_1_packet = true; | |
| } else if (packet.header().buffer_lifetime_ordinal() == 3) { | |
| client_received_ordinal_3_packet = true; | |
| processor->RecycleOutputPacket(std::move(*packet.mutable_header())); | |
| } | |
| }; | |
| Create(processor.NewRequest(), [&](FakeCodecAdapter* adapter) { | |
| adapter->SetSupportsDynamicBuffers(false); | |
| adapter->SetOnStartStream([&] { stream_started = true; }); | |
| adapter->SetOnMidStreamOutputBufferReConfigPrepare([&] { | |
| re_config_prepare_entered = true; | |
| ZX_ASSERT(allow_re_config_prepare_to_finish.Wait(kWaitTimeout) == ZX_OK); | |
| }); | |
| adapter->SetOnEnsureBuffersNotConfigured([&](CodecPort port) { | |
| if (port == kOutputPort && packet_1_emitted.load() && | |
| !ensure_output_buffers_not_configured_checked_queued) { | |
| EXPECT_TRUE(IsPacketQueued(saved_output_packet_1)); | |
| ensure_output_buffers_not_configured_checked_queued = true; | |
| } | |
| }); | |
| adapter->SetOnRecycleOutputPacket([&](CodecPacket* packet) { | |
| if (packet->buffer_lifetime_ordinal() == 1) { | |
| if (!saved_output_packet_1) { | |
| saved_output_packet_1 = packet; | |
| } else if (packet == saved_output_packet_1 && packet_1_emitted.load()) { | |
| ++packet_1_post_emit_recycle_count; | |
| } | |
| } else if (packet->buffer_lifetime_ordinal() == 3 && !saved_output_packet_3) { | |
| saved_output_packet_3 = packet; | |
| } | |
| }); | |
| adapter->SetOnAddBuffer([&](CodecPort port, const CodecBuffer* buffer) { | |
| if (port == kOutputPort && buffer->lifetime_ordinal() == 1 && buffer->index() == 0) { | |
| saved_output_buffer_1 = buffer; | |
| } else if (port == kOutputPort && buffer->lifetime_ordinal() == 3 && buffer->index() == 0) { | |
| saved_output_buffer_3 = buffer; | |
| } | |
| }); | |
| adapter->SetOnCloseBufferLifetimeOrdinal([&](CodecPort port, uint64_t ordinal) { | |
| if (port == kOutputPort && ordinal == 1) { | |
| closed_buffer_lifetime_ordinal_1 = true; | |
| saved_output_packet_1 = nullptr; | |
| } | |
| }); | |
| }); | |
| TestAllocator allocator; | |
| ASSERT_TRUE(sysmem_request_.has_value()); | |
| allocator.Bind(std::move(sysmem_request_.value())); | |
| sysmem_request_ = nullptr; | |
| WaitForAndCompleteCollectionAllocation(allocator, 0, kInputMinBufferCountForCamping, | |
| kInputBufferSize); | |
| processor->QueueInputPacket(CreateInputPacket()); | |
| WaitForAndCompleteCollectionAllocation(allocator, 1, kOutputBufferCount, kOutputBufferSize); | |
| processor->CompleteOutputBufferPartialSettings(1); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { | |
| return error_handler_ran_ || (saved_output_buffer_1 != nullptr && | |
| saved_output_packet_1 != nullptr && stream_started.load()); | |
| }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| // Initiate a mid-stream output constraints change from the core codec thread. | |
| // MidStreamOutputConstraintsChange first runs StartIgnoringClientOldOutputConfig on | |
| // shared_fidl_queue_ and then calls CoreCodecMidStreamOutputBufferReConfigPrepare() on | |
| // StreamControl before enqueuing the second RunSyncOnSharedFidlForStream task | |
| // (EnsureBuffersNotConfigured(kOutputPort) + GenerateAndSendNewOutputConstraints(paused_output)). | |
| std::thread([this] { | |
| static_cast<CodecAdapterEvents*>(codec_impl_.get()) | |
| ->onCoreCodecMidStreamOutputConstraintsChange(true); | |
| }).join(); | |
| // Pump shared_fidl_dispatcher_ until the first RunSyncOnSharedFidlForStream | |
| // (StartIgnoringClientOldOutputConfig) has run and StreamControl has entered | |
| // CoreCodecMidStreamOutputBufferReConfigPrepare(). | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { return error_handler_ran_ || re_config_prepare_entered.load(); }, kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| // Release CoreCodecMidStreamOutputBufferReConfigPrepare() while not pumping | |
| // shared_fidl_dispatcher_, and wait deterministically until StreamControl has enqueued the second | |
| // RunSyncOnSharedFidlForStream closure (EnsureBuffersNotConfigured + | |
| // GenerateAndSendNewOutputConstraints) onto shared_fidl_queue_. | |
| uint64_t wait_count_before = GetSharedFidlForStreamWaitCount(); | |
| allow_re_config_prepare_to_finish.Signal(); | |
| WaitForSharedFidlForStreamWaitCount(wait_count_before + 1); | |
| EmitOutputPacketFromCoreCodecThread(saved_output_packet_1, saved_output_buffer_1, | |
| &packet_1_emitted); | |
| // Before shared_fidl_queue_ runs EnsureBuffersNotConfigured (Task 1) and the queued | |
| // short_circuit_packet closure (Task 2), saved_output_packet_1 is queued with | |
| // saved_output_buffer_1 attached. | |
| ASSERT_TRUE(IsPacketQueued(saved_output_packet_1)); | |
| ASSERT_EQ(saved_output_packet_1->buffer(), saved_output_buffer_1); | |
| // Pumping shared_fidl_queue_ runs Task 1 (EnsureBuffersNotConfigured, which skips | |
| // saved_output_packet_1 because is_queued() is true, followed by | |
| // GenerateAndSendNewOutputConstraints posting Task 3), then Task 2 (saved_output_packet_1's | |
| // short_circuit_packet closure, which sees 1 < 2 and clears SetBuffer(nullptr) without calling | |
| // CoreCodecRecycleOutputPacket), then Task 3 (OnOutputConstraints). Releasing the packet's | |
| // buffer drops the last remaining child VMO handle, triggering ZX_VMO_ZERO_CHILDREN -> | |
| // DoCodecBufferDelete -> DeleteBuffer -> CoreCodecCloseBufferLifetimeOrdinal(kOutputPort, 1), | |
| // which destroys ordinal 1's packets (including saved_output_packet_1). | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { return error_handler_ran_ || output_constraints_count == 2; }, kWaitTimeout)); | |
| RunLoopUntilIdle(); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_TRUE(ensure_output_buffers_not_configured_checked_queued); | |
| ASSERT_FALSE(client_received_ordinal_1_packet); | |
| ASSERT_EQ(packet_1_post_emit_recycle_count.load(), 0u); | |
| ASSERT_TRUE(closed_buffer_lifetime_ordinal_1.load()); | |
| ASSERT_EQ(saved_output_packet_1, nullptr); | |
| // Complete the mid-stream output buffer reconfiguration to ordinal 3 so that subsequent output | |
| // packet delivery on ordinal 3 can be verified. | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token_2; | |
| output_token_request_2 = token_2.NewRequest(); | |
| processor->SetOutputBufferPartialSettings(CreateStreamBufferPartialSettings( | |
| 3, initial_output_constraints.buffer_constraints(), std::move(token_2))); | |
| WaitForAndCompleteCollectionAllocation(allocator, 2, kOutputBufferCount, kOutputBufferSize); | |
| processor->CompleteOutputBufferPartialSettings(3); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { | |
| return error_handler_ran_ || | |
| (saved_output_buffer_3 != nullptr && saved_output_packet_3 != nullptr); | |
| }, | |
| kWaitTimeout)); | |
| RunLoopUntilIdle(); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_FALSE(client_received_ordinal_1_packet); | |
| ASSERT_EQ(packet_1_post_emit_recycle_count.load(), 0u); | |
| ASSERT_EQ(saved_output_packet_1, nullptr); | |
| // Emit an output packet from ordinal 3 to verify normal output delivery after the short-circuited | |
| // ordinal 1 packet. | |
| EmitOutputPacketFromCoreCodecThread(saved_output_packet_3, saved_output_buffer_3); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { return error_handler_ran_ || client_received_ordinal_3_packet; }, kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_FALSE(client_received_ordinal_1_packet); | |
| ASSERT_TRUE(client_received_ordinal_3_packet); | |
| ASSERT_EQ(packet_1_post_emit_recycle_count.load(), 0u); | |
| processor.Unbind(); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([this] { return !codec_impl_; }, kWaitTimeout)); | |
| } | |
| TEST_F(CodecImplFailures, RecycleOutputPacketWhileQueued) { | |
| StreamProcessorPtr processor; | |
| std::optional<fidl::InterfaceRequest<fuchsia::sysmem2::BufferCollectionToken>> | |
| output_token_request; | |
| CodecPacket* saved_output_packet = nullptr; | |
| const CodecBuffer* saved_output_buffer = nullptr; | |
| std::atomic<bool> packet_emitted = false; | |
| zx_status_t channel_epitaph = ZX_OK; | |
| processor.set_error_handler([&](zx_status_t status) { channel_epitaph = status; }); | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| CreateValidInputBufferCollectionConstraints()); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| }; | |
| processor.events().OnOutputConstraints = [&](auto output_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| output_token_request = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kOutputPort, | |
| CreateValidOutputBufferCollectionConstraints()); | |
| processor->SetOutputBufferPartialSettings(CreateStreamBufferPartialSettings( | |
| 1, output_constraints.buffer_constraints(), std::move(token))); | |
| }; | |
| Create(processor.NewRequest(), [&](FakeCodecAdapter* adapter) { | |
| adapter->SetSupportsDynamicBuffers(true); | |
| adapter->SetOnRecycleOutputPacket([&](CodecPacket* packet) { | |
| if (!saved_output_packet) { | |
| saved_output_packet = packet; | |
| } | |
| }); | |
| adapter->SetOnAddBuffer([&](CodecPort port, const CodecBuffer* buffer) { | |
| if (port == kOutputPort && buffer->lifetime_ordinal() == 1 && buffer->index() == 0) { | |
| saved_output_buffer = buffer; | |
| ASSERT_NE(saved_output_packet, nullptr); | |
| // Emit an output packet while StartNewStream's PausedOutput is still active (before | |
| // CompleteOutputBufferPartialSettings(1) is sent), so saved_output_packet->is_queued() is | |
| // true and saved_output_packet->is_free() is false. | |
| EmitOutputPacketFromCoreCodecThread(saved_output_packet, saved_output_buffer, | |
| &packet_emitted); | |
| } | |
| }); | |
| }); | |
| TestAllocator allocator; | |
| ASSERT_TRUE(sysmem_request_.has_value()); | |
| allocator.Bind(std::move(sysmem_request_.value())); | |
| sysmem_request_ = nullptr; | |
| WaitForAndCompleteCollectionAllocation(allocator, 0, kInputMinBufferCountForCamping, | |
| kInputBufferSize); | |
| processor->QueueInputPacket(CreateInputPacket()); | |
| WaitForAndCompleteCollectionAllocation(allocator, 1, kOutputBufferCount, kOutputBufferSize); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([&] { return error_handler_ran_ || packet_emitted.load(); }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_TRUE(IsPacketQueued(saved_output_packet)); | |
| ASSERT_FALSE(saved_output_packet->is_free()); | |
| // Sending RecycleOutputPacket while the packet is still queued in output_queue_ (not yet | |
| // delivered to the client via OnOutputPacket) is a client protocol error and must fail the | |
| // channel cleanly without crashing or tripping assertions when output_queue_ drains during | |
| // shutdown. | |
| fuchsia::media::PacketHeader bad_recycle; | |
| bad_recycle.set_buffer_lifetime_ordinal(1).set_packet_index(0); | |
| processor->RecycleOutputPacket(std::move(bad_recycle)); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { return error_handler_ran_ && !codec_impl_ && channel_epitaph != ZX_OK; }, | |
| kWaitTimeout)); | |
| EXPECT_EQ(channel_epitaph, ZX_ERR_PEER_CLOSED); | |
| } | |
| TEST_F(CodecImplFailures, FailStreamWhilePausedOutputShortCircuitsQueuedPacket) { | |
| StreamProcessorPtr processor; | |
| std::optional<fidl::InterfaceRequest<fuchsia::sysmem2::BufferCollectionToken>> | |
| output_token_request; | |
| CodecPacket* saved_output_packet = nullptr; | |
| const CodecBuffer* saved_output_buffer = nullptr; | |
| std::atomic<bool> packet_emitted = false; | |
| std::atomic<uint32_t> post_emit_recycle_count = 0; | |
| bool client_received_output_format = false; | |
| bool client_received_output_packet = false; | |
| bool stream_failed_seen = false; | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| CreateValidInputBufferCollectionConstraints()); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| }; | |
| processor.events().OnOutputConstraints = [&](auto output_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| output_token_request = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kOutputPort, | |
| CreateValidOutputBufferCollectionConstraints()); | |
| processor->SetOutputBufferPartialSettings(CreateStreamBufferPartialSettings( | |
| 1, output_constraints.buffer_constraints(), std::move(token))); | |
| }; | |
| processor.events().OnOutputFormat = [&](fuchsia::media::StreamOutputFormat output_format) { | |
| client_received_output_format = true; | |
| }; | |
| processor.events().OnOutputPacket = [&](fuchsia::media::Packet output_packet, | |
| bool error_detected_before, bool error_detected_during) { | |
| client_received_output_packet = true; | |
| }; | |
| processor.events().OnStreamFailed = [&](uint64_t stream_lifetime_ordinal, | |
| fuchsia::media::StreamError error) { | |
| EXPECT_EQ(stream_lifetime_ordinal, 1u); | |
| EXPECT_EQ(error, fuchsia::media::StreamError::DECODER_DATA_PARSING); | |
| stream_failed_seen = true; | |
| }; | |
| Create(processor.NewRequest(), [&](FakeCodecAdapter* adapter) { | |
| adapter->SetSupportsDynamicBuffers(true); | |
| adapter->SetOnRecycleOutputPacket([&](CodecPacket* packet) { | |
| if (!saved_output_packet) { | |
| saved_output_packet = packet; | |
| } else if (packet_emitted.load() && packet == saved_output_packet) { | |
| ++post_emit_recycle_count; | |
| } | |
| }); | |
| adapter->SetOnAddBuffer([&](CodecPort port, const CodecBuffer* buffer) { | |
| if (port == kOutputPort && buffer->lifetime_ordinal() == 1 && buffer->index() == 0) { | |
| saved_output_buffer = buffer; | |
| ASSERT_NE(saved_output_packet, nullptr); | |
| EmitOutputPacketFromCoreCodecThread(saved_output_packet, saved_output_buffer, | |
| &packet_emitted); | |
| } | |
| }); | |
| }); | |
| processor->EnableOnStreamFailed(); | |
| TestAllocator allocator; | |
| ASSERT_TRUE(sysmem_request_.has_value()); | |
| allocator.Bind(std::move(sysmem_request_.value())); | |
| sysmem_request_ = nullptr; | |
| WaitForAndCompleteCollectionAllocation(allocator, 0, kInputMinBufferCountForCamping, | |
| kInputBufferSize); | |
| processor->QueueInputPacket(CreateInputPacket()); | |
| WaitForAndCompleteCollectionAllocation(allocator, 1, kOutputBufferCount, kOutputBufferSize); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([&] { return error_handler_ran_ || packet_emitted.load(); }, | |
| kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_TRUE(IsPacketQueued(saved_output_packet)); | |
| ASSERT_FALSE(saved_output_packet->is_free()); | |
| // Fail the stream from the core codec thread while PausedOutput is still holding back | |
| // output_queue_ (before CompleteOutputBufferPartialSettings(1) is sent). onCoreCodecFailStream | |
| // marks the stream future_discarded, waking StartNewStream so ~PausedOutput() drains | |
| // output_queue_ and short-circuits/recycles saved_output_packet without delivering OnOutputFormat | |
| // or OnOutputPacket to the client. | |
| std::thread([this] { | |
| static_cast<CodecAdapterEvents*>(codec_impl_.get()) | |
| ->onCoreCodecFailStream(fuchsia::media::StreamError::DECODER_DATA_PARSING); | |
| }).join(); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [&] { | |
| return error_handler_ran_ || (stream_failed_seen && post_emit_recycle_count.load() == 1u); | |
| }, | |
| kWaitTimeout)); | |
| RunLoopUntilIdle(); | |
| ASSERT_FALSE(error_handler_ran_); | |
| EXPECT_TRUE(stream_failed_seen); | |
| EXPECT_FALSE(client_received_output_format); | |
| EXPECT_FALSE(client_received_output_packet); | |
| EXPECT_EQ(post_emit_recycle_count.load(), 1u); | |
| EXPECT_FALSE(IsPacketQueued(saved_output_packet)); | |
| EXPECT_TRUE(saved_output_packet->is_free()); | |
| EXPECT_EQ(saved_output_packet->buffer(), nullptr); | |
| // Also verify that closing the failed stream from the client succeeds cleanly (exercising | |
| // idempotent SetFutureDiscarded()). | |
| processor->CloseCurrentStream(1, false, false); | |
| RunLoopUntilIdle(); | |
| ASSERT_FALSE(error_handler_ran_); | |
| processor.Unbind(); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([this] { return !codec_impl_; }, kWaitTimeout)); | |
| } | |
| TEST_F(CodecImplFailures, QueueInputPacketOutOfBoundsFailsAndShutsDownCleanly) { | |
| StreamProcessorPtr processor; | |
| processor.events().OnInputConstraints = [&](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| CreateValidInputBufferCollectionConstraints()); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| }; | |
| Create(processor.NewRequest(), [&](FakeCodecAdapter* adapter) { | |
| adapter->SetIsCoreCodecRequiringOutputConfigForFormatDetection(false); | |
| }); | |
| TestAllocator allocator; | |
| ASSERT_TRUE(sysmem_request_.has_value()); | |
| allocator.Bind(std::move(sysmem_request_.value())); | |
| sysmem_request_ = nullptr; | |
| WaitForAndCompleteCollectionAllocation(allocator, 0, kInputMinBufferCountForCamping, | |
| kInputBufferSize); | |
| // Queue an input packet whose start_offset + valid_length_bytes exceeds kInputBufferSize. | |
| // QueueInputPacket_StreamControl must reject the packet before marking codec_packet busy or | |
| // attaching buffer_keep_alive_, failing the channel and allowing CodecImpl to shut down cleanly. | |
| fuchsia::media::Packet bad_packet = CreateInputPacket(); | |
| bad_packet.set_start_offset(kInputBufferSize - 16); | |
| bad_packet.set_valid_length_bytes(32); | |
| processor->QueueInputPacket(std::move(bad_packet)); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([this] { return error_handler_ran_; }, kWaitTimeout)); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([this] { return !codec_impl_; }, kWaitTimeout)); | |
| } | |
| class FakeCodecAdapterWithFormatTracking : public FakeCodecAdapter { | |
| public: | |
| using FakeCodecAdapter::FakeCodecAdapter; | |
| void CoreCodecQueueInputFormatDetails( | |
| const fuchsia::media::FormatDetails& per_stream_override_format_details) override { | |
| last_format_details_ = fidl::Clone(per_stream_override_format_details); | |
| call_count_++; | |
| } | |
| bool IsCoreCodecRequiringOutputConfigForFormatDetection() override { return false; } | |
| std::optional<fuchsia::media::FormatDetails> last_format_details_; | |
| std::atomic<int> call_count_{0}; | |
| }; | |
| class CodecImplFormatTrackingFailures : public CodecImplFailures { | |
| public: | |
| std::unique_ptr<FakeCodecAdapter> CreateCodecAdapter() override { | |
| auto codec_adapter = std::make_unique<FakeCodecAdapterWithFormatTracking>(codec_impl_->lock(), | |
| codec_impl_.get()); | |
| codec_adapter_ = codec_adapter.get(); | |
| return codec_adapter; | |
| } | |
| void ConfigureInputBuffers(StreamProcessorPtr& processor) { | |
| processor.events().OnInputConstraints = [this, &processor](auto input_constraints) { | |
| fidl::InterfaceHandle<fuchsia::sysmem2::BufferCollectionToken> token; | |
| token_request_ = token.NewRequest(); | |
| auto buffer_collection_constraints = CreateValidInputBufferCollectionConstraints(); | |
| codec_adapter_->SetBufferCollectionConstraints(kInputPort, | |
| std::move(buffer_collection_constraints)); | |
| processor->SetInputBufferPartialSettings( | |
| CreateStreamBufferPartialSettings(1, input_constraints, std::move(token))); | |
| }; | |
| processor.events().OnFreeInputPacket = [this](fuchsia::media::PacketHeader free_input_packet) { | |
| free_input_packet_count_++; | |
| }; | |
| Create(processor.NewRequest()); | |
| allocator_ = std::make_unique<TestAllocator>(); | |
| ASSERT_TRUE(sysmem_request_.has_value()); | |
| allocator_->Bind(std::move(sysmem_request_.value())); | |
| sysmem_request_ = nullptr; | |
| WaitForAndCompleteCollectionAllocation(*allocator_, 0, kInputMinBufferCountForCamping, | |
| kInputBufferSize); | |
| } | |
| static void QueueInputPacket(StreamProcessorPtr& processor, | |
| uint64_t stream_lifetime_ordinal = 1) { | |
| auto packet = CreateInputPacket(); | |
| packet.set_stream_lifetime_ordinal(stream_lifetime_ordinal); | |
| processor->QueueInputPacket(std::move(packet)); | |
| } | |
| int free_input_packet_count() const { return free_input_packet_count_; } | |
| private: | |
| std::unique_ptr<TestAllocator> allocator_; | |
| int free_input_packet_count_ = 0; | |
| }; | |
| TEST_F(CodecImplFormatTrackingFailures, IdenticalFormatDetailsSucceeds) { | |
| StreamProcessorPtr processor; | |
| ConfigureInputBuffers(processor); | |
| // Call QueueInputFormatDetails with version ordinal 0 and same content (empty). | |
| fuchsia::media::FormatDetails details; | |
| details.set_format_details_version_ordinal(0); | |
| processor->QueueInputFormatDetails(1, std::move(details)); | |
| QueueInputPacket(processor); | |
| auto* tracking_adapter = static_cast<FakeCodecAdapterWithFormatTracking*>(codec_adapter_); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [this] { return error_handler_ran_ || free_input_packet_count() == 1; }, kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_EQ(tracking_adapter->call_count_.load(), 1); | |
| ASSERT_TRUE(tracking_adapter->last_format_details_.has_value()); | |
| ASSERT_EQ(tracking_adapter->last_format_details_->format_details_version_ordinal(), 0u); | |
| // Call QueueInputFormatDetails with version ordinal 1 (greater than 0). | |
| fuchsia::media::FormatDetails details2; | |
| details2.set_format_details_version_ordinal(1); | |
| details2.set_mime_type("video/h264"); | |
| processor->QueueInputFormatDetails(1, std::move(details2)); | |
| QueueInputPacket(processor); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [this] { return error_handler_ran_ || free_input_packet_count() == 2; }, kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_EQ(tracking_adapter->call_count_.load(), 2); | |
| ASSERT_TRUE(tracking_adapter->last_format_details_.has_value()); | |
| ASSERT_EQ(tracking_adapter->last_format_details_->format_details_version_ordinal(), 1u); | |
| ASSERT_EQ(tracking_adapter->last_format_details_->mime_type(), "video/h264"); | |
| // Call QueueInputFormatDetails with version ordinal 1 and identical content. | |
| fuchsia::media::FormatDetails details3; | |
| details3.set_format_details_version_ordinal(1); | |
| details3.set_mime_type("video/h264"); | |
| processor->QueueInputFormatDetails(1, std::move(details3)); | |
| QueueInputPacket(processor); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [this] { return error_handler_ran_ || free_input_packet_count() == 3; }, kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_EQ(tracking_adapter->call_count_.load(), 3); | |
| // Call QueueInputFormatDetails with version ordinal 1 but different content (mime type). | |
| // Currently CodecImpl logs an ERROR without failing the channel and still forwards the updated | |
| // format details. | |
| fuchsia::media::FormatDetails details4; | |
| details4.set_format_details_version_ordinal(1); | |
| details4.set_mime_type("video/vp9"); | |
| processor->QueueInputFormatDetails(1, std::move(details4)); | |
| QueueInputPacket(processor); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [this] { return error_handler_ran_ || free_input_packet_count() == 4; }, kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_EQ(tracking_adapter->call_count_.load(), 4); | |
| ASSERT_TRUE(tracking_adapter->last_format_details_.has_value()); | |
| ASSERT_EQ(tracking_adapter->last_format_details_->format_details_version_ordinal(), 1u); | |
| ASSERT_EQ(tracking_adapter->last_format_details_->mime_type(), "video/vp9"); | |
| // Start a new stream (stream_lifetime_ordinal 3) with version ordinal 0 (dropping back to the | |
| // initial ordinal across a stream switch). | |
| fuchsia::media::FormatDetails details5; | |
| details5.set_format_details_version_ordinal(0); | |
| processor->QueueInputFormatDetails(3, std::move(details5)); | |
| QueueInputPacket(processor, 3); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [this] { return error_handler_ran_ || free_input_packet_count() == 5; }, kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_EQ(tracking_adapter->call_count_.load(), 5); | |
| ASSERT_TRUE(tracking_adapter->last_format_details_.has_value()); | |
| ASSERT_EQ(tracking_adapter->last_format_details_->format_details_version_ordinal(), 0u); | |
| ASSERT_FALSE(tracking_adapter->last_format_details_->has_mime_type()); | |
| } | |
| TEST_F(CodecImplFormatTrackingFailures, DecreasingFormatDetailsVersionFails) { | |
| StreamProcessorPtr processor; | |
| ConfigureInputBuffers(processor); | |
| // First call with version 1 (greater than 0) | |
| fuchsia::media::FormatDetails details1; | |
| details1.set_format_details_version_ordinal(1); | |
| processor->QueueInputFormatDetails(1, std::move(details1)); | |
| QueueInputPacket(processor); | |
| auto* tracking_adapter = static_cast<FakeCodecAdapterWithFormatTracking*>(codec_adapter_); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil( | |
| [this] { return error_handler_ran_ || free_input_packet_count() == 1; }, kWaitTimeout)); | |
| ASSERT_FALSE(error_handler_ran_); | |
| ASSERT_EQ(tracking_adapter->call_count_.load(), 1); | |
| // Second call with version 0 (less than 1) | |
| fuchsia::media::FormatDetails details2; | |
| details2.set_format_details_version_ordinal(0); | |
| processor->QueueInputFormatDetails(1, std::move(details2)); | |
| ASSERT_TRUE(RunLoopWithTimeoutOrUntil([this] { return error_handler_ran_; }, kWaitTimeout)); | |
| ASSERT_TRUE(error_handler_ran_); | |
| } | |
| } // namespace |