Fix some instances of -Wshadow.
Bug: 794619 Change-Id: Ic2ccb78d8c9d65aca45d1b7eab92d5ace40dbd84 Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3110906 Commit-Queue: Peter Kasting <pkasting@chromium.org> Reviewed-by: Tom Sepez <tsepez@chromium.org> Reviewed-by: Thomas Guilbert <tguilbert@chromium.org> Reviewed-by: Peter Kvitek <kvitekp@chromium.org> Reviewed-by: Peng Huang <penghuang@chromium.org> Cr-Commit-Position: refs/heads/main@{#914925}
This commit is contained in:

committed by
Chromium LUCI CQ

parent
5714acca3c
commit
905a2a9713
gpu
command_buffer
client
service
gles2_cmd_decoder_unittest_2.ccgles2_cmd_decoder_unittest_base.ccshared_image_backing_factory_gl_image_unittest.cctest_helper.cc
tests
ipc
service
vulkan
tests
headless/public
ipc
media
base
capture
content
video
cast
net
sender
filters
ffmpeg_audio_decoder.ccffmpeg_audio_decoder.hffmpeg_video_decoder.ccffmpeg_video_decoder.hsource_buffer_state.ccvideo_renderer_algorithm_unittest.ccvpx_video_decoder.ccvpx_video_decoder.h
formats
gpu
learning
midi
renderers
video
@ -7371,8 +7371,7 @@ bool GLES2Implementation::PackStringsToBucket(GLsizei count,
|
|||||||
if (copy_size < buffer.size()) {
|
if (copy_size < buffer.size()) {
|
||||||
// Append NULL in the end.
|
// Append NULL in the end.
|
||||||
DCHECK(copy_size + 1 == buffer.size());
|
DCHECK(copy_size + 1 == buffer.size());
|
||||||
char* str = reinterpret_cast<char*>(buffer.address());
|
reinterpret_cast<char*>(buffer.address())[copy_size] = 0;
|
||||||
str[copy_size] = 0;
|
|
||||||
}
|
}
|
||||||
helper_->SetBucketData(kResultBucketId, offset, buffer.size(),
|
helper_->SetBucketData(kResultBucketId, offset, buffer.size(),
|
||||||
buffer.shm_id(), buffer.offset());
|
buffer.shm_id(), buffer.offset());
|
||||||
|
@ -625,28 +625,27 @@ INSTANTIATE_TEST_SUITE_P(Service, GLES3DecoderTest2, ::testing::Bool());
|
|||||||
template <>
|
template <>
|
||||||
void GLES2DecoderTestBase::SpecializedSetup<cmds::GetProgramInfoLog, 0>(
|
void GLES2DecoderTestBase::SpecializedSetup<cmds::GetProgramInfoLog, 0>(
|
||||||
bool /* valid */) {
|
bool /* valid */) {
|
||||||
const GLuint kClientVertexShaderId = 5001;
|
const GLuint kTestClientVertexShaderId = 5001;
|
||||||
const GLuint kServiceVertexShaderId = 6001;
|
const GLuint kTestServiceVertexShaderId = 6001;
|
||||||
const GLuint kClientFragmentShaderId = 5002;
|
const GLuint kTestClientFragmentShaderId = 5002;
|
||||||
const GLuint kServiceFragmentShaderId = 6002;
|
const GLuint kTestServiceFragmentShaderId = 6002;
|
||||||
const char* log = "hello"; // Matches auto-generated unit test.
|
const char* log = "hello"; // Matches auto-generated unit test.
|
||||||
DoCreateShader(
|
DoCreateShader(GL_VERTEX_SHADER, kTestClientVertexShaderId,
|
||||||
GL_VERTEX_SHADER, kClientVertexShaderId, kServiceVertexShaderId);
|
kTestServiceVertexShaderId);
|
||||||
DoCreateShader(
|
DoCreateShader(GL_FRAGMENT_SHADER, kTestClientFragmentShaderId,
|
||||||
GL_FRAGMENT_SHADER, kClientFragmentShaderId, kServiceFragmentShaderId);
|
kTestServiceFragmentShaderId);
|
||||||
|
|
||||||
TestHelper::SetShaderStates(
|
TestHelper::SetShaderStates(gl_.get(), GetShader(kTestClientVertexShaderId),
|
||||||
gl_.get(), GetShader(kClientVertexShaderId), true);
|
true);
|
||||||
TestHelper::SetShaderStates(
|
TestHelper::SetShaderStates(gl_.get(), GetShader(kTestClientFragmentShaderId),
|
||||||
gl_.get(), GetShader(kClientFragmentShaderId), true);
|
true);
|
||||||
|
|
||||||
InSequence dummy;
|
InSequence dummy;
|
||||||
EXPECT_CALL(*gl_,
|
EXPECT_CALL(*gl_, AttachShader(kServiceProgramId, kTestServiceVertexShaderId))
|
||||||
AttachShader(kServiceProgramId, kServiceVertexShaderId))
|
|
||||||
.Times(1)
|
.Times(1)
|
||||||
.RetiresOnSaturation();
|
.RetiresOnSaturation();
|
||||||
EXPECT_CALL(*gl_,
|
EXPECT_CALL(*gl_,
|
||||||
AttachShader(kServiceProgramId, kServiceFragmentShaderId))
|
AttachShader(kServiceProgramId, kTestServiceFragmentShaderId))
|
||||||
.Times(1)
|
.Times(1)
|
||||||
.RetiresOnSaturation();
|
.RetiresOnSaturation();
|
||||||
EXPECT_CALL(*gl_, LinkProgram(kServiceProgramId))
|
EXPECT_CALL(*gl_, LinkProgram(kServiceProgramId))
|
||||||
@ -673,10 +672,10 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::GetProgramInfoLog, 0>(
|
|||||||
ASSERT_TRUE(program != nullptr);
|
ASSERT_TRUE(program != nullptr);
|
||||||
|
|
||||||
cmds::AttachShader attach_cmd;
|
cmds::AttachShader attach_cmd;
|
||||||
attach_cmd.Init(client_program_id_, kClientVertexShaderId);
|
attach_cmd.Init(client_program_id_, kTestClientVertexShaderId);
|
||||||
EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
|
EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
|
||||||
|
|
||||||
attach_cmd.Init(client_program_id_, kClientFragmentShaderId);
|
attach_cmd.Init(client_program_id_, kTestClientFragmentShaderId);
|
||||||
EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
|
EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
|
||||||
|
|
||||||
program->Link(nullptr, Program::kCountOnlyStaticallyUsed, this);
|
program->Link(nullptr, Program::kCountOnlyStaticallyUsed, this);
|
||||||
@ -754,27 +753,26 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::DeleteQueriesEXTImmediate, 0>(
|
|||||||
template <>
|
template <>
|
||||||
void GLES2DecoderTestBase::SpecializedSetup<cmds::LinkProgram, 0>(
|
void GLES2DecoderTestBase::SpecializedSetup<cmds::LinkProgram, 0>(
|
||||||
bool /* valid */) {
|
bool /* valid */) {
|
||||||
const GLuint kClientVertexShaderId = 5001;
|
const GLuint kTestClientVertexShaderId = 5001;
|
||||||
const GLuint kServiceVertexShaderId = 6001;
|
const GLuint kTestServiceVertexShaderId = 6001;
|
||||||
const GLuint kClientFragmentShaderId = 5002;
|
const GLuint kTestClientFragmentShaderId = 5002;
|
||||||
const GLuint kServiceFragmentShaderId = 6002;
|
const GLuint kTestServiceFragmentShaderId = 6002;
|
||||||
DoCreateShader(
|
DoCreateShader(GL_VERTEX_SHADER, kTestClientVertexShaderId,
|
||||||
GL_VERTEX_SHADER, kClientVertexShaderId, kServiceVertexShaderId);
|
kTestServiceVertexShaderId);
|
||||||
DoCreateShader(
|
DoCreateShader(GL_FRAGMENT_SHADER, kTestClientFragmentShaderId,
|
||||||
GL_FRAGMENT_SHADER, kClientFragmentShaderId, kServiceFragmentShaderId);
|
kTestServiceFragmentShaderId);
|
||||||
|
|
||||||
TestHelper::SetShaderStates(
|
TestHelper::SetShaderStates(gl_.get(), GetShader(kTestClientVertexShaderId),
|
||||||
gl_.get(), GetShader(kClientVertexShaderId), true);
|
true);
|
||||||
TestHelper::SetShaderStates(
|
TestHelper::SetShaderStates(gl_.get(), GetShader(kTestClientFragmentShaderId),
|
||||||
gl_.get(), GetShader(kClientFragmentShaderId), true);
|
true);
|
||||||
|
|
||||||
InSequence dummy;
|
InSequence dummy;
|
||||||
EXPECT_CALL(*gl_,
|
EXPECT_CALL(*gl_, AttachShader(kServiceProgramId, kTestServiceVertexShaderId))
|
||||||
AttachShader(kServiceProgramId, kServiceVertexShaderId))
|
|
||||||
.Times(1)
|
.Times(1)
|
||||||
.RetiresOnSaturation();
|
.RetiresOnSaturation();
|
||||||
EXPECT_CALL(*gl_,
|
EXPECT_CALL(*gl_,
|
||||||
AttachShader(kServiceProgramId, kServiceFragmentShaderId))
|
AttachShader(kServiceProgramId, kTestServiceFragmentShaderId))
|
||||||
.Times(1)
|
.Times(1)
|
||||||
.RetiresOnSaturation();
|
.RetiresOnSaturation();
|
||||||
EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
|
EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
|
||||||
@ -791,10 +789,10 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::LinkProgram, 0>(
|
|||||||
.WillOnce(SetArgPointee<2>(0));
|
.WillOnce(SetArgPointee<2>(0));
|
||||||
|
|
||||||
cmds::AttachShader attach_cmd;
|
cmds::AttachShader attach_cmd;
|
||||||
attach_cmd.Init(client_program_id_, kClientVertexShaderId);
|
attach_cmd.Init(client_program_id_, kTestClientVertexShaderId);
|
||||||
EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
|
EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
|
||||||
|
|
||||||
attach_cmd.Init(client_program_id_, kClientFragmentShaderId);
|
attach_cmd.Init(client_program_id_, kTestClientFragmentShaderId);
|
||||||
EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
|
EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1051,14 +1051,14 @@ void GLES2DecoderTestBase::SetupShaderForUniform(GLenum uniform_type) {
|
|||||||
{ "bar", 1, uniform_type, 0, 2, -1, },
|
{ "bar", 1, uniform_type, 0, 2, -1, },
|
||||||
{ "car", 4, uniform_type, 1, 1, -1, },
|
{ "car", 4, uniform_type, 1, 1, -1, },
|
||||||
};
|
};
|
||||||
const GLuint kClientVertexShaderId = 5001;
|
const GLuint kTestClientVertexShaderId = 5001;
|
||||||
const GLuint kServiceVertexShaderId = 6001;
|
const GLuint kTestServiceVertexShaderId = 6001;
|
||||||
const GLuint kClientFragmentShaderId = 5002;
|
const GLuint kTestClientFragmentShaderId = 5002;
|
||||||
const GLuint kServiceFragmentShaderId = 6002;
|
const GLuint kTestServiceFragmentShaderId = 6002;
|
||||||
SetupShader(attribs, base::size(attribs), uniforms, base::size(uniforms),
|
SetupShader(attribs, base::size(attribs), uniforms, base::size(uniforms),
|
||||||
client_program_id_, kServiceProgramId, kClientVertexShaderId,
|
client_program_id_, kServiceProgramId, kTestClientVertexShaderId,
|
||||||
kServiceVertexShaderId, kClientFragmentShaderId,
|
kTestServiceVertexShaderId, kTestClientFragmentShaderId,
|
||||||
kServiceFragmentShaderId);
|
kTestServiceFragmentShaderId);
|
||||||
|
|
||||||
EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
|
EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
|
||||||
.Times(1)
|
.Times(1)
|
||||||
|
@ -301,11 +301,10 @@ TEST_P(SharedImageBackingFactoryGLImageTest, Basic) {
|
|||||||
// Create a R-8 image texture, and check that the internal_format is that
|
// Create a R-8 image texture, and check that the internal_format is that
|
||||||
// of the image (GL_RGBA for TextureImageFactory). This only matters for
|
// of the image (GL_RGBA for TextureImageFactory). This only matters for
|
||||||
// the validating decoder.
|
// the validating decoder.
|
||||||
auto format = viz::ResourceFormat::RED_8;
|
|
||||||
gpu::SurfaceHandle surface_handle = gpu::kNullSurfaceHandle;
|
|
||||||
backing = backing_factory_->CreateSharedImage(
|
backing = backing_factory_->CreateSharedImage(
|
||||||
mailbox, format, surface_handle, size, color_space, surface_origin,
|
mailbox, viz::ResourceFormat::RED_8, gpu::kNullSurfaceHandle, size,
|
||||||
alpha_type, usage, false /* is_thread_safe */);
|
color_space, surface_origin, alpha_type, usage,
|
||||||
|
false /* is_thread_safe */);
|
||||||
EXPECT_TRUE(backing);
|
EXPECT_TRUE(backing);
|
||||||
shared_image = shared_image_manager_->Register(std::move(backing),
|
shared_image = shared_image_manager_->Register(std::move(backing),
|
||||||
memory_type_tracker_.get());
|
memory_type_tracker_.get());
|
||||||
|
@ -176,8 +176,8 @@ void TestHelper::SetupTextureInitializationExpectations(
|
|||||||
GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
|
GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
|
||||||
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
|
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
|
||||||
};
|
};
|
||||||
for (size_t ii = 0; ii < base::size(faces); ++ii) {
|
for (size_t face = 0; face < base::size(faces); ++face) {
|
||||||
EXPECT_CALL(*gl, TexImage2D(faces[ii], 0, GL_RGBA, 1, 1, 0, GL_RGBA,
|
EXPECT_CALL(*gl, TexImage2D(faces[face], 0, GL_RGBA, 1, 1, 0, GL_RGBA,
|
||||||
GL_UNSIGNED_BYTE, _))
|
GL_UNSIGNED_BYTE, _))
|
||||||
.Times(1)
|
.Times(1)
|
||||||
.RetiresOnSaturation();
|
.RetiresOnSaturation();
|
||||||
|
@ -146,7 +146,7 @@ TEST_F(SharedImageGLBackingProduceDawnTest, Basic) {
|
|||||||
reservation.deviceId, reservation.deviceGeneration, reservation.id,
|
reservation.deviceId, reservation.deviceGeneration, reservation.id,
|
||||||
reservation.generation, WGPUTextureUsage_CopySrc,
|
reservation.generation, WGPUTextureUsage_CopySrc,
|
||||||
webgpu::WEBGPU_MAILBOX_NONE, reinterpret_cast<GLbyte*>(&gl_mailbox));
|
webgpu::WEBGPU_MAILBOX_NONE, reinterpret_cast<GLbyte*>(&gl_mailbox));
|
||||||
wgpu::Texture texture = wgpu::Texture::Acquire(reservation.texture);
|
wgpu::Texture wgpu_texture = wgpu::Texture::Acquire(reservation.texture);
|
||||||
|
|
||||||
// Copy the texture in a mappable buffer.
|
// Copy the texture in a mappable buffer.
|
||||||
wgpu::BufferDescriptor buffer_desc;
|
wgpu::BufferDescriptor buffer_desc;
|
||||||
@ -155,7 +155,7 @@ TEST_F(SharedImageGLBackingProduceDawnTest, Basic) {
|
|||||||
wgpu::Buffer readback_buffer = device.CreateBuffer(&buffer_desc);
|
wgpu::Buffer readback_buffer = device.CreateBuffer(&buffer_desc);
|
||||||
|
|
||||||
wgpu::ImageCopyTexture copy_src = {};
|
wgpu::ImageCopyTexture copy_src = {};
|
||||||
copy_src.texture = texture;
|
copy_src.texture = wgpu_texture;
|
||||||
copy_src.mipLevel = 0;
|
copy_src.mipLevel = 0;
|
||||||
copy_src.origin = {0, 0, 0};
|
copy_src.origin = {0, 0, 0};
|
||||||
|
|
||||||
|
@ -277,16 +277,17 @@ void GpuChannelManager::GpuPeakMemoryMonitor::OnMemoryAllocatedChange(
|
|||||||
// approaches peak. If that is the case we should track a
|
// approaches peak. If that is the case we should track a
|
||||||
// |peak_since_last_sequence_update_| on the the memory changes. Then only
|
// |peak_since_last_sequence_update_| on the the memory changes. Then only
|
||||||
// update the sequences with a new one is added, or the peak is requested.
|
// update the sequences with a new one is added, or the peak is requested.
|
||||||
for (auto& sequence : sequence_trackers_) {
|
for (auto& seq : sequence_trackers_) {
|
||||||
if (current_memory_ > sequence.second.total_memory_) {
|
if (current_memory_ > seq.second.total_memory_) {
|
||||||
sequence.second.total_memory_ = current_memory_;
|
seq.second.total_memory_ = current_memory_;
|
||||||
for (auto& sequence : sequence_trackers_) {
|
for (auto& sequence : sequence_trackers_) {
|
||||||
TRACE_EVENT_ASYNC_STEP_INTO1("gpu", "PeakMemoryTracking",
|
TRACE_EVENT_ASYNC_STEP_INTO1("gpu", "PeakMemoryTracking",
|
||||||
sequence.first, "Peak", "peak",
|
sequence.first, "Peak", "peak",
|
||||||
current_memory_);
|
current_memory_);
|
||||||
}
|
}
|
||||||
for (auto& source : current_memory_per_source_) {
|
for (auto& memory_per_source : current_memory_per_source_) {
|
||||||
sequence.second.peak_memory_per_source_[source.first] = source.second;
|
seq.second.peak_memory_per_source_[memory_per_source.first] =
|
||||||
|
memory_per_source.second;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -75,17 +75,16 @@ TEST_F(BasicVulkanTest, EmptyVulkanSwaps) {
|
|||||||
|
|
||||||
// Also make sure we can swap multiple times.
|
// Also make sure we can swap multiple times.
|
||||||
for (int i = 0; i < 10; ++i) {
|
for (int i = 0; i < 10; ++i) {
|
||||||
absl::optional<VulkanSwapChain::ScopedWrite> scoped_write;
|
|
||||||
scoped_write.emplace(surface->swap_chain());
|
scoped_write.emplace(surface->swap_chain());
|
||||||
EXPECT_TRUE(scoped_write->success());
|
EXPECT_TRUE(scoped_write->success());
|
||||||
|
|
||||||
VkSemaphore begin_semaphore = scoped_write->begin_semaphore();
|
begin_semaphore = scoped_write->begin_semaphore();
|
||||||
EXPECT_NE(begin_semaphore, kNullSemaphore);
|
EXPECT_NE(begin_semaphore, kNullSemaphore);
|
||||||
|
|
||||||
VkSemaphore end_semaphore = scoped_write->end_semaphore();
|
end_semaphore = scoped_write->end_semaphore();
|
||||||
EXPECT_NE(end_semaphore, kNullSemaphore);
|
EXPECT_NE(end_semaphore, kNullSemaphore);
|
||||||
|
|
||||||
auto command_buffer = command_pool->CreatePrimaryCommandBuffer();
|
command_buffer = command_pool->CreatePrimaryCommandBuffer();
|
||||||
{
|
{
|
||||||
ScopedSingleUseCommandBufferRecorder recorder(*command_buffer);
|
ScopedSingleUseCommandBufferRecorder recorder(*command_buffer);
|
||||||
|
|
||||||
@ -99,6 +98,7 @@ TEST_F(BasicVulkanTest, EmptyVulkanSwaps) {
|
|||||||
EXPECT_EQ(gfx::SwapResult::SWAP_ACK, surface->SwapBuffers());
|
EXPECT_EQ(gfx::SwapResult::SWAP_ACK, surface->SwapBuffers());
|
||||||
vkQueueWaitIdle(GetDeviceQueue()->GetVulkanQueue());
|
vkQueueWaitIdle(GetDeviceQueue()->GetVulkanQueue());
|
||||||
command_buffer->Destroy();
|
command_buffer->Destroy();
|
||||||
|
command_buffer.reset();
|
||||||
}
|
}
|
||||||
surface->Finish();
|
surface->Finish();
|
||||||
surface->Destroy();
|
surface->Destroy();
|
||||||
|
@ -65,23 +65,23 @@ Builder::Builder() : options_(0, nullptr) {}
|
|||||||
Builder::~Builder() = default;
|
Builder::~Builder() = default;
|
||||||
|
|
||||||
Builder& Builder::SetProductNameAndVersion(
|
Builder& Builder::SetProductNameAndVersion(
|
||||||
const std::string& product_name_and_version) {
|
const std::string& name_and_version) {
|
||||||
options_.product_name_and_version = product_name_and_version;
|
options_.product_name_and_version = name_and_version;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetUserAgent(const std::string& user_agent) {
|
Builder& Builder::SetUserAgent(const std::string& agent) {
|
||||||
options_.user_agent = user_agent;
|
options_.user_agent = agent;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetAcceptLanguage(const std::string& accept_language) {
|
Builder& Builder::SetAcceptLanguage(const std::string& language) {
|
||||||
options_.accept_language = accept_language;
|
options_.accept_language = language;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetEnableBeginFrameControl(bool enable_begin_frame_control) {
|
Builder& Builder::SetEnableBeginFrameControl(bool enable) {
|
||||||
options_.enable_begin_frame_control = enable_begin_frame_control;
|
options_.enable_begin_frame_control = enable;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -95,40 +95,38 @@ Builder& Builder::EnableDevToolsPipe() {
|
|||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetMessagePump(base::MessagePump* message_pump) {
|
Builder& Builder::SetMessagePump(base::MessagePump* pump) {
|
||||||
options_.message_pump = message_pump;
|
options_.message_pump = pump;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetProxyConfig(
|
Builder& Builder::SetProxyConfig(std::unique_ptr<net::ProxyConfig> config) {
|
||||||
std::unique_ptr<net::ProxyConfig> proxy_config) {
|
options_.proxy_config = std::move(config);
|
||||||
options_.proxy_config = std::move(proxy_config);
|
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetSingleProcessMode(bool single_process_mode) {
|
Builder& Builder::SetSingleProcessMode(bool single_process) {
|
||||||
options_.single_process_mode = single_process_mode;
|
options_.single_process_mode = single_process;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetDisableSandbox(bool disable_sandbox) {
|
Builder& Builder::SetDisableSandbox(bool disable) {
|
||||||
options_.disable_sandbox = disable_sandbox;
|
options_.disable_sandbox = disable;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetEnableResourceScheduler(bool enable_resource_scheduler) {
|
Builder& Builder::SetEnableResourceScheduler(bool enable) {
|
||||||
options_.enable_resource_scheduler = enable_resource_scheduler;
|
options_.enable_resource_scheduler = enable;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetGLImplementation(const std::string& gl_implementation) {
|
Builder& Builder::SetGLImplementation(const std::string& implementation) {
|
||||||
options_.gl_implementation = gl_implementation;
|
options_.gl_implementation = implementation;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetANGLEImplementation(
|
Builder& Builder::SetANGLEImplementation(const std::string& implementation) {
|
||||||
const std::string& angle_implementation) {
|
options_.angle_implementation = implementation;
|
||||||
options_.angle_implementation = angle_implementation;
|
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -139,39 +137,39 @@ Builder& Builder::SetAppendCommandLineFlagsCallback(
|
|||||||
}
|
}
|
||||||
|
|
||||||
#if defined(OS_WIN)
|
#if defined(OS_WIN)
|
||||||
Builder& Builder::SetInstance(HINSTANCE instance) {
|
Builder& Builder::SetInstance(HINSTANCE hinstance) {
|
||||||
options_.instance = instance;
|
options_.instance = hinstance;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetSandboxInfo(sandbox::SandboxInterfaceInfo* sandbox_info) {
|
Builder& Builder::SetSandboxInfo(sandbox::SandboxInterfaceInfo* info) {
|
||||||
options_.sandbox_info = sandbox_info;
|
options_.sandbox_info = info;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
#endif // defined(OS_WIN)
|
#endif // defined(OS_WIN)
|
||||||
|
|
||||||
Builder& Builder::SetUserDataDir(const base::FilePath& user_data_dir) {
|
Builder& Builder::SetUserDataDir(const base::FilePath& dir) {
|
||||||
options_.user_data_dir = user_data_dir;
|
options_.user_data_dir = dir;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetWindowSize(const gfx::Size& window_size) {
|
Builder& Builder::SetWindowSize(const gfx::Size& size) {
|
||||||
options_.window_size = window_size;
|
options_.window_size = size;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetIncognitoMode(bool incognito_mode) {
|
Builder& Builder::SetIncognitoMode(bool incognito) {
|
||||||
options_.incognito_mode = incognito_mode;
|
options_.incognito_mode = incognito;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetSitePerProcess(bool site_per_process) {
|
Builder& Builder::SetSitePerProcess(bool per_process) {
|
||||||
options_.site_per_process = site_per_process;
|
options_.site_per_process = per_process;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetBlockNewWebContents(bool block_new_web_contents) {
|
Builder& Builder::SetBlockNewWebContents(bool block) {
|
||||||
options_.block_new_web_contents = block_new_web_contents;
|
options_.block_new_web_contents = block;
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -191,9 +189,8 @@ Builder& Builder::SetCrashDumpsDir(const base::FilePath& dir) {
|
|||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
Builder& Builder::SetFontRenderHinting(
|
Builder& Builder::SetFontRenderHinting(gfx::FontRenderParams::Hinting hinting) {
|
||||||
gfx::FontRenderParams::Hinting font_render_hinting) {
|
options_.font_render_hinting = hinting;
|
||||||
options_.font_render_hinting = font_render_hinting;
|
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -235,38 +235,36 @@ class HEADLESS_EXPORT HeadlessBrowser::Options::Builder {
|
|||||||
|
|
||||||
Builder& EnableDevToolsServer(const net::HostPortPair& endpoint);
|
Builder& EnableDevToolsServer(const net::HostPortPair& endpoint);
|
||||||
Builder& EnableDevToolsPipe();
|
Builder& EnableDevToolsPipe();
|
||||||
Builder& SetMessagePump(base::MessagePump* message_pump);
|
Builder& SetMessagePump(base::MessagePump* pump);
|
||||||
Builder& SetSingleProcessMode(bool single_process_mode);
|
Builder& SetSingleProcessMode(bool single_process);
|
||||||
Builder& SetDisableSandbox(bool disable_sandbox);
|
Builder& SetDisableSandbox(bool disable);
|
||||||
Builder& SetEnableResourceScheduler(bool enable_resource_scheduler);
|
Builder& SetEnableResourceScheduler(bool enable);
|
||||||
Builder& SetGLImplementation(const std::string& gl_implementation);
|
Builder& SetGLImplementation(const std::string& implementation);
|
||||||
Builder& SetANGLEImplementation(const std::string& angle_implementation);
|
Builder& SetANGLEImplementation(const std::string& implementation);
|
||||||
Builder& SetAppendCommandLineFlagsCallback(
|
Builder& SetAppendCommandLineFlagsCallback(
|
||||||
const Options::AppendCommandLineFlagsCallback& callback);
|
const Options::AppendCommandLineFlagsCallback& callback);
|
||||||
#if defined(OS_WIN)
|
#if defined(OS_WIN)
|
||||||
Builder& SetInstance(HINSTANCE instance);
|
Builder& SetInstance(HINSTANCE hinstance);
|
||||||
Builder& SetSandboxInfo(sandbox::SandboxInterfaceInfo* sandbox_info);
|
Builder& SetSandboxInfo(sandbox::SandboxInterfaceInfo* info);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
// Per-context settings.
|
// Per-context settings.
|
||||||
|
|
||||||
Builder& SetProductNameAndVersion(
|
Builder& SetProductNameAndVersion(const std::string& name_and_version);
|
||||||
const std::string& product_name_and_version);
|
Builder& SetAcceptLanguage(const std::string& language);
|
||||||
Builder& SetAcceptLanguage(const std::string& accept_language);
|
Builder& SetEnableBeginFrameControl(bool enable);
|
||||||
Builder& SetEnableBeginFrameControl(bool enable_begin_frame_control);
|
Builder& SetUserAgent(const std::string& agent);
|
||||||
Builder& SetUserAgent(const std::string& user_agent);
|
Builder& SetProxyConfig(std::unique_ptr<net::ProxyConfig> config);
|
||||||
Builder& SetProxyConfig(std::unique_ptr<net::ProxyConfig> proxy_config);
|
Builder& SetWindowSize(const gfx::Size& size);
|
||||||
Builder& SetWindowSize(const gfx::Size& window_size);
|
Builder& SetUserDataDir(const base::FilePath& dir);
|
||||||
Builder& SetUserDataDir(const base::FilePath& user_data_dir);
|
Builder& SetIncognitoMode(bool incognito);
|
||||||
Builder& SetIncognitoMode(bool incognito_mode);
|
Builder& SetSitePerProcess(bool per_process);
|
||||||
Builder& SetSitePerProcess(bool site_per_process);
|
Builder& SetBlockNewWebContents(bool block);
|
||||||
Builder& SetBlockNewWebContents(bool block_new_web_contents);
|
|
||||||
Builder& SetOverrideWebPreferencesCallback(
|
Builder& SetOverrideWebPreferencesCallback(
|
||||||
base::RepeatingCallback<void(blink::web_pref::WebPreferences*)> callback);
|
base::RepeatingCallback<void(blink::web_pref::WebPreferences*)> callback);
|
||||||
Builder& SetCrashReporterEnabled(bool enabled);
|
Builder& SetCrashReporterEnabled(bool enabled);
|
||||||
Builder& SetCrashDumpsDir(const base::FilePath& dir);
|
Builder& SetCrashDumpsDir(const base::FilePath& dir);
|
||||||
Builder& SetFontRenderHinting(
|
Builder& SetFontRenderHinting(gfx::FontRenderParams::Hinting hinting);
|
||||||
gfx::FontRenderParams::Hinting font_render_hinting);
|
|
||||||
|
|
||||||
Options Build();
|
Options Build();
|
||||||
|
|
||||||
|
@ -59,7 +59,7 @@ void ChannelProxy::Context::ClearIPCTaskRunner() {
|
|||||||
|
|
||||||
void ChannelProxy::Context::CreateChannel(
|
void ChannelProxy::Context::CreateChannel(
|
||||||
std::unique_ptr<ChannelFactory> factory) {
|
std::unique_ptr<ChannelFactory> factory) {
|
||||||
base::AutoLock l(channel_lifetime_lock_);
|
base::AutoLock channel_lock(channel_lifetime_lock_);
|
||||||
DCHECK(!channel_);
|
DCHECK(!channel_);
|
||||||
DCHECK_EQ(factory->GetIPCTaskRunner(), ipc_task_runner_);
|
DCHECK_EQ(factory->GetIPCTaskRunner(), ipc_task_runner_);
|
||||||
channel_ = factory->BuildChannel(this);
|
channel_ = factory->BuildChannel(this);
|
||||||
@ -69,7 +69,7 @@ void ChannelProxy::Context::CreateChannel(
|
|||||||
if (support) {
|
if (support) {
|
||||||
thread_safe_channel_ = support->CreateThreadSafeChannel();
|
thread_safe_channel_ = support->CreateThreadSafeChannel();
|
||||||
|
|
||||||
base::AutoLock l(pending_filters_lock_);
|
base::AutoLock filter_lock(pending_filters_lock_);
|
||||||
for (auto& entry : pending_io_thread_interfaces_)
|
for (auto& entry : pending_io_thread_interfaces_)
|
||||||
support->AddGenericAssociatedInterface(entry.first, entry.second);
|
support->AddGenericAssociatedInterface(entry.first, entry.second);
|
||||||
pending_io_thread_interfaces_.clear();
|
pending_io_thread_interfaces_.clear();
|
||||||
@ -409,9 +409,9 @@ void ChannelProxy::Context::ClearChannel() {
|
|||||||
void ChannelProxy::Context::AddGenericAssociatedInterfaceForIOThread(
|
void ChannelProxy::Context::AddGenericAssociatedInterfaceForIOThread(
|
||||||
const std::string& name,
|
const std::string& name,
|
||||||
const GenericAssociatedInterfaceFactory& factory) {
|
const GenericAssociatedInterfaceFactory& factory) {
|
||||||
base::AutoLock l(channel_lifetime_lock_);
|
base::AutoLock channel_lock(channel_lifetime_lock_);
|
||||||
if (!channel_) {
|
if (!channel_) {
|
||||||
base::AutoLock l(pending_filters_lock_);
|
base::AutoLock filter_lock(pending_filters_lock_);
|
||||||
pending_io_thread_interfaces_.emplace_back(name, factory);
|
pending_io_thread_interfaces_.emplace_back(name, factory);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
@ -138,18 +138,20 @@ scoped_refptr<MessageAttachment> MessageAttachment::CreateFromMojoHandle(
|
|||||||
}
|
}
|
||||||
#elif defined(OS_FUCHSIA)
|
#elif defined(OS_FUCHSIA)
|
||||||
if (type == Type::FUCHSIA_HANDLE) {
|
if (type == Type::FUCHSIA_HANDLE) {
|
||||||
zx::handle handle;
|
zx::handle zx_handle;
|
||||||
if (platform_handle.type == MOJO_PLATFORM_HANDLE_TYPE_FUCHSIA_HANDLE)
|
if (platform_handle.type == MOJO_PLATFORM_HANDLE_TYPE_FUCHSIA_HANDLE)
|
||||||
handle.reset(static_cast<zx_handle_t>(platform_handle.value));
|
zx_handle.reset(static_cast<zx_handle_t>(platform_handle.value));
|
||||||
return new internal::HandleAttachmentFuchsia(std::move(handle));
|
return new internal::HandleAttachmentFuchsia(std::move(zx_handle));
|
||||||
}
|
}
|
||||||
#elif defined(OS_WIN)
|
#elif defined(OS_WIN)
|
||||||
if (type == Type::WIN_HANDLE) {
|
if (type == Type::WIN_HANDLE) {
|
||||||
base::PlatformFile handle = base::kInvalidPlatformFile;
|
base::PlatformFile platform_file = base::kInvalidPlatformFile;
|
||||||
if (platform_handle.type == MOJO_PLATFORM_HANDLE_TYPE_WINDOWS_HANDLE)
|
if (platform_handle.type == MOJO_PLATFORM_HANDLE_TYPE_WINDOWS_HANDLE) {
|
||||||
handle = reinterpret_cast<base::PlatformFile>(platform_handle.value);
|
platform_file =
|
||||||
|
reinterpret_cast<base::PlatformFile>(platform_handle.value);
|
||||||
|
}
|
||||||
return new internal::HandleAttachmentWin(
|
return new internal::HandleAttachmentWin(
|
||||||
handle, internal::HandleAttachmentWin::FROM_WIRE);
|
platform_file, internal::HandleAttachmentWin::FROM_WIRE);
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
NOTREACHED();
|
NOTREACHED();
|
||||||
|
@ -114,7 +114,7 @@ TEST_F(AudioBlockFifoTest, PushAndConsume) {
|
|||||||
|
|
||||||
// Consume all blocks of data.
|
// Consume all blocks of data.
|
||||||
for (int i = 1; i <= blocks; ++i) {
|
for (int i = 1; i <= blocks; ++i) {
|
||||||
const AudioBus* bus = fifo.Consume();
|
bus = fifo.Consume();
|
||||||
EXPECT_TRUE(channels == bus->channels());
|
EXPECT_TRUE(channels == bus->channels());
|
||||||
EXPECT_TRUE(frames == bus->frames());
|
EXPECT_TRUE(frames == bus->frames());
|
||||||
EXPECT_TRUE(fifo.GetUnfilledFrames() == frames * i);
|
EXPECT_TRUE(fifo.GetUnfilledFrames() == frames * i);
|
||||||
@ -132,7 +132,7 @@ TEST_F(AudioBlockFifoTest, PushAndConsume) {
|
|||||||
|
|
||||||
// Consume all the existing filled blocks of data.
|
// Consume all the existing filled blocks of data.
|
||||||
while (fifo.available_blocks()) {
|
while (fifo.available_blocks()) {
|
||||||
const AudioBus* bus = fifo.Consume();
|
bus = fifo.Consume();
|
||||||
EXPECT_TRUE(channels == bus->channels());
|
EXPECT_TRUE(channels == bus->channels());
|
||||||
EXPECT_TRUE(frames == bus->frames());
|
EXPECT_TRUE(frames == bus->frames());
|
||||||
}
|
}
|
||||||
|
@ -121,7 +121,7 @@ TEST_F(AudioFifoTest, FramesInFifo) {
|
|||||||
const int frames_in_fifo = bus2->frames();
|
const int frames_in_fifo = bus2->frames();
|
||||||
fifo.Push(bus2.get());
|
fifo.Push(bus2.get());
|
||||||
EXPECT_EQ(fifo.frames(), frames_in_fifo);
|
EXPECT_EQ(fifo.frames(), frames_in_fifo);
|
||||||
for (int n = 0; n < kMaxFrameCount; ++n) {
|
for (n = 0; n < kMaxFrameCount; ++n) {
|
||||||
fifo.Push(bus2.get());
|
fifo.Push(bus2.get());
|
||||||
fifo.Consume(bus2.get(), 0, frames_in_fifo);
|
fifo.Consume(bus2.get(), 0, frames_in_fifo);
|
||||||
EXPECT_EQ(fifo.frames(), frames_in_fifo);
|
EXPECT_EQ(fifo.frames(), frames_in_fifo);
|
||||||
|
@ -253,7 +253,7 @@ TEST(VideoCaptureOracleTest, SamplesAtCorrectTimesAroundRefreshRequests) {
|
|||||||
t += refresh_interval;
|
t += refresh_interval;
|
||||||
if (oracle.ObserveEventAndDecideCapture(VideoCaptureOracle::kRefreshRequest,
|
if (oracle.ObserveEventAndDecideCapture(VideoCaptureOracle::kRefreshRequest,
|
||||||
gfx::Rect(), t)) {
|
gfx::Rect(), t)) {
|
||||||
const int frame_number = oracle.next_frame_number();
|
frame_number = oracle.next_frame_number();
|
||||||
oracle.RecordCapture(0.0);
|
oracle.RecordCapture(0.0);
|
||||||
ASSERT_TRUE(oracle.CompleteCapture(frame_number, true, &ignored));
|
ASSERT_TRUE(oracle.CompleteCapture(frame_number, true, &ignored));
|
||||||
did_complete_a_capture = true;
|
did_complete_a_capture = true;
|
||||||
|
@ -107,8 +107,8 @@ VideoCaptureFeedback& VideoCaptureFeedback::RequireMapped(bool require) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
VideoCaptureFeedback& VideoCaptureFeedback::WithMappedSizes(
|
VideoCaptureFeedback& VideoCaptureFeedback::WithMappedSizes(
|
||||||
std::vector<gfx::Size> mapped_sizes) {
|
std::vector<gfx::Size> sizes) {
|
||||||
this->mapped_sizes = std::move(mapped_sizes);
|
mapped_sizes = std::move(sizes);
|
||||||
SortSizesDescending(mapped_sizes);
|
SortSizesDescending(mapped_sizes);
|
||||||
return *this;
|
return *this;
|
||||||
}
|
}
|
||||||
|
@ -48,7 +48,7 @@ struct CAPTURE_EXPORT VideoCaptureFeedback {
|
|||||||
VideoCaptureFeedback& WithMaxFramerate(float max_framerate_fps);
|
VideoCaptureFeedback& WithMaxFramerate(float max_framerate_fps);
|
||||||
VideoCaptureFeedback& WithMaxPixels(int max_pixels);
|
VideoCaptureFeedback& WithMaxPixels(int max_pixels);
|
||||||
VideoCaptureFeedback& RequireMapped(bool require);
|
VideoCaptureFeedback& RequireMapped(bool require);
|
||||||
VideoCaptureFeedback& WithMappedSizes(std::vector<gfx::Size> mapped_sizes);
|
VideoCaptureFeedback& WithMappedSizes(std::vector<gfx::Size> sizes);
|
||||||
|
|
||||||
// Combine constraints of two different sinks resulting in constraints fitting
|
// Combine constraints of two different sinks resulting in constraints fitting
|
||||||
// both of them.
|
// both of them.
|
||||||
|
@ -435,7 +435,7 @@ bool VideoCaptureDeviceFactoryWin::CreateDeviceFilterDirectShow(
|
|||||||
for (ComPtr<IMoniker> moniker;
|
for (ComPtr<IMoniker> moniker;
|
||||||
enum_moniker->Next(1, &moniker, nullptr) == S_OK; moniker.Reset()) {
|
enum_moniker->Next(1, &moniker, nullptr) == S_OK; moniker.Reset()) {
|
||||||
ComPtr<IPropertyBag> prop_bag;
|
ComPtr<IPropertyBag> prop_bag;
|
||||||
HRESULT hr = moniker->BindToStorage(0, 0, IID_PPV_ARGS(&prop_bag));
|
hr = moniker->BindToStorage(0, 0, IID_PPV_ARGS(&prop_bag));
|
||||||
if (FAILED(hr))
|
if (FAILED(hr))
|
||||||
continue;
|
continue;
|
||||||
|
|
||||||
|
@ -128,15 +128,15 @@ void VideoCaptureDeviceWin::GetPinCapabilityList(
|
|||||||
ComPtr<IAMVideoControl> video_control;
|
ComPtr<IAMVideoControl> video_control;
|
||||||
hr = capture_filter.As(&video_control);
|
hr = capture_filter.As(&video_control);
|
||||||
|
|
||||||
int count = 0, size = 0;
|
int count = 0, byte_size = 0;
|
||||||
hr = stream_config->GetNumberOfCapabilities(&count, &size);
|
hr = stream_config->GetNumberOfCapabilities(&count, &byte_size);
|
||||||
if (FAILED(hr)) {
|
if (FAILED(hr)) {
|
||||||
DLOG(ERROR) << "GetNumberOfCapabilities failed: "
|
DLOG(ERROR) << "GetNumberOfCapabilities failed: "
|
||||||
<< logging::SystemErrorCodeToString(hr);
|
<< logging::SystemErrorCodeToString(hr);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
std::unique_ptr<BYTE[]> caps(new BYTE[size]);
|
std::unique_ptr<BYTE[]> caps(new BYTE[byte_size]);
|
||||||
for (int i = 0; i < count; ++i) {
|
for (int i = 0; i < count; ++i) {
|
||||||
VideoCaptureDeviceWin::ScopedMediaType media_type;
|
VideoCaptureDeviceWin::ScopedMediaType media_type;
|
||||||
hr = stream_config->GetStreamCaps(i, media_type.Receive(), caps.get());
|
hr = stream_config->GetStreamCaps(i, media_type.Receive(), caps.get());
|
||||||
|
@ -419,9 +419,9 @@ TEST_F(RtcpBuilderTest, RtcpReceiverReportRedundancy) {
|
|||||||
p.AddReceiverFrameLog(test_rtp_timestamp().lower_32_bits(), num_events,
|
p.AddReceiverFrameLog(test_rtp_timestamp().lower_32_bits(), num_events,
|
||||||
time_base_ms - (num_events - 1) * kResendDelay *
|
time_base_ms - (num_events - 1) * kResendDelay *
|
||||||
kTimeBetweenEventsMs);
|
kTimeBetweenEventsMs);
|
||||||
for (int i = 0; i < num_events; i++) {
|
for (int event = 0; event < num_events; event++) {
|
||||||
p.AddReceiverEventLog(0, FRAME_ACK_SENT,
|
p.AddReceiverEventLog(0, FRAME_ACK_SENT,
|
||||||
base::checked_cast<uint16_t>(i * kResendDelay *
|
base::checked_cast<uint16_t>(event * kResendDelay *
|
||||||
kTimeBetweenEventsMs));
|
kTimeBetweenEventsMs));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -79,8 +79,9 @@ void RtpSender::ResendPackets(
|
|||||||
if (!stored_packets)
|
if (!stored_packets)
|
||||||
continue;
|
continue;
|
||||||
|
|
||||||
for (auto it = stored_packets->begin(); it != stored_packets->end(); ++it) {
|
for (auto packet_it = stored_packets->begin();
|
||||||
const PacketKey& packet_key = it->first;
|
packet_it != stored_packets->end(); ++packet_it) {
|
||||||
|
const PacketKey& packet_key = packet_it->first;
|
||||||
const uint16_t packet_id = packet_key.packet_id;
|
const uint16_t packet_id = packet_key.packet_id;
|
||||||
|
|
||||||
// Should we resend the packet?
|
// Should we resend the packet?
|
||||||
@ -94,7 +95,7 @@ void RtpSender::ResendPackets(
|
|||||||
|
|
||||||
// If we were asked to resend the last packet, check if it's the
|
// If we were asked to resend the last packet, check if it's the
|
||||||
// last packet.
|
// last packet.
|
||||||
if (!resend && resend_last && (it + 1) == stored_packets->end()) {
|
if (!resend && resend_last && (packet_it + 1) == stored_packets->end()) {
|
||||||
resend = true;
|
resend = true;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -102,11 +103,11 @@ void RtpSender::ResendPackets(
|
|||||||
// Resend packet to the network.
|
// Resend packet to the network.
|
||||||
VLOG(3) << "Resend " << frame_id << ":" << packet_id;
|
VLOG(3) << "Resend " << frame_id << ":" << packet_id;
|
||||||
// Set a unique incremental sequence number for every packet.
|
// Set a unique incremental sequence number for every packet.
|
||||||
PacketRef packet_copy = FastCopyPacket(it->second);
|
PacketRef packet_copy = FastCopyPacket(packet_it->second);
|
||||||
UpdateSequenceNumber(&packet_copy->data);
|
UpdateSequenceNumber(&packet_copy->data);
|
||||||
packets_to_resend.push_back(std::make_pair(packet_key, packet_copy));
|
packets_to_resend.push_back(std::make_pair(packet_key, packet_copy));
|
||||||
} else if (cancel_rtx_if_not_in_list) {
|
} else if (cancel_rtx_if_not_in_list) {
|
||||||
transport_->CancelSendingPacket(it->first);
|
transport_->CancelSendingPacket(packet_it->first);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
transport_->ResendPackets(packets_to_resend, dedup_info);
|
transport_->ResendPackets(packets_to_resend, dedup_info);
|
||||||
|
@ -152,7 +152,7 @@ TEST_F(CongestionControlTest, RetainsSufficientHistory) {
|
|||||||
base::TimeDelta::FromMilliseconds(400);
|
base::TimeDelta::FromMilliseconds(400);
|
||||||
|
|
||||||
// Sanity-check: With no data, GetBitrate() returns an in-range value.
|
// Sanity-check: With no data, GetBitrate() returns an in-range value.
|
||||||
const int bitrate = congestion_control_->GetBitrate(
|
int bitrate = congestion_control_->GetBitrate(
|
||||||
testing_clock_.NowTicks() + kFakePlayoutDelay, kFakePlayoutDelay);
|
testing_clock_.NowTicks() + kFakePlayoutDelay, kFakePlayoutDelay);
|
||||||
ASSERT_GE(bitrate, kMinBitrateConfigured);
|
ASSERT_GE(bitrate, kMinBitrateConfigured);
|
||||||
ASSERT_LE(bitrate, kMaxBitrateConfigured);
|
ASSERT_LE(bitrate, kMaxBitrateConfigured);
|
||||||
@ -165,7 +165,7 @@ TEST_F(CongestionControlTest, RetainsSufficientHistory) {
|
|||||||
congestion_control_->SendFrameToTransport(frame_id, 16384,
|
congestion_control_->SendFrameToTransport(frame_id, 16384,
|
||||||
testing_clock_.NowTicks());
|
testing_clock_.NowTicks());
|
||||||
|
|
||||||
const int bitrate = congestion_control_->GetBitrate(
|
bitrate = congestion_control_->GetBitrate(
|
||||||
testing_clock_.NowTicks() + kFakePlayoutDelay, kFakePlayoutDelay);
|
testing_clock_.NowTicks() + kFakePlayoutDelay, kFakePlayoutDelay);
|
||||||
ASSERT_GE(bitrate, kMinBitrateConfigured);
|
ASSERT_GE(bitrate, kMinBitrateConfigured);
|
||||||
ASSERT_LE(bitrate, kMaxBitrateConfigured);
|
ASSERT_LE(bitrate, kMaxBitrateConfigured);
|
||||||
@ -180,7 +180,7 @@ TEST_F(CongestionControlTest, RetainsSufficientHistory) {
|
|||||||
for (int i = 0; i < kMaxUnackedFrames; ++i) {
|
for (int i = 0; i < kMaxUnackedFrames; ++i) {
|
||||||
congestion_control_->AckFrame(frame_id, testing_clock_.NowTicks());
|
congestion_control_->AckFrame(frame_id, testing_clock_.NowTicks());
|
||||||
|
|
||||||
const int bitrate = congestion_control_->GetBitrate(
|
bitrate = congestion_control_->GetBitrate(
|
||||||
testing_clock_.NowTicks() + kFakePlayoutDelay, kFakePlayoutDelay);
|
testing_clock_.NowTicks() + kFakePlayoutDelay, kFakePlayoutDelay);
|
||||||
ASSERT_GE(bitrate, kMinBitrateConfigured);
|
ASSERT_GE(bitrate, kMinBitrateConfigured);
|
||||||
ASSERT_LE(bitrate, kMaxBitrateConfigured);
|
ASSERT_LE(bitrate, kMaxBitrateConfigured);
|
||||||
|
@ -415,7 +415,7 @@ TEST_F(VideoSenderTest, StopSendingInTheAbsenceOfAck) {
|
|||||||
|
|
||||||
// Send 3 more frames and record the number of packets sent.
|
// Send 3 more frames and record the number of packets sent.
|
||||||
for (int i = 0; i < 3; ++i) {
|
for (int i = 0; i < 3; ++i) {
|
||||||
scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
|
video_frame = GetNewVideoFrame();
|
||||||
video_sender_->InsertRawVideoFrame(video_frame, testing_clock_.NowTicks());
|
video_sender_->InsertRawVideoFrame(video_frame, testing_clock_.NowTicks());
|
||||||
RunTasks(33);
|
RunTasks(33);
|
||||||
}
|
}
|
||||||
@ -424,7 +424,7 @@ TEST_F(VideoSenderTest, StopSendingInTheAbsenceOfAck) {
|
|||||||
// Send 3 more frames - they should not be encoded, as we have not received
|
// Send 3 more frames - they should not be encoded, as we have not received
|
||||||
// any acks.
|
// any acks.
|
||||||
for (int i = 0; i < 3; ++i) {
|
for (int i = 0; i < 3; ++i) {
|
||||||
scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
|
video_frame = GetNewVideoFrame();
|
||||||
video_sender_->InsertRawVideoFrame(video_frame, testing_clock_.NowTicks());
|
video_sender_->InsertRawVideoFrame(video_frame, testing_clock_.NowTicks());
|
||||||
RunTasks(33);
|
RunTasks(33);
|
||||||
}
|
}
|
||||||
@ -461,7 +461,7 @@ TEST_F(VideoSenderTest, DuplicateAckRetransmit) {
|
|||||||
|
|
||||||
// Send 3 more frames but don't ACK.
|
// Send 3 more frames but don't ACK.
|
||||||
for (int i = 0; i < 3; ++i) {
|
for (int i = 0; i < 3; ++i) {
|
||||||
scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
|
video_frame = GetNewVideoFrame();
|
||||||
video_sender_->InsertRawVideoFrame(video_frame, testing_clock_.NowTicks());
|
video_sender_->InsertRawVideoFrame(video_frame, testing_clock_.NowTicks());
|
||||||
RunTasks(33);
|
RunTasks(33);
|
||||||
}
|
}
|
||||||
@ -504,7 +504,7 @@ TEST_F(VideoSenderTest, DuplicateAckRetransmitDoesNotCancelRetransmits) {
|
|||||||
|
|
||||||
// Send 2 more frames but don't ACK.
|
// Send 2 more frames but don't ACK.
|
||||||
for (int i = 0; i < 2; ++i) {
|
for (int i = 0; i < 2; ++i) {
|
||||||
scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
|
video_frame = GetNewVideoFrame();
|
||||||
video_sender_->InsertRawVideoFrame(video_frame, testing_clock_.NowTicks());
|
video_sender_->InsertRawVideoFrame(video_frame, testing_clock_.NowTicks());
|
||||||
RunTasks(33);
|
RunTasks(33);
|
||||||
}
|
}
|
||||||
|
@ -52,7 +52,7 @@ FFmpegAudioDecoder::FFmpegAudioDecoder(
|
|||||||
const scoped_refptr<base::SequencedTaskRunner>& task_runner,
|
const scoped_refptr<base::SequencedTaskRunner>& task_runner,
|
||||||
MediaLog* media_log)
|
MediaLog* media_log)
|
||||||
: task_runner_(task_runner),
|
: task_runner_(task_runner),
|
||||||
state_(kUninitialized),
|
state_(DecoderState::kUninitialized),
|
||||||
av_sample_format_(0),
|
av_sample_format_(0),
|
||||||
media_log_(media_log),
|
media_log_(media_log),
|
||||||
pool_(new AudioBufferMemoryPool()) {
|
pool_(new AudioBufferMemoryPool()) {
|
||||||
@ -62,7 +62,7 @@ FFmpegAudioDecoder::FFmpegAudioDecoder(
|
|||||||
FFmpegAudioDecoder::~FFmpegAudioDecoder() {
|
FFmpegAudioDecoder::~FFmpegAudioDecoder() {
|
||||||
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
||||||
|
|
||||||
if (state_ != kUninitialized)
|
if (state_ != DecoderState::kUninitialized)
|
||||||
ReleaseFFmpegResources();
|
ReleaseFFmpegResources();
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -105,7 +105,7 @@ void FFmpegAudioDecoder::Initialize(const AudioDecoderConfig& config,
|
|||||||
// Success!
|
// Success!
|
||||||
config_ = config;
|
config_ = config;
|
||||||
output_cb_ = BindToCurrentLoop(output_cb);
|
output_cb_ = BindToCurrentLoop(output_cb);
|
||||||
state_ = kNormal;
|
state_ = DecoderState::kNormal;
|
||||||
std::move(bound_init_cb).Run(OkStatus());
|
std::move(bound_init_cb).Run(OkStatus());
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -113,16 +113,16 @@ void FFmpegAudioDecoder::Decode(scoped_refptr<DecoderBuffer> buffer,
|
|||||||
DecodeCB decode_cb) {
|
DecodeCB decode_cb) {
|
||||||
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
||||||
DCHECK(decode_cb);
|
DCHECK(decode_cb);
|
||||||
CHECK_NE(state_, kUninitialized);
|
CHECK_NE(state_, DecoderState::kUninitialized);
|
||||||
DecodeCB decode_cb_bound = BindToCurrentLoop(std::move(decode_cb));
|
DecodeCB decode_cb_bound = BindToCurrentLoop(std::move(decode_cb));
|
||||||
|
|
||||||
if (state_ == kError) {
|
if (state_ == DecoderState::kError) {
|
||||||
std::move(decode_cb_bound).Run(DecodeStatus::DECODE_ERROR);
|
std::move(decode_cb_bound).Run(DecodeStatus::DECODE_ERROR);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
// Do nothing if decoding has finished.
|
// Do nothing if decoding has finished.
|
||||||
if (state_ == kDecodeFinished) {
|
if (state_ == DecoderState::kDecodeFinished) {
|
||||||
std::move(decode_cb_bound).Run(DecodeStatus::OK);
|
std::move(decode_cb_bound).Run(DecodeStatus::OK);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
@ -134,7 +134,7 @@ void FFmpegAudioDecoder::Reset(base::OnceClosure closure) {
|
|||||||
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
||||||
|
|
||||||
avcodec_flush_buffers(codec_context_.get());
|
avcodec_flush_buffers(codec_context_.get());
|
||||||
state_ = kNormal;
|
state_ = DecoderState::kNormal;
|
||||||
ResetTimestampState(config_);
|
ResetTimestampState(config_);
|
||||||
task_runner_->PostTask(FROM_HERE, std::move(closure));
|
task_runner_->PostTask(FROM_HERE, std::move(closure));
|
||||||
}
|
}
|
||||||
@ -142,9 +142,9 @@ void FFmpegAudioDecoder::Reset(base::OnceClosure closure) {
|
|||||||
void FFmpegAudioDecoder::DecodeBuffer(const DecoderBuffer& buffer,
|
void FFmpegAudioDecoder::DecodeBuffer(const DecoderBuffer& buffer,
|
||||||
DecodeCB decode_cb) {
|
DecodeCB decode_cb) {
|
||||||
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
||||||
DCHECK_NE(state_, kUninitialized);
|
DCHECK_NE(state_, DecoderState::kUninitialized);
|
||||||
DCHECK_NE(state_, kDecodeFinished);
|
DCHECK_NE(state_, DecoderState::kDecodeFinished);
|
||||||
DCHECK_NE(state_, kError);
|
DCHECK_NE(state_, DecoderState::kError);
|
||||||
|
|
||||||
// Make sure we are notified if http://crbug.com/49709 returns. Issue also
|
// Make sure we are notified if http://crbug.com/49709 returns. Issue also
|
||||||
// occurs with some damaged files.
|
// occurs with some damaged files.
|
||||||
@ -155,13 +155,13 @@ void FFmpegAudioDecoder::DecodeBuffer(const DecoderBuffer& buffer,
|
|||||||
}
|
}
|
||||||
|
|
||||||
if (!FFmpegDecode(buffer)) {
|
if (!FFmpegDecode(buffer)) {
|
||||||
state_ = kError;
|
state_ = DecoderState::kError;
|
||||||
std::move(decode_cb).Run(DecodeStatus::DECODE_ERROR);
|
std::move(decode_cb).Run(DecodeStatus::DECODE_ERROR);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (buffer.end_of_stream())
|
if (buffer.end_of_stream())
|
||||||
state_ = kDecodeFinished;
|
state_ = DecoderState::kDecodeFinished;
|
||||||
|
|
||||||
std::move(decode_cb).Run(DecodeStatus::OK);
|
std::move(decode_cb).Run(DecodeStatus::OK);
|
||||||
}
|
}
|
||||||
@ -337,7 +337,7 @@ bool FFmpegAudioDecoder::ConfigureDecoder(const AudioDecoderConfig& config) {
|
|||||||
DLOG(ERROR) << "Could not initialize audio decoder: "
|
DLOG(ERROR) << "Could not initialize audio decoder: "
|
||||||
<< codec_context_->codec_id;
|
<< codec_context_->codec_id;
|
||||||
ReleaseFFmpegResources();
|
ReleaseFFmpegResources();
|
||||||
state_ = kUninitialized;
|
state_ = DecoderState::kUninitialized;
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
// Verify avcodec_open2() used all given options.
|
// Verify avcodec_open2() used all given options.
|
||||||
@ -352,7 +352,7 @@ bool FFmpegAudioDecoder::ConfigureDecoder(const AudioDecoderConfig& config) {
|
|||||||
<< " channels, but FFmpeg thinks the file contains "
|
<< " channels, but FFmpeg thinks the file contains "
|
||||||
<< codec_context_->channels << " channels";
|
<< codec_context_->channels << " channels";
|
||||||
ReleaseFFmpegResources();
|
ReleaseFFmpegResources();
|
||||||
state_ = kUninitialized;
|
state_ = DecoderState::kUninitialized;
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -73,12 +73,7 @@ class MEDIA_EXPORT FFmpegAudioDecoder : public AudioDecoder {
|
|||||||
// A decoding error occurs and decoding needs to stop.
|
// A decoding error occurs and decoding needs to stop.
|
||||||
// (any state) -> kNormal:
|
// (any state) -> kNormal:
|
||||||
// Any time Reset() is called.
|
// Any time Reset() is called.
|
||||||
enum DecoderState {
|
enum class DecoderState { kUninitialized, kNormal, kDecodeFinished, kError };
|
||||||
kUninitialized,
|
|
||||||
kNormal,
|
|
||||||
kDecodeFinished,
|
|
||||||
kError
|
|
||||||
};
|
|
||||||
|
|
||||||
// Reset decoder and call |reset_cb_|.
|
// Reset decoder and call |reset_cb_|.
|
||||||
void DoReset();
|
void DoReset();
|
||||||
|
@ -260,7 +260,7 @@ void FFmpegVideoDecoder::Initialize(const VideoDecoderConfig& config,
|
|||||||
// Success!
|
// Success!
|
||||||
config_ = config;
|
config_ = config;
|
||||||
output_cb_ = output_cb;
|
output_cb_ = output_cb;
|
||||||
state_ = kNormal;
|
state_ = DecoderState::kNormal;
|
||||||
std::move(bound_init_cb).Run(OkStatus());
|
std::move(bound_init_cb).Run(OkStatus());
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -270,48 +270,48 @@ void FFmpegVideoDecoder::Decode(scoped_refptr<DecoderBuffer> buffer,
|
|||||||
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
||||||
DCHECK(buffer.get());
|
DCHECK(buffer.get());
|
||||||
DCHECK(decode_cb);
|
DCHECK(decode_cb);
|
||||||
CHECK_NE(state_, kUninitialized);
|
CHECK_NE(state_, DecoderState::kUninitialized);
|
||||||
|
|
||||||
DecodeCB decode_cb_bound = BindToCurrentLoop(std::move(decode_cb));
|
DecodeCB decode_cb_bound = BindToCurrentLoop(std::move(decode_cb));
|
||||||
|
|
||||||
if (state_ == kError) {
|
if (state_ == DecoderState::kError) {
|
||||||
std::move(decode_cb_bound).Run(DecodeStatus::DECODE_ERROR);
|
std::move(decode_cb_bound).Run(DecodeStatus::DECODE_ERROR);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (state_ == kDecodeFinished) {
|
if (state_ == DecoderState::kDecodeFinished) {
|
||||||
std::move(decode_cb_bound).Run(DecodeStatus::OK);
|
std::move(decode_cb_bound).Run(DecodeStatus::OK);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
DCHECK_EQ(state_, kNormal);
|
DCHECK_EQ(state_, DecoderState::kNormal);
|
||||||
|
|
||||||
// During decode, because reads are issued asynchronously, it is possible to
|
// During decode, because reads are issued asynchronously, it is possible to
|
||||||
// receive multiple end of stream buffers since each decode is acked. There
|
// receive multiple end of stream buffers since each decode is acked. There
|
||||||
// are three states the decoder can be in:
|
// are three states the decoder can be in:
|
||||||
//
|
//
|
||||||
// kNormal: This is the starting state. Buffers are decoded. Decode errors
|
// DecoderState::kNormal: This is the starting state. Buffers are decoded.
|
||||||
// are discarded.
|
// Decode errors are discarded.
|
||||||
// kDecodeFinished: All calls return empty frames.
|
// DecoderState::kDecodeFinished: All calls return empty frames.
|
||||||
// kError: Unexpected error happened.
|
// DecoderState::kError: Unexpected error happened.
|
||||||
//
|
//
|
||||||
// These are the possible state transitions.
|
// These are the possible state transitions.
|
||||||
//
|
//
|
||||||
// kNormal -> kDecodeFinished:
|
// DecoderState::kNormal -> DecoderState::kDecodeFinished:
|
||||||
// When EOS buffer is received and the codec has been flushed.
|
// When EOS buffer is received and the codec has been flushed.
|
||||||
// kNormal -> kError:
|
// DecoderState::kNormal -> DecoderState::kError:
|
||||||
// A decoding error occurs and decoding needs to stop.
|
// A decoding error occurs and decoding needs to stop.
|
||||||
// (any state) -> kNormal:
|
// (any state) -> DecoderState::kNormal:
|
||||||
// Any time Reset() is called.
|
// Any time Reset() is called.
|
||||||
|
|
||||||
if (!FFmpegDecode(*buffer)) {
|
if (!FFmpegDecode(*buffer)) {
|
||||||
state_ = kError;
|
state_ = DecoderState::kError;
|
||||||
std::move(decode_cb_bound).Run(DecodeStatus::DECODE_ERROR);
|
std::move(decode_cb_bound).Run(DecodeStatus::DECODE_ERROR);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (buffer->end_of_stream())
|
if (buffer->end_of_stream())
|
||||||
state_ = kDecodeFinished;
|
state_ = DecoderState::kDecodeFinished;
|
||||||
|
|
||||||
// VideoDecoderShim expects that |decode_cb| is called only after
|
// VideoDecoderShim expects that |decode_cb| is called only after
|
||||||
// |output_cb_|.
|
// |output_cb_|.
|
||||||
@ -323,7 +323,7 @@ void FFmpegVideoDecoder::Reset(base::OnceClosure closure) {
|
|||||||
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
||||||
|
|
||||||
avcodec_flush_buffers(codec_context_.get());
|
avcodec_flush_buffers(codec_context_.get());
|
||||||
state_ = kNormal;
|
state_ = DecoderState::kNormal;
|
||||||
// PostTask() to avoid calling |closure| immediately.
|
// PostTask() to avoid calling |closure| immediately.
|
||||||
base::SequencedTaskRunnerHandle::Get()->PostTask(FROM_HERE,
|
base::SequencedTaskRunnerHandle::Get()->PostTask(FROM_HERE,
|
||||||
std::move(closure));
|
std::move(closure));
|
||||||
@ -332,7 +332,7 @@ void FFmpegVideoDecoder::Reset(base::OnceClosure closure) {
|
|||||||
FFmpegVideoDecoder::~FFmpegVideoDecoder() {
|
FFmpegVideoDecoder::~FFmpegVideoDecoder() {
|
||||||
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
||||||
|
|
||||||
if (state_ != kUninitialized)
|
if (state_ != DecoderState::kUninitialized)
|
||||||
ReleaseFFmpegResources();
|
ReleaseFFmpegResources();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -60,12 +60,7 @@ class MEDIA_EXPORT FFmpegVideoDecoder : public VideoDecoder {
|
|||||||
void force_allocation_error_for_testing() { force_allocation_error_ = true; }
|
void force_allocation_error_for_testing() { force_allocation_error_ = true; }
|
||||||
|
|
||||||
private:
|
private:
|
||||||
enum DecoderState {
|
enum class DecoderState { kUninitialized, kNormal, kDecodeFinished, kError };
|
||||||
kUninitialized,
|
|
||||||
kNormal,
|
|
||||||
kDecodeFinished,
|
|
||||||
kError
|
|
||||||
};
|
|
||||||
|
|
||||||
// Handles decoding of an unencrypted encoded buffer. A return value of false
|
// Handles decoding of an unencrypted encoded buffer. A return value of false
|
||||||
// indicates that an error has occurred.
|
// indicates that an error has occurred.
|
||||||
@ -83,7 +78,7 @@ class MEDIA_EXPORT FFmpegVideoDecoder : public VideoDecoder {
|
|||||||
|
|
||||||
MediaLog* const media_log_;
|
MediaLog* const media_log_;
|
||||||
|
|
||||||
DecoderState state_ = kUninitialized;
|
DecoderState state_ = DecoderState::kUninitialized;
|
||||||
|
|
||||||
OutputCB output_cb_;
|
OutputCB output_cb_;
|
||||||
|
|
||||||
|
@ -683,19 +683,19 @@ bool SourceBufferState::OnNewConfigs(
|
|||||||
std::vector<AudioDecoderConfig>{audio_config});
|
std::vector<AudioDecoderConfig>{audio_config});
|
||||||
} else {
|
} else {
|
||||||
if (audio_streams_.size() > 1) {
|
if (audio_streams_.size() > 1) {
|
||||||
auto it = audio_streams_.find(track_id);
|
auto stream_it = audio_streams_.find(track_id);
|
||||||
if (it != audio_streams_.end())
|
if (stream_it != audio_streams_.end())
|
||||||
stream = it->second;
|
stream = stream_it->second;
|
||||||
} else {
|
} else {
|
||||||
// If there is only one audio track then bytestream id might change in
|
// If there is only one audio track then bytestream id might change in
|
||||||
// a new init segment. So update our state and notify frame processor.
|
// a new init segment. So update our state and notify frame processor.
|
||||||
const auto& it = audio_streams_.begin();
|
const auto& stream_it = audio_streams_.begin();
|
||||||
if (it != audio_streams_.end()) {
|
if (stream_it != audio_streams_.end()) {
|
||||||
stream = it->second;
|
stream = stream_it->second;
|
||||||
if (it->first != track_id) {
|
if (stream_it->first != track_id) {
|
||||||
track_id_changes[it->first] = track_id;
|
track_id_changes[stream_it->first] = track_id;
|
||||||
audio_streams_[track_id] = stream;
|
audio_streams_[track_id] = stream;
|
||||||
audio_streams_.erase(it->first);
|
audio_streams_.erase(stream_it->first);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -771,19 +771,19 @@ bool SourceBufferState::OnNewConfigs(
|
|||||||
std::vector<VideoDecoderConfig>{video_config});
|
std::vector<VideoDecoderConfig>{video_config});
|
||||||
} else {
|
} else {
|
||||||
if (video_streams_.size() > 1) {
|
if (video_streams_.size() > 1) {
|
||||||
auto it = video_streams_.find(track_id);
|
auto stream_it = video_streams_.find(track_id);
|
||||||
if (it != video_streams_.end())
|
if (stream_it != video_streams_.end())
|
||||||
stream = it->second;
|
stream = stream_it->second;
|
||||||
} else {
|
} else {
|
||||||
// If there is only one video track then bytestream id might change in
|
// If there is only one video track then bytestream id might change in
|
||||||
// a new init segment. So update our state and notify frame processor.
|
// a new init segment. So update our state and notify frame processor.
|
||||||
const auto& it = video_streams_.begin();
|
const auto& stream_it = video_streams_.begin();
|
||||||
if (it != video_streams_.end()) {
|
if (stream_it != video_streams_.end()) {
|
||||||
stream = it->second;
|
stream = stream_it->second;
|
||||||
if (it->first != track_id) {
|
if (stream_it->first != track_id) {
|
||||||
track_id_changes[it->first] = track_id;
|
track_id_changes[stream_it->first] = track_id;
|
||||||
video_streams_[track_id] = stream;
|
video_streams_[track_id] = stream;
|
||||||
video_streams_.erase(it->first);
|
video_streams_.erase(stream_it->first);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1414,12 +1414,12 @@ TEST_F(VideoRendererAlgorithmTest, VariablePlaybackRateCadence) {
|
|||||||
TickGenerator frame_tg(base::TimeTicks(), NTSC(30));
|
TickGenerator frame_tg(base::TimeTicks(), NTSC(30));
|
||||||
TickGenerator display_tg(tick_clock_->NowTicks(), 60);
|
TickGenerator display_tg(tick_clock_->NowTicks(), 60);
|
||||||
|
|
||||||
const double kTestRates[] = {1.0, 2, 0.215, 0.5, 1.0, 3.15};
|
const double kPlaybackRates[] = {1.0, 2, 0.215, 0.5, 1.0, 3.15};
|
||||||
const bool kTestRateHasCadence[base::size(kTestRates)] = {true, true, true,
|
const bool kTestRateHasCadence[base::size(kPlaybackRates)] = {
|
||||||
true, true, false};
|
true, true, true, true, true, false};
|
||||||
|
|
||||||
for (size_t i = 0; i < base::size(kTestRates); ++i) {
|
for (size_t i = 0; i < base::size(kPlaybackRates); ++i) {
|
||||||
const double playback_rate = kTestRates[i];
|
const double playback_rate = kPlaybackRates[i];
|
||||||
SCOPED_TRACE(base::StringPrintf("Playback Rate: %.03f", playback_rate));
|
SCOPED_TRACE(base::StringPrintf("Playback Rate: %.03f", playback_rate));
|
||||||
time_source_.SetPlaybackRate(playback_rate);
|
time_source_.SetPlaybackRate(playback_rate);
|
||||||
RunFramePumpTest(
|
RunFramePumpTest(
|
||||||
|
@ -158,7 +158,7 @@ void VpxVideoDecoder::Initialize(const VideoDecoderConfig& config,
|
|||||||
|
|
||||||
// Success!
|
// Success!
|
||||||
config_ = config;
|
config_ = config;
|
||||||
state_ = kNormal;
|
state_ = DecoderState::kNormal;
|
||||||
output_cb_ = output_cb;
|
output_cb_ = output_cb;
|
||||||
std::move(bound_init_cb).Run(OkStatus());
|
std::move(bound_init_cb).Run(OkStatus());
|
||||||
}
|
}
|
||||||
@ -169,32 +169,32 @@ void VpxVideoDecoder::Decode(scoped_refptr<DecoderBuffer> buffer,
|
|||||||
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
||||||
DCHECK(buffer);
|
DCHECK(buffer);
|
||||||
DCHECK(decode_cb);
|
DCHECK(decode_cb);
|
||||||
DCHECK_NE(state_, kUninitialized)
|
DCHECK_NE(state_, DecoderState::kUninitialized)
|
||||||
<< "Called Decode() before successful Initialize()";
|
<< "Called Decode() before successful Initialize()";
|
||||||
|
|
||||||
DecodeCB bound_decode_cb = bind_callbacks_
|
DecodeCB bound_decode_cb = bind_callbacks_
|
||||||
? BindToCurrentLoop(std::move(decode_cb))
|
? BindToCurrentLoop(std::move(decode_cb))
|
||||||
: std::move(decode_cb);
|
: std::move(decode_cb);
|
||||||
|
|
||||||
if (state_ == kError) {
|
if (state_ == DecoderState::kError) {
|
||||||
std::move(bound_decode_cb).Run(DecodeStatus::DECODE_ERROR);
|
std::move(bound_decode_cb).Run(DecodeStatus::DECODE_ERROR);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (state_ == kDecodeFinished) {
|
if (state_ == DecoderState::kDecodeFinished) {
|
||||||
std::move(bound_decode_cb).Run(DecodeStatus::OK);
|
std::move(bound_decode_cb).Run(DecodeStatus::OK);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (state_ == kNormal && buffer->end_of_stream()) {
|
if (state_ == DecoderState::kNormal && buffer->end_of_stream()) {
|
||||||
state_ = kDecodeFinished;
|
state_ = DecoderState::kDecodeFinished;
|
||||||
std::move(bound_decode_cb).Run(DecodeStatus::OK);
|
std::move(bound_decode_cb).Run(DecodeStatus::OK);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
scoped_refptr<VideoFrame> video_frame;
|
scoped_refptr<VideoFrame> video_frame;
|
||||||
if (!VpxDecode(buffer.get(), &video_frame)) {
|
if (!VpxDecode(buffer.get(), &video_frame)) {
|
||||||
state_ = kError;
|
state_ = DecoderState::kError;
|
||||||
std::move(bound_decode_cb).Run(DecodeStatus::DECODE_ERROR);
|
std::move(bound_decode_cb).Run(DecodeStatus::DECODE_ERROR);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
@ -212,7 +212,7 @@ void VpxVideoDecoder::Decode(scoped_refptr<DecoderBuffer> buffer,
|
|||||||
|
|
||||||
void VpxVideoDecoder::Reset(base::OnceClosure reset_cb) {
|
void VpxVideoDecoder::Reset(base::OnceClosure reset_cb) {
|
||||||
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
|
||||||
state_ = kNormal;
|
state_ = DecoderState::kNormal;
|
||||||
|
|
||||||
if (bind_callbacks_)
|
if (bind_callbacks_)
|
||||||
BindToCurrentLoop(std::move(reset_cb)).Run();
|
BindToCurrentLoop(std::move(reset_cb)).Run();
|
||||||
|
@ -55,13 +55,7 @@ class MEDIA_EXPORT VpxVideoDecoder : public OffloadableVideoDecoder {
|
|||||||
}
|
}
|
||||||
|
|
||||||
private:
|
private:
|
||||||
enum DecoderState {
|
enum class DecoderState { kUninitialized, kNormal, kDecodeFinished, kError };
|
||||||
kUninitialized,
|
|
||||||
kNormal,
|
|
||||||
kFlushCodec,
|
|
||||||
kDecodeFinished,
|
|
||||||
kError
|
|
||||||
};
|
|
||||||
|
|
||||||
// Return values for decoding alpha plane.
|
// Return values for decoding alpha plane.
|
||||||
enum AlphaDecodeStatus {
|
enum AlphaDecodeStatus {
|
||||||
@ -99,7 +93,7 @@ class MEDIA_EXPORT VpxVideoDecoder : public OffloadableVideoDecoder {
|
|||||||
|
|
||||||
// |state_| must only be read and written to on |offload_task_runner_| if it
|
// |state_| must only be read and written to on |offload_task_runner_| if it
|
||||||
// is non-null and there are outstanding tasks on the offload thread.
|
// is non-null and there are outstanding tasks on the offload thread.
|
||||||
DecoderState state_ = kUninitialized;
|
DecoderState state_ = DecoderState::kUninitialized;
|
||||||
|
|
||||||
OutputCB output_cb_;
|
OutputCB output_cb_;
|
||||||
|
|
||||||
|
@ -1186,16 +1186,16 @@ bool VideoSampleEntry::Parse(BoxReader* reader) {
|
|||||||
video_color_space = vp_config->color_space;
|
video_color_space = vp_config->color_space;
|
||||||
video_codec_level = vp_config->level;
|
video_codec_level = vp_config->level;
|
||||||
|
|
||||||
SMPTE2086MasteringDisplayMetadataBox mastering_display_color_volume;
|
SMPTE2086MasteringDisplayMetadataBox color_volume;
|
||||||
if (reader->HasChild(&mastering_display_color_volume)) {
|
if (reader->HasChild(&color_volume)) {
|
||||||
RCHECK(reader->ReadChild(&mastering_display_color_volume));
|
RCHECK(reader->ReadChild(&color_volume));
|
||||||
this->mastering_display_color_volume = mastering_display_color_volume;
|
mastering_display_color_volume = color_volume;
|
||||||
}
|
}
|
||||||
|
|
||||||
ContentLightLevel content_light_level_information;
|
ContentLightLevel level_information;
|
||||||
if (reader->HasChild(&content_light_level_information)) {
|
if (reader->HasChild(&level_information)) {
|
||||||
RCHECK(reader->ReadChild(&content_light_level_information));
|
RCHECK(reader->ReadChild(&level_information));
|
||||||
this->content_light_level_information = content_light_level_information;
|
content_light_level_information = level_information;
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
@ -1225,16 +1225,16 @@ bool VideoSampleEntry::Parse(BoxReader* reader) {
|
|||||||
color_parameter_information);
|
color_parameter_information);
|
||||||
}
|
}
|
||||||
|
|
||||||
MasteringDisplayColorVolume mastering_display_color_volume;
|
MasteringDisplayColorVolume color_volume;
|
||||||
if (reader->HasChild(&mastering_display_color_volume)) {
|
if (reader->HasChild(&color_volume)) {
|
||||||
RCHECK(reader->ReadChild(&mastering_display_color_volume));
|
RCHECK(reader->ReadChild(&color_volume));
|
||||||
this->mastering_display_color_volume = mastering_display_color_volume;
|
mastering_display_color_volume = color_volume;
|
||||||
}
|
}
|
||||||
|
|
||||||
ContentLightLevelInformation content_light_level_information;
|
ContentLightLevelInformation level_information;
|
||||||
if (reader->HasChild(&content_light_level_information)) {
|
if (reader->HasChild(&level_information)) {
|
||||||
RCHECK(reader->ReadChild(&content_light_level_information));
|
RCHECK(reader->ReadChild(&level_information));
|
||||||
this->content_light_level_information = content_light_level_information;
|
content_light_level_information = level_information;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (video_codec_profile == VIDEO_CODEC_PROFILE_UNKNOWN) {
|
if (video_codec_profile == VIDEO_CODEC_PROFILE_UNKNOWN) {
|
||||||
|
@ -109,7 +109,7 @@ H264Decoder::H264Accelerator::ParseEncryptedSliceHeader(
|
|||||||
H264Decoder::H264Decoder(std::unique_ptr<H264Accelerator> accelerator,
|
H264Decoder::H264Decoder(std::unique_ptr<H264Accelerator> accelerator,
|
||||||
VideoCodecProfile profile,
|
VideoCodecProfile profile,
|
||||||
const VideoColorSpace& container_color_space)
|
const VideoColorSpace& container_color_space)
|
||||||
: state_(kNeedStreamMetadata),
|
: state_(State::kNeedStreamMetadata),
|
||||||
container_color_space_(container_color_space),
|
container_color_space_(container_color_space),
|
||||||
max_frame_num_(0),
|
max_frame_num_(0),
|
||||||
max_pic_num_(0),
|
max_pic_num_(0),
|
||||||
@ -159,8 +159,8 @@ void H264Decoder::Reset() {
|
|||||||
// If we are in kDecoding, we can resume without processing an SPS.
|
// If we are in kDecoding, we can resume without processing an SPS.
|
||||||
// The state becomes kDecoding again, (1) at the first IDR slice or (2) at
|
// The state becomes kDecoding again, (1) at the first IDR slice or (2) at
|
||||||
// the first slice after the recovery point SEI.
|
// the first slice after the recovery point SEI.
|
||||||
if (state_ == kDecoding)
|
if (state_ == State::kDecoding)
|
||||||
state_ = kAfterReset;
|
state_ = State::kAfterReset;
|
||||||
}
|
}
|
||||||
|
|
||||||
void H264Decoder::PrepareRefPicLists() {
|
void H264Decoder::PrepareRefPicLists() {
|
||||||
@ -876,8 +876,8 @@ bool H264Decoder::HandleMemoryManagementOps(scoped_refptr<H264Picture> pic) {
|
|||||||
ref_pic_marking->max_long_term_frame_idx_plus1 - 1;
|
ref_pic_marking->max_long_term_frame_idx_plus1 - 1;
|
||||||
H264Picture::Vector long_terms;
|
H264Picture::Vector long_terms;
|
||||||
dpb_.GetLongTermRefPicsAppending(&long_terms);
|
dpb_.GetLongTermRefPicsAppending(&long_terms);
|
||||||
for (size_t i = 0; i < long_terms.size(); ++i) {
|
for (size_t long_term = 0; long_term < long_terms.size(); ++long_term) {
|
||||||
scoped_refptr<H264Picture>& long_term_pic = long_terms[i];
|
scoped_refptr<H264Picture>& long_term_pic = long_terms[long_term];
|
||||||
DCHECK(long_term_pic->ref && long_term_pic->long_term);
|
DCHECK(long_term_pic->ref && long_term_pic->long_term);
|
||||||
// Ok to cast, max_long_term_frame_idx is much smaller than 16bit.
|
// Ok to cast, max_long_term_frame_idx is much smaller than 16bit.
|
||||||
if (long_term_pic->long_term_frame_idx >
|
if (long_term_pic->long_term_frame_idx >
|
||||||
@ -899,8 +899,8 @@ bool H264Decoder::HandleMemoryManagementOps(scoped_refptr<H264Picture> pic) {
|
|||||||
// First unmark if any existing with this long_term_frame_idx...
|
// First unmark if any existing with this long_term_frame_idx...
|
||||||
H264Picture::Vector long_terms;
|
H264Picture::Vector long_terms;
|
||||||
dpb_.GetLongTermRefPicsAppending(&long_terms);
|
dpb_.GetLongTermRefPicsAppending(&long_terms);
|
||||||
for (size_t i = 0; i < long_terms.size(); ++i) {
|
for (size_t long_term = 0; long_term < long_terms.size(); ++long_term) {
|
||||||
scoped_refptr<H264Picture>& long_term_pic = long_terms[i];
|
scoped_refptr<H264Picture>& long_term_pic = long_terms[long_term];
|
||||||
DCHECK(long_term_pic->ref && long_term_pic->long_term);
|
DCHECK(long_term_pic->ref && long_term_pic->long_term);
|
||||||
// Ok to cast, long_term_frame_idx is much smaller than 16bit.
|
// Ok to cast, long_term_frame_idx is much smaller than 16bit.
|
||||||
if (long_term_pic->long_term_frame_idx ==
|
if (long_term_pic->long_term_frame_idx ==
|
||||||
@ -1364,7 +1364,7 @@ H264Decoder::H264Accelerator::Status H264Decoder::ProcessCurrentSlice() {
|
|||||||
#define SET_ERROR_AND_RETURN() \
|
#define SET_ERROR_AND_RETURN() \
|
||||||
do { \
|
do { \
|
||||||
DVLOG(1) << "Error during decode"; \
|
DVLOG(1) << "Error during decode"; \
|
||||||
state_ = kError; \
|
state_ = State::kError; \
|
||||||
return H264Decoder::kDecodeError; \
|
return H264Decoder::kDecodeError; \
|
||||||
} while (0)
|
} while (0)
|
||||||
|
|
||||||
@ -1408,7 +1408,7 @@ void H264Decoder::SetStream(int32_t id, const DecoderBuffer& decoder_buffer) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
H264Decoder::DecodeResult H264Decoder::Decode() {
|
H264Decoder::DecodeResult H264Decoder::Decode() {
|
||||||
if (state_ == kError) {
|
if (state_ == State::kError) {
|
||||||
DVLOG(1) << "Decoder in error state";
|
DVLOG(1) << "Decoder in error state";
|
||||||
return kDecodeError;
|
return kDecodeError;
|
||||||
}
|
}
|
||||||
@ -1457,7 +1457,8 @@ H264Decoder::DecodeResult H264Decoder::Decode() {
|
|||||||
case H264NALU::kNonIDRSlice:
|
case H264NALU::kNonIDRSlice:
|
||||||
// We can't resume from a non-IDR slice unless recovery point SEI
|
// We can't resume from a non-IDR slice unless recovery point SEI
|
||||||
// process is going.
|
// process is going.
|
||||||
if (state_ == kError || (state_ == kAfterReset && !recovery_frame_cnt_))
|
if (state_ == State::kError ||
|
||||||
|
(state_ == State::kAfterReset && !recovery_frame_cnt_))
|
||||||
break;
|
break;
|
||||||
|
|
||||||
FALLTHROUGH;
|
FALLTHROUGH;
|
||||||
@ -1465,7 +1466,7 @@ H264Decoder::DecodeResult H264Decoder::Decode() {
|
|||||||
// TODO(posciak): the IDR may require an SPS that we don't have
|
// TODO(posciak): the IDR may require an SPS that we don't have
|
||||||
// available. For now we'd fail if that happens, but ideally we'd like
|
// available. For now we'd fail if that happens, but ideally we'd like
|
||||||
// to keep going until the next SPS in the stream.
|
// to keep going until the next SPS in the stream.
|
||||||
if (state_ == kNeedStreamMetadata) {
|
if (state_ == State::kNeedStreamMetadata) {
|
||||||
// We need an SPS, skip this IDR and keep looking.
|
// We need an SPS, skip this IDR and keep looking.
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
@ -1479,10 +1480,10 @@ H264Decoder::DecodeResult H264Decoder::Decode() {
|
|||||||
// steps will be executed.
|
// steps will be executed.
|
||||||
if (!curr_slice_hdr_) {
|
if (!curr_slice_hdr_) {
|
||||||
curr_slice_hdr_ = std::make_unique<H264SliceHeader>();
|
curr_slice_hdr_ = std::make_unique<H264SliceHeader>();
|
||||||
state_ = kParseSliceHeader;
|
state_ = State::kParseSliceHeader;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (state_ == kParseSliceHeader) {
|
if (state_ == State::kParseSliceHeader) {
|
||||||
// Check if the slice header is encrypted.
|
// Check if the slice header is encrypted.
|
||||||
bool parsed_header = false;
|
bool parsed_header = false;
|
||||||
if (current_decrypt_config_) {
|
if (current_decrypt_config_) {
|
||||||
@ -1504,18 +1505,18 @@ H264Decoder::DecodeResult H264Decoder::Decode() {
|
|||||||
if (par_res != H264Parser::kOk)
|
if (par_res != H264Parser::kOk)
|
||||||
SET_ERROR_AND_RETURN();
|
SET_ERROR_AND_RETURN();
|
||||||
}
|
}
|
||||||
state_ = kTryPreprocessCurrentSlice;
|
state_ = State::kTryPreprocessCurrentSlice;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (state_ == kTryPreprocessCurrentSlice) {
|
if (state_ == State::kTryPreprocessCurrentSlice) {
|
||||||
CHECK_ACCELERATOR_RESULT(PreprocessCurrentSlice());
|
CHECK_ACCELERATOR_RESULT(PreprocessCurrentSlice());
|
||||||
state_ = kEnsurePicture;
|
state_ = State::kEnsurePicture;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (state_ == kEnsurePicture) {
|
if (state_ == State::kEnsurePicture) {
|
||||||
if (curr_pic_) {
|
if (curr_pic_) {
|
||||||
// |curr_pic_| already exists, so skip to ProcessCurrentSlice().
|
// |curr_pic_| already exists, so skip to ProcessCurrentSlice().
|
||||||
state_ = kTryCurrentSlice;
|
state_ = State::kTryCurrentSlice;
|
||||||
} else {
|
} else {
|
||||||
// New picture/finished previous one, try to start a new one
|
// New picture/finished previous one, try to start a new one
|
||||||
// or tell the client we need more surfaces.
|
// or tell the client we need more surfaces.
|
||||||
@ -1525,19 +1526,19 @@ H264Decoder::DecodeResult H264Decoder::Decode() {
|
|||||||
if (current_decrypt_config_)
|
if (current_decrypt_config_)
|
||||||
curr_pic_->set_decrypt_config(current_decrypt_config_->Clone());
|
curr_pic_->set_decrypt_config(current_decrypt_config_->Clone());
|
||||||
|
|
||||||
state_ = kTryNewFrame;
|
state_ = State::kTryNewFrame;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (state_ == kTryNewFrame) {
|
if (state_ == State::kTryNewFrame) {
|
||||||
CHECK_ACCELERATOR_RESULT(StartNewFrame(curr_slice_hdr_.get()));
|
CHECK_ACCELERATOR_RESULT(StartNewFrame(curr_slice_hdr_.get()));
|
||||||
state_ = kTryCurrentSlice;
|
state_ = State::kTryCurrentSlice;
|
||||||
}
|
}
|
||||||
|
|
||||||
DCHECK_EQ(state_, kTryCurrentSlice);
|
DCHECK_EQ(state_, State::kTryCurrentSlice);
|
||||||
CHECK_ACCELERATOR_RESULT(ProcessCurrentSlice());
|
CHECK_ACCELERATOR_RESULT(ProcessCurrentSlice());
|
||||||
curr_slice_hdr_.reset();
|
curr_slice_hdr_.reset();
|
||||||
state_ = kDecoding;
|
state_ = State::kDecoding;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -1555,8 +1556,8 @@ H264Decoder::DecodeResult H264Decoder::Decode() {
|
|||||||
|
|
||||||
last_sps_nalu_.assign(curr_nalu_->data,
|
last_sps_nalu_.assign(curr_nalu_->data,
|
||||||
curr_nalu_->data + curr_nalu_->size);
|
curr_nalu_->data + curr_nalu_->size);
|
||||||
if (state_ == kNeedStreamMetadata)
|
if (state_ == State::kNeedStreamMetadata)
|
||||||
state_ = kAfterReset;
|
state_ = State::kAfterReset;
|
||||||
|
|
||||||
if (need_new_buffers) {
|
if (need_new_buffers) {
|
||||||
curr_pic_ = nullptr;
|
curr_pic_ = nullptr;
|
||||||
@ -1584,7 +1585,7 @@ H264Decoder::DecodeResult H264Decoder::Decode() {
|
|||||||
case H264NALU::kAUD:
|
case H264NALU::kAUD:
|
||||||
case H264NALU::kEOSeq:
|
case H264NALU::kEOSeq:
|
||||||
case H264NALU::kEOStream:
|
case H264NALU::kEOStream:
|
||||||
if (state_ != kDecoding)
|
if (state_ != State::kDecoding)
|
||||||
break;
|
break;
|
||||||
|
|
||||||
CHECK_ACCELERATOR_RESULT(FinishPrevFrameIfPresent());
|
CHECK_ACCELERATOR_RESULT(FinishPrevFrameIfPresent());
|
||||||
@ -1605,7 +1606,7 @@ H264Decoder::DecodeResult H264Decoder::Decode() {
|
|||||||
sei_subsamples_.push_back(subsamples[0]);
|
sei_subsamples_.push_back(subsamples[0]);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (state_ == kAfterReset && !recovery_frame_cnt_ &&
|
if (state_ == State::kAfterReset && !recovery_frame_cnt_ &&
|
||||||
!recovery_frame_num_) {
|
!recovery_frame_num_) {
|
||||||
// If we are after reset, we can also resume from a SEI recovery point
|
// If we are after reset, we can also resume from a SEI recovery point
|
||||||
// (spec D.2.8) if one is present. However, if we are already in the
|
// (spec D.2.8) if one is present. However, if we are already in the
|
||||||
|
@ -194,7 +194,7 @@ class MEDIA_GPU_EXPORT H264Decoder : public AcceleratedVideoDecoder {
|
|||||||
|
|
||||||
private:
|
private:
|
||||||
// Internal state of the decoder.
|
// Internal state of the decoder.
|
||||||
enum State {
|
enum class State {
|
||||||
// After initialization, need an SPS.
|
// After initialization, need an SPS.
|
||||||
kNeedStreamMetadata,
|
kNeedStreamMetadata,
|
||||||
// Ready to decode from any point.
|
// Ready to decode from any point.
|
||||||
|
@ -2742,8 +2742,8 @@ void DXVAVideoDecodeAccelerator::BindPictureBufferToSample(
|
|||||||
// Get the viz resource format per texture.
|
// Get the viz resource format per texture.
|
||||||
std::array<viz::ResourceFormat, VideoFrame::kMaxPlanes> viz_formats;
|
std::array<viz::ResourceFormat, VideoFrame::kMaxPlanes> viz_formats;
|
||||||
{
|
{
|
||||||
const bool result = VideoPixelFormatToVizFormat(
|
result = VideoPixelFormatToVizFormat(picture_buffer->pixel_format(),
|
||||||
picture_buffer->pixel_format(), textures_per_picture, viz_formats);
|
textures_per_picture, viz_formats);
|
||||||
RETURN_AND_NOTIFY_ON_FAILURE(
|
RETURN_AND_NOTIFY_ON_FAILURE(
|
||||||
result, "Could not convert pixel format to viz format",
|
result, "Could not convert pixel format to viz format",
|
||||||
PLATFORM_FAILURE, );
|
PLATFORM_FAILURE, );
|
||||||
@ -2899,8 +2899,7 @@ void DXVAVideoDecodeAccelerator::CopyTextureOnDecoderThread(
|
|||||||
DCHECK(d3d11_processor_.Get());
|
DCHECK(d3d11_processor_.Get());
|
||||||
|
|
||||||
if (dest_keyed_mutex) {
|
if (dest_keyed_mutex) {
|
||||||
HRESULT hr =
|
hr = dest_keyed_mutex->AcquireSync(keyed_mutex_value, kAcquireSyncWaitMs);
|
||||||
dest_keyed_mutex->AcquireSync(keyed_mutex_value, kAcquireSyncWaitMs);
|
|
||||||
RETURN_AND_NOTIFY_ON_FAILURE(
|
RETURN_AND_NOTIFY_ON_FAILURE(
|
||||||
hr == S_OK, "D3D11 failed to acquire keyed mutex for texture.",
|
hr == S_OK, "D3D11 failed to acquire keyed mutex for texture.",
|
||||||
PLATFORM_FAILURE, );
|
PLATFORM_FAILURE, );
|
||||||
@ -2956,7 +2955,7 @@ void DXVAVideoDecodeAccelerator::CopyTextureOnDecoderThread(
|
|||||||
PLATFORM_FAILURE, );
|
PLATFORM_FAILURE, );
|
||||||
|
|
||||||
if (dest_keyed_mutex) {
|
if (dest_keyed_mutex) {
|
||||||
HRESULT hr = dest_keyed_mutex->ReleaseSync(keyed_mutex_value + 1);
|
hr = dest_keyed_mutex->ReleaseSync(keyed_mutex_value + 1);
|
||||||
RETURN_AND_NOTIFY_ON_FAILURE(hr == S_OK, "Failed to release keyed mutex.",
|
RETURN_AND_NOTIFY_ON_FAILURE(hr == S_OK, "Failed to release keyed mutex.",
|
||||||
PLATFORM_FAILURE, );
|
PLATFORM_FAILURE, );
|
||||||
|
|
||||||
|
@ -57,15 +57,15 @@ void ExtraTreesTrainer::OnRandomTreeModel(TrainedModelCB model_cb,
|
|||||||
|
|
||||||
// If this is the last tree, then return the finished model.
|
// If this is the last tree, then return the finished model.
|
||||||
if (trees_.size() == task_.rf_number_of_trees) {
|
if (trees_.size() == task_.rf_number_of_trees) {
|
||||||
std::unique_ptr<Model> model =
|
std::unique_ptr<Model> finished_model =
|
||||||
std::make_unique<VotingEnsemble>(std::move(trees_));
|
std::make_unique<VotingEnsemble>(std::move(trees_));
|
||||||
// If we have a converter, then wrap everything in a ConvertingModel.
|
// If we have a converter, then wrap everything in a ConvertingModel.
|
||||||
if (converter_) {
|
if (converter_) {
|
||||||
model = std::make_unique<ConvertingModel>(std::move(converter_),
|
finished_model = std::make_unique<ConvertingModel>(
|
||||||
std::move(model));
|
std::move(converter_), std::move(finished_model));
|
||||||
}
|
}
|
||||||
|
|
||||||
std::move(model_cb).Run(std::move(model));
|
std::move(model_cb).Run(std::move(finished_model));
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -15,8 +15,6 @@ UsbMidiOutputStream::UsbMidiOutputStream(const UsbMidiJack& jack)
|
|||||||
: jack_(jack), pending_size_(0), is_sending_sysex_(false) {}
|
: jack_(jack), pending_size_(0), is_sending_sysex_(false) {}
|
||||||
|
|
||||||
void UsbMidiOutputStream::Send(const std::vector<uint8_t>& data) {
|
void UsbMidiOutputStream::Send(const std::vector<uint8_t>& data) {
|
||||||
// To prevent link errors caused by DCHECK_*.
|
|
||||||
const size_t kPacketContentSize = UsbMidiOutputStream::kPacketContentSize;
|
|
||||||
DCHECK_LT(jack_.cable_number, 16u);
|
DCHECK_LT(jack_.cable_number, 16u);
|
||||||
|
|
||||||
std::vector<uint8_t> data_to_send;
|
std::vector<uint8_t> data_to_send;
|
||||||
|
@ -538,11 +538,10 @@ void AudioRendererImpl::OnDeviceInfoReceived(
|
|||||||
// mixer will attempt to up-mix stereo source streams to just the left/right
|
// mixer will attempt to up-mix stereo source streams to just the left/right
|
||||||
// speaker of the 5.1 setup, nulling out the other channels
|
// speaker of the 5.1 setup, nulling out the other channels
|
||||||
// (http://crbug.com/177872).
|
// (http://crbug.com/177872).
|
||||||
ChannelLayout hw_channel_layout =
|
hw_channel_layout = hw_params.channel_layout() == CHANNEL_LAYOUT_DISCRETE ||
|
||||||
hw_params.channel_layout() == CHANNEL_LAYOUT_DISCRETE ||
|
try_supported_channel_layouts
|
||||||
try_supported_channel_layouts
|
? CHANNEL_LAYOUT_STEREO
|
||||||
? CHANNEL_LAYOUT_STEREO
|
: hw_params.channel_layout();
|
||||||
: hw_params.channel_layout();
|
|
||||||
int hw_channel_count = ChannelLayoutToChannelCount(hw_channel_layout);
|
int hw_channel_count = ChannelLayoutToChannelCount(hw_channel_layout);
|
||||||
|
|
||||||
// The layout we pass to |audio_parameters_| will be used for the lifetime
|
// The layout we pass to |audio_parameters_| will be used for the lifetime
|
||||||
|
@ -682,20 +682,20 @@ TEST_F(PaintCanvasVideoRendererTest, Y16) {
|
|||||||
TEST_F(PaintCanvasVideoRendererTest, Yuv420P12OddWidth) {
|
TEST_F(PaintCanvasVideoRendererTest, Yuv420P12OddWidth) {
|
||||||
// Allocate the Y, U, V planes for a 3x3 12-bit YUV 4:2:0 image. Note that
|
// Allocate the Y, U, V planes for a 3x3 12-bit YUV 4:2:0 image. Note that
|
||||||
// there are no padding bytes after each row.
|
// there are no padding bytes after each row.
|
||||||
constexpr int kWidth = 3;
|
constexpr int kImgWidth = 3;
|
||||||
constexpr int kHeight = 3;
|
constexpr int kImgHeight = 3;
|
||||||
constexpr int kUvWidth = (kWidth + 1) / 2;
|
constexpr int kUvWidth = (kImgWidth + 1) / 2;
|
||||||
constexpr int kUvHeight = (kHeight + 1) / 2;
|
constexpr int kUvHeight = (kImgHeight + 1) / 2;
|
||||||
std::unique_ptr<uint16_t[]> y_plane =
|
std::unique_ptr<uint16_t[]> y_plane =
|
||||||
std::make_unique<uint16_t[]>(kWidth * kHeight);
|
std::make_unique<uint16_t[]>(kImgWidth * kImgHeight);
|
||||||
std::unique_ptr<uint16_t[]> u_plane =
|
std::unique_ptr<uint16_t[]> u_plane =
|
||||||
std::make_unique<uint16_t[]>(kUvWidth * kUvHeight);
|
std::make_unique<uint16_t[]>(kUvWidth * kUvHeight);
|
||||||
std::unique_ptr<uint16_t[]> v_plane =
|
std::unique_ptr<uint16_t[]> v_plane =
|
||||||
std::make_unique<uint16_t[]>(kUvWidth * kUvHeight);
|
std::make_unique<uint16_t[]>(kUvWidth * kUvHeight);
|
||||||
// Set all pixels to white.
|
// Set all pixels to white.
|
||||||
for (int i = 0; i < kHeight; ++i) {
|
for (int i = 0; i < kImgHeight; ++i) {
|
||||||
for (int j = 0; j < kWidth; ++j) {
|
for (int j = 0; j < kImgWidth; ++j) {
|
||||||
y_plane[i * kWidth + j] = 4095;
|
y_plane[i * kImgWidth + j] = 4095;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
for (int i = 0; i < kUvHeight; ++i) {
|
for (int i = 0; i < kUvHeight; ++i) {
|
||||||
@ -704,25 +704,25 @@ TEST_F(PaintCanvasVideoRendererTest, Yuv420P12OddWidth) {
|
|||||||
v_plane[i * kUvWidth + j] = 2048;
|
v_plane[i * kUvWidth + j] = 2048;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
const int32_t y_stride = sizeof(uint16_t) * kWidth;
|
const int32_t y_stride = sizeof(uint16_t) * kImgWidth;
|
||||||
const int32_t uv_stride = sizeof(uint16_t) * kUvWidth;
|
const int32_t uv_stride = sizeof(uint16_t) * kUvWidth;
|
||||||
uint8_t* const y_data = reinterpret_cast<uint8_t*>(y_plane.get());
|
uint8_t* const y_data = reinterpret_cast<uint8_t*>(y_plane.get());
|
||||||
uint8_t* const u_data = reinterpret_cast<uint8_t*>(u_plane.get());
|
uint8_t* const u_data = reinterpret_cast<uint8_t*>(u_plane.get());
|
||||||
uint8_t* const v_data = reinterpret_cast<uint8_t*>(v_plane.get());
|
uint8_t* const v_data = reinterpret_cast<uint8_t*>(v_plane.get());
|
||||||
|
|
||||||
auto size = gfx::Size(kWidth, kHeight);
|
auto size = gfx::Size(kImgWidth, kImgHeight);
|
||||||
scoped_refptr<VideoFrame> frame = VideoFrame::WrapExternalYuvData(
|
scoped_refptr<VideoFrame> frame = VideoFrame::WrapExternalYuvData(
|
||||||
PIXEL_FORMAT_YUV420P12, size, gfx::Rect(size), size, y_stride, uv_stride,
|
PIXEL_FORMAT_YUV420P12, size, gfx::Rect(size), size, y_stride, uv_stride,
|
||||||
uv_stride, y_data, u_data, v_data, base::TimeDelta());
|
uv_stride, y_data, u_data, v_data, base::TimeDelta());
|
||||||
|
|
||||||
std::unique_ptr<uint32_t[]> rgba =
|
std::unique_ptr<uint32_t[]> rgba =
|
||||||
std::make_unique<uint32_t[]>(kWidth * kHeight);
|
std::make_unique<uint32_t[]>(kImgWidth * kImgHeight);
|
||||||
PaintCanvasVideoRenderer::ConvertVideoFrameToRGBPixels(
|
PaintCanvasVideoRenderer::ConvertVideoFrameToRGBPixels(
|
||||||
frame.get(), rgba.get(), frame->visible_rect().width() * 4,
|
frame.get(), rgba.get(), frame->visible_rect().width() * 4,
|
||||||
/*premultiply_alpha=*/true);
|
/*premultiply_alpha=*/true);
|
||||||
for (int i = 0; i < kHeight; ++i) {
|
for (int i = 0; i < kImgHeight; ++i) {
|
||||||
for (int j = 0; j < kWidth; ++j) {
|
for (int j = 0; j < kImgWidth; ++j) {
|
||||||
EXPECT_EQ(rgba[i * kWidth + j], 0xffffffff);
|
EXPECT_EQ(rgba[i * kImgWidth + j], 0xffffffff);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1336,15 +1336,15 @@ void GpuMemoryBufferVideoFramePool::PoolImpl::MailboxHoldersReleased(
|
|||||||
frame_resources->MarkUnused(now);
|
frame_resources->MarkUnused(now);
|
||||||
auto it = resources_pool_.begin();
|
auto it = resources_pool_.begin();
|
||||||
while (it != resources_pool_.end()) {
|
while (it != resources_pool_.end()) {
|
||||||
FrameResources* frame_resources = *it;
|
FrameResources* resources = *it;
|
||||||
|
|
||||||
constexpr base::TimeDelta kStaleFrameLimit =
|
constexpr base::TimeDelta kStaleFrameLimit =
|
||||||
base::TimeDelta::FromSeconds(10);
|
base::TimeDelta::FromSeconds(10);
|
||||||
if (!frame_resources->is_used() &&
|
if (!resources->is_used() &&
|
||||||
now - frame_resources->last_use_time() > kStaleFrameLimit) {
|
now - resources->last_use_time() > kStaleFrameLimit) {
|
||||||
resources_pool_.erase(it++);
|
resources_pool_.erase(it++);
|
||||||
DeleteFrameResources(gpu_factories_, frame_resources);
|
DeleteFrameResources(gpu_factories_, resources);
|
||||||
delete frame_resources;
|
delete resources;
|
||||||
} else {
|
} else {
|
||||||
it++;
|
it++;
|
||||||
}
|
}
|
||||||
|
@ -348,7 +348,6 @@ void VpxVideoEncoder::Initialize(VideoCodecProfile profile,
|
|||||||
void VpxVideoEncoder::Encode(scoped_refptr<VideoFrame> frame,
|
void VpxVideoEncoder::Encode(scoped_refptr<VideoFrame> frame,
|
||||||
bool key_frame,
|
bool key_frame,
|
||||||
StatusCB done_cb) {
|
StatusCB done_cb) {
|
||||||
Status status;
|
|
||||||
done_cb = BindToCurrentLoop(std::move(done_cb));
|
done_cb = BindToCurrentLoop(std::move(done_cb));
|
||||||
if (!codec_) {
|
if (!codec_) {
|
||||||
std::move(done_cb).Run(StatusCode::kEncoderInitializeNeverCompleted);
|
std::move(done_cb).Run(StatusCode::kEncoderInitializeNeverCompleted);
|
||||||
@ -368,7 +367,7 @@ void VpxVideoEncoder::Encode(scoped_refptr<VideoFrame> frame,
|
|||||||
frame->format() == PIXEL_FORMAT_ARGB;
|
frame->format() == PIXEL_FORMAT_ARGB;
|
||||||
if ((!frame->IsMappable() && !frame->HasGpuMemoryBuffer()) ||
|
if ((!frame->IsMappable() && !frame->HasGpuMemoryBuffer()) ||
|
||||||
!supported_format) {
|
!supported_format) {
|
||||||
status =
|
Status status =
|
||||||
Status(StatusCode::kEncoderFailedEncode, "Unexpected frame format.")
|
Status(StatusCode::kEncoderFailedEncode, "Unexpected frame format.")
|
||||||
.WithData("IsMappable", frame->IsMappable())
|
.WithData("IsMappable", frame->IsMappable())
|
||||||
.WithData("format", frame->format());
|
.WithData("format", frame->format());
|
||||||
@ -392,6 +391,7 @@ void VpxVideoEncoder::Encode(scoped_refptr<VideoFrame> frame,
|
|||||||
is_yuv ? frame->format() : PIXEL_FORMAT_I420, options_.frame_size,
|
is_yuv ? frame->format() : PIXEL_FORMAT_I420, options_.frame_size,
|
||||||
gfx::Rect(options_.frame_size), options_.frame_size,
|
gfx::Rect(options_.frame_size), options_.frame_size,
|
||||||
frame->timestamp());
|
frame->timestamp());
|
||||||
|
Status status;
|
||||||
if (resized_frame) {
|
if (resized_frame) {
|
||||||
status = ConvertAndScaleFrame(*frame, *resized_frame, resize_buf_);
|
status = ConvertAndScaleFrame(*frame, *resized_frame, resize_buf_);
|
||||||
} else {
|
} else {
|
||||||
@ -498,8 +498,8 @@ void VpxVideoEncoder::Encode(scoped_refptr<VideoFrame> frame,
|
|||||||
vpx_codec_err_to_string(vpx_error),
|
vpx_codec_err_to_string(vpx_error),
|
||||||
vpx_codec_error_detail(codec_.get()));
|
vpx_codec_error_detail(codec_.get()));
|
||||||
DLOG(ERROR) << msg;
|
DLOG(ERROR) << msg;
|
||||||
status = Status(StatusCode::kEncoderFailedEncode, msg)
|
Status status = Status(StatusCode::kEncoderFailedEncode, msg)
|
||||||
.WithData("vpx_error", vpx_error);
|
.WithData("vpx_error", vpx_error);
|
||||||
std::move(done_cb).Run(std::move(status));
|
std::move(done_cb).Run(std::move(status));
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
Reference in New Issue
Block a user