dany/libwebp
1
0
Fork 0
mirror of https://github.com/webmproject/libwebp.git synced 2025-04-04 16:06:49 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

simplify code by introducing a CopyPlane() helper func

Browse Source 
Change-Id: Id1a2a5d8a3bf48cf614213442c1386a77c0d6880
This commit is contained in:
Pascal Massimino 2011-11-23 22:17:40 +00:00 committed by James Zern
parent 113b312881
commit afc4c5d695
1 changed files with 52 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
src/enc/picture.c
View File

@ -17,6 +17,8 @@
extern "C" { extern "C" {
#endif #endif
#define HALVE(x) (((x) + 1) >> 1)
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// WebPPicture // WebPPicture
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -28,8 +30,8 @@ int WebPPictureAlloc(WebPPicture* const picture) {
const int width = picture->width; const int width = picture->width;
const int height = picture->height; const int height = picture->height;
const int y_stride = width; const int y_stride = width;
const int uv_width = (width + 1) / 2; const int uv_width = HALVE(width);
const int uv_height = (height + 1) / 2; const int uv_height = HALVE(height);
const int uv_stride = uv_width; const int uv_stride = uv_width;
int uv0_stride = 0; int uv0_stride = 0;
int a_width, a_stride; int a_width, a_stride;
@ -122,42 +124,43 @@ void WebPPictureFree(WebPPicture* const picture) {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Picture copying // Picture copying
// TODO(skal): move to dsp/ ?
static void CopyPlane(const uint8_t* src, int src_stride,
uint8_t* dst, int dst_stride, int width, int height) {
while (height-- > 0) {
memcpy(dst, src, width);
src += src_stride;
dst += dst_stride;
}
}
int WebPPictureCopy(const WebPPicture* const src, WebPPicture* const dst) { int WebPPictureCopy(const WebPPicture* const src, WebPPicture* const dst) {
int y;
if (src == NULL || dst == NULL) return 0; if (src == NULL || dst == NULL) return 0;
if (src == dst) return 1; if (src == dst) return 1;
WebPPictureGrabSpecs(src, dst); WebPPictureGrabSpecs(src, dst);
if (!WebPPictureAlloc(dst)) return 0; if (!WebPPictureAlloc(dst)) return 0;
for (y = 0; y < dst->height; ++y) { CopyPlane(src->y, src->y_stride,
memcpy(dst->y + y * dst->y_stride, dst->y, dst->y_stride, dst->width, dst->height);
src->y + y * src->y_stride, src->width); CopyPlane(src->u, src->uv_stride,
} dst->u, dst->uv_stride, HALVE(dst->width), HALVE(dst->height));
for (y = 0; y < (dst->height + 1) / 2; ++y) { CopyPlane(src->v, src->uv_stride,
memcpy(dst->u + y * dst->uv_stride, dst->v, dst->uv_stride, HALVE(dst->width), HALVE(dst->height));
src->u + y * src->uv_stride, (src->width + 1) / 2);
memcpy(dst->v + y * dst->uv_stride,
src->v + y * src->uv_stride, (src->width + 1) / 2);
}
#ifdef WEBP_EXPERIMENTAL_FEATURES #ifdef WEBP_EXPERIMENTAL_FEATURES
if (dst->a != NULL) { if (dst->a != NULL) {
for (y = 0; y < dst->height; ++y) { CopyPlane(src->a, src->a_stride,
memcpy(dst->a + y * dst->a_stride, dst->a, dst->a_stride, dst->width, dst->height);
src->a + y * src->a_stride, src->width);
}
} }
if (dst->u0 != NULL) { if (dst->u0 != NULL) {
int uv0_width = src->width; int uv0_width = src->width;
if ((dst->colorspace & WEBP_CSP_UV_MASK) == WEBP_YUV422) { if ((dst->colorspace & WEBP_CSP_UV_MASK) == WEBP_YUV422) {
uv0_width = (uv0_width + 1) / 2; uv0_width = HALVE(uv0_width);
}
for (y = 0; y < dst->height; ++y) {
memcpy(dst->u0 + y * dst->uv0_stride,
src->u0 + y * src->uv0_stride, uv0_width);
memcpy(dst->v0 + y * dst->uv0_stride,
src->v0 + y * src->uv0_stride, uv0_width);
} }
CopyPlane(src->u0, src->uv0_stride,
dst->u0, dst->uv0_stride, uv0_width, dst->height);
CopyPlane(src->v0, src->uv0_stride,
dst->v0, dst->uv0_stride, uv0_width, dst->height);
} }
#endif #endif
return 1; return 1;
@ -169,7 +172,6 @@ int WebPPictureCopy(const WebPPicture* const src, WebPPicture* const dst) {
int WebPPictureCrop(WebPPicture* const pic, int WebPPictureCrop(WebPPicture* const pic,
int left, int top, int width, int height) { int left, int top, int width, int height) {
WebPPicture tmp; WebPPicture tmp;
int y;
if (pic == NULL) return 0; if (pic == NULL) return 0;
if (width <= 0 || height <= 0) return 0; if (width <= 0 || height <= 0) return 0;
@ -181,36 +183,34 @@ int WebPPictureCrop(WebPPicture* const pic,
tmp.height = height; tmp.height = height;
if (!WebPPictureAlloc(&tmp)) return 0; if (!WebPPictureAlloc(&tmp)) return 0;
for (y = 0; y < height; ++y) { {
memcpy(tmp.y + y * tmp.y_stride, const int y_offset = top * pic->y_stride + left;
pic->y + (top + y) * pic->y_stride + left, width); const int uv_offset = (top / 2) * pic->uv_stride + left / 2;
} CopyPlane(pic->y + y_offset, pic->y_stride,
for (y = 0; y < (height + 1) / 2; ++y) { tmp.y, tmp.y_stride, width, height);
const int offset = (y + top / 2) * pic->uv_stride + left / 2; CopyPlane(pic->u + uv_offset, pic->uv_stride,
memcpy(tmp.u + y * tmp.uv_stride, pic->u + offset, (width + 1) / 2); tmp.u, tmp.uv_stride, HALVE(width), HALVE(height));
memcpy(tmp.v + y * tmp.uv_stride, pic->v + offset, (width + 1) / 2); CopyPlane(pic->v + uv_offset, pic->uv_stride,
tmp.v, tmp.uv_stride, HALVE(width), HALVE(height));
} }
#ifdef WEBP_EXPERIMENTAL_FEATURES #ifdef WEBP_EXPERIMENTAL_FEATURES
if (tmp.a) { if (tmp.a) {
for (y = 0; y < height; ++y) { const int a_offset = top * pic->a_stride + left;
memcpy(tmp.a + y * tmp.a_stride, CopyPlane(pic->a + a_offset, pic->a_stride,
pic->a + (top + y) * pic->a_stride + left, width); tmp.a, tmp.a_stride, width, height);
}
} }
if (tmp.u0) { if (tmp.u0) {
int w = width; int w = width;
int l = left; int l = left;
if (tmp.colorspace == WEBP_YUV422) { if (tmp.colorspace == WEBP_YUV422) {
w = (w + 1) / 2; w = HALVE(w);
l = (l + 1) / 2; l = HALVE(l);
}
for (y = 0; y < height; ++y) {
memcpy(tmp.u0 + y * tmp.uv0_stride,
pic->u0 + (top + y) * pic->uv0_stride + l, w);
memcpy(tmp.v0 + y * tmp.uv0_stride,
pic->v0 + (top + y) * pic->uv0_stride + l, w);
} }
CopyPlane(pic->u0 + top * pic->uv0_stride + l, pic->uv0_stride,
tmp.u0, tmp.uv0_stride, w, l);
CopyPlane(pic->v0 + top * pic->uv0_stride + l, pic->uv0_stride,
tmp.v0, tmp.uv0_stride, w, l);
} }
#endif #endif
@ -339,13 +339,13 @@ int WebPPictureRescale(WebPPicture* const pic, int width, int height) {
RescalePlane(pic->y, prev_width, prev_height, pic->y_stride, RescalePlane(pic->y, prev_width, prev_height, pic->y_stride,
tmp.y, width, height, tmp.y_stride, work); tmp.y, width, height, tmp.y_stride, work);
RescalePlane(pic->u, RescalePlane(pic->u,
(prev_width + 1) / 2, (prev_height + 1) / 2, pic->uv_stride, HALVE(prev_width), HALVE(prev_height), pic->uv_stride,
tmp.u, tmp.u,
(width + 1) / 2, (height + 1) / 2, tmp.uv_stride, work); HALVE(width), HALVE(height), tmp.uv_stride, work);
RescalePlane(pic->v, RescalePlane(pic->v,
(prev_width + 1) / 2, (prev_height + 1) / 2, pic->uv_stride, HALVE(prev_width), HALVE(prev_height), pic->uv_stride,
tmp.v, tmp.v,
(width + 1) / 2, (height + 1) / 2, tmp.uv_stride, work); HALVE(width), HALVE(height), tmp.uv_stride, work);
#ifdef WEBP_EXPERIMENTAL_FEATURES #ifdef WEBP_EXPERIMENTAL_FEATURES
if (tmp.a) { if (tmp.a) {
@ -476,8 +476,9 @@ static WEBP_INLINE int rgb_to_v(int r, int g, int b) {
static void MakeGray(WebPPicture* const picture) { static void MakeGray(WebPPicture* const picture) {
int y; int y;
const int uv_width = (picture->width + 1) >> 1; const int uv_width = HALVE(picture->width);
for (y = 0; y < ((picture->height + 1) >> 1); ++y) { const int uv_height = HALVE(picture->height);
for (y = 0; y < uv_height; ++y) {
memset(picture->u + y * picture->uv_stride, 128, uv_width); memset(picture->u + y * picture->uv_stride, 128, uv_width);
memset(picture->v + y * picture->uv_stride, 128, uv_width); memset(picture->v + y * picture->uv_stride, 128, uv_width);
} }