Improving the decoder pipeline.

remoting/client/frame_consumer.h

 // 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.
 
 #ifndef REMOTING_CLIENT_FRAME_CONSUMER_H_
 #define REMOTING_CLIENT_FRAME_CONSUMER_H_
 
-#include "remoting/base/decoder.h"  // For UpdatedRects
+#include "base/callback_forward.h"
+#include "base/memory/scoped_ptr.h"
+#include "third_party/skia/include/core/SkRect.h"
+#include "third_party/skia/include/core/SkRegion.h"
+#include "third_party/skia/include/core/SkSize.h"
+
+namespace pp {
+class ImageData;
+} // namespace pp
 
 namespace remoting {
 
 class FrameConsumer {
  public:
   FrameConsumer() {}
   virtual ~FrameConsumer() {}
 
-  // Request a frame be allocated from the FrameConsumer.
-  //
-  // If a frame cannot be allocated to fit the format, and |size|
-  // requirements, |frame_out| will be set to NULL.
-  //
-  // An allocated frame will have at least the |size| requested, but
-  // may be bigger. Query the retrun frame for the actual frame size,
-  // stride, etc.
-  //
-  // The AllocateFrame call is asynchronous.  From invocation, until when the
-  // |done| callback is invoked, |frame_out| should be considered to be locked
-  // by the FrameConsumer, must remain a valid pointer, and should not be
-  // examined or modified.  After |done| is called, the |frame_out| will
-  // contain a result of the allocation. If a frame could not be allocated,
-  // |frame_out| will be NULL.
-  //
-  // All frames retrieved via the AllocateFrame call must be released by a
-  // corresponding call ReleaseFrame(scoped_refptr<VideoFrame>* frame_out.
-  virtual void AllocateFrame(media::VideoFrame::Format format,
-                             const SkISize& size,
-                             scoped_refptr<media::VideoFrame>* frame_out,
-                             const base::Closure& done) = 0;
+  // OnFrameReady() is called every time at least one rectangle of
+  // output is produced. The routine captures the view parameters and
+  // the backing store where the updated pixels should be written to.

[Wez, 2012/02/07 01:56:31]

Not sure what it means for it to "capture" them?

[Wez, 2012/02/07 01:56:31]

It looks like OnFrameReady() is used to indicate that there is data ready to
render, and it asynchronously determines the current clip area, view dimensions
and backing-store and returns them.  Won't that introduce extra latency in the
common case where none of those properties are changing?

[alexeypa (please no reviews), 2012/02/15 23:06:22]

This interface was completely changed. So this comment and the comments below
are not not relevant.

+  virtual void OnFrameReady(const SkISize& screen_size,
+                            SkISize* view_size_out,
+                            SkIRect* clip_area_out,
+                            scoped_ptr<pp::ImageData>* backing_store_out,

[Wez, 2012/02/07 01:56:31]

Rather than having out-parameters, define a frame-ready callback to replace
|done|.

+                            const base::Closure& done) = 0;
 
-  virtual void ReleaseFrame(media::VideoFrame* frame) = 0;
-
-  // OnPartialFrameOutput() is called every time at least one rectangle of
-  // output is produced.  The |frame| is guaranteed to have valid data for all
-  // of |region|.
-  //
-  // Both |frame| and |region| are guaranteed to be valid until the |done|
-  // callback is invoked.
-  virtual void OnPartialFrameOutput(media::VideoFrame* frame,
-                                    SkRegion* region,
-                                    const base::Closure& done) = 0;
+  // OnPaintDone is called when painting has been done and the backing
+  // store should be flushed to the screen.
+  virtual void OnPaintDone(scoped_ptr<pp::ImageData> backing_store,
+                           scoped_ptr<SkRegion> updated_region) = 0;

[Wez, 2012/02/07 01:56:31]

No completion indicator?  How do we rate-limit to match the system's rendering
throughput?

 
  private:
   DISALLOW_COPY_AND_ASSIGN(FrameConsumer);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_CLIENT_FRAME_CONSUMER_H_