Update VideoDecode PPAPI structs to be consistent with media structures, part 1

media/video/video_decode_accelerator.h

 // Copyright (c) 2011 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_VIDEO_VIDEO_DECODE_ACCELERATOR_H_
 #define MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 229 matching lines @@
     VIDEODECODERERROR_UNINITIALIZED,
     VIDEODECODERERROR_UNSUPPORTED,
     VIDEODECODERERROR_INVALIDINPUT,
     VIDEODECODERERROR_MEMFAILURE,
     VIDEODECODERERROR_INSUFFICIENT_BUFFERS,
     VIDEODECODERERROR_INSUFFICIENT_RESOURCES,
     VIDEODECODERERROR_HARDWARE,
     VIDEODECODERERROR_UNEXPECTED_FLUSH,
   };
 
   // Interface expected from PictureBuffers where pictures are stored.

[Ami GONE FROM CHROMIUM, 2011/04/29 18:40:34]

Yay!

   class PictureBuffer {
    public:
     enum MemoryType {
       PICTUREBUFFER_MEMORYTYPE_NONE = 0,
       PICTUREBUFFER_MEMORYTYPE_SYSTEM,
       PICTUREBUFFER_MEMORYTYPE_GL_TEXTURE,
     };
     // Union to represent one data plane in picture buffer.
     union DataPlaneHandle {
       struct {
         uint32 context_id;  // GLES context id.
         uint32 texture_id;  // GLES texture id.
-      };
+      } gles2_texture;
       void* sysmem;  // Simply a pointer to system memory.
     };
 
     virtual ~PictureBuffer();
     virtual int32 GetId() = 0;
     virtual gfx::Size GetSize() = 0;
-    virtual const std::vector<uint32>& GetColorFormat() = 0;
     virtual MemoryType GetMemoryType() = 0;
     virtual std::vector<DataPlaneHandle>& GetPlaneHandles() = 0;
   };
 
   class Picture {
    public:
     virtual ~Picture();
 
     // Picture size related functions.
     // There are three types of logical picture sizes that applications using
@@ skipping 14 matching lines @@
     // redundant data left on the sides of the output picture, which are not
     // intended for display. For example, this happens to video of size 854x480
     // and H.264 codec. Since the width (854 pixels) is not multiple of the
     // block size of the coding format (16 pixels), pixel columns 854-863
     // contain garbage data which is notintended for display.
     //
     // Plugin is providing the buffers for output decoding and it should know
     // the picture buffer size it has provided to the decoder. Thus, there is
     // no function to query the buffer size from this class.
 
-    // Returns the picture buffer where this picture is contained.
-    virtual PictureBuffer* picture_buffer() = 0;
+    // Returns the id of the picture buffer where this picture is contained.
+    virtual int32 GetId() = 0;
 
     // Returns the decoded size of the decoded picture in pixels.
     virtual gfx::Size GetDecodedSize() const = 0;
 
     // Returns the visible size of the decoded picture in pixels.
     virtual gfx::Size GetVisibleSize() const = 0;
 
     // Returns metadata associated with the picture.
     virtual void* GetUserHandle() = 0;
   };
 
   // Interface for collaborating with picture interface to provide memory for
   // output picture and blitting them.
   class Client {
    public:
     virtual ~Client() {}
 
     // Callback to tell the information needed by the client to provide decoding
     // buffer to the decoder.
     virtual void ProvidePictureBuffers(
         uint32 requested_num_of_buffers,
         const std::vector<uint32>& buffer_properties) = 0;
 
     // Callback to dismiss picture buffer that was assigned earlier.
-    virtual void DismissPictureBuffer(PictureBuffer* picture_buffer) = 0;
+    virtual void DismissPictureBuffer(int32 picture_buffer_id) = 0;
 
     // Callback to deliver decoded pictures ready to be displayed.
-    virtual void PictureReady(Picture* picture) = 0;
+    virtual void PictureReady(Picture& picture) = 0;

[scherkus (not reviewing), 2011/04/26 22:36:34]

why ref versus pointer?

if ref we usually go with a const-ref if possible

[vrk (LEFT CHROMIUM), 2011/04/27 00:40:33]

I believe the only reason the parameter is a pointer is to avoid the copy of the
struct, so I changed it to a ref.
Yeah this can be a const-ref ptr. Changed!

 
     // Callback to notify that decoder has decoded end of stream marker and has
     // outputted all displayable pictures.
     virtual void NotifyEndOfStream() = 0;
 
     // Callback to notify about decoding errors.
     virtual void NotifyError(Error error) = 0;
   };
 
   // Video decoder functions.
@@ skipping 35 matching lines @@
   // Parameters:
   //  |picture_buffers| contains the allocated picture buffers for the output.
   virtual void AssignPictureBuffer(
       std::vector<PictureBuffer*> picture_buffers) = 0;
 
   // Sends picture buffers to be reused by the decoder. This needs to be called
   // for each buffer that has been processed so that decoder may know onto which
   // picture buffers it can write the output to.
   //
   // Parameters:
-  //  |picture_buffer| points to the picture buffer that is to be reused.
-  virtual void ReusePictureBuffer(PictureBuffer* picture_buffer) = 0;
+  //  |picture_buffer_id| id of the picture buffer that is to be reused.
+  virtual void ReusePictureBuffer(uint32 picture_buffer_id) = 0;
 
   // Flushes the decoder. Flushing will result in output of the
   // pictures and buffers held inside the decoder and returning of bitstream
   // buffers using the callbacks implemented by the plug-in. Once done with
   // flushing, the decode will call the |callback|.
   //
   // Parameters:
   //  |callback| contains the callback function pointer.
   //
   // Returns true when command successfully accepted. Otherwise false.
   virtual bool Flush(VideoDecodeAcceleratorCallback* callback) = 0;
 
   // Aborts the decoder. Decode will abort the decoding as soon as possible and
   // will not output anything. |callback| will be called as soon as abort has
   // been finished. After abort all buffers can be considered dismissed, even
   // when there has not been callbacks to dismiss them.
   //
   // Parameters:
   //  |callback| contains the callback function pointer.
   //
   // Returns true when command successfully accepted. Otherwise false.
   virtual bool Abort(VideoDecodeAcceleratorCallback* callback) = 0;
 };
 
 }  // namespace media
 
 #endif  // MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_