| // 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 for measuring distortion | |
| // | |
| // Author: Skal (pascal.massimino@gmail.com) | |
| #include "src/webp/encode.h" | |
| #if !(defined(WEBP_DISABLE_STATS) || defined(WEBP_REDUCE_SIZE)) | |
| #include <math.h> | |
| #include <stdlib.h> | |
| #include "src/dsp/dsp.h" | |
| #include "src/enc/vp8i_enc.h" | |
| #include "src/utils/utils.h" | |
| typedef double (*AccumulateFunc)(const uint8_t* src, int src_stride, | |
| const uint8_t* ref, int ref_stride, | |
| int w, int h); | |
| //------------------------------------------------------------------------------ | |
| // local-min distortion | |
| // | |
| // For every pixel in the *reference* picture, we search for the local best | |
| // match in the compressed image. This is not a symmetrical measure. | |
| #define RADIUS 2 // search radius. Shouldn't be too large. | |
| static double AccumulateLSIM(const uint8_t* src, int src_stride, | |
| const uint8_t* ref, int ref_stride, | |
| int w, int h) { | |
| int x, y; | |
| double total_sse = 0.; | |
| for (y = 0; y < h; ++y) { | |
| const int y_0 = (y - RADIUS < 0) ? 0 : y - RADIUS; | |
| const int y_1 = (y + RADIUS + 1 >= h) ? h : y + RADIUS + 1; | |
| for (x = 0; x < w; ++x) { | |
| const int x_0 = (x - RADIUS < 0) ? 0 : x - RADIUS; | |
| const int x_1 = (x + RADIUS + 1 >= w) ? w : x + RADIUS + 1; | |
| double best_sse = 255. * 255.; | |
| const double value = (double)ref[y * ref_stride + x]; | |
| int i, j; | |
| for (j = y_0; j < y_1; ++j) { | |
| const uint8_t* const s = src + j * src_stride; | |
| for (i = x_0; i < x_1; ++i) { | |
| const double diff = s[i] - value; | |
| const double sse = diff * diff; | |
| if (sse < best_sse) best_sse = sse; | |
| } | |
| } | |
| total_sse += best_sse; | |
| } | |
| } | |
| return total_sse; | |
| } | |
| #undef RADIUS | |
| static double AccumulateSSE(const uint8_t* src, int src_stride, | |
| const uint8_t* ref, int ref_stride, | |
| int w, int h) { | |
| int y; | |
| double total_sse = 0.; | |
| for (y = 0; y < h; ++y) { | |
| total_sse += VP8AccumulateSSE(src, ref, w); | |
| src += src_stride; | |
| ref += ref_stride; | |
| } | |
| return total_sse; | |
| } | |
| //------------------------------------------------------------------------------ | |
| static double AccumulateSSIM(const uint8_t* src, int src_stride, | |
| const uint8_t* ref, int ref_stride, | |
| int w, int h) { | |
| const int w0 = (w < VP8_SSIM_KERNEL) ? w : VP8_SSIM_KERNEL; | |
| const int w1 = w - VP8_SSIM_KERNEL - 1; | |
| const int h0 = (h < VP8_SSIM_KERNEL) ? h : VP8_SSIM_KERNEL; | |
| const int h1 = h - VP8_SSIM_KERNEL - 1; | |
| int x, y; | |
| double sum = 0.; | |
| for (y = 0; y < h0; ++y) { | |
| for (x = 0; x < w; ++x) { | |
| sum += VP8SSIMGetClipped(src, src_stride, ref, ref_stride, x, y, w, h); | |
| } | |
| } | |
| for (; y < h1; ++y) { | |
| for (x = 0; x < w0; ++x) { | |
| sum += VP8SSIMGetClipped(src, src_stride, ref, ref_stride, x, y, w, h); | |
| } | |
| for (; x < w1; ++x) { | |
| const int off1 = x - VP8_SSIM_KERNEL + (y - VP8_SSIM_KERNEL) * src_stride; | |
| const int off2 = x - VP8_SSIM_KERNEL + (y - VP8_SSIM_KERNEL) * ref_stride; | |
| sum += VP8SSIMGet(src + off1, src_stride, ref + off2, ref_stride); | |
| } | |
| for (; x < w; ++x) { | |
| sum += VP8SSIMGetClipped(src, src_stride, ref, ref_stride, x, y, w, h); | |
| } | |
| } | |
| for (; y < h; ++y) { | |
| for (x = 0; x < w; ++x) { | |
| sum += VP8SSIMGetClipped(src, src_stride, ref, ref_stride, x, y, w, h); | |
| } | |
| } | |
| return sum; | |
| } | |
| //------------------------------------------------------------------------------ | |
| // Distortion | |
| // Max value returned in case of exact similarity. | |
| static const double kMinDistortion_dB = 99.; | |
| static double GetPSNR(double v, double size) { | |
| return (v > 0. && size > 0.) ? -4.3429448 * log(v / (size * 255 * 255.)) | |
| : kMinDistortion_dB; | |
| } | |
| static double GetLogSSIM(double v, double size) { | |
| v = (size > 0.) ? v / size : 1.; | |
| return (v < 1.) ? -10.0 * log10(1. - v) : kMinDistortion_dB; | |
| } | |
| int WebPPlaneDistortion(const uint8_t* src, size_t src_stride, | |
| const uint8_t* ref, size_t ref_stride, | |
| int width, int height, size_t x_step, | |
| int type, float* distortion, float* result) { | |
| uint8_t* allocated = NULL; | |
| const AccumulateFunc metric = (type == 0) ? AccumulateSSE : | |
| (type == 1) ? AccumulateSSIM : | |
| AccumulateLSIM; | |
| if (src == NULL || ref == NULL || | |
| src_stride < x_step * width || ref_stride < x_step * width || | |
| result == NULL || distortion == NULL) { | |
| return 0; | |
| } | |
| VP8SSIMDspInit(); | |
| if (x_step != 1) { // extract a packed plane if needed | |
| int x, y; | |
| uint8_t* tmp1; | |
| uint8_t* tmp2; | |
| allocated = | |
| (uint8_t*)WebPSafeMalloc(2ULL * width * height, sizeof(*allocated)); | |
| if (allocated == NULL) return 0; | |
| tmp1 = allocated; | |
| tmp2 = tmp1 + (size_t)width * height; | |
| for (y = 0; y < height; ++y) { | |
| for (x = 0; x < width; ++x) { | |
| tmp1[x + y * width] = src[x * x_step + y * src_stride]; | |
| tmp2[x + y * width] = ref[x * x_step + y * ref_stride]; | |
| } | |
| } | |
| src = tmp1; | |
| ref = tmp2; | |
| } | |
| *distortion = (float)metric(src, width, ref, width, width, height); | |
| WebPSafeFree(allocated); | |
| *result = (type == 1) ? (float)GetLogSSIM(*distortion, (double)width * height) | |
| : (float)GetPSNR(*distortion, (double)width * height); | |
| return 1; | |
| } | |
| #ifdef WORDS_BIGENDIAN | |
| #define BLUE_OFFSET 3 // uint32_t 0x000000ff is 0x00,00,00,ff in memory | |
| #else | |
| #define BLUE_OFFSET 0 // uint32_t 0x000000ff is 0xff,00,00,00 in memory | |
| #endif | |
| int WebPPictureDistortion(const WebPPicture* src, const WebPPicture* ref, | |
| int type, float results[5]) { | |
| int w, h, c; | |
| int ok = 0; | |
| WebPPicture p0, p1; | |
| double total_size = 0., total_distortion = 0.; | |
| if (src == NULL || ref == NULL || | |
| src->width != ref->width || src->height != ref->height || | |
| results == NULL) { | |
| return 0; | |
| } | |
| VP8SSIMDspInit(); | |
| if (!WebPPictureInit(&p0) || !WebPPictureInit(&p1)) return 0; | |
| w = src->width; | |
| h = src->height; | |
| if (!WebPPictureView(src, 0, 0, w, h, &p0)) goto Error; | |
| if (!WebPPictureView(ref, 0, 0, w, h, &p1)) goto Error; | |
| // We always measure distortion in ARGB space. | |
| if (p0.use_argb == 0 && !WebPPictureYUVAToARGB(&p0)) goto Error; | |
| if (p1.use_argb == 0 && !WebPPictureYUVAToARGB(&p1)) goto Error; | |
| for (c = 0; c < 4; ++c) { | |
| float distortion; | |
| const size_t stride0 = 4 * (size_t)p0.argb_stride; | |
| const size_t stride1 = 4 * (size_t)p1.argb_stride; | |
| // results are reported as BGRA | |
| const int offset = c ^ BLUE_OFFSET; | |
| if (!WebPPlaneDistortion((const uint8_t*)p0.argb + offset, stride0, | |
| (const uint8_t*)p1.argb + offset, stride1, | |
| w, h, 4, type, &distortion, results + c)) { | |
| goto Error; | |
| } | |
| total_distortion += distortion; | |
| total_size += w * h; | |
| } | |
| results[4] = (type == 1) ? (float)GetLogSSIM(total_distortion, total_size) | |
| : (float)GetPSNR(total_distortion, total_size); | |
| ok = 1; | |
| Error: | |
| WebPPictureFree(&p0); | |
| WebPPictureFree(&p1); | |
| return ok; | |
| } | |
| #undef BLUE_OFFSET | |
| #else // defined(WEBP_DISABLE_STATS) | |
| int WebPPlaneDistortion(const uint8_t* src, size_t src_stride, | |
| const uint8_t* ref, size_t ref_stride, | |
| int width, int height, size_t x_step, | |
| int type, float* distortion, float* result) { | |
| (void)src; | |
| (void)src_stride; | |
| (void)ref; | |
| (void)ref_stride; | |
| (void)width; | |
| (void)height; | |
| (void)x_step; | |
| (void)type; | |
| if (distortion == NULL || result == NULL) return 0; | |
| *distortion = 0.f; | |
| *result = 0.f; | |
| return 1; | |
| } | |
| int WebPPictureDistortion(const WebPPicture* src, const WebPPicture* ref, | |
| int type, float results[5]) { | |
| int i; | |
| (void)src; | |
| (void)ref; | |
| (void)type; | |
| if (results == NULL) return 0; | |
| for (i = 0; i < 5; ++i) results[i] = 0.f; | |
| return 1; | |
| } | |
| #endif // !defined(WEBP_DISABLE_STATS) |