Cleanups in the video encoding decoding code. Reenable VP8.

remoting/client/rectangle_update_decoder.cc

 // Copyright (c) 2010 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/logging.h"
 #include "base/message_loop.h"
 #include "media/base/callback.h"
 #include "remoting/base/decoder.h"
 #include "remoting/base/decoder_row_based.h"
+#include "remoting/base/decoder_vp8.h"
 #include "remoting/base/tracer.h"
 #include "remoting/base/util.h"
 #include "remoting/client/frame_consumer.h"
 
 using media::AutoTaskRunner;
 
 namespace remoting {
 
 namespace {
 
@@ skipping 17 matching lines @@
 
 RectangleUpdateDecoder::RectangleUpdateDecoder(MessageLoop* message_loop,
                                                FrameConsumer* consumer)
     : message_loop_(message_loop),
       consumer_(consumer) {
 }
 
 RectangleUpdateDecoder::~RectangleUpdateDecoder() {
 }
 
-void RectangleUpdateDecoder::DecodePacket(const RectangleUpdatePacket& packet,
+void RectangleUpdateDecoder::DecodePacket(const VideoPacket& packet,
                                           Task* done) {
   if (message_loop_ != MessageLoop::current()) {
     message_loop_->PostTask(
         FROM_HERE,
         NewTracedMethod(this,
                         &RectangleUpdateDecoder::DecodePacket, packet,
                         done));
     return;
   }
   AutoTaskRunner done_runner(done);
 
   TraceContext::tracer()->PrintString("Decode Packet called.");
 
   if (!IsValidPacket(packet)) {
     LOG(ERROR) << "Received invalid packet.";
     return;
   }
 
   Task* process_packet_data =
       NewTracedMethod(this,
                       &RectangleUpdateDecoder::ProcessPacketData,
                       packet, done_runner.release());
 
-  if (packet.flags() | RectangleUpdatePacket::FIRST_PACKET) {
-    const RectangleFormat& format = packet.format();
+  if (packet.flags() | VideoPacket::FIRST_PACKET) {
+    const VideoPacketFormat& format = packet.format();
 
     InitializeDecoder(format, process_packet_data);
   } else {
     process_packet_data->Run();
     delete process_packet_data;
   }
 }
 
 void RectangleUpdateDecoder::ProcessPacketData(
-    const RectangleUpdatePacket& packet,
-    Task* done) {
+    const VideoPacket& packet, Task* done) {
   AutoTaskRunner done_runner(done);
 
   if (!decoder_->IsReadyForData()) {
     // TODO(ajwong): This whole thing should move into an invalid state.
     LOG(ERROR) << "Decoder is unable to process data. Dropping packet.";
     return;
   }
 
   TraceContext::tracer()->PrintString("Executing Decode.");
-  decoder_->DecodeBytes(packet.encoded_rect());
+  decoder_->DecodeBytes(packet.data());
 
-  if (packet.flags() | RectangleUpdatePacket::LAST_PACKET) {
+  if (packet.flags() | VideoPacket::LAST_PACKET) {
     decoder_->Reset();
 
     UpdatedRects* rects = new UpdatedRects();
 
     // Empty out the list of current updated rects so the decoder can keep
     // writing new ones while these are processed.
     rects->swap(updated_rects_);
 
     consumer_->OnPartialFrameOutput(frame_, rects,
                                     new PartialFrameCleanup(frame_, rects));
   }
 }
 
 // static
-bool RectangleUpdateDecoder::IsValidPacket(
-    const RectangleUpdatePacket& packet) {
+bool RectangleUpdateDecoder::IsValidPacket(const VideoPacket& packet) {
   if (!packet.IsInitialized()) {
     LOG(WARNING) << "Protobuf consistency checks fail.";
     return false;
   }
 
   // First packet must have a format.
-  if (packet.flags() | RectangleUpdatePacket::FIRST_PACKET) {
+  if (packet.flags() | VideoPacket::FIRST_PACKET) {
     if (!packet.has_format()) {
       LOG(WARNING) << "First packet must have format.";
       return false;
     }
 
     // TODO(ajwong): Verify that we don't need to whitelist encodings.
-    const RectangleFormat& format = packet.format();
+    const VideoPacketFormat& format = packet.format();
     if (!format.has_encoding() ||
-        format.encoding() == EncodingInvalid) {
+        format.encoding() == VideoPacketFormat::ENCODING_INVALID) {
       LOG(WARNING) << "Invalid encoding specified.";
       return false;
     }
   }
 
   // We shouldn't generate null packets.
-  if (!packet.has_encoded_rect()) {
-    LOG(WARNING) << "Packet w/o an encoded rectangle received.";
+  if (!packet.has_data()) {
+    LOG(WARNING) << "Packet w/o data received.";
     return false;
   }
 
   return true;
 }
 
-void RectangleUpdateDecoder::InitializeDecoder(const RectangleFormat& format,
+void RectangleUpdateDecoder::InitializeDecoder(const VideoPacketFormat& format,
                                                Task* done) {
   if (message_loop_ != MessageLoop::current()) {
     message_loop_->PostTask(
         FROM_HERE,
         NewTracedMethod(this,
                         &RectangleUpdateDecoder::InitializeDecoder,
                         format, done));
     return;
   }
   AutoTaskRunner done_runner(done);
@@ skipping 30 matching lines @@
     // stream that changes decoders. At the very leask, we should not
     // crash the process.
     //
     // For now though, assume that only one encoding is used throughout.
     //
     // Note, this may be as simple as just deleting the current decoder.
     // However, we need to verify the flushing semantics of the decoder first.
     CHECK(decoder_->Encoding() == format.encoding());
   } else {
     // Initialize a new decoder based on this message encoding.
-    if (format.encoding() == EncodingNone) {
+    if (format.encoding() == VideoPacketFormat::ENCODING_VERBATIM) {
       TraceContext::tracer()->PrintString("Creating Verbatim decoder.");
       decoder_.reset(DecoderRowBased::CreateVerbatimDecoder());
-    } else if (format.encoding() == EncodingZlib) {
+    } else if (format.encoding() == VideoPacketFormat::ENCODING_ZLIB) {
       TraceContext::tracer()->PrintString("Creating Zlib decoder");
       decoder_.reset(DecoderRowBased::CreateZlibDecoder());
+    } else if (format.encoding() == VideoPacketFormat::ENCODING_VP8) {
+      TraceContext::tracer()->PrintString("Creating VP8 decoder");
+      decoder_.reset(new DecoderVp8());
     } else {
       NOTREACHED() << "Invalid Encoding found: " << format.encoding();
     }
   }
 
   // TODO(ajwong): This can happen in the face of corrupt input data.  Figure
   // out the right behavior and make this more resilient.
   CHECK(updated_rects_.empty());
 
   gfx::Rect rectangle_size(format.x(), format.y(),
                            format.width(), format.height());
   updated_rects_.push_back(rectangle_size);
   decoder_->Initialize(frame_, rectangle_size,
                        GetBytesPerPixel(format.pixel_format()));
   TraceContext::tracer()->PrintString("Decoder is Initialized");
 }
 
 }  // namespace remoting