Home | History | Annotate | Download | only in media 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 //
      5 // This file contains the definition of VASurface class, used for decoding by
      6 // VaapiVideoDecodeAccelerator and VaapiH264Decoder.
      7 
      8 #ifndef CONTENT_COMMON_GPU_MEDIA_VA_SURFACE_H_
      9 #define CONTENT_COMMON_GPU_MEDIA_VA_SURFACE_H_
     10 
     11 #include "third_party/libva/va/va.h"
     12 
     13 namespace content {
     14 
     15 // A VA-API-specific decode surface used by VaapiH264Decoder to decode into
     16 // and use as reference for decoding other surfaces. It is also handed by the
     17 // decoder to VaapiVideoDecodeAccelerator when the contents of the surface are
     18 // ready and should be displayed. VAVDA converts the surface contents into an
     19 // X Pixmap bound to a texture for display and releases its reference to it.
     20 // Decoder releases its references to the surface when it's done decoding and
     21 // using it as reference. Note that a surface may still be used for reference
     22 // after it's been sent to output and also after it is no longer used by VAVDA.
     23 // Thus, the surface can be in use by both VAVDA and the Decoder at the same
     24 // time, or by either of them, with the restriction that VAVDA will never get
     25 // the surface until the contents are ready, and it is guaranteed that the
     26 // contents will not change after that.
     27 // When both the decoder and VAVDA release their references to the surface,
     28 // it is freed and the release callback is executed to put the surface back
     29 // into available surfaces pool, which is managed externally.
     30 //
     31 //   VASurfaceID is allocated in VaapiWrapper.
     32 //        |
     33 // +----->|
     34 // |      v
     35 // | VASurfaceID is put onto VaapiVideoDecodeAccelerator::available_va_surfaces_
     36 // |      |      list.
     37 // |      v
     38 // | VASurfaceID is taken off of the VVDA:available_va_surfaces_ when
     39 // |      |      VaapiH264Decoder requests more output surfaces, is wrapped into
     40 // |      |      a VASurface and passed to VaapiH264Decoder.
     41 // |      v
     42 // | VASurface is put onto VaapiH264Decoder::available_va_surfaces_, keeping
     43 // |      |      the only reference to it until it's needed for decoding.
     44 // |      v
     45 // | VaapiH264Decoder starts decoding a new frame. It takes a VASurface off of
     46 // |      |      VHD::available_va_surfaces_ and assigns it to a DecodeSurface,
     47 // |      |      which now keeps the only reference.
     48 // |      v
     49 // | DecodeSurface is used for decoding, putting data into associated VASurface.
     50 // |      |
     51 // |      |--------------------------------------------------+
     52 // |      |                                                  |
     53 // |      v                                                  v
     54 // | DecodeSurface is to be output.              VaapiH264Decoder uses the
     55 // | VaapiH264Decoder passes the associated      DecodeSurface and associated
     56 // | VASurface to VaapiVideoDecodeAccelerator,   VASurface as reference for
     57 // | which stores it (taking a ref) on           decoding more frames.
     58 // | pending_output_cbs_ queue until an output               |
     59 // | TFPPicture becomes available.                           v
     60 // |                 |                           Once the DecodeSurface is not
     61 // |                 |                           needed as reference anymore,
     62 // |                 v                           it is released, releasing the
     63 // | A TFPPicture becomes available after        associated VASurface reference.
     64 // | the client of VVDA returns                              |
     65 // | a PictureBuffer associated with it. VVDA                |
     66 // | puts the contents of the VASurface into                 |
     67 // | it and releases the reference to VASurface.             |
     68 // |                 |                                       |
     69 // |                 '---------------------------------------'
     70 // |                                     |
     71 // |                                     v
     72 // | Neither VVDA nor VHD hold a reference to VASurface. VASurface is released,
     73 // | ReleaseCB gets called in its destructor, which puts the associated
     74 // | VASurfaceID back onto VVDA::available_va_surfaces_.
     75 // |                                     |
     76 // '-------------------------------------|
     77 //                                       |
     78 //                                       v
     79 //                       VaapiWrapper frees VASurfaceID.
     80 //
     81 class CONTENT_EXPORT VASurface : public base::RefCountedThreadSafe<VASurface> {
     82  public:
     83   // Provided by user, will be called when all references to the surface
     84   // are released.
     85   typedef base::Callback<void(VASurfaceID)> ReleaseCB;
     86 
     87   VASurface(VASurfaceID va_surface_id, const ReleaseCB& release_cb);
     88 
     89   VASurfaceID id() {
     90     return va_surface_id_;
     91   }
     92 
     93  private:
     94   friend class base::RefCountedThreadSafe<VASurface>;
     95   ~VASurface();
     96 
     97   const VASurfaceID va_surface_id_;
     98   ReleaseCB release_cb_;
     99 
    100   DISALLOW_COPY_AND_ASSIGN(VASurface);
    101 };
    102 
    103 }  // namespace content
    104 
    105 #endif  // CONTENT_COMMON_GPU_MEDIA_VA_SURFACE_H_
    106