dany/libwebp
1
0
Fork 0
mirror of https://github.com/webmproject/libwebp.git synced 2025-02-21 19:32:52 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Some renamings for consistency.

Browse Source 
- pic->picture in public header
- match implementation to declaration in PictureImport, WebPPictureRescale, WebpBlendAlpha

Change-Id: Ibf3771af22d671bba6fd657684add618c6f32978
This commit is contained in:
Vincent Rabaud 2022-05-16 17:33:49 +02:00
parent a2093acc4b
commit 6c43219a5f
4 changed files with 59 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/enc/picture_csp_enc.c
View File

@ -798,24 +798,24 @@ static int Import(WebPPicture* const picture,
#if !defined(WEBP_REDUCE_CSP) #if !defined(WEBP_REDUCE_CSP)
int WebPPictureImportBGR(WebPPicture* picture, int WebPPictureImportBGR(WebPPicture* picture,
const uint8_t* rgb, int rgb_stride) { const uint8_t* bgr, int bgr_stride) {
return (picture != NULL && rgb != NULL) return (picture != NULL && bgr != NULL)
? Import(picture, rgb, rgb_stride, 3, 1, 0) ? Import(picture, bgr, bgr_stride, 3, 1, 0)
: 0; : 0;
} }
int WebPPictureImportBGRA(WebPPicture* picture, int WebPPictureImportBGRA(WebPPicture* picture,
const uint8_t* rgba, int rgba_stride) { const uint8_t* bgra, int bgra_stride) {
return (picture != NULL && rgba != NULL) return (picture != NULL && bgra != NULL)
? Import(picture, rgba, rgba_stride, 4, 1, 1) ? Import(picture, bgra, bgra_stride, 4, 1, 1)
: 0; : 0;
} }
int WebPPictureImportBGRX(WebPPicture* picture, int WebPPictureImportBGRX(WebPPicture* picture,
const uint8_t* rgba, int rgba_stride) { const uint8_t* bgrx, int bgrx_stride) {
return (picture != NULL && rgba != NULL) return (picture != NULL && bgrx != NULL)
? Import(picture, rgba, rgba_stride, 4, 1, 0) ? Import(picture, bgrx, bgrx_stride, 4, 1, 0)
: 0; : 0;
} }
@ -836,9 +836,9 @@ int WebPPictureImportRGBA(WebPPicture* picture,
} }
int WebPPictureImportRGBX(WebPPicture* picture, int WebPPictureImportRGBX(WebPPicture* picture,
const uint8_t* rgba, int rgba_stride) { const uint8_t* rgbx, int rgbx_stride) {
return (picture != NULL && rgba != NULL) return (picture != NULL && rgbx != NULL)
? Import(picture, rgba, rgba_stride, 4, 0, 0) ? Import(picture, rgbx, rgbx_stride, 4, 0, 0)
: 0; : 0;
} }

47
src/enc/picture_rescale_enc.c
View File

@ -198,34 +198,34 @@ static void AlphaMultiplyY(WebPPicture* const pic, int inverse) {
} }
} }
int WebPPictureRescale(WebPPicture* pic, int width, int height) { int WebPPictureRescale(WebPPicture* picture, int width, int height) {
WebPPicture tmp; WebPPicture tmp;
int prev_width, prev_height; int prev_width, prev_height;
rescaler_t* work; rescaler_t* work;
if (pic == NULL) return 0; if (picture == NULL) return 0;
prev_width = pic->width; prev_width = picture->width;
prev_height = pic->height; prev_height = picture->height;
if (!WebPRescalerGetScaledDimensions( if (!WebPRescalerGetScaledDimensions(
prev_width, prev_height, &width, &height)) { prev_width, prev_height, &width, &height)) {
return 0; return 0;
} }
PictureGrabSpecs(pic, &tmp); PictureGrabSpecs(picture, &tmp);
tmp.width = width; tmp.width = width;
tmp.height = height; tmp.height = height;
if (!WebPPictureAlloc(&tmp)) return 0; if (!WebPPictureAlloc(&tmp)) return 0;
if (!pic->use_argb) { if (!picture->use_argb) {
work = (rescaler_t*)WebPSafeMalloc(2ULL * width, sizeof(*work)); work = (rescaler_t*)WebPSafeMalloc(2ULL * width, sizeof(*work));
if (work == NULL) { if (work == NULL) {
WebPPictureFree(&tmp); WebPPictureFree(&tmp);
return 0; return 0;
} }
// If present, we need to rescale alpha first (for AlphaMultiplyY). // If present, we need to rescale alpha first (for AlphaMultiplyY).
if (pic->a != NULL) { if (picture->a != NULL) {
WebPInitAlphaProcessing(); WebPInitAlphaProcessing();
if (!RescalePlane(pic->a, prev_width, prev_height, pic->a_stride, if (!RescalePlane(picture->a, prev_width, prev_height, picture->a_stride,
tmp.a, width, height, tmp.a_stride, work, 1)) { tmp.a, width, height, tmp.a_stride, work, 1)) {
return 0; return 0;
} }
@ -233,17 +233,15 @@ int WebPPictureRescale(WebPPicture* pic, int width, int height) {
// We take transparency into account on the luma plane only. That's not // We take transparency into account on the luma plane only. That's not
// totally exact blending, but still is a good approximation. // totally exact blending, but still is a good approximation.
AlphaMultiplyY(pic, 0); AlphaMultiplyY(picture, 0);
if (!RescalePlane(pic->y, prev_width, prev_height, pic->y_stride, if (!RescalePlane(picture->y, prev_width, prev_height, picture->y_stride,
tmp.y, width, height, tmp.y_stride, work, 1) || tmp.y, width, height, tmp.y_stride, work, 1) ||
!RescalePlane(pic->u, !RescalePlane(picture->u, HALVE(prev_width), HALVE(prev_height),
HALVE(prev_width), HALVE(prev_height), pic->uv_stride, picture->uv_stride, tmp.u, HALVE(width), HALVE(height),
tmp.u, tmp.uv_stride, work, 1) ||
HALVE(width), HALVE(height), tmp.uv_stride, work, 1) || !RescalePlane(picture->v, HALVE(prev_width), HALVE(prev_height),
!RescalePlane(pic->v, picture->uv_stride, tmp.v, HALVE(width), HALVE(height),
HALVE(prev_width), HALVE(prev_height), pic->uv_stride, tmp.uv_stride, work, 1)) {
tmp.v,
HALVE(width), HALVE(height), tmp.uv_stride, work, 1)) {
return 0; return 0;
} }
AlphaMultiplyY(&tmp, 1); AlphaMultiplyY(&tmp, 1);
@ -257,18 +255,17 @@ int WebPPictureRescale(WebPPicture* pic, int width, int height) {
// weighting first (black-matting), scale the RGB values, and remove // weighting first (black-matting), scale the RGB values, and remove
// the premultiplication afterward (while preserving the alpha channel). // the premultiplication afterward (while preserving the alpha channel).
WebPInitAlphaProcessing(); WebPInitAlphaProcessing();
AlphaMultiplyARGB(pic, 0); AlphaMultiplyARGB(picture, 0);
if (!RescalePlane((const uint8_t*)pic->argb, prev_width, prev_height, if (!RescalePlane((const uint8_t*)picture->argb, prev_width, prev_height,
pic->argb_stride * 4, picture->argb_stride * 4, (uint8_t*)tmp.argb, width,
(uint8_t*)tmp.argb, width, height, height, tmp.argb_stride * 4, work, 4)) {
tmp.argb_stride * 4, work, 4)) {
return 0; return 0;
} }
AlphaMultiplyARGB(&tmp, 1); AlphaMultiplyARGB(&tmp, 1);
} }
WebPPictureFree(pic); WebPPictureFree(picture);
WebPSafeFree(work); WebPSafeFree(work);
*pic = tmp; *picture = tmp;
return 1; return 1;
} }

45
src/enc/picture_tools_enc.c
View File

@ -190,27 +190,28 @@ static WEBP_INLINE uint32_t MakeARGB32(int r, int g, int b) {
return (0xff000000u | (r << 16) | (g << 8) | b); return (0xff000000u | (r << 16) | (g << 8) | b);
} }
void WebPBlendAlpha(WebPPicture* pic, uint32_t background_rgb) { void WebPBlendAlpha(WebPPicture* picture, uint32_t background_rgb) {
const int red = (background_rgb >> 16) & 0xff; const int red = (background_rgb >> 16) & 0xff;
const int green = (background_rgb >> 8) & 0xff; const int green = (background_rgb >> 8) & 0xff;
const int blue = (background_rgb >> 0) & 0xff; const int blue = (background_rgb >> 0) & 0xff;
int x, y; int x, y;
if (pic == NULL) return; if (picture == NULL) return;
if (!pic->use_argb) { if (!picture->use_argb) {
const int uv_width = (pic->width >> 1); // omit last pixel during u/v loop // omit last pixel during u/v loop
const int uv_width = (picture->width >> 1);
const int Y0 = VP8RGBToY(red, green, blue, YUV_HALF); const int Y0 = VP8RGBToY(red, green, blue, YUV_HALF);
// VP8RGBToU/V expects the u/v values summed over four pixels // VP8RGBToU/V expects the u/v values summed over four pixels
const int U0 = VP8RGBToU(4 * red, 4 * green, 4 * blue, 4 * YUV_HALF); const int U0 = VP8RGBToU(4 * red, 4 * green, 4 * blue, 4 * YUV_HALF);
const int V0 = VP8RGBToV(4 * red, 4 * green, 4 * blue, 4 * YUV_HALF); const int V0 = VP8RGBToV(4 * red, 4 * green, 4 * blue, 4 * YUV_HALF);
const int has_alpha = pic->colorspace & WEBP_CSP_ALPHA_BIT; const int has_alpha = picture->colorspace & WEBP_CSP_ALPHA_BIT;
uint8_t* y_ptr = pic->y; uint8_t* y_ptr = picture->y;
uint8_t* u_ptr = pic->u; uint8_t* u_ptr = picture->u;
uint8_t* v_ptr = pic->v; uint8_t* v_ptr = picture->v;
uint8_t* a_ptr = pic->a; uint8_t* a_ptr = picture->a;
if (!has_alpha || a_ptr == NULL) return; // nothing to do if (!has_alpha || a_ptr == NULL) return; // nothing to do
for (y = 0; y < pic->height; ++y) { for (y = 0; y < picture->height; ++y) {
// Luma blending // Luma blending
for (x = 0; x < pic->width; ++x) { for (x = 0; x < picture->width; ++x) {
const uint8_t alpha = a_ptr[x]; const uint8_t alpha = a_ptr[x];
if (alpha < 0xff) { if (alpha < 0xff) {
y_ptr[x] = BLEND(Y0, y_ptr[x], alpha); y_ptr[x] = BLEND(Y0, y_ptr[x], alpha);
@ -219,7 +220,7 @@ void WebPBlendAlpha(WebPPicture* pic, uint32_t background_rgb) {
// Chroma blending every even line // Chroma blending every even line
if ((y & 1) == 0) { if ((y & 1) == 0) {
uint8_t* const a_ptr2 = uint8_t* const a_ptr2 =
(y + 1 == pic->height) ? a_ptr : a_ptr + pic->a_stride; (y + 1 == picture->height) ? a_ptr : a_ptr + picture->a_stride;
for (x = 0; x < uv_width; ++x) { for (x = 0; x < uv_width; ++x) {
// Average four alpha values into a single blending weight. // Average four alpha values into a single blending weight.
// TODO(skal): might lead to visible contouring. Can we do better? // TODO(skal): might lead to visible contouring. Can we do better?
@ -229,24 +230,24 @@ void WebPBlendAlpha(WebPPicture* pic, uint32_t background_rgb) {
u_ptr[x] = BLEND_10BIT(U0, u_ptr[x], alpha); u_ptr[x] = BLEND_10BIT(U0, u_ptr[x], alpha);
v_ptr[x] = BLEND_10BIT(V0, v_ptr[x], alpha); v_ptr[x] = BLEND_10BIT(V0, v_ptr[x], alpha);
} }
if (pic->width & 1) { // rightmost pixel if (picture->width & 1) { // rightmost pixel
const uint32_t alpha = 2 * (a_ptr[2 * x + 0] + a_ptr2[2 * x + 0]); const uint32_t alpha = 2 * (a_ptr[2 * x + 0] + a_ptr2[2 * x + 0]);
u_ptr[x] = BLEND_10BIT(U0, u_ptr[x], alpha); u_ptr[x] = BLEND_10BIT(U0, u_ptr[x], alpha);
v_ptr[x] = BLEND_10BIT(V0, v_ptr[x], alpha); v_ptr[x] = BLEND_10BIT(V0, v_ptr[x], alpha);
} }
} else { } else {
u_ptr += pic->uv_stride; u_ptr += picture->uv_stride;
v_ptr += pic->uv_stride; v_ptr += picture->uv_stride;
} }
memset(a_ptr, 0xff, pic->width); // reset alpha value to opaque memset(a_ptr, 0xff, picture->width); // reset alpha value to opaque
a_ptr += pic->a_stride; a_ptr += picture->a_stride;
y_ptr += pic->y_stride; y_ptr += picture->y_stride;
} }
} else { } else {
uint32_t* argb = pic->argb; uint32_t* argb = picture->argb;
const uint32_t background = MakeARGB32(red, green, blue); const uint32_t background = MakeARGB32(red, green, blue);
for (y = 0; y < pic->height; ++y) { for (y = 0; y < picture->height; ++y) {
for (x = 0; x < pic->width; ++x) { for (x = 0; x < picture->width; ++x) {
const int alpha = (argb[x] >> 24) & 0xff; const int alpha = (argb[x] >> 24) & 0xff;
if (alpha != 0xff) { if (alpha != 0xff) {
if (alpha > 0) { if (alpha > 0) {
@ -262,7 +263,7 @@ void WebPBlendAlpha(WebPPicture* pic, uint32_t background_rgb) {
} }
} }
} }
argb += pic->argb_stride; argb += picture->argb_stride;
} }
} }
} }

4
src/webp/encode.h
View File

@ -455,7 +455,7 @@ WEBP_EXTERN int WebPPictureIsView(const WebPPicture* picture);
// dimension will be calculated preserving the aspect ratio. // dimension will be calculated preserving the aspect ratio.
// No gamma correction is applied. // No gamma correction is applied.
// Returns false in case of error (invalid parameter or insufficient memory). // Returns false in case of error (invalid parameter or insufficient memory).
WEBP_EXTERN int WebPPictureRescale(WebPPicture* pic, int width, int height); WEBP_EXTERN int WebPPictureRescale(WebPPicture* picture, int width, int height);
// Colorspace conversion function to import RGB samples. // Colorspace conversion function to import RGB samples.
// Previous buffer will be free'd, if any. // Previous buffer will be free'd, if any.
@ -526,7 +526,7 @@ WEBP_EXTERN int WebPPictureHasTransparency(const WebPPicture* picture);
// Remove the transparency information (if present) by blending the color with // Remove the transparency information (if present) by blending the color with
// the background color 'background_rgb' (specified as 24bit RGB triplet). // the background color 'background_rgb' (specified as 24bit RGB triplet).
// After this call, all alpha values are reset to 0xff. // After this call, all alpha values are reset to 0xff.
WEBP_EXTERN void WebPBlendAlpha(WebPPicture* pic, uint32_t background_rgb); WEBP_EXTERN void WebPBlendAlpha(WebPPicture* picture, uint32_t background_rgb);
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Main call // Main call