Support reading pixels from HW-decoded video textures into canvas/webgl.

media/base/video_frame.h

Index: media/base/video_frame.h
diff --git a/media/base/video_frame.h b/media/base/video_frame.h
index c40cb239ed4d331d3d1d2f2702c20cdd1b17502d..f34630fa1ff5f0e3cb6b4cdf3c3ab65bd970774e 100644
--- a/media/base/video_frame.h
+++ b/media/base/video_frame.h
@@ -55,19 +55,30 @@ class MEDIA_EXPORT VideoFrame : public base::RefCountedThreadSafe<VideoFrame> {
   static bool IsValidConfig(Format format, const gfx::Size& data_size,
                             const gfx::Size& natural_size);
 
+  // CB to write pixels from the texture backing this frame into the
+  // |void*| parameter.
+  typedef base::Callback<void(void*)> ReadPixelsCB;
+
   // Wraps a native texture of the given parameters with a VideoFrame.  When the
   // frame is destroyed |no_longer_needed.Run()| will be called.
   // |data_size| is the width and height of the frame data in pixels.
   // |natural_size| is the width and height of the frame when the frame's aspect
   // ratio is applied to |size|.
+  // |read_pixels_cb| may be used to do (slow!) readbacks from the
+  // texture to main memory.
   static scoped_refptr<VideoFrame> WrapNativeTexture(
       uint32 texture_id,
       uint32 texture_target,
       const gfx::Size& data_size,
       const gfx::Size& natural_size,
       base::TimeDelta timestamp,
+      const ReadPixelsCB& read_pixels_cb,
       const base::Closure& no_longer_needed);
 
+  // Read pixels from the native texture backing |*this| and write
+  // them to |*pixels|.

[Ken Russell (switch to Gerrit), 2012/10/01 17:56:16]

Document the format of the pixels (i.e., RGBA, in that order, rows tightly
packed). May be worth having caller pass in the size of the storage and
returning false if it isn't large enough.

[scherkus (not reviewing), 2012/10/01 18:15:04]

+1,000,000

I don't know if our hardware decode path supports frame size changes, but it
seems that we could make a contract about |pixels| pointing to memory that
matches the dimensions of the video frame

For example, in SkCVR we adjust our allocation of |bitmap| in case dimensions
have changed.

[Ami GONE FROM CHROMIUM, 2012/10/01 18:16:12]

Done.
I don't think that's worthwhile, since the number of ways this can go wrong is
so large.

[Ami GONE FROM CHROMIUM, 2012/10/01 18:40:26]

It does not.
At some point you have to hand the pointer to GL, and at that point you'd better
have not made a mistake in sizing its allocation.

Since there is a multitude of layers between the allocating code and the using
code, I see two options:
1) Pass the size data alongside the pointer everywhere it goes and DCHECK at
every layer.
2) Have *none* of the intermediate layers worry about the size, since they can't
do anything about it.
Perhaps your +1e6 of worry is allayed by the knowledge that we malloc the pixels
for every frame?

(basically, VideoFrame is the only piece that knows the correct sizing for
pixels; none of the other layers can assert anything else)

[scherkus (not reviewing), 2012/10/01 18:52:06]

Where "we" == SkCVR?

So the best practice for using this function is documented as code in SkCVR as
opposed to here?

I'm not advocating plumbing but a mention of, say, assumptions on dimensions
might be nice.

[Ami GONE FROM CHROMIUM, 2012/10/01 19:26:39]

OIC; done.

+  void ReadPixelsFromNativeTexture(void* pixels);
+
   // Creates a frame with format equals to VideoFrame::EMPTY, width, height,
   // and timestamp are all 0.
   static scoped_refptr<VideoFrame> CreateEmptyFrame();
@@ -152,6 +163,7 @@ class MEDIA_EXPORT VideoFrame : public base::RefCountedThreadSafe<VideoFrame> {
   // Native texture ID, if this is a NATIVE_TEXTURE frame.
   uint32 texture_id_;
   uint32 texture_target_;
+  ReadPixelsCB read_pixels_cb_;
   base::Closure texture_no_longer_needed_;
 
   base::TimeDelta timestamp_;