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

media/base/video_frame.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 MEDIA_BASE_VIDEO_FRAME_H_
 #define MEDIA_BASE_VIDEO_FRAME_H_
 
 #include "base/callback.h"
 #include "base/md5.h"
 #include "media/base/buffers.h"
@@ skipping 37 matching lines @@
       const gfx::Size& data_size,
       const gfx::Size& natural_size,
       base::TimeDelta timestamp);
 
   // Call prior to CreateFrame to ensure validity of frame configuration. Called
   // automatically by VideoDecoderConfig::IsValidConfig().
   // TODO(scherkus): VideoDecoderConfig shouldn't call this method
   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();
 
   // Allocates YV12 frame based on |width| and |height|, and sets its data to
   // the YUV equivalent of RGB(0,0,0).
   static scoped_refptr<VideoFrame> CreateBlackFrame(const gfx::Size& size);
 
   Format format() const { return format_; }
 
@@ skipping 64 matching lines @@
   // of the surface divided by the horizontal sampling period.  Note that
   // strides can be negative.
   int32 strides_[kMaxPlanes];
 
   // Array of data pointers to each plane.
   uint8* data_[kMaxPlanes];
 
   // 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_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoFrame);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_FRAME_H_