chromium/third_party/skia/src/image/SkSurface.cpp

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

#include "include/core/SkSurface.h"

#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkCapabilities.h" // IWYU pragma: keep
#include "include/core/SkColorSpace.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkSize.h"
#include "include/core/SkSurfaceProps.h"
#include "include/private/base/SkTemplates.h"
#include "src/core/SkImageInfoPriv.h"
#include "src/core/SkSurfacePriv.h"
#include "src/image/SkSurface_Base.h"

#include <cstddef>
#include <cstdint>
#include <utility>

class GrBackendSemaphore;
class GrRecordingContext;  // IWYU pragma: keep
class SkPaint;
class GrSurfaceCharacterization;
namespace skgpu { namespace graphite { class Recorder; } }

SkSurfaceProps::SkSurfaceProps()
    : … { … }

SkSurfaceProps::SkSurfaceProps(uint32_t flags, SkPixelGeometry pg)
    : … { … }

SkSurfaceProps::SkSurfaceProps(uint32_t flags,
                               SkPixelGeometry pg,
                               SkScalar textContrast,
                               SkScalar textGamma)
    : … { … }

SkSurface::SkSurface(int width, int height, const SkSurfaceProps* props)
    : … { … }

SkSurface::SkSurface(const SkImageInfo& info, const SkSurfaceProps* props)
    : … { … }

uint32_t SkSurface::generationID() { … }

void SkSurface::notifyContentWillChange(ContentChangeMode mode) { … }

SkCanvas* SkSurface::getCanvas() { … }

sk_sp<const SkCapabilities> SkSurface::capabilities() { … }

sk_sp<SkImage> SkSurface::makeImageSnapshot() { … }

sk_sp<SkImage> SkSurface::makeImageSnapshot(const SkIRect& srcBounds) { … }

sk_sp<SkSurface> SkSurface::makeSurface(const SkImageInfo& info) { … }

sk_sp<SkSurface> SkSurface::makeSurface(int width, int height) { … }

void SkSurface::draw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkSamplingOptions& sampling,
                     const SkPaint* paint) { … }

bool SkSurface::peekPixels(SkPixmap* pmap) { … }

bool SkSurface::readPixels(const SkPixmap& pm, int srcX, int srcY) { … }

bool SkSurface::readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
                           int srcX, int srcY) { … }

bool SkSurface::readPixels(const SkBitmap& bitmap, int srcX, int srcY) { … }

void SkSurface::asyncRescaleAndReadPixels(const SkImageInfo& info,
                                          const SkIRect& srcRect,
                                          RescaleGamma rescaleGamma,
                                          RescaleMode rescaleMode,
                                          ReadPixelsCallback callback,
                                          ReadPixelsContext context) { … }

void SkSurface::asyncRescaleAndReadPixelsYUV420(SkYUVColorSpace yuvColorSpace,
                                                sk_sp<SkColorSpace> dstColorSpace,
                                                const SkIRect& srcRect,
                                                const SkISize& dstSize,
                                                RescaleGamma rescaleGamma,
                                                RescaleMode rescaleMode,
                                                ReadPixelsCallback callback,
                                                ReadPixelsContext context) { … }

void SkSurface::asyncRescaleAndReadPixelsYUVA420(SkYUVColorSpace yuvColorSpace,
                                                 sk_sp<SkColorSpace> dstColorSpace,
                                                 const SkIRect& srcRect,
                                                 const SkISize& dstSize,
                                                 RescaleGamma rescaleGamma,
                                                 RescaleMode rescaleMode,
                                                 ReadPixelsCallback callback,
                                                 ReadPixelsContext context) { … }

void SkSurface::writePixels(const SkPixmap& pmap, int x, int y) { … }

void SkSurface::writePixels(const SkBitmap& src, int x, int y) { … }

GrRecordingContext* SkSurface::recordingContext() const { … }

skgpu::graphite::Recorder* SkSurface::recorder() const { … }

bool SkSurface::wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores,
                     bool deleteSemaphoresAfterWait) { … }

bool SkSurface::characterize(GrSurfaceCharacterization* characterization) const { … }

bool SkSurface::isCompatible(const GrSurfaceCharacterization& characterization) const { … }