Add JPEG decoder for VAAPI JPEG decode acceleration

content/common/gpu/media/vaapi_wrapper.h

 // Copyright 2013 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.
 //
 // This file contains an implementation of VaapiWrapper, used by
 // VaapiVideoDecodeAccelerator and VaapiH264Decoder for decode,
 // and VaapiVideoEncodeAccelerator for encode, to interface
 // with libva (VA-API library for hardware video codec).
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_VAAPI_WRAPPER_H_
@@ skipping 27 matching lines @@
 // It is also responsible for managing and freeing VABuffers (not VASurfaces),
 // which are used to queue parameters and slice data to the HW codec,
 // as well as underlying memory for VASurfaces themselves.
 class CONTENT_EXPORT VaapiWrapper {
  public:
   enum CodecMode {
     kDecode,
     kEncode,
   };
 
+  // Create VaapiWrapper.
   // |report_error_to_uma_cb| will be called independently from reporting
   // errors to clients via method return values.
   static scoped_ptr<VaapiWrapper> Create(
       CodecMode mode,
+      VAProfile profile,
+      const base::Closure& report_error_to_uma_cb);
+
+  // Create VaapiWrapper for video codec. It maps VideoCodecProfile |profile|
+  // to VAProfile according to supported profiles.
+  // |report_error_to_uma_cb| will be called independently from reporting
+  // errors to clients via method return values.
+  static scoped_ptr<VaapiWrapper> CreateForVideoCodec(
+      CodecMode mode,
       media::VideoCodecProfile profile,
       const base::Closure& report_error_to_uma_cb);
 
   // Return the supported encode profiles.
   static std::vector<media::VideoCodecProfile> GetSupportedEncodeProfiles(
       const base::Closure& report_error_to_uma_cb);
 
   ~VaapiWrapper();
 
   // Create |num_surfaces| backing surfaces in driver for VASurfaces, each
@@ skipping 49 matching lines @@
   // Put data from |va_surface_id| into |x_pixmap| of size
   // |dest_size|, converting/scaling to it.
   bool PutSurfaceIntoPixmap(VASurfaceID va_surface_id,
                             Pixmap x_pixmap,
                             gfx::Size dest_size);
 #endif  // USE_X11
 
   // Returns true if the VAAPI version is less than the specified version.
   bool VAAPIVersionLessThan(int major, int minor);
 
-  // Get a VAImage from a VASurface and map it into memory. The VAImage should
-  // be released using the ReturnVaImage function. Returns true when successful.
-  // This is intended for testing only.
-  bool GetVaImageForTesting(VASurfaceID va_surface_id,
-                            VAImage* image,
-                            void** mem);
+  // Get a VAImage from a VASurface and map it into memory. The size and format
+  // are derived from the surface. The VAImage should be released using the
+  // ReturnVaImage function. Returns true when successful. This is intended
+  // for testing only.
+  bool GetDerivedVaImageForTesting(VASurfaceID va_surface_id,
+                                   VAImage* image,
+                                   void** mem);
+
+  // Get a VAImage from a VASurface |va_surface_id| and map it into memory with
+  // given |format| and |size|. The output is |image| and the mapped memory is
+  // |mem|. The VAImage should be released using the ReturnVaImage function.
+  // Returns true when successful.
+  bool GetVaImage(VASurfaceID va_surface_id,

[wuchengli, 2015/01/20 07:55:54]

GetDerivedVaImageForTesting, GetVaImage, and ReturnVaImage are used for testing
in this CL. All of them should have ForTesting suffix or all shouldn't. Please
choose one. If GetVaImage or ReturnVaImage are used by the jpeg accelerator in
the next CL, they should be renamed in the next CL.

[kcwu, 2015/01/21 12:23:48]

Done.

+                  VAImageFormat* format,
+                  const gfx::Size& size,
+                  VAImage* image,
+                  void** mem);
 
   // Release the VAImage (and the associated memory mapping) obtained from
-  // GetVaImage(). This is intended for testing only.
-  void ReturnVaImageForTesting(VAImage* image);
+  // GetVaImage().
+  void ReturnVaImage(VAImage* image);
 
   // Upload contents of |frame| into |va_surface_id| for encode.
   bool UploadVideoFrameToSurface(const scoped_refptr<media::VideoFrame>& frame,
                                  VASurfaceID va_surface_id);
 
   // Create a buffer of |size| bytes to be used as encode output.
   bool CreateCodedBuffer(size_t size, VABufferID* buffer_id);
 
   // Download the contents of the buffer with given |buffer_id| into a buffer of
   // size |target_size|, pointed to by |target_ptr|. The number of bytes
@@ skipping 15 matching lines @@
   // if needed.
   bool BlitSurface(VASurfaceID va_surface_id_src,
                    const gfx::Size& src_size,
                    VASurfaceID va_surface_id_dest,
                    const gfx::Size& dest_size);
 
  private:
   VaapiWrapper();
 
   bool Initialize(CodecMode mode,
-                  media::VideoCodecProfile profile,
+                  VAProfile va_profile,
                   const base::Closure& report_error__to_uma_cb);
   void Deinitialize();
   bool VaInitialize(const base::Closure& report_error_to_uma_cb);
   bool GetSupportedVaProfiles(std::vector<VAProfile>* profiles);
   bool IsEntrypointSupported(VAProfile va_profile, VAEntrypoint entrypoint);
   bool AreAttribsSupported(VAProfile va_profile,
                            VAEntrypoint entrypoint,
                            const std::vector<VAConfigAttrib>& required_attribs);
 
   // Destroys a |va_surface| created using CreateUnownedSurface.
@@ skipping 56 matching lines @@
   VAConfigID va_vpp_config_id_;
   VAContextID va_vpp_context_id_;
   VABufferID va_vpp_buffer_id_;
 
   DISALLOW_COPY_AND_ASSIGN(VaapiWrapper);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_VAAPI_WRAPPER_H_