1/*
2 * Copyright 2021 Google LLC
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "src/gpu/GrWritePixelsRenderTask.h"
9
10#include "src/gpu/GrGpu.h"
11#include "src/gpu/GrOpFlushState.h"
12#include "src/gpu/GrResourceAllocator.h"
13
14sk_sp<GrRenderTask> GrWritePixelsTask::Make(GrDrawingManager* dm,
15                                            sk_sp<GrSurfaceProxy> dst,
16                                            SkIRect rect,
17                                            GrColorType srcColorType,
18                                            GrColorType dstColorType,
19                                            const GrMipLevel texels[],
20                                            int levelCount) {
21    return sk_sp<GrRenderTask>(new GrWritePixelsTask(dm,
22                                                     std::move(dst),
23                                                     rect,
24                                                     srcColorType,
25                                                     dstColorType,
26                                                     texels,
27                                                     levelCount));
28}
29
30GrWritePixelsTask::GrWritePixelsTask(GrDrawingManager* dm,
31                                     sk_sp<GrSurfaceProxy> dst,
32                                     SkIRect rect,
33                                     GrColorType srcColorType,
34                                     GrColorType dstColorType,
35                                     const GrMipLevel texels[],
36                                     int levelCount)
37        : fRect(rect)
38        , fSrcColorType(srcColorType)
39        , fDstColorType(dstColorType) {
40    this->addTarget(dm, std::move(dst));
41    fLevels.reset(levelCount);
42    std::copy_n(texels, levelCount, fLevels.get());
43}
44
45void GrWritePixelsTask::gatherProxyIntervals(GrResourceAllocator* alloc) const {
46    alloc->addInterval(this->target(0), alloc->curOp(), alloc->curOp(),
47                       GrResourceAllocator::ActualUse::kYes);
48    alloc->incOps();
49}
50
51GrRenderTask::ExpectedOutcome GrWritePixelsTask::onMakeClosed(GrRecordingContext*,
52                                                              SkIRect* targetUpdateBounds) {
53    *targetUpdateBounds = fRect;
54    return ExpectedOutcome::kTargetDirty;
55}
56
57bool GrWritePixelsTask::onExecute(GrOpFlushState* flushState) {
58    GrSurfaceProxy* dstProxy = this->target(0);
59    if (!dstProxy->isInstantiated()) {
60        return false;
61    }
62    GrSurface* dstSurface = dstProxy->peekSurface();
63    return flushState->gpu()->writePixels(dstSurface,
64                                          fRect,
65                                          fDstColorType,
66                                          fSrcColorType,
67                                          fLevels.get(),
68                                          fLevels.count());
69}
70