OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "content/renderer/media/media_stream_video_renderer_sink.h" | 5 #include "content/renderer/media/media_stream_video_renderer_sink.h" |
6 | 6 |
| 7 #include "base/single_thread_task_runner.h" |
7 #include "base/thread_task_runner_handle.h" | 8 #include "base/thread_task_runner_handle.h" |
8 #include "base/trace_event/trace_event.h" | 9 #include "base/trace_event/trace_event.h" |
9 #include "media/base/bind_to_current_loop.h" | 10 #include "media/base/bind_to_current_loop.h" |
10 #include "media/base/video_frame.h" | 11 #include "media/base/video_frame.h" |
11 #include "media/base/video_util.h" | 12 #include "media/base/video_util.h" |
| 13 #include "media/renderers/gpu_video_accelerator_factories.h" |
12 | 14 |
13 const int kMinFrameSize = 2; | 15 const int kMinFrameSize = 2; |
14 | 16 |
15 namespace content { | 17 namespace content { |
16 | 18 |
17 MediaStreamVideoRendererSink::MediaStreamVideoRendererSink( | 19 MediaStreamVideoRendererSink::MediaStreamVideoRendererSink( |
18 const blink::WebMediaStreamTrack& video_track, | 20 const blink::WebMediaStreamTrack& video_track, |
19 const base::Closure& error_cb, | 21 const base::Closure& error_cb, |
20 const RepaintCB& repaint_cb) | 22 const RepaintCB& repaint_cb, |
| 23 const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner, |
| 24 const scoped_refptr<base::TaskRunner>& worker_task_runner, |
| 25 const scoped_refptr<media::GpuVideoAcceleratorFactories>& gpu_factories) |
21 : error_cb_(error_cb), | 26 : error_cb_(error_cb), |
22 repaint_cb_(repaint_cb), | 27 repaint_cb_(repaint_cb), |
23 task_runner_(base::ThreadTaskRunnerHandle::Get()), | 28 task_runner_(base::ThreadTaskRunnerHandle::Get()), |
24 state_(STOPPED), | 29 state_(STOPPED), |
25 frame_size_(kMinFrameSize, kMinFrameSize), | 30 frame_size_(kMinFrameSize, kMinFrameSize), |
26 video_track_(video_track), | 31 video_track_(video_track), |
| 32 media_task_runner_(media_task_runner), |
27 weak_factory_(this) { | 33 weak_factory_(this) { |
| 34 if (gpu_factories && |
| 35 gpu_factories->ShouldUseGpuMemoryBuffersForVideoFrames()) { |
| 36 gpu_memory_buffer_pool_.reset(new media::GpuMemoryBufferVideoFramePool( |
| 37 media_task_runner, worker_task_runner, gpu_factories)); |
| 38 } |
28 } | 39 } |
29 | 40 |
30 MediaStreamVideoRendererSink::~MediaStreamVideoRendererSink() { | 41 MediaStreamVideoRendererSink::~MediaStreamVideoRendererSink() { |
31 } | 42 } |
32 | 43 |
33 void MediaStreamVideoRendererSink::Start() { | 44 void MediaStreamVideoRendererSink::Start() { |
34 DCHECK(task_runner_->BelongsToCurrentThread()); | 45 DCHECK(task_runner_->BelongsToCurrentThread()); |
35 DCHECK_EQ(state_, STOPPED); | 46 DCHECK_EQ(state_, STOPPED); |
36 | 47 |
37 AddToVideoTrack( | 48 AddToVideoTrack( |
(...skipping 27 matching lines...) Expand all Loading... |
65 if (state_ == PAUSED) | 76 if (state_ == PAUSED) |
66 state_ = STARTED; | 77 state_ = STARTED; |
67 } | 78 } |
68 | 79 |
69 void MediaStreamVideoRendererSink::Pause() { | 80 void MediaStreamVideoRendererSink::Pause() { |
70 DCHECK(task_runner_->BelongsToCurrentThread()); | 81 DCHECK(task_runner_->BelongsToCurrentThread()); |
71 if (state_ == STARTED) | 82 if (state_ == STARTED) |
72 state_ = PAUSED; | 83 state_ = PAUSED; |
73 } | 84 } |
74 | 85 |
| 86 void MediaStreamVideoRendererSink::SetGpuMemoryBufferVideoForTesting( |
| 87 scoped_ptr<media::GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool) { |
| 88 gpu_memory_buffer_pool_.swap(gpu_memory_buffer_pool); |
| 89 } |
| 90 |
75 void MediaStreamVideoRendererSink::OnReadyStateChanged( | 91 void MediaStreamVideoRendererSink::OnReadyStateChanged( |
76 blink::WebMediaStreamSource::ReadyState state) { | 92 blink::WebMediaStreamSource::ReadyState state) { |
77 DCHECK(task_runner_->BelongsToCurrentThread()); | 93 DCHECK(task_runner_->BelongsToCurrentThread()); |
78 if (state == blink::WebMediaStreamSource::ReadyStateEnded) | 94 if (state == blink::WebMediaStreamSource::ReadyStateEnded) |
79 RenderSignalingFrame(); | 95 RenderSignalingFrame(); |
80 } | 96 } |
81 | 97 |
82 void MediaStreamVideoRendererSink::OnVideoFrame( | 98 void MediaStreamVideoRendererSink::OnVideoFrame( |
83 const scoped_refptr<media::VideoFrame>& frame, | 99 const scoped_refptr<media::VideoFrame>& frame, |
84 base::TimeTicks estimated_capture_time) { | 100 base::TimeTicks estimated_capture_time) { |
85 DCHECK(task_runner_->BelongsToCurrentThread()); | 101 DCHECK(task_runner_->BelongsToCurrentThread()); |
| 102 DCHECK(frame); |
86 if (state_ != STARTED) | 103 if (state_ != STARTED) |
87 return; | 104 return; |
88 | 105 |
| 106 if (!gpu_memory_buffer_pool_) { |
| 107 FrameReady(frame); |
| 108 return; |
| 109 } |
| 110 |
| 111 media_task_runner_->PostTask( |
| 112 FROM_HERE, |
| 113 base::Bind( |
| 114 &media::GpuMemoryBufferVideoFramePool::MaybeCreateHardwareFrame, |
| 115 base::Unretained(gpu_memory_buffer_pool_.get()), frame, |
| 116 media::BindToCurrentLoop( |
| 117 base::Bind(&MediaStreamVideoRendererSink::FrameReady, this)))); |
| 118 } |
| 119 |
| 120 void MediaStreamVideoRendererSink::FrameReady( |
| 121 const scoped_refptr<media::VideoFrame>& frame) { |
| 122 DCHECK(task_runner_->BelongsToCurrentThread()); |
| 123 DCHECK(frame); |
| 124 |
89 frame_size_ = frame->natural_size(); | 125 frame_size_ = frame->natural_size(); |
90 | 126 TRACE_EVENT_INSTANT1("media_stream_video_renderer_sink", "FrameReady", |
91 TRACE_EVENT_INSTANT1("media_stream_video_renderer_sink", | 127 TRACE_EVENT_SCOPE_THREAD, "timestamp", |
92 "OnVideoFrame", | |
93 TRACE_EVENT_SCOPE_THREAD, | |
94 "timestamp", | |
95 frame->timestamp().InMilliseconds()); | 128 frame->timestamp().InMilliseconds()); |
96 repaint_cb_.Run(frame); | 129 repaint_cb_.Run(frame); |
97 } | 130 } |
98 | 131 |
99 void MediaStreamVideoRendererSink::RenderSignalingFrame() { | 132 void MediaStreamVideoRendererSink::RenderSignalingFrame() { |
100 // This is necessary to make sure audio can play if the video tag src is | 133 // This is necessary to make sure audio can play if the video tag src is |
101 // a MediaStream video track that has been rejected or ended. | 134 // a MediaStream video track that has been rejected or ended. |
102 // It also ensure that the renderer don't hold a reference to a real video | 135 // It also ensure that the renderer don't hold a reference to a real video |
103 // frame if no more frames are provided. This is since there might be a | 136 // frame if no more frames are provided. This is since there might be a |
104 // finite number of available buffers. E.g, video that | 137 // finite number of available buffers. E.g, video that |
105 // originates from a video camera. | 138 // originates from a video camera. |
106 scoped_refptr<media::VideoFrame> video_frame = | 139 scoped_refptr<media::VideoFrame> video_frame = |
107 media::VideoFrame::CreateBlackFrame(frame_size_); | 140 media::VideoFrame::CreateBlackFrame(frame_size_); |
108 OnVideoFrame(video_frame, base::TimeTicks()); | 141 OnVideoFrame(video_frame, base::TimeTicks()); |
109 } | 142 } |
110 | 143 |
111 } // namespace content | 144 } // namespace content |
OLD | NEW |