DDLTileHelper.h

Go to the documentation of this file.

/*
 * Copyright 2018 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
#ifndef DDLTileHelper_DEFINED
#define DDLTileHelper_DEFINED
 
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSpan.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/chromium/GrDeferredDisplayList.h"
#include "include/private/chromium/GrSurfaceCharacterization.h"
 
class DDLPromiseImageHelper;
class PromiseImageCallbackContext;
class SkCanvas;
class SkData;
class GrDeferredDisplayListRecorder;
class SkImage;
class SkPicture;
class SkSurface;
class GrSurfaceCharacterization;
class SkTaskGroup;
 
class DDLTileHelper {
public:
    // The TileData class encapsulates the information and behavior of a single tile when
    // rendering with DDLs.
    class TileData {
    public:
        TileData();
        ~TileData();
 
        bool initialized() const { return fID != -1; }
 
        void init(int id,
                  GrDirectContext*,
                  const GrSurfaceCharacterization& dstChar,
                  const SkIRect& clip,
                  const SkIRect& paddingOutsets);
 
        // Create the DDL for this tile (i.e., fill in 'fDisplayList').
        void createDDL(const SkPicture*);
 
        void dropDDL() { fDisplayList.reset(); }
 
        // Precompile all the programs required to draw this tile's DDL
        void precompile(GrDirectContext*);
 
        // Just draw the re-inflated per-tile SKP directly into this tile w/o going through a DDL
        // first. This is used for determining the overhead of using DDLs (i.e., it replaces
        // a 'createDDL' and 'draw' pair.
        void drawSKPDirectly(GrDirectContext*, const SkPicture*);
 
        // Replay the recorded DDL into the tile surface - filling in 'fBackendTexture'.
        void draw(GrDirectContext*);
 
        void reset();
 
        int id() const { return fID; }
        SkIRect clipRect() const { return fClip; }
        SkISize paddedRectSize() const {
            return { fClip.width() + fPaddingOutsets.fLeft + fPaddingOutsets.fRight,
                     fClip.height() + fPaddingOutsets.fTop + fPaddingOutsets.fBottom };
        }
        SkIVector padOffset() const { return { fPaddingOutsets.fLeft, fPaddingOutsets.fTop }; }
 
        GrDeferredDisplayList* ddl() { return fDisplayList.get(); }
 
        sk_sp<SkImage> makePromiseImageForDst(sk_sp<GrContextThreadSafeProxy>);
        void dropCallbackContext() { fCallbackContext.reset(); }
 
        static void CreateBackendTexture(GrDirectContext*, TileData*);
        static void DeleteBackendTexture(GrDirectContext*, TileData*);
 
    private:
        sk_sp<SkSurface> makeWrappedTileDest(GrRecordingContext* context);
 
        sk_sp<PromiseImageCallbackContext> refCallbackContext() { return fCallbackContext; }
 
        int                       fID = -1;
        SkIRect                   fClip;             // in the device space of the final SkSurface
        SkIRect                   fPaddingOutsets;   // random padding for the output surface
        GrSurfaceCharacterization fPlaybackChar;     // characterization for the tile's dst surface
 
        // The callback context holds (via its GrPromiseImageTexture) the backend texture
        // that is both wrapped in 'fTileSurface' and backs this tile's promise image
        // (i.e., the one returned by 'makePromiseImage').
        sk_sp<PromiseImageCallbackContext> fCallbackContext;
        // 'fTileSurface' wraps the backend texture in 'fCallbackContext' and must exist until
        // after 'fDisplayList' has been flushed (bc it owns the proxy the DDL's destination
        // trampoline points at).
        // TODO: fix the ref-order so we don't need 'fTileSurface' here
        sk_sp<SkSurface>              fTileSurface;
 
        sk_sp<GrDeferredDisplayList>  fDisplayList;
    };
 
    DDLTileHelper(GrDirectContext*,
                  const GrSurfaceCharacterization& dstChar,
                  const SkIRect& viewport,
                  int numXDivisions, int numYDivisions,
                  bool addRandomPaddingToDst);
 
    void kickOffThreadedWork(SkTaskGroup* recordingTaskGroup,
                             SkTaskGroup* gpuTaskGroup,
                             GrDirectContext*,
                             SkPicture*);
 
    void createDDLsInParallel(SkPicture*);
 
    // Create the DDL that will compose all the tile images into a final result.
    void createComposeDDL();
    const sk_sp<GrDeferredDisplayList>& composeDDL() const { return fComposeDDL; }
 
    // For each tile, create its DDL and then draw it - all on a single thread. This is to allow
    // comparison w/ just drawing the SKP directly (i.e., drawAllTilesDirectly). The
    // DDL creations and draws are interleaved to prevent starvation of the GPU.
    // Note: this is somewhat of a misuse/pessimistic-use of DDLs since they are supposed to
    // be created on a separate thread.
    void interleaveDDLCreationAndDraw(GrDirectContext*, SkPicture*);
 
    // This draws all the per-tile SKPs directly into all of the tiles w/o converting them to
    // DDLs first - all on a single thread.
    void drawAllTilesDirectly(GrDirectContext*, SkPicture*);
 
    void dropCallbackContexts();
    void resetAllTiles();
 
    int numTiles() const { return fNumXDivisions * fNumYDivisions; }
 
    void createBackendTextures(SkTaskGroup*, GrDirectContext*);
    void deleteBackendTextures(SkTaskGroup*, GrDirectContext*);
 
private:
    int                                    fNumXDivisions; // number of tiles horizontally
    int                                    fNumYDivisions; // number of tiles vertically
    skia_private::AutoTArray<TileData>   fTiles;        // 'fNumXDivisions' x
    // 'fNumYDivisions'
 
    sk_sp<GrDeferredDisplayList>           fComposeDDL;
 
    const GrSurfaceCharacterization        fDstCharacterization;
};
 
#endif