Fix VideoDecoderVpx to use pixel format the consumer wants.

remoting/client/software_video_renderer.cc

 // Copyright 2014 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/software_video_renderer.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 13 matching lines @@
 #include "third_party/libyuv/include/libyuv/convert_argb.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 using remoting::protocol::ChannelConfig;
 using remoting::protocol::SessionConfig;
 
 namespace remoting {
 
 namespace {
 
-// This class wraps a VideoDecoder and byte-swaps the pixels for compatibility
-// with the android.graphics.Bitmap class.
-// TODO(lambroslambrou): Refactor so that the VideoDecoder produces data
-// in the right byte-order, instead of swapping it here.
-class RgbToBgrVideoDecoderFilter : public VideoDecoder {
- public:
-  RgbToBgrVideoDecoderFilter(std::unique_ptr<VideoDecoder> parent)
-      : parent_(std::move(parent)) {}
-
-  bool DecodePacket(const VideoPacket& packet,
-                    webrtc::DesktopFrame* frame) override {
-    if (!parent_->DecodePacket(packet, frame))
-      return false;
-    for (webrtc::DesktopRegion::Iterator i(frame->updated_region());
-         !i.IsAtEnd(); i.Advance()) {
-      webrtc::DesktopRect rect = i.rect();
-      uint8_t* pixels = frame->data() + (rect.top() * frame->stride()) +
-                        (rect.left() * webrtc::DesktopFrame::kBytesPerPixel);
-      libyuv::ABGRToARGB(pixels, frame->stride(), pixels, frame->stride(),
-                         rect.width(), rect.height());
-    }
-
-    return true;
-  }
-
- private:
-  std::unique_ptr<VideoDecoder> parent_;
-};
-
 std::unique_ptr<webrtc::DesktopFrame> DoDecodeFrame(
     VideoDecoder* decoder,
     std::unique_ptr<VideoPacket> packet,
     std::unique_ptr<webrtc::DesktopFrame> frame) {
   if (!decoder->DecodePacket(*packet, frame.get()))
     frame.reset();
   return frame;
 }
 
 }  // namespace
@@ skipping 21 matching lines @@
   if (codec == ChannelConfig::CODEC_VERBATIM) {
     decoder_.reset(new VideoDecoderVerbatim());
   } else if (codec == ChannelConfig::CODEC_VP8) {
     decoder_ = VideoDecoderVpx::CreateForVP8();
   } else if (codec == ChannelConfig::CODEC_VP9) {
     decoder_ = VideoDecoderVpx::CreateForVP9();
   } else {
     NOTREACHED() << "Invalid Encoding found: " << codec;
   }
 
-  if (consumer_->GetPixelFormat() == protocol::FrameConsumer::FORMAT_RGBA) {
-    decoder_ =
-        base::WrapUnique(new RgbToBgrVideoDecoderFilter(std::move(decoder_)));
-  }
+  decoder_->SetPixelFormat(
+      (consumer_->GetPixelFormat() == protocol::FrameConsumer::FORMAT_BGRA)
+          ? VideoDecoder::PixelFormat::BGRA
+          : VideoDecoder::PixelFormat::RGBA);
 }
 
 protocol::VideoStub* SoftwareVideoRenderer::GetVideoStub() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return this;
 }
 
 protocol::FrameConsumer* SoftwareVideoRenderer::GetFrameConsumer() {
   return consumer_;
 }
@@ skipping 71 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (perf_tracker_)
     perf_tracker_->OnFramePainted(frame_id);
 
   if (!done.is_null())
     done.Run();
 }
 
 }  // namespace remoting