1// Copyright (c) 2011 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#include "webkit/glue/media/video_renderer_impl.h"
6
7#include "media/base/video_frame.h"
8#include "media/base/yuv_convert.h"
9#include "webkit/glue/webmediaplayer_impl.h"
10
11namespace webkit_glue {
12
13VideoRendererImpl::VideoRendererImpl(bool pts_logging)
14    : last_converted_frame_(NULL),
15      pts_logging_(pts_logging) {
16}
17
18VideoRendererImpl::~VideoRendererImpl() {}
19
20bool VideoRendererImpl::OnInitialize(media::VideoDecoder* decoder) {
21  video_size_.SetSize(width(), height());
22  bitmap_.setConfig(SkBitmap::kARGB_8888_Config, width(), height());
23  if (bitmap_.allocPixels(NULL, NULL)) {
24    bitmap_.eraseRGB(0x00, 0x00, 0x00);
25    return true;
26  }
27
28  NOTREACHED();
29  return false;
30}
31
32void VideoRendererImpl::OnStop(media::FilterCallback* callback) {
33  if (callback) {
34    callback->Run();
35    delete callback;
36  }
37}
38
39void VideoRendererImpl::OnFrameAvailable() {
40  proxy_->Repaint();
41}
42
43void VideoRendererImpl::SetWebMediaPlayerImplProxy(
44    WebMediaPlayerImpl::Proxy* proxy) {
45  proxy_ = proxy;
46}
47
48void VideoRendererImpl::SetRect(const gfx::Rect& rect) {
49}
50
51// This method is always called on the renderer's thread.
52void VideoRendererImpl::Paint(SkCanvas* canvas,
53                              const gfx::Rect& dest_rect) {
54  scoped_refptr<media::VideoFrame> video_frame;
55  GetCurrentFrame(&video_frame);
56  if (!video_frame) {
57    SkPaint paint;
58    paint.setColor(SK_ColorBLACK);
59    canvas->drawRectCoords(
60        static_cast<float>(dest_rect.x()),
61        static_cast<float>(dest_rect.y()),
62        static_cast<float>(dest_rect.right()),
63        static_cast<float>(dest_rect.bottom()),
64        paint);
65  } else {
66    if (CanFastPaint(canvas, dest_rect)) {
67      FastPaint(video_frame, canvas, dest_rect);
68    } else {
69      SlowPaint(video_frame, canvas, dest_rect);
70    }
71
72    // Presentation timestamp logging is primarily used to measure performance
73    // on low-end devices.  When profiled on an Intel Atom N280 @ 1.66GHz this
74    // code had a ~63 microsecond perf hit when logging to a file (not stdout),
75    // which is neglible enough for measuring playback performance.
76    if (pts_logging_)
77      VLOG(1) << "pts=" << video_frame->GetTimestamp().InMicroseconds();
78  }
79
80  PutCurrentFrame(video_frame);
81}
82
83void VideoRendererImpl::GetCurrentFrame(
84    scoped_refptr<media::VideoFrame>* frame_out) {
85  VideoRendererBase::GetCurrentFrame(frame_out);
86}
87
88void VideoRendererImpl::PutCurrentFrame(
89    scoped_refptr<media::VideoFrame> frame) {
90  VideoRendererBase::PutCurrentFrame(frame);
91}
92
93// CanFastPaint is a helper method to determine the conditions for fast
94// painting. The conditions are:
95// 1. No skew in canvas matrix.
96// 2. No flipping nor mirroring.
97// 3. Canvas has pixel format ARGB8888.
98// 4. Canvas is opaque.
99// TODO(hclam): The fast paint method should support flipping and mirroring.
100// Disable the flipping and mirroring checks once we have it.
101bool VideoRendererImpl::CanFastPaint(SkCanvas* canvas,
102                                     const gfx::Rect& dest_rect) {
103  // Fast paint does not handle opacity value other than 1.0. Hence use slow
104  // paint if opacity is not 1.0. Since alpha = opacity * 0xFF, we check that
105  // alpha != 0xFF.
106  //
107  // Additonal notes: If opacity = 0.0, the chrome display engine does not try
108  // to render the video. So, this method is never called. However, if the
109  // opacity = 0.0001, alpha is again 0, but the display engine tries to render
110  // the video. If we use Fast paint, the video shows up with opacity = 1.0.
111  // Hence we use slow paint also in the case where alpha = 0. It would be ideal
112  // if rendering was never called even for cases where alpha is 0. Created
113  // bug 48090 for this.
114  SkCanvas::LayerIter layer_iter(canvas, false);
115  SkColor sk_color = layer_iter.paint().getColor();
116  SkAlpha sk_alpha = SkColorGetA(sk_color);
117  if (sk_alpha != 0xFF) {
118    return false;
119  }
120
121  const SkMatrix& total_matrix = canvas->getTotalMatrix();
122  // Perform the following checks here:
123  // 1. Check for skewing factors of the transformation matrix. They should be
124  //    zero.
125  // 2. Check for mirroring and flipping. Make sure they are greater than zero.
126  if (SkScalarNearlyZero(total_matrix.getSkewX()) &&
127      SkScalarNearlyZero(total_matrix.getSkewY()) &&
128      total_matrix.getScaleX() > 0 &&
129      total_matrix.getScaleY() > 0) {
130    // Get the properties of the SkDevice and the clip rect.
131    SkDevice* device = canvas->getDevice();
132
133    // Get the boundary of the device.
134    SkIRect device_rect;
135    device->getBounds(&device_rect);
136
137    // Get the pixel config of the device.
138    const SkBitmap::Config config = device->config();
139    // Get the total clip rect associated with the canvas.
140    const SkRegion& total_clip = canvas->getTotalClip();
141
142    SkIRect dest_irect;
143    TransformToSkIRect(canvas->getTotalMatrix(), dest_rect, &dest_irect);
144
145    if (config == SkBitmap::kARGB_8888_Config && device->isOpaque() &&
146        device_rect.contains(total_clip.getBounds())) {
147      return true;
148    }
149  }
150
151  return false;
152}
153
154void VideoRendererImpl::SlowPaint(media::VideoFrame* video_frame,
155                                  SkCanvas* canvas,
156                                  const gfx::Rect& dest_rect) {
157  // 1. Convert YUV frame to RGB.
158  base::TimeDelta timestamp = video_frame->GetTimestamp();
159  if (video_frame != last_converted_frame_ ||
160      timestamp != last_converted_timestamp_) {
161    last_converted_frame_ = video_frame;
162    last_converted_timestamp_ = timestamp;
163    DCHECK(video_frame->format() == media::VideoFrame::YV12 ||
164           video_frame->format() == media::VideoFrame::YV16);
165    DCHECK(video_frame->stride(media::VideoFrame::kUPlane) ==
166           video_frame->stride(media::VideoFrame::kVPlane));
167    DCHECK(video_frame->planes() == media::VideoFrame::kNumYUVPlanes);
168    bitmap_.lockPixels();
169    media::YUVType yuv_type =
170        (video_frame->format() == media::VideoFrame::YV12) ?
171        media::YV12 : media::YV16;
172    media::ConvertYUVToRGB32(video_frame->data(media::VideoFrame::kYPlane),
173                             video_frame->data(media::VideoFrame::kUPlane),
174                             video_frame->data(media::VideoFrame::kVPlane),
175                             static_cast<uint8*>(bitmap_.getPixels()),
176                             video_frame->width(),
177                             video_frame->height(),
178                             video_frame->stride(media::VideoFrame::kYPlane),
179                             video_frame->stride(media::VideoFrame::kUPlane),
180                             bitmap_.rowBytes(),
181                             yuv_type);
182    bitmap_.unlockPixels();
183  }
184
185  // 2. Paint the bitmap to canvas.
186  SkMatrix matrix;
187  matrix.setTranslate(static_cast<SkScalar>(dest_rect.x()),
188                      static_cast<SkScalar>(dest_rect.y()));
189  if (dest_rect.width()  != video_size_.width() ||
190      dest_rect.height() != video_size_.height()) {
191    matrix.preScale(SkIntToScalar(dest_rect.width()) /
192                    SkIntToScalar(video_size_.width()),
193                    SkIntToScalar(dest_rect.height()) /
194                    SkIntToScalar(video_size_.height()));
195  }
196  SkPaint paint;
197  paint.setFlags(SkPaint::kFilterBitmap_Flag);
198  canvas->drawBitmapMatrix(bitmap_, matrix, &paint);
199}
200
201void VideoRendererImpl::FastPaint(media::VideoFrame* video_frame,
202                                  SkCanvas* canvas,
203                                  const gfx::Rect& dest_rect) {
204  DCHECK(video_frame->format() == media::VideoFrame::YV12 ||
205         video_frame->format() == media::VideoFrame::YV16);
206  DCHECK(video_frame->stride(media::VideoFrame::kUPlane) ==
207         video_frame->stride(media::VideoFrame::kVPlane));
208  DCHECK(video_frame->planes() == media::VideoFrame::kNumYUVPlanes);
209  const SkBitmap& bitmap = canvas->getDevice()->accessBitmap(true);
210  media::YUVType yuv_type = (video_frame->format() == media::VideoFrame::YV12) ?
211                            media::YV12 : media::YV16;
212  int y_shift = yuv_type;  // 1 for YV12, 0 for YV16.
213
214  // Create a rectangle backed by SkScalar.
215  SkRect scalar_dest_rect;
216  scalar_dest_rect.iset(dest_rect.x(), dest_rect.y(),
217                        dest_rect.right(), dest_rect.bottom());
218
219  // Transform the destination rectangle to local coordinates.
220  const SkMatrix& local_matrix = canvas->getTotalMatrix();
221  SkRect local_dest_rect;
222  local_matrix.mapRect(&local_dest_rect, scalar_dest_rect);
223
224  // After projecting the destination rectangle to local coordinates, round
225  // the projected rectangle to integer values, this will give us pixel values
226  // of the rectangle.
227  SkIRect local_dest_irect, local_dest_irect_saved;
228  local_dest_rect.round(&local_dest_irect);
229  local_dest_rect.round(&local_dest_irect_saved);
230
231  // Only does the paint if the destination rect intersects with the clip
232  // rect.
233  if (local_dest_irect.intersect(canvas->getTotalClip().getBounds())) {
234    // At this point |local_dest_irect| contains the rect that we should draw
235    // to within the clipping rect.
236
237    // Calculate the address for the top left corner of destination rect in
238    // the canvas that we will draw to. The address is obtained by the base
239    // address of the canvas shifted by "left" and "top" of the rect.
240    uint8* dest_rect_pointer = static_cast<uint8*>(bitmap.getPixels()) +
241        local_dest_irect.fTop * bitmap.rowBytes() +
242        local_dest_irect.fLeft * 4;
243
244    // Project the clip rect to the original video frame, obtains the
245    // dimensions of the projected clip rect, "left" and "top" of the rect.
246    // The math here are all integer math so we won't have rounding error and
247    // write outside of the canvas.
248    // We have the assumptions of dest_rect.width() and dest_rect.height()
249    // being non-zero, these are valid assumptions since finding intersection
250    // above rejects empty rectangle so we just do a DCHECK here.
251    DCHECK_NE(0, dest_rect.width());
252    DCHECK_NE(0, dest_rect.height());
253    size_t frame_clip_width = local_dest_irect.width() *
254        video_frame->width() / local_dest_irect_saved.width();
255    size_t frame_clip_height = local_dest_irect.height() *
256        video_frame->height() / local_dest_irect_saved.height();
257
258    // Project the "left" and "top" of the final destination rect to local
259    // coordinates of the video frame, use these values to find the offsets
260    // in the video frame to start reading.
261    size_t frame_clip_left =
262        (local_dest_irect.fLeft - local_dest_irect_saved.fLeft) *
263        video_frame->width() / local_dest_irect_saved.width();
264    size_t frame_clip_top =
265        (local_dest_irect.fTop - local_dest_irect_saved.fTop) *
266        video_frame->height() / local_dest_irect_saved.height();
267
268    // Use the "left" and "top" of the destination rect to locate the offset
269    // in Y, U and V planes.
270    size_t y_offset = video_frame->stride(media::VideoFrame::kYPlane) *
271        frame_clip_top + frame_clip_left;
272    // For format YV12, there is one U, V value per 2x2 block.
273    // For format YV16, there is one u, V value per 2x1 block.
274    size_t uv_offset = (video_frame->stride(media::VideoFrame::kUPlane) *
275                        (frame_clip_top >> y_shift)) + (frame_clip_left >> 1);
276    uint8* frame_clip_y =
277        video_frame->data(media::VideoFrame::kYPlane) + y_offset;
278    uint8* frame_clip_u =
279        video_frame->data(media::VideoFrame::kUPlane) + uv_offset;
280    uint8* frame_clip_v =
281        video_frame->data(media::VideoFrame::kVPlane) + uv_offset;
282    bitmap.lockPixels();
283
284    // TODO(hclam): do rotation and mirroring here.
285    // TODO(fbarchard): switch filtering based on performance.
286    media::ScaleYUVToRGB32(frame_clip_y,
287                           frame_clip_u,
288                           frame_clip_v,
289                           dest_rect_pointer,
290                           frame_clip_width,
291                           frame_clip_height,
292                           local_dest_irect.width(),
293                           local_dest_irect.height(),
294                           video_frame->stride(media::VideoFrame::kYPlane),
295                           video_frame->stride(media::VideoFrame::kUPlane),
296                           bitmap.rowBytes(),
297                           yuv_type,
298                           media::ROTATE_0,
299                           media::FILTER_BILINEAR);
300    bitmap.unlockPixels();
301  }
302}
303
304void VideoRendererImpl::TransformToSkIRect(const SkMatrix& matrix,
305                                           const gfx::Rect& src_rect,
306                                           SkIRect* dest_rect) {
307    // Transform destination rect to local coordinates.
308    SkRect transformed_rect;
309    SkRect skia_dest_rect;
310    skia_dest_rect.iset(src_rect.x(), src_rect.y(),
311                        src_rect.right(), src_rect.bottom());
312    matrix.mapRect(&transformed_rect, skia_dest_rect);
313    transformed_rect.round(dest_rect);
314}
315
316}  // namespace webkit_glue
317