tools/SkSharingProc.h

/*
 * Copyright 2019 Google LLC
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef SkSharingProc_DEFINED
#define SkSharingProc_DEFINED

#include <unordered_map>
#include <vector>

#include "include/core/SkData.h"
#include "include/core/SkImage.h"
#include "include/core/SkSerialProcs.h"
#include "src/core/SkTHash.h"

namespace skgpu::graphite {
class Context;
}

/**
 * This serial proc serializes each image it encounters only once, using their uniqueId as the
 * property for sameness.
 *
 * It's most basic usage involves setting your imageProc to SkSharingContext::serializeImage
 * and creating an SkSharingSerialContext in an appropriate scope to outlive all the images that
 * will be encountered before serialization.
 *
 * Optionally, collectNonTextureImagesFromPicture can be called with an SkSharingContext and an
 * SkPicture that may reference not-yet-released texture backed images. It will make non-texture
 * copies if necessary and store them in the context. If present, they will be used in the
 * final serialization.
 *
 * This is intended to be used on Android with MultiPictureDocument's onEndPage parameter, in a
 * lambda that captures the context, because MPD cannot make assumptions about the type of proc it
 * receives and clients (Chrome) build MPD without this source file.
 */

struct SkSharingSerialContext {
    // --- Data and and function for optional texture collection pass --- //

    // A map from uniqueID of images referenced by commands to non-texture images
    // collected at the end of each frame.
    skia_private::THashMap<uint32_t, sk_sp<SkImage>> fNonTexMap;
    GrDirectContext* fDirectContext = nullptr;
    skgpu::graphite::Context* fGraphiteContext = nullptr;

    // Collects any non-texture images referenced by the picture and stores non-texture copies
    // in the fNonTexMap of the provided SkSharingContext
    static void collectNonTextureImagesFromPicture(const SkPicture*, SkSharingSerialContext* ctx);

    void setDirectContext(GrDirectContext* ctx);
    void setGraphiteContext(skgpu::graphite::Context* ctx);

    // --- Data and serialization function for regular use --- //

    // A map from the ids from SkImage::uniqueID() to ids used within the file
    // The keys are ids of original images, not of non-texture copies
    skia_private::THashMap<uint32_t, int> fImageMap;
};

struct SkSharingDeserialContext {
    // a list of unique images in the order they were encountered in the file
    // Subsequent occurrences of an image refer to it by its index in this list.
    std::vector<sk_sp<SkImage>> fImages;
};

namespace SkSharingContext {
// A serial proc that shares images between subpictures
// To use this, create an instance of SkSerialProcs and populate it this way.
// The client must retain ownership of the context.
// auto ctx = std::make_unique<SkSharingSerialContext>()
// SkSerialProcs procs;
// procs.fImageProc = SkSharingContext::serializeImage;
// procs.fImageCtx = ctx.get();
SkSerialReturnType serializeImage(SkImage* img, void* ctx);

// A deserial proc that can interpret ids in place of images as references to previous images.
// Can also deserialize a SKP where all images are inlined (it's backwards compatible)
sk_sp<SkImage> deserializeImage(sk_sp<SkData>, std::optional<SkAlphaType>, void* ctx);
}  // namespace SkSharingContext

#endif