OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #if !defined(__has_feature) || !__has_feature(objc_arc) | |
6 #error "This file requires ARC support." | |
7 #endif | |
8 | |
9 #import <Foundation/Foundation.h> | |
10 #import <GLKit/GLKit.h> | |
11 | |
12 #import "remoting/client/ios/display/gl_display_handler.h" | |
13 | |
14 #import "remoting/client/ios/display/gl_demo_screen.h" | |
15 | |
16 #import "remoting/client/sys_opengl.h" | |
17 | |
18 #include "base/macros.h" | |
19 #include "base/memory/ptr_util.h" | |
20 #include "base/memory/weak_ptr.h" | |
21 #include "remoting/client/chromoting_client.h" | |
22 #include "remoting/client/dual_buffer_frame_consumer.h" | |
23 #include "remoting/client/gl_renderer.h" | |
24 #include "remoting/client/gl_renderer_delegate.h" | |
25 #include "remoting/client/ios/app_runtime.h" | |
26 #include "remoting/client/software_video_renderer.h" | |
27 | |
28 namespace remoting { | |
29 namespace GlDisplayHandler { | |
30 | |
31 // The core that lives on the display thread. | |
32 class Core : // public protocol::CursorShapeStub, | |
joedow
2016/12/19 23:56:26
Should CursorShapeStub be commented out? Delete i
| |
33 public GlRendererDelegate { | |
34 public: | |
35 Core(remoting::ios::AppRuntime* runtime); | |
36 ~Core() override; | |
37 | |
38 // GlRendererDelegate interface. | |
39 bool CanRenderFrame() override; | |
40 void OnFrameRendered() override; | |
41 void OnSizeChanged(int width, int height) override; | |
42 void Draw(); | |
43 void Created(); | |
44 void SurfaceChanged(int width, int height); | |
45 std::unique_ptr<protocol::FrameConsumer> GrabFrameConsumer(); | |
46 base::WeakPtr<Core> GetWeakPtr(); | |
47 | |
48 private: | |
49 // Will be std::move'd when GrabFrameConsumer() is called. | |
50 remoting::ios::AppRuntime* runtime_; | |
51 std::unique_ptr<DualBufferFrameConsumer> owned_frame_consumer_; | |
52 | |
53 base::WeakPtr<DualBufferFrameConsumer> frame_consumer_; | |
54 EAGLContext* eagl_context_; | |
55 GlRenderer renderer_; | |
56 GlDemoScreen demoScreen_; | |
Yuwei
2016/12/19 23:26:09
s/demoScreen_/demo_screen_/ ?
| |
57 | |
58 // Used on display thread. | |
59 base::WeakPtr<Core> weak_ptr_; | |
60 base::WeakPtrFactory<Core> weak_factory_; | |
61 | |
62 DISALLOW_COPY_AND_ASSIGN(Core); | |
63 }; | |
64 | |
65 Core::Core(remoting::ios::AppRuntime* runtime) | |
66 : runtime_(runtime), weak_factory_(this) { | |
67 weak_ptr_ = weak_factory_.GetWeakPtr(); | |
68 renderer_.SetDelegate(weak_ptr_); | |
69 owned_frame_consumer_.reset(new remoting::DualBufferFrameConsumer( | |
70 base::Bind(&remoting::GlRenderer::OnFrameReceived, | |
71 renderer_.GetWeakPtr()), | |
72 runtime_->display_task_runner(), | |
73 remoting::protocol::FrameConsumer::PixelFormat::FORMAT_RGBA)); | |
74 frame_consumer_ = owned_frame_consumer_->GetWeakPtr(); | |
75 renderer_.AddDrawable(&demoScreen_); | |
76 } | |
77 | |
78 Core::~Core() {} | |
79 | |
80 bool Core::CanRenderFrame() { | |
81 DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread()); | |
82 return eagl_context_ != NULL; // && egl_context_->IsWindowBound(); | |
joedow
2016/12/19 23:56:26
Is the commented out condition intentional?
| |
83 } | |
84 | |
85 std::unique_ptr<protocol::FrameConsumer> Core::GrabFrameConsumer() { | |
86 // DCHECK(owned_frame_consumer_) << "The frame consumer is already grabbed."; | |
joedow
2016/12/19 23:56:26
Why are all the DCHECKS commented out?
| |
87 return std::move(owned_frame_consumer_); | |
88 } | |
89 | |
90 void Core::OnFrameRendered() { | |
91 // DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread()); | |
92 // egl_context_->SwapBuffers(); | |
93 // runtime_->ui_task_runner()->PostTask( | |
94 // FROM_HERE, base::Bind(&JniGlDisplayHandler::OnRenderDone, shell_)); | |
95 } | |
96 | |
97 void Core::OnSizeChanged(int width, int height) { | |
98 // DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread()); | |
99 // runtime_->ui_task_runner()->PostTask( | |
100 // FROM_HERE, base::Bind(&JniGlDisplayHandler::OnCanvasSizeChanged, | |
101 // shell_, | |
102 // width, height)); | |
joedow
2016/12/19 23:56:26
Use NOTIMPLEMENTED() or NOTREACHED() instead of co
| |
103 } | |
104 | |
105 void Core::Created() { | |
106 // DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread()); | |
107 // DCHECK(!egl_context_); | |
108 // DCHECK(!window_); | |
109 eagl_context_ = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2]; | |
Yuwei
2016/12/19 23:26:09
How does this work? Looks like you have created an
| |
110 | |
111 // eagl_context_ = [EAGLContext currentContext]; | |
112 renderer_.RequestCanvasSize(); | |
113 // window_ = ANativeWindow_fromSurface(base::android::AttachCurrentThread(), | |
114 // surface.obj()); | |
115 // egl_context_.reset(new EglThreadContext()); | |
116 // egl_context_->BindToWindow(window_); | |
117 | |
118 renderer_.OnSurfaceCreated([eagl_context_ API]); | |
119 // runtime_->network_task_runner()->PostTask( | |
120 // FROM_HERE, | |
121 // base::Bind(&DualBufferFrameConsumer::RequestFullDesktopFrame, | |
122 // frame_consumer_)); | |
123 } | |
124 | |
125 void Core::Draw() {} | |
126 | |
127 void Core::SurfaceChanged(int width, int height) { | |
128 // DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread()); | |
129 renderer_.OnSurfaceChanged(width, height); | |
130 } | |
131 | |
132 base::WeakPtr<remoting::GlDisplayHandler::Core> Core::GetWeakPtr() { | |
133 return weak_ptr_; | |
134 } | |
135 | |
136 } // namespace GlDisplayHandler | |
137 } // namespace remoting | |
138 | |
139 @interface GlDisplayHandler () | |
140 @property(nonatomic) remoting::GlDisplayHandler::Core* core_; | |
141 @property(nonatomic) remoting::ios::AppRuntime* runtime_; | |
142 @end | |
143 | |
144 @implementation GlDisplayHandler | |
145 | |
146 @synthesize core_ = _core_; | |
147 @synthesize runtime_ = _runtime_; | |
148 | |
149 - (id)initWithRuntime:(remoting::ios::AppRuntime*)runtime { | |
150 self.runtime_ = runtime; | |
151 return self; | |
152 } | |
153 | |
154 - (void)created { | |
155 _core_ = new remoting::GlDisplayHandler::Core(self.runtime_); | |
156 | |
157 self.runtime_->display_task_runner()->PostTask( | |
158 FROM_HERE, base::Bind(&remoting::GlDisplayHandler::Core::Created, | |
159 self.core_->GetWeakPtr())); | |
160 } | |
161 | |
162 // In general, avoid expensive work in this function to maximize frame rate. | |
163 - (void)draw { | |
164 self.runtime_->display_task_runner()->PostTask( | |
165 FROM_HERE, base::Bind(&remoting::GlDisplayHandler::Core::Draw, | |
166 self.core_->GetWeakPtr())); | |
167 | |
168 // core_->DrawFrame(std::move(frame), base::Closure()); | |
169 } | |
170 | |
171 - (std::unique_ptr<remoting::protocol::VideoRenderer>)CreateVideoRenderer { | |
172 return base::MakeUnique<remoting::SoftwareVideoRenderer>( | |
173 _core_->GrabFrameConsumer()); | |
174 } | |
175 | |
176 - (void)glkView:(GLKView*)view drawInRect:(CGRect)rect { | |
177 if (_core_) { | |
178 _core_->SurfaceChanged(rect.size.width, rect.size.height); | |
179 } | |
180 } | |
181 | |
182 @end | |
OLD | NEW |