// 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 "src/webp/encode.h"

#if !defined(WEBP_REDUCE_SIZE)

#include <assert.h>

#include <stdlib.h>

#include "src/enc/vp8i_enc.h"

#include "src/utils/rescaler_utils.h"

#include "src/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 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;

}

#else // defined(WEBP_REDUCE_SIZE)

int WebPPictureCopy(const WebPPicture* src, WebPPicture* dst) {

(void)src;

(void)dst;

return 0;

}

int WebPPictureIsView(const WebPPicture* picture) {

(void)picture;

return 0;

}

int WebPPictureView(const WebPPicture* src,

int left, int top, int width, int height,

WebPPicture* dst) {

(void)src;

(void)left;

(void)top;

(void)width;

(void)height;

(void)dst;

return 0;

}

int WebPPictureCrop(WebPPicture* pic,

int left, int top, int width, int height) {

(void)pic;

(void)left;

(void)top;

(void)width;

(void)height;

return 0;

}

int WebPPictureRescale(WebPPicture* pic, int width, int height) {

(void)pic;

(void)width;

(void)height;

return 0;

}

#endif // !defined(WEBP_REDUCE_SIZE)