Byte-swap the video frame pixels before passing them to Java.

remoting/client/plugin/pepper_view.cc

 // Copyright (c) 2012 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.
 
 #include "remoting/client/plugin/pepper_view.h"
 
 #include <functional>
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
@@ skipping 43 matching lines @@
 namespace remoting {
 
 namespace {
 
 // The maximum number of image buffers to be allocated at any point of time.
 const size_t kMaxPendingBuffersCount = 2;
 
 }  // namespace
 
 PepperView::PepperView(ChromotingInstance* instance,
-                       ClientContext* context,
-                       FrameProducer* producer)
+                       ClientContext* context)
   : instance_(instance),
     context_(context),
-    producer_(producer),
+    producer_(NULL),
     merge_buffer_(NULL),
     dips_to_device_scale_(1.0f),
     dips_to_view_scale_(1.0f),
     flush_pending_(false),
     is_initialized_(false),
     frame_received_(false),
     callback_factory_(this) {
-  InitiateDrawing();
 }
 
 PepperView::~PepperView() {
   // The producer should now return any pending buffers. At this point, however,
   // ReturnBuffer() tasks scheduled by the producer will not be delivered,
   // so we free all the buffers once the producer's queue is empty.
   base::WaitableEvent done_event(true, false);
   producer_->RequestReturnBuffers(
       base::Bind(&base::WaitableEvent::Signal, base::Unretained(&done_event)));
   done_event.Wait();
 
   merge_buffer_ = NULL;
   while (!buffers_.empty()) {
     FreeBuffer(buffers_.front());
   }
 }
 
+void PepperView::Initialize(FrameProducer* producer) {
+  producer_ = producer;
+  webrtc::DesktopFrame* buffer = AllocateBuffer();
+  while (buffer) {
+    producer_->DrawBuffer(buffer);
+    buffer = AllocateBuffer();
+  }
+}
+
 void PepperView::SetView(const pp::View& view) {
   bool view_changed = false;
 
   pp::Rect pp_size = view.GetRect();
   webrtc::DesktopSize new_dips_size(pp_size.width(), pp_size.height());
   float new_dips_to_device_scale = view.GetDeviceScale();
 
   if (!dips_size_.equals(new_dips_size) ||
       dips_to_device_scale_ != new_dips_to_device_scale) {
     view_changed = true;
@@ skipping 39 matching lines @@
     view_changed = true;
 
     // YUV to RGB conversion may require even X and Y coordinates for
     // the top left corner of the clipping area.
     clip_area_ = AlignRect(new_clip);
     clip_area_.IntersectWith(webrtc::DesktopRect::MakeSize(view_size_));
   }
 
   if (view_changed) {
     producer_->SetOutputSizeAndClip(view_size_, clip_area_);
-    InitiateDrawing();
+    Initialize(producer_);
   }
 }
 
 void PepperView::ApplyBuffer(const webrtc::DesktopSize& view_size,
                              const webrtc::DesktopRect& clip_area,
                              webrtc::DesktopFrame* buffer,
                              const webrtc::DesktopRegion& region) {
   DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 
   if (!frame_received_) {
     instance_->OnFirstFrameReceived();
     frame_received_ = true;
   }
   // We cannot use the data in the buffer if its dimensions don't match the
   // current view size.
   // TODO(alexeypa): We could rescale and draw it (or even draw it without
   // rescaling) to reduce the perceived lag while we are waiting for
   // the properly scaled data.
   if (!view_size_.equals(view_size)) {
     FreeBuffer(buffer);
-    InitiateDrawing();
+    Initialize(producer_);
   } else {
     FlushBuffer(clip_area, buffer, region);
   }
 }
 
 void PepperView::ReturnBuffer(webrtc::DesktopFrame* buffer) {
   DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 
   // Reuse the buffer if it is large enough, otherwise drop it on the floor
   // and allocate a new one.
   if (buffer->size().width() >= clip_area_.width() &&
       buffer->size().height() >= clip_area_.height()) {
     producer_->DrawBuffer(buffer);
   } else {
     FreeBuffer(buffer);
-    InitiateDrawing();
+    Initialize(producer_);
   }
 }
 
 void PepperView::SetSourceSize(const webrtc::DesktopSize& source_size,
                                const webrtc::DesktopVector& source_dpi) {
   DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 
   if (source_size_.equals(source_size) && source_dpi_.equals(source_dpi))
     return;
 
   source_size_ = source_size;
   source_dpi_ = source_dpi;
 
   // Notify JavaScript of the change in source size.
   instance_->SetDesktopSize(source_size, source_dpi);
 }
 
+FrameConsumer::PixelFormat PepperView::GetPixelFormat() {
+  return FORMAT_BGRA;
+}
+
 webrtc::DesktopFrame* PepperView::AllocateBuffer() {
   if (buffers_.size() >= kMaxPendingBuffersCount)
     return NULL;
 
   if (clip_area_.width()==0 || clip_area_.height()==0)
     return NULL;
 
   // Create an image buffer of the required size, but don't zero it.
   pp::ImageData buffer_data(instance_,
                     PP_IMAGEDATAFORMAT_BGRA_PREMUL,
@@ skipping 10 matching lines @@
   return buffer;
 }
 
 void PepperView::FreeBuffer(webrtc::DesktopFrame* buffer) {
   DCHECK(std::find(buffers_.begin(), buffers_.end(), buffer) != buffers_.end());
 
   buffers_.remove(buffer);
   delete buffer;
 }
 
-void PepperView::InitiateDrawing() {
-  webrtc::DesktopFrame* buffer = AllocateBuffer();
-  while (buffer) {
-    producer_->DrawBuffer(buffer);
-    buffer = AllocateBuffer();
-  }
-}
-
 void PepperView::FlushBuffer(const webrtc::DesktopRect& clip_area,
                              webrtc::DesktopFrame* buffer,
                              const webrtc::DesktopRegion& region) {
   // Defer drawing if the flush is already in progress.
   if (flush_pending_) {
     // |merge_buffer_| is guaranteed to be free here because we allocate only
     // two buffers simultaneously. If more buffers are allowed this code should
     // apply all pending changes to the screen.
     DCHECK(merge_buffer_ == NULL);
 
@@ skipping 65 matching lines @@
 
   // If there is a buffer queued for rendering then render it now.
   if (merge_buffer_ != NULL) {
     buffer = merge_buffer_;
     merge_buffer_ = NULL;
     FlushBuffer(merge_clip_area_, buffer, merge_region_);
   }
 }
 
 }  // namespace remoting