static void FinalizePSNR(const VP8Encoder* const enc) { WebPAuxStats* stats = enc->pic_->stats; const uint64_t size = enc->sse_count_; const uint64_t* const sse = enc->sse_; stats->PSNR[0] = (float)GetPSNR(sse[0], size); stats->PSNR[1] = (float)GetPSNR(sse[1], size / 4); stats->PSNR[2] = (float)GetPSNR(sse[2], size / 4); stats->PSNR[3] = (float)GetPSNR(sse[0] + sse[1] + sse[2], size * 3 / 2); }
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; if (!WebPPlaneDistortion((const uint8_t*)p0.argb + c, stride0, (const uint8_t*)p1.argb + c, 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; }
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; }