1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_COMMON_GPU_MEDIA_GPU_VIDEO_ENCODE_ACCELERATOR_H_
#define CONTENT_COMMON_GPU_MEDIA_GPU_VIDEO_ENCODE_ACCELERATOR_H_
#include <stddef.h>
#include <stdint.h>
#include <vector>
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "content/common/gpu/gpu_command_buffer_stub.h"
#include "gpu/config/gpu_info.h"
#include "ipc/ipc_listener.h"
#include "media/video/video_encode_accelerator.h"
#include "ui/gfx/geometry/size.h"
struct AcceleratedVideoEncoderMsg_Encode_Params;
struct AcceleratedVideoEncoderMsg_Encode_Params2;
namespace base {
class SharedMemory;
} // namespace base
namespace gpu {
struct GpuPreferences;
} // namespace gpu
namespace content {
// This class encapsulates the GPU process view of a VideoEncodeAccelerator,
// wrapping the platform-specific VideoEncodeAccelerator instance. It handles
// IPC coming in from the renderer and passes it to the underlying VEA.
class GpuVideoEncodeAccelerator
: public IPC::Listener,
public media::VideoEncodeAccelerator::Client,
public GpuCommandBufferStub::DestructionObserver {
public:
GpuVideoEncodeAccelerator(int32_t host_route_id, GpuCommandBufferStub* stub);
~GpuVideoEncodeAccelerator() override;
// Initialize this accelerator with the given parameters and send
// |init_done_msg| when complete.
bool Initialize(media::VideoPixelFormat input_format,
const gfx::Size& input_visible_size,
media::VideoCodecProfile output_profile,
uint32_t initial_bitrate);
// IPC::Listener implementation
bool OnMessageReceived(const IPC::Message& message) override;
// media::VideoEncodeAccelerator::Client implementation.
void RequireBitstreamBuffers(unsigned int input_count,
const gfx::Size& input_coded_size,
size_t output_buffer_size) override;
void BitstreamBufferReady(int32_t bitstream_buffer_id,
size_t payload_size,
bool key_frame) override;
void NotifyError(media::VideoEncodeAccelerator::Error error) override;
// GpuCommandBufferStub::DestructionObserver implementation.
void OnWillDestroyStub() override;
// Static query for supported profiles. This query calls the appropriate
// platform-specific version. The returned supported profiles vector will
// not contain duplicates.
static gpu::VideoEncodeAcceleratorSupportedProfiles GetSupportedProfiles(
const gpu::GpuPreferences& gpu_preferences);
private:
typedef scoped_ptr<media::VideoEncodeAccelerator>(*CreateVEAFp)();
// Return a set of VEA Create function pointers applicable to the current
// platform.
static std::vector<CreateVEAFp> CreateVEAFps(
const gpu::GpuPreferences& gpu_preferences);
#if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
static scoped_ptr<media::VideoEncodeAccelerator> CreateV4L2VEA();
#endif
#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
static scoped_ptr<media::VideoEncodeAccelerator> CreateVaapiVEA();
#endif
#if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
static scoped_ptr<media::VideoEncodeAccelerator> CreateAndroidVEA();
#endif
// IPC handlers, proxying media::VideoEncodeAccelerator for the renderer
// process.
void OnEncode(const AcceleratedVideoEncoderMsg_Encode_Params& params);
void OnEncode2(const AcceleratedVideoEncoderMsg_Encode_Params2& params);
void OnUseOutputBitstreamBuffer(int32_t buffer_id,
base::SharedMemoryHandle buffer_handle,
uint32_t buffer_size);
void OnRequestEncodingParametersChange(uint32_t bitrate, uint32_t framerate);
void OnDestroy();
void EncodeFrameFinished(int32_t frame_id,
scoped_ptr<base::SharedMemory> shm);
void EncodeFrameFinished2(int32_t frame_id,
ScopedVector<gfx::GpuMemoryBuffer> buffers);
void Send(IPC::Message* message);
// Route ID to communicate with the host.
const uint32_t host_route_id_;
// Unowned pointer to the underlying GpuCommandBufferStub. |this| is
// registered as a DestuctionObserver of |stub_| and will self-delete when
// |stub_| is destroyed.
GpuCommandBufferStub* const stub_;
// Owned pointer to the underlying VideoEncodeAccelerator.
scoped_ptr<media::VideoEncodeAccelerator> encoder_;
base::Callback<bool(void)> make_context_current_;
// Video encoding parameters.
media::VideoPixelFormat input_format_;
gfx::Size input_visible_size_;
gfx::Size input_coded_size_;
size_t output_buffer_size_;
// Weak pointer for media::VideoFrames that refer back to |this|.
base::WeakPtrFactory<GpuVideoEncodeAccelerator> weak_this_factory_;
DISALLOW_COPY_AND_ASSIGN(GpuVideoEncodeAccelerator);
};
} // namespace content
#endif // CONTENT_COMMON_GPU_MEDIA_GPU_VIDEO_ENCODE_ACCELERATOR_H_
|
