OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/blink/video_frame_compositor.h" | 5 #include "media/blink/video_frame_compositor.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/message_loop/message_loop.h" | 8 #include "base/message_loop/message_loop.h" |
9 #include "base/time/default_tick_clock.h" | |
10 #include "base/trace_event/trace_event.h" | |
9 #include "media/base/video_frame.h" | 11 #include "media/base/video_frame.h" |
10 | 12 |
11 namespace media { | 13 namespace media { |
12 | 14 |
15 // The maximum time we'll allow to elapse between Render() callbacks if there is | |
16 // an external caller requesting frames via GetCurrentFrame(); i.e. there is a | |
17 // canvas which frames are being copied into. | |
18 static const int kStaleFrameThresholdMs = 250; | |
xhwang
2015/04/29 22:42:03
s/static//
DaleCurtis
2015/04/30 03:49:37
Done.
| |
19 | |
13 static bool IsOpaque(const scoped_refptr<VideoFrame>& frame) { | 20 static bool IsOpaque(const scoped_refptr<VideoFrame>& frame) { |
14 switch (frame->format()) { | 21 switch (frame->format()) { |
15 case VideoFrame::UNKNOWN: | 22 case VideoFrame::UNKNOWN: |
16 case VideoFrame::YV12: | 23 case VideoFrame::YV12: |
17 case VideoFrame::YV12J: | 24 case VideoFrame::YV12J: |
18 case VideoFrame::YV12HD: | 25 case VideoFrame::YV12HD: |
19 case VideoFrame::YV16: | 26 case VideoFrame::YV16: |
20 case VideoFrame::I420: | 27 case VideoFrame::I420: |
21 case VideoFrame::YV24: | 28 case VideoFrame::YV24: |
22 case VideoFrame::NV12: | 29 case VideoFrame::NV12: |
23 return true; | 30 return true; |
24 | 31 |
25 case VideoFrame::YV12A: | 32 case VideoFrame::YV12A: |
26 #if defined(VIDEO_HOLE) | 33 #if defined(VIDEO_HOLE) |
27 case VideoFrame::HOLE: | 34 case VideoFrame::HOLE: |
28 #endif // defined(VIDEO_HOLE) | 35 #endif // defined(VIDEO_HOLE) |
29 case VideoFrame::NATIVE_TEXTURE: | 36 case VideoFrame::NATIVE_TEXTURE: |
30 case VideoFrame::ARGB: | 37 case VideoFrame::ARGB: |
31 break; | 38 break; |
32 } | 39 } |
33 return false; | 40 return false; |
34 } | 41 } |
35 | 42 |
36 VideoFrameCompositor::VideoFrameCompositor( | 43 VideoFrameCompositor::VideoFrameCompositor( |
37 const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner, | 44 const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner, |
38 const base::Callback<void(gfx::Size)>& natural_size_changed_cb, | 45 const base::Callback<void(gfx::Size)>& natural_size_changed_cb, |
39 const base::Callback<void(bool)>& opacity_changed_cb) | 46 const base::Callback<void(bool)>& opacity_changed_cb) |
40 : compositor_task_runner_(compositor_task_runner), | 47 : compositor_task_runner_(compositor_task_runner), |
48 tick_clock_(new base::DefaultTickClock()), | |
41 natural_size_changed_cb_(natural_size_changed_cb), | 49 natural_size_changed_cb_(natural_size_changed_cb), |
42 opacity_changed_cb_(opacity_changed_cb), | 50 opacity_changed_cb_(opacity_changed_cb), |
43 client_(nullptr), | 51 client_(nullptr), |
52 stale_frame_threshold_( | |
53 base::TimeDelta::FromMilliseconds(kStaleFrameThresholdMs)), | |
44 rendering_(false), | 54 rendering_(false), |
55 rendered_last_frame_(false), | |
45 callback_(nullptr) { | 56 callback_(nullptr) { |
46 } | 57 } |
47 | 58 |
48 VideoFrameCompositor::~VideoFrameCompositor() { | 59 VideoFrameCompositor::~VideoFrameCompositor() { |
49 DCHECK(compositor_task_runner_->BelongsToCurrentThread()); | 60 DCHECK(compositor_task_runner_->BelongsToCurrentThread()); |
50 DCHECK(!callback_); | 61 DCHECK(!callback_); |
51 DCHECK(!rendering_); | 62 DCHECK(!rendering_); |
52 if (client_) | 63 if (client_) |
53 client_->StopUsingProvider(); | 64 client_->StopUsingProvider(); |
54 } | 65 } |
55 | 66 |
56 void VideoFrameCompositor::OnRendererStateUpdate() { | 67 void VideoFrameCompositor::OnRendererStateUpdate(bool new_state) { |
57 DCHECK(compositor_task_runner_->BelongsToCurrentThread()); | 68 DCHECK(compositor_task_runner_->BelongsToCurrentThread()); |
69 DCHECK_NE(rendering_, new_state); | |
70 rendering_ = new_state; | |
71 | |
58 if (!client_) | 72 if (!client_) |
59 return; | 73 return; |
60 | 74 |
61 base::AutoLock lock(lock_); | 75 if (rendering_) |
62 if (callback_) { | 76 client_->StartRendering(); |
63 if (rendering_) | 77 else |
64 client_->StartRendering(); | |
65 | |
66 // TODO(dalecurtis): This will need to request the first frame so we have | |
67 // something to show, even if playback hasn't started yet. | |
68 } else if (rendering_) { | |
69 client_->StopRendering(); | 78 client_->StopRendering(); |
70 } | |
71 } | 79 } |
72 | 80 |
73 scoped_refptr<VideoFrame> | 81 scoped_refptr<VideoFrame> |
74 VideoFrameCompositor::GetCurrentFrameAndUpdateIfStale() { | 82 VideoFrameCompositor::GetCurrentFrameAndUpdateIfStale() { |
75 // TODO(dalecurtis): Implement frame refresh when stale. | |
76 DCHECK(compositor_task_runner_->BelongsToCurrentThread()); | 83 DCHECK(compositor_task_runner_->BelongsToCurrentThread()); |
84 const base::TimeTicks now = tick_clock_->NowTicks(); | |
85 if (now - last_frame_update_time_ > stale_frame_threshold_) | |
86 UpdateCurrentFrame(now, now + last_interval_); | |
87 | |
77 return GetCurrentFrame(); | 88 return GetCurrentFrame(); |
78 } | 89 } |
79 | 90 |
80 void VideoFrameCompositor::SetVideoFrameProviderClient( | 91 void VideoFrameCompositor::SetVideoFrameProviderClient( |
81 cc::VideoFrameProvider::Client* client) { | 92 cc::VideoFrameProvider::Client* client) { |
82 DCHECK(compositor_task_runner_->BelongsToCurrentThread()); | 93 DCHECK(compositor_task_runner_->BelongsToCurrentThread()); |
83 if (client_) | 94 if (client_) |
84 client_->StopUsingProvider(); | 95 client_->StopUsingProvider(); |
85 client_ = client; | 96 client_ = client; |
86 OnRendererStateUpdate(); | 97 |
98 if (rendering_) | |
99 client_->StartRendering(); | |
87 } | 100 } |
88 | 101 |
89 scoped_refptr<VideoFrame> VideoFrameCompositor::GetCurrentFrame() { | 102 scoped_refptr<VideoFrame> VideoFrameCompositor::GetCurrentFrame() { |
90 DCHECK(compositor_task_runner_->BelongsToCurrentThread()); | 103 DCHECK(compositor_task_runner_->BelongsToCurrentThread()); |
91 return current_frame_; | 104 return current_frame_; |
92 } | 105 } |
93 | 106 |
94 void VideoFrameCompositor::PutCurrentFrame() { | 107 void VideoFrameCompositor::PutCurrentFrame() { |
95 DCHECK(compositor_task_runner_->BelongsToCurrentThread()); | 108 DCHECK(compositor_task_runner_->BelongsToCurrentThread()); |
96 // TODO(dalecurtis): Wire up a flag for RenderCallback::OnFrameDropped(). | 109 rendered_last_frame_ = true; |
97 } | 110 } |
98 | 111 |
99 bool VideoFrameCompositor::UpdateCurrentFrame(base::TimeTicks deadline_min, | 112 bool VideoFrameCompositor::UpdateCurrentFrame(base::TimeTicks deadline_min, |
100 base::TimeTicks deadline_max) { | 113 base::TimeTicks deadline_max) { |
101 // TODO(dalecurtis): Wire this up to RenderCallback::Render(). | 114 DCHECK(compositor_task_runner_->BelongsToCurrentThread()); |
102 base::AutoLock lock(lock_); | 115 base::AutoLock lock(lock_); |
103 return false; | 116 if (!callback_) |
117 return false; | |
118 | |
119 DCHECK(rendering_); | |
120 | |
121 // If the previous frame was never rendered, let the client know. | |
122 if (!rendered_last_frame_ && current_frame_) | |
123 callback_->OnFrameDropped(); | |
124 | |
125 last_frame_update_time_ = tick_clock_->NowTicks(); | |
126 last_interval_ = deadline_max - deadline_min; | |
xhwang
2015/04/29 22:42:03
We use |last| for most member variables here, but
DaleCurtis
2015/04/30 03:49:37
Yeah it does seem odd, but I think it matches the
| |
127 scoped_refptr<VideoFrame> frame = | |
128 callback_->Render(deadline_min, deadline_max); | |
129 | |
130 // Do nothing if the current frame has already been rendered. | |
131 if (current_frame_ == frame) | |
132 return false; | |
133 | |
134 // Set the flag indicating that the current frame is unrendered, if we get a | |
135 // subsequent PutCurrentFrame() call it will mark it as rendered. | |
136 rendered_last_frame_ = false; | |
137 | |
138 if (current_frame_.get() && | |
139 current_frame_->natural_size() != frame->natural_size()) { | |
140 natural_size_changed_cb_.Run(frame->natural_size()); | |
141 } | |
142 | |
143 if (!current_frame_.get() || IsOpaque(current_frame_) != IsOpaque(frame)) { | |
144 opacity_changed_cb_.Run(IsOpaque(frame)); | |
145 } | |
146 | |
147 current_frame_ = frame; | |
148 return true; | |
104 } | 149 } |
105 | 150 |
106 void VideoFrameCompositor::Start(RenderCallback* callback) { | 151 void VideoFrameCompositor::Start(RenderCallback* callback) { |
107 NOTREACHED(); | 152 TRACE_EVENT0("media", "VideoFrameCompositor::Start"); |
108 | |
109 // Called from the media thread, so acquire the callback under lock before | 153 // Called from the media thread, so acquire the callback under lock before |
110 // returning in case a Stop() call comes in before the PostTask is processed. | 154 // returning in case a Stop() call comes in before the PostTask is processed. |
111 base::AutoLock lock(lock_); | 155 base::AutoLock lock(lock_); |
156 DCHECK(!callback_); | |
157 | |
158 // Don't clear |current_frame_| as we won't be able to recover from damage to | |
159 // the video display area if an UpdateCurrentFrame() call doesn't come in | |
160 // before Stop() is called again. | |
161 | |
112 callback_ = callback; | 162 callback_ = callback; |
113 rendering_ = true; | |
114 compositor_task_runner_->PostTask( | 163 compositor_task_runner_->PostTask( |
115 FROM_HERE, base::Bind(&VideoFrameCompositor::OnRendererStateUpdate, | 164 FROM_HERE, base::Bind(&VideoFrameCompositor::OnRendererStateUpdate, |
116 base::Unretained(this))); | 165 base::Unretained(this), true)); |
117 } | 166 } |
118 | 167 |
119 void VideoFrameCompositor::Stop() { | 168 void VideoFrameCompositor::Stop() { |
120 NOTREACHED(); | 169 TRACE_EVENT0("media", "VideoFrameCompositor::Stop"); |
xhwang
2015/04/29 22:42:03
nit: TRACE_EVENT0("media", __FUCNTION__) if you pr
DaleCurtis
2015/04/30 03:49:37
Done.
| |
121 | |
122 // Called from the media thread, so release the callback under lock before | 170 // Called from the media thread, so release the callback under lock before |
123 // returning to avoid a pending UpdateCurrentFrame() call occurring before | 171 // returning to avoid a pending UpdateCurrentFrame() call occurring before |
124 // the PostTask is processed. | 172 // the PostTask is processed. |
125 base::AutoLock lock(lock_); | 173 base::AutoLock lock(lock_); |
174 DCHECK(callback_); | |
175 | |
176 // Don't clear |current_frame_| as we won't be able to recover from damage to | |
177 // the video display area. | |
178 | |
126 callback_ = nullptr; | 179 callback_ = nullptr; |
127 rendering_ = false; | |
128 compositor_task_runner_->PostTask( | 180 compositor_task_runner_->PostTask( |
129 FROM_HERE, base::Bind(&VideoFrameCompositor::OnRendererStateUpdate, | 181 FROM_HERE, base::Bind(&VideoFrameCompositor::OnRendererStateUpdate, |
130 base::Unretained(this))); | 182 base::Unretained(this), false)); |
131 } | 183 } |
132 | 184 |
133 void VideoFrameCompositor::PaintFrameUsingOldRenderingPath( | 185 void VideoFrameCompositor::PaintFrameUsingOldRenderingPath( |
134 const scoped_refptr<VideoFrame>& frame) { | 186 const scoped_refptr<VideoFrame>& frame) { |
135 if (!compositor_task_runner_->BelongsToCurrentThread()) { | 187 if (!compositor_task_runner_->BelongsToCurrentThread()) { |
136 compositor_task_runner_->PostTask( | 188 compositor_task_runner_->PostTask( |
137 FROM_HERE, | 189 FROM_HERE, |
138 base::Bind(&VideoFrameCompositor::PaintFrameUsingOldRenderingPath, | 190 base::Bind(&VideoFrameCompositor::PaintFrameUsingOldRenderingPath, |
139 base::Unretained(this), frame)); | 191 base::Unretained(this), frame)); |
140 return; | 192 return; |
141 } | 193 } |
142 | 194 |
143 if (current_frame_.get() && | 195 if (current_frame_.get() && |
144 current_frame_->natural_size() != frame->natural_size()) { | 196 current_frame_->natural_size() != frame->natural_size()) { |
145 natural_size_changed_cb_.Run(frame->natural_size()); | 197 natural_size_changed_cb_.Run(frame->natural_size()); |
146 } | 198 } |
147 | 199 |
148 if (!current_frame_.get() || IsOpaque(current_frame_) != IsOpaque(frame)) { | 200 if (!current_frame_.get() || IsOpaque(current_frame_) != IsOpaque(frame)) { |
149 opacity_changed_cb_.Run(IsOpaque(frame)); | 201 opacity_changed_cb_.Run(IsOpaque(frame)); |
150 } | 202 } |
151 | 203 |
152 current_frame_ = frame; | 204 current_frame_ = frame; |
153 | 205 |
154 if (client_) | 206 if (client_) |
155 client_->DidReceiveFrame(); | 207 client_->DidReceiveFrame(); |
156 } | 208 } |
157 | 209 |
158 } // namespace media | 210 } // namespace media |
OLD | NEW |