Skip to content

GitLab

T
tangled
Commit 31615517 authored by Ted Meyer's avatar Ted Meyer Committed by Chromium LUCI CQ
Browse files
Options

Remove fallback video decoder 

It's no longer used, so get rid of it.

Change-Id: I2e9b98b3719a71645f8148dcc1acaae804559be4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2623155
Commit-Queue: Ted Meyer <tmathmeyer@chromium.org>
Reviewed-by: default avatarFrank Liberato <liberato@chromium.org>
Cr-Commit-Position: refs/heads/master@{#843295}
parent 87b13f01
Show whitespace changes
Inline Side-by-side
Showing with 0 additions and 337 deletions
media/base/BUILD.gn
View file @ 31615517
...@@ -156,8 +156,6 @@ source_set("base") { ...@@ -156,8 +156,6 @@ source_set("base") {
"encryption_scheme.h", "encryption_scheme.h",
"fake_audio_worker.cc", "fake_audio_worker.cc",
"fake_audio_worker.h", "fake_audio_worker.h",
"fallback_video_decoder.cc",
"fallback_video_decoder.h",
"feedback_signal_accumulator.h", "feedback_signal_accumulator.h",
"flinging_controller.h", "flinging_controller.h",
"format_utils.cc", "format_utils.cc",
...@@ -567,7 +565,6 @@ source_set("unit_tests") { ...@@ -567,7 +565,6 @@ source_set("unit_tests") {
"djb2_unittest.cc", "djb2_unittest.cc",
"fake_audio_worker_unittest.cc", "fake_audio_worker_unittest.cc",
"fake_demuxer_stream_unittest.cc", "fake_demuxer_stream_unittest.cc",
"fallback_video_decoder_unittest.cc",
"feedback_signal_accumulator_unittest.cc", "feedback_signal_accumulator_unittest.cc",
"frame_rate_estimator_unittest.cc", "frame_rate_estimator_unittest.cc",
"key_systems_unittest.cc", "key_systems_unittest.cc",
......
media/base/fallback_video_decoder.cc deleted 100644 → 0
View file @ 87b13f01
// Copyright 2018 The Chromium 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 <utility>
#include "base/bind.h"
#include "base/callback_helpers.h"
#include "base/threading/sequenced_task_runner_handle.h"
#include "media/base/decoder_buffer.h"
#include "media/base/fallback_video_decoder.h"
#include "media/base/video_decoder_config.h"
namespace media {
FallbackVideoDecoder::FallbackVideoDecoder(
std::unique_ptr<VideoDecoder> preferred,
std::unique_ptr<VideoDecoder> fallback)
: preferred_decoder_(std::move(preferred)),
fallback_decoder_(std::move(fallback)) {}
void FallbackVideoDecoder::Initialize(const VideoDecoderConfig& config,
bool low_delay,
CdmContext* cdm_context,
InitCB init_cb,
const OutputCB& output_cb,
const WaitingCB& waiting_cb) {
// If we've already fallen back, just reinitialize the selected decoder.
if (selected_decoder_ && did_fallback_) {
selected_decoder_->Initialize(config, low_delay, cdm_context,
std::move(init_cb), output_cb, waiting_cb);
return;
}
InitCB fallback_initialize_cb =
base::BindOnce(&FallbackVideoDecoder::FallbackInitialize,
weak_factory_.GetWeakPtr(), config, low_delay, cdm_context,
std::move(init_cb), output_cb, waiting_cb);
preferred_decoder_->Initialize(config, low_delay, cdm_context,
std::move(fallback_initialize_cb), output_cb,
waiting_cb);
}
void FallbackVideoDecoder::FallbackInitialize(const VideoDecoderConfig& config,
bool low_delay,
CdmContext* cdm_context,
InitCB init_cb,
const OutputCB& output_cb,
const WaitingCB& waiting_cb,
Status status) {
// The preferred decoder was successfully initialized.
if (status.is_ok()) {
selected_decoder_ = preferred_decoder_.get();
std::move(init_cb).Run(OkStatus());
return;
}
did_fallback_ = true;
// Post destruction of |preferred_decoder_| so that we don't destroy the
// object during the callback. DeleteSoon doesn't handle custom deleters, so
// we post a do-nothing task instead.
base::SequencedTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
base::BindOnce(base::DoNothing::Once<std::unique_ptr<VideoDecoder>>(),
std::move(preferred_decoder_)));
selected_decoder_ = fallback_decoder_.get();
fallback_decoder_->Initialize(config, low_delay, cdm_context,
std::move(init_cb), output_cb, waiting_cb);
}
void FallbackVideoDecoder::Decode(scoped_refptr<DecoderBuffer> buffer,
DecodeCB decode_cb) {
DCHECK(selected_decoder_);
selected_decoder_->Decode(std::move(buffer), std::move(decode_cb));
}
void FallbackVideoDecoder::Reset(base::OnceClosure reset_cb) {
DCHECK(selected_decoder_);
selected_decoder_->Reset(std::move(reset_cb));
}
bool FallbackVideoDecoder::NeedsBitstreamConversion() const {
DCHECK(selected_decoder_);
return selected_decoder_->NeedsBitstreamConversion();
}
bool FallbackVideoDecoder::CanReadWithoutStalling() const {
DCHECK(selected_decoder_);
return selected_decoder_->CanReadWithoutStalling();
}
int FallbackVideoDecoder::GetMaxDecodeRequests() const {
DCHECK(selected_decoder_);
return selected_decoder_->GetMaxDecodeRequests();
}
std::string FallbackVideoDecoder::GetDisplayName() const {
// MojoVideoDecoder always identifies itself as such, and never asks for the
// name of the underlying decoder.
NOTREACHED();
return "FallbackVideoDecoder";
}
FallbackVideoDecoder::~FallbackVideoDecoder() = default;
} // namespace media
media/base/fallback_video_decoder.h deleted 100644 → 0
View file @ 87b13f01
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef MEDIA_BASE_FALLBACK_VIDEO_DECODER_H_
#define MEDIA_BASE_FALLBACK_VIDEO_DECODER_H_
#include <memory>
#include <string>
#include "base/memory/weak_ptr.h"
#include "media/base/video_decoder.h"
namespace media {
// A Wrapper VideoDecoder which supports a fallback and a preferred decoder.
class MEDIA_EXPORT FallbackVideoDecoder : public VideoDecoder {
public:
FallbackVideoDecoder(std::unique_ptr<VideoDecoder> preferred,
std::unique_ptr<VideoDecoder> fallback);
// media::VideoDecoder implementation.
std::string GetDisplayName() const override;
void Initialize(const VideoDecoderConfig& config,
bool low_delay,
CdmContext* cdm_context,
InitCB init_cb,
const OutputCB& output_cb,
const WaitingCB& waiting_cb) override;
void Decode(scoped_refptr<DecoderBuffer> buffer, DecodeCB decode_cb) override;
void Reset(base::OnceClosure reset_cb) override;
bool NeedsBitstreamConversion() const override;
bool CanReadWithoutStalling() const override;
int GetMaxDecodeRequests() const override;
protected:
~FallbackVideoDecoder() override;
private:
void FallbackInitialize(const VideoDecoderConfig& config,
bool low_delay,
CdmContext* cdm_context,
InitCB init_cb,
const OutputCB& output_cb,
const WaitingCB& waiting_cb,
Status status);
std::unique_ptr<media::VideoDecoder> preferred_decoder_;
std::unique_ptr<media::VideoDecoder> fallback_decoder_;
media::VideoDecoder* selected_decoder_ = nullptr;
bool did_fallback_ = false;
base::WeakPtrFactory<FallbackVideoDecoder> weak_factory_{this};
DISALLOW_COPY_AND_ASSIGN(FallbackVideoDecoder);
};
} // namespace media
#endif // MEDIA_BASE_FALLBACK_VIDEO_DECODER_H_
media/base/fallback_video_decoder_unittest.cc deleted 100644 → 0
View file @ 87b13f01
// Copyright 2018 The Chromium 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 <tuple>
#include "base/bind.h"
#include "base/callback_helpers.h"
#include "base/run_loop.h"
#include "base/test/gmock_callback_support.h"
#include "base/test/task_environment.h"
#include "media/base/decoder_buffer.h"
#include "media/base/fallback_video_decoder.h"
#include "media/base/mock_filters.h"
#include "media/base/test_helpers.h"
#include "media/base/video_decoder.h"
#include "media/base/video_decoder_config.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest-param-test.h"
#include "testing/gtest/include/gtest/gtest.h"
using ::base::test::RunOnceCallback;
using ::testing::_;
using ::testing::StrictMock;
namespace media {
class FallbackVideoDecoderUnittest : public ::testing::TestWithParam<bool> {
public:
FallbackVideoDecoderUnittest()
: backup_decoder_(nullptr),
preferred_decoder_(nullptr),
fallback_decoder_(nullptr) {}
~FallbackVideoDecoderUnittest() override { Destroy(); }
std::unique_ptr<VideoDecoder> MakeMockDecoderWithExpectations(
bool is_fallback,
bool preferred_should_succeed) {
std::string n = is_fallback ? "Fallback" : "Preferred";
StrictMock<MockVideoDecoder>* result = new StrictMock<MockVideoDecoder>(n);
if (is_fallback && !preferred_should_succeed) {
EXPECT_CALL(*result, Initialize_(_, _, _, _, _, _))
.WillOnce(RunOnceCallback<3>(OkStatus()));
}
if (!is_fallback) {
preferred_decoder_ = result;
EXPECT_CALL(*result, Initialize_(_, _, _, _, _, _))
.WillOnce(RunOnceCallback<3>(preferred_should_succeed
? OkStatus()
: StatusCode::kCodeOnlyForTesting));
} else {
backup_decoder_ = result;
}
return std::unique_ptr<VideoDecoder>(result);
}
void Initialize(bool preferred_should_succeed) {
fallback_decoder_ = new FallbackVideoDecoder(
MakeMockDecoderWithExpectations(false, preferred_should_succeed),
MakeMockDecoderWithExpectations(true, preferred_should_succeed));
fallback_decoder_->Initialize(
video_decoder_config_, false, nullptr,
base::BindOnce([](Status status) { EXPECT_TRUE(status.is_ok()); }),
base::DoNothing(), base::DoNothing());
}
protected:
void Destroy() { std::default_delete<VideoDecoder>()(fallback_decoder_); }
bool PreferredShouldSucceed() { return GetParam(); }
base::test::TaskEnvironment task_environment_;
StrictMock<MockVideoDecoder>* backup_decoder_;
StrictMock<MockVideoDecoder>* preferred_decoder_;
VideoDecoder* fallback_decoder_;
VideoDecoderConfig video_decoder_config_;
private:
DISALLOW_COPY_AND_ASSIGN(FallbackVideoDecoderUnittest);
};
INSTANTIATE_TEST_SUITE_P(DoesPreferredInitFail,
FallbackVideoDecoderUnittest,
testing::ValuesIn({true, false}));
#define EXPECT_ON_CORRECT_DECODER(method) \
if (PreferredShouldSucceed()) \
EXPECT_CALL(*preferred_decoder_, method); \
else \
EXPECT_CALL(*backup_decoder_, method) // Intentionally leave off semicolon.
// Do not test the name lookup; it is NOTREACHED.
TEST_P(FallbackVideoDecoderUnittest, MethodsRedirectedAsExpected) {
Initialize(PreferredShouldSucceed());
EXPECT_ON_CORRECT_DECODER(Decode_(_, _));
fallback_decoder_->Decode(nullptr, base::DoNothing());
EXPECT_ON_CORRECT_DECODER(Reset_(_));
fallback_decoder_->Reset(base::DoNothing());
EXPECT_ON_CORRECT_DECODER(NeedsBitstreamConversion());
fallback_decoder_->NeedsBitstreamConversion();
EXPECT_ON_CORRECT_DECODER(CanReadWithoutStalling());
fallback_decoder_->CanReadWithoutStalling();
EXPECT_ON_CORRECT_DECODER(GetMaxDecodeRequests());
fallback_decoder_->GetMaxDecodeRequests();
}
// │ first initialization │ second initialization │
// preferred │ preferred │ backup │ preferred │ backup │
// will succeed │ init called │ init called │ init called │ init called │
//───────────────┼─────────────┼─────────────┼─────────────┼─────────────┤
// false │ ✓ │ ✓ │ x │ ✓ │
// true │ ✓ │ x │ ✓ │ ✓ │
TEST_P(FallbackVideoDecoderUnittest, ReinitializeWithPreferredFailing) {
Initialize(PreferredShouldSucceed());
// If we succeedd the first time, it should still be alive.
if (PreferredShouldSucceed()) { // fail initialization
EXPECT_CALL(*preferred_decoder_, Initialize_(_, _, _, _, _, _))
.WillOnce(RunOnceCallback<3>(StatusCode::kCodeOnlyForTesting));
}
EXPECT_CALL(*backup_decoder_, Initialize_(_, _, _, _, _, _))
.WillOnce(RunOnceCallback<3>(OkStatus()));
fallback_decoder_->Initialize(
video_decoder_config_, false, nullptr,
base::BindOnce([](Status status) { EXPECT_TRUE(status.is_ok()); }),
base::DoNothing(), base::DoNothing());
}
// │ first initialization │ second initialization │
// preferred │ preferred │ backup │ preferred │ backup │
// will succeed │ init called │ init called │ init called │ init called │
//───────────────┼─────────────┼─────────────┼─────────────┼─────────────┤
// false │ ✓ │ ✓ │ x │ ✓ │
// true │ ✓ │ x │ ✓ │ x │
TEST_P(FallbackVideoDecoderUnittest, ReinitializeWithPreferredSuccessful) {
Initialize(PreferredShouldSucceed());
// If we succeedd the first time, it should still be alive.
if (PreferredShouldSucceed()) {
EXPECT_CALL(*preferred_decoder_, Initialize_(_, _, _, _, _, _))
.WillOnce(RunOnceCallback<3>(OkStatus())); // pass initialization
} else {
// Otherwise, preferred was deleted, and we only backup still exists.
EXPECT_CALL(*backup_decoder_, Initialize_(_, _, _, _, _, _))
.WillOnce(RunOnceCallback<3>(OkStatus()));
}
fallback_decoder_->Initialize(
video_decoder_config_, false, nullptr,
base::BindOnce([](Status status) { EXPECT_TRUE(status.is_ok()); }),
base::DoNothing(), base::DoNothing());
}
} // namespace media
media/mojo/services/gpu_mojo_media_client.cc
View file @ 31615517
...@@ -13,7 +13,6 @@ ...@@ -13,7 +13,6 @@
#include "gpu/ipc/service/gpu_channel.h" #include "gpu/ipc/service/gpu_channel.h"
#include "media/base/audio_decoder.h" #include "media/base/audio_decoder.h"
#include "media/base/cdm_factory.h" #include "media/base/cdm_factory.h"
#include "media/base/fallback_video_decoder.h"
#include "media/base/media_switches.h" #include "media/base/media_switches.h"
#include "media/base/video_decoder.h" #include "media/base/video_decoder.h"
#include "media/gpu/gpu_video_accelerator_util.h" #include "media/gpu/gpu_video_accelerator_util.h"
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment