mirror of
https://github.com/godotengine/godot.git
synced 2024-11-27 09:16:35 +08:00
265 lines
9.0 KiB
C
265 lines
9.0 KiB
C
// Copyright 2014 Google Inc. All Rights Reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style license
|
|
// that can be found in the COPYING file in the root of the source
|
|
// tree. An additional intellectual property rights grant can be found
|
|
// in the file PATENTS. All contributing project authors may
|
|
// be found in the AUTHORS file in the root of the source tree.
|
|
// -----------------------------------------------------------------------------
|
|
//
|
|
// WebPPicture tools: copy, crop, rescaling and view.
|
|
//
|
|
// Author: Skal (pascal.massimino@gmail.com)
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "./vp8i_enc.h"
|
|
#include "../utils/rescaler_utils.h"
|
|
#include "../utils/utils.h"
|
|
|
|
#define HALVE(x) (((x) + 1) >> 1)
|
|
|
|
// Grab the 'specs' (writer, *opaque, width, height...) from 'src' and copy them
|
|
// into 'dst'. Mark 'dst' as not owning any memory.
|
|
static void PictureGrabSpecs(const WebPPicture* const src,
|
|
WebPPicture* const dst) {
|
|
assert(src != NULL && dst != NULL);
|
|
*dst = *src;
|
|
WebPPictureResetBuffers(dst);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Adjust top-left corner to chroma sample position.
|
|
static void SnapTopLeftPosition(const WebPPicture* const pic,
|
|
int* const left, int* const top) {
|
|
if (!pic->use_argb) {
|
|
*left &= ~1;
|
|
*top &= ~1;
|
|
}
|
|
}
|
|
|
|
// Adjust top-left corner and verify that the sub-rectangle is valid.
|
|
static int AdjustAndCheckRectangle(const WebPPicture* const pic,
|
|
int* const left, int* const top,
|
|
int width, int height) {
|
|
SnapTopLeftPosition(pic, left, top);
|
|
if ((*left) < 0 || (*top) < 0) return 0;
|
|
if (width <= 0 || height <= 0) return 0;
|
|
if ((*left) + width > pic->width) return 0;
|
|
if ((*top) + height > pic->height) return 0;
|
|
return 1;
|
|
}
|
|
|
|
int WebPPictureCopy(const WebPPicture* src, WebPPicture* dst) {
|
|
if (src == NULL || dst == NULL) return 0;
|
|
if (src == dst) return 1;
|
|
|
|
PictureGrabSpecs(src, dst);
|
|
if (!WebPPictureAlloc(dst)) return 0;
|
|
|
|
if (!src->use_argb) {
|
|
WebPCopyPlane(src->y, src->y_stride,
|
|
dst->y, dst->y_stride, dst->width, dst->height);
|
|
WebPCopyPlane(src->u, src->uv_stride, dst->u, dst->uv_stride,
|
|
HALVE(dst->width), HALVE(dst->height));
|
|
WebPCopyPlane(src->v, src->uv_stride, dst->v, dst->uv_stride,
|
|
HALVE(dst->width), HALVE(dst->height));
|
|
if (dst->a != NULL) {
|
|
WebPCopyPlane(src->a, src->a_stride,
|
|
dst->a, dst->a_stride, dst->width, dst->height);
|
|
}
|
|
} else {
|
|
WebPCopyPlane((const uint8_t*)src->argb, 4 * src->argb_stride,
|
|
(uint8_t*)dst->argb, 4 * dst->argb_stride,
|
|
4 * dst->width, dst->height);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int WebPPictureIsView(const WebPPicture* picture) {
|
|
if (picture == NULL) return 0;
|
|
if (picture->use_argb) {
|
|
return (picture->memory_argb_ == NULL);
|
|
}
|
|
return (picture->memory_ == NULL);
|
|
}
|
|
|
|
int WebPPictureView(const WebPPicture* src,
|
|
int left, int top, int width, int height,
|
|
WebPPicture* dst) {
|
|
if (src == NULL || dst == NULL) return 0;
|
|
|
|
// verify rectangle position.
|
|
if (!AdjustAndCheckRectangle(src, &left, &top, width, height)) return 0;
|
|
|
|
if (src != dst) { // beware of aliasing! We don't want to leak 'memory_'.
|
|
PictureGrabSpecs(src, dst);
|
|
}
|
|
dst->width = width;
|
|
dst->height = height;
|
|
if (!src->use_argb) {
|
|
dst->y = src->y + top * src->y_stride + left;
|
|
dst->u = src->u + (top >> 1) * src->uv_stride + (left >> 1);
|
|
dst->v = src->v + (top >> 1) * src->uv_stride + (left >> 1);
|
|
dst->y_stride = src->y_stride;
|
|
dst->uv_stride = src->uv_stride;
|
|
if (src->a != NULL) {
|
|
dst->a = src->a + top * src->a_stride + left;
|
|
dst->a_stride = src->a_stride;
|
|
}
|
|
} else {
|
|
dst->argb = src->argb + top * src->argb_stride + left;
|
|
dst->argb_stride = src->argb_stride;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Picture cropping
|
|
|
|
int WebPPictureCrop(WebPPicture* pic,
|
|
int left, int top, int width, int height) {
|
|
WebPPicture tmp;
|
|
|
|
if (pic == NULL) return 0;
|
|
if (!AdjustAndCheckRectangle(pic, &left, &top, width, height)) return 0;
|
|
|
|
PictureGrabSpecs(pic, &tmp);
|
|
tmp.width = width;
|
|
tmp.height = height;
|
|
if (!WebPPictureAlloc(&tmp)) return 0;
|
|
|
|
if (!pic->use_argb) {
|
|
const int y_offset = top * pic->y_stride + left;
|
|
const int uv_offset = (top / 2) * pic->uv_stride + left / 2;
|
|
WebPCopyPlane(pic->y + y_offset, pic->y_stride,
|
|
tmp.y, tmp.y_stride, width, height);
|
|
WebPCopyPlane(pic->u + uv_offset, pic->uv_stride,
|
|
tmp.u, tmp.uv_stride, HALVE(width), HALVE(height));
|
|
WebPCopyPlane(pic->v + uv_offset, pic->uv_stride,
|
|
tmp.v, tmp.uv_stride, HALVE(width), HALVE(height));
|
|
|
|
if (tmp.a != NULL) {
|
|
const int a_offset = top * pic->a_stride + left;
|
|
WebPCopyPlane(pic->a + a_offset, pic->a_stride,
|
|
tmp.a, tmp.a_stride, width, height);
|
|
}
|
|
} else {
|
|
const uint8_t* const src =
|
|
(const uint8_t*)(pic->argb + top * pic->argb_stride + left);
|
|
WebPCopyPlane(src, pic->argb_stride * 4, (uint8_t*)tmp.argb,
|
|
tmp.argb_stride * 4, width * 4, height);
|
|
}
|
|
WebPPictureFree(pic);
|
|
*pic = tmp;
|
|
return 1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Simple picture rescaler
|
|
|
|
static void RescalePlane(const uint8_t* src,
|
|
int src_width, int src_height, int src_stride,
|
|
uint8_t* dst,
|
|
int dst_width, int dst_height, int dst_stride,
|
|
rescaler_t* const work,
|
|
int num_channels) {
|
|
WebPRescaler rescaler;
|
|
int y = 0;
|
|
WebPRescalerInit(&rescaler, src_width, src_height,
|
|
dst, dst_width, dst_height, dst_stride,
|
|
num_channels, work);
|
|
while (y < src_height) {
|
|
y += WebPRescalerImport(&rescaler, src_height - y,
|
|
src + y * src_stride, src_stride);
|
|
WebPRescalerExport(&rescaler);
|
|
}
|
|
}
|
|
|
|
static void AlphaMultiplyARGB(WebPPicture* const pic, int inverse) {
|
|
assert(pic->argb != NULL);
|
|
WebPMultARGBRows((uint8_t*)pic->argb, pic->argb_stride * sizeof(*pic->argb),
|
|
pic->width, pic->height, inverse);
|
|
}
|
|
|
|
static void AlphaMultiplyY(WebPPicture* const pic, int inverse) {
|
|
if (pic->a != NULL) {
|
|
WebPMultRows(pic->y, pic->y_stride, pic->a, pic->a_stride,
|
|
pic->width, pic->height, inverse);
|
|
}
|
|
}
|
|
|
|
int WebPPictureRescale(WebPPicture* pic, int width, int height) {
|
|
WebPPicture tmp;
|
|
int prev_width, prev_height;
|
|
rescaler_t* work;
|
|
|
|
if (pic == NULL) return 0;
|
|
prev_width = pic->width;
|
|
prev_height = pic->height;
|
|
if (!WebPRescalerGetScaledDimensions(
|
|
prev_width, prev_height, &width, &height)) {
|
|
return 0;
|
|
}
|
|
|
|
PictureGrabSpecs(pic, &tmp);
|
|
tmp.width = width;
|
|
tmp.height = height;
|
|
if (!WebPPictureAlloc(&tmp)) return 0;
|
|
|
|
if (!pic->use_argb) {
|
|
work = (rescaler_t*)WebPSafeMalloc(2ULL * width, sizeof(*work));
|
|
if (work == NULL) {
|
|
WebPPictureFree(&tmp);
|
|
return 0;
|
|
}
|
|
// If present, we need to rescale alpha first (for AlphaMultiplyY).
|
|
if (pic->a != NULL) {
|
|
WebPInitAlphaProcessing();
|
|
RescalePlane(pic->a, prev_width, prev_height, pic->a_stride,
|
|
tmp.a, width, height, tmp.a_stride, work, 1);
|
|
}
|
|
|
|
// We take transparency into account on the luma plane only. That's not
|
|
// totally exact blending, but still is a good approximation.
|
|
AlphaMultiplyY(pic, 0);
|
|
RescalePlane(pic->y, prev_width, prev_height, pic->y_stride,
|
|
tmp.y, width, height, tmp.y_stride, work, 1);
|
|
AlphaMultiplyY(&tmp, 1);
|
|
|
|
RescalePlane(pic->u,
|
|
HALVE(prev_width), HALVE(prev_height), pic->uv_stride,
|
|
tmp.u,
|
|
HALVE(width), HALVE(height), tmp.uv_stride, work, 1);
|
|
RescalePlane(pic->v,
|
|
HALVE(prev_width), HALVE(prev_height), pic->uv_stride,
|
|
tmp.v,
|
|
HALVE(width), HALVE(height), tmp.uv_stride, work, 1);
|
|
} else {
|
|
work = (rescaler_t*)WebPSafeMalloc(2ULL * width * 4, sizeof(*work));
|
|
if (work == NULL) {
|
|
WebPPictureFree(&tmp);
|
|
return 0;
|
|
}
|
|
// In order to correctly interpolate colors, we need to apply the alpha
|
|
// weighting first (black-matting), scale the RGB values, and remove
|
|
// the premultiplication afterward (while preserving the alpha channel).
|
|
WebPInitAlphaProcessing();
|
|
AlphaMultiplyARGB(pic, 0);
|
|
RescalePlane((const uint8_t*)pic->argb, prev_width, prev_height,
|
|
pic->argb_stride * 4,
|
|
(uint8_t*)tmp.argb, width, height,
|
|
tmp.argb_stride * 4,
|
|
work, 4);
|
|
AlphaMultiplyARGB(&tmp, 1);
|
|
}
|
|
WebPPictureFree(pic);
|
|
WebPSafeFree(work);
|
|
*pic = tmp;
|
|
return 1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|