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

remoting/client/rectangle_update_decoder.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/rectangle_update_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "remoting/base/util.h"
 #include "remoting/codec/video_decoder.h"
 #include "remoting/codec/video_decoder_verbatim.h"
 #include "remoting/codec/video_decoder_vp8.h"
 #include "remoting/client/frame_consumer.h"
 #include "remoting/protocol/session_config.h"
+#include "third_party/libyuv/include/libyuv/convert_argb.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 using base::Passed;
 using remoting::protocol::ChannelConfig;
 using remoting::protocol::SessionConfig;
 
 namespace remoting {
 
+class RgbToBgrVideoDecoderFilter : public VideoDecoder {
+ public:
+  RgbToBgrVideoDecoderFilter(scoped_ptr<VideoDecoder> parent)
+      : parent_(parent.Pass()) {
+  }
+
+  virtual void Initialize(const webrtc::DesktopSize& screen_size) OVERRIDE {
+    parent_->Initialize(screen_size);
+  }
+
+  virtual bool DecodePacket(const VideoPacket& packet) OVERRIDE {
+    return parent_->DecodePacket(packet);
+  }
+
+  virtual void Invalidate(const webrtc::DesktopSize& view_size,
+                          const webrtc::DesktopRegion& region) OVERRIDE {
+    return parent_->Invalidate(view_size, region);
+  }
+
+  virtual void RenderFrame(const webrtc::DesktopSize& view_size,
+                           const webrtc::DesktopRect& clip_area,
+                           uint8* image_buffer,
+                           int image_stride,
+                           webrtc::DesktopRegion* output_region) OVERRIDE {
+    parent_->RenderFrame(view_size, clip_area, image_buffer, image_stride,
+                         output_region);
+
+    // Byte-swap the pixels for compatibility with the android.graphics.Bitmap
+    // class.

[Sergey Ulanov, 2013/09/28 00:33:32]

nit: Don't need this comment here. it might be better to a comment for the whole
class.

[Lambros, 2013/09/28 00:51:11]

Done.

+    // TODO(lambroslambrou): Refactor so that the VideoDecoder produces data

[Sergey Ulanov, 2013/09/28 00:33:32]

Move this TODO above the class definition - we won't need this class when the
TODO is addressed.

[Lambros, 2013/09/28 00:51:11]

Done.

+    // in the right byte-order, instead of swapping it here.
+    for (webrtc::DesktopRegion::Iterator i(*output_region); !i.IsAtEnd();
+         i.Advance()) {
+      webrtc::DesktopRect rect = i.rect();
+      uint8* pixels = image_buffer + (rect.top() * image_stride) +
+        (rect.left() * kBytesPerPixel);
+      libyuv::ABGRToARGB(pixels, image_stride, pixels, image_stride,
+                         rect.width(), rect.height());
+    }
+  }
+
+  virtual const webrtc::DesktopRegion* GetImageShape() OVERRIDE {
+    return parent_->GetImageShape();
+  }
+
+ private:
+  scoped_ptr<VideoDecoder> parent_;
+};
+
 RectangleUpdateDecoder::RectangleUpdateDecoder(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
     scoped_refptr<FrameConsumerProxy> consumer)
     : main_task_runner_(main_task_runner),
       decode_task_runner_(decode_task_runner),
       consumer_(consumer),
       paint_scheduled_(false),
       latest_sequence_number_(0) {
 }
 
 RectangleUpdateDecoder::~RectangleUpdateDecoder() {
 }
 
 void RectangleUpdateDecoder::Initialize(const SessionConfig& config) {
+  if (!decode_task_runner_->BelongsToCurrentThread()) {
+    decode_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&RectangleUpdateDecoder::Initialize, this,
+                              config));
+    return;
+  }
+
   // Initialize decoder based on the selected codec.
   ChannelConfig::Codec codec = config.video_config().codec;
   if (codec == ChannelConfig::CODEC_VERBATIM) {
     decoder_.reset(new VideoDecoderVerbatim());
   } else if (codec == ChannelConfig::CODEC_VP8) {
     decoder_.reset(new VideoDecoderVp8());
   } else {
     NOTREACHED() << "Invalid Encoding found: " << codec;
   }
+
+  if (consumer_->GetPixelFormat() == FrameConsumer::FORMAT_RGBA) {
+    scoped_ptr<VideoDecoder> wrapper(
+        new RgbToBgrVideoDecoderFilter(decoder_.Pass()));
+    decoder_ = wrapper.Pass();
+  }
 }
 
 void RectangleUpdateDecoder::DecodePacket(scoped_ptr<VideoPacket> packet,
                                           const base::Closure& done) {
   DCHECK(decode_task_runner_->BelongsToCurrentThread());
 
   base::ScopedClosureRunner done_runner(done);
 
   bool decoder_needs_reset = false;
   bool notify_size_or_dpi_change = false;
@@ skipping 214 matching lines @@
 
   done.Run();
 }
 
 ChromotingStats* RectangleUpdateDecoder::GetStats() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   return &stats_;
 }
 
 }  // namespace remoting