48 |
|
|
49 |
typedef struct { |
typedef struct { |
50 |
|
|
51 |
uint64_t mse_sum; /* for avrg psnrhvsm */ |
uint64_t mse_sum_y; /* for avrg psnr-hvs-m */ |
52 |
|
uint64_t mse_sum_u; |
53 |
|
uint64_t mse_sum_v; |
54 |
|
|
55 |
long frame_cnt; |
long frame_cnt; |
56 |
|
|
57 |
} psnrhvsm_data_t; /* internal plugin data */ |
} psnrhvsm_data_t; /* internal plugin data */ |
157 |
return MSE_H; /* Fixed-point value right-shifted by eight */ |
return MSE_H; /* Fixed-point value right-shifted by eight */ |
158 |
} |
} |
159 |
|
|
160 |
#else /* First draft of a fixed-point implementation. |
#else |
161 |
|
|
162 |
|
/* First draft of a fixed-point implementation. |
163 |
Might serve as a template for MMX/SSE code */ |
Might serve as a template for MMX/SSE code */ |
164 |
|
|
165 |
static const uint16_t iMask_Coeff[64] = |
static const uint16_t iMask_Coeff[64] = |
306 |
static void psnrhvsm_after(xvid_plg_data_t *data, psnrhvsm_data_t *psnrhvsm) |
static void psnrhvsm_after(xvid_plg_data_t *data, psnrhvsm_data_t *psnrhvsm) |
307 |
{ |
{ |
308 |
DECLARE_ALIGNED_MATRIX(DCT, 2, 64, int16_t, CACHE_LINE); |
DECLARE_ALIGNED_MATRIX(DCT, 2, 64, int16_t, CACHE_LINE); |
309 |
uint32_t x, y, stride = data->original.stride[0]; |
int32_t x, y, u, v; |
310 |
int16_t *DCT_A = &DCT[0], *DCT_B = &DCT[64]; |
int16_t *DCT_A = &DCT[0], *DCT_B = &DCT[64]; |
311 |
|
uint64_t sse_y = 0, sse_u = 0, sse_v = 0; |
312 |
|
|
313 |
|
for (y = 0; y < data->height>>3; y++) { |
314 |
uint8_t *IMG_A = (uint8_t *) data->original.plane[0]; |
uint8_t *IMG_A = (uint8_t *) data->original.plane[0]; |
315 |
uint8_t *IMG_B = (uint8_t *) data->current.plane[0]; |
uint8_t *IMG_B = (uint8_t *) data->current.plane[0]; |
316 |
uint64_t MSE_H = 0; |
uint32_t stride = data->original.stride[0]; |
317 |
|
|
318 |
for (y = 0; y < data->height; y += 8) { |
for (x = 0; x < data->width>>3; x++) { /* non multiple of 8 handling ?? */ |
319 |
for (x = 0; x < data->width; x += 8) { |
int offset = (y<<3)*stride + (x<<3); |
|
int offset = y*stride + x; |
|
320 |
|
|
321 |
emms(); |
emms(); |
322 |
|
|
331 |
emms(); |
emms(); |
332 |
|
|
333 |
/* Calculate MSE_H reduced by contrast masking effect */ |
/* Calculate MSE_H reduced by contrast masking effect */ |
334 |
MSE_H += Calc_MSE_H(DCT_A, DCT_B, IMG_A + offset, IMG_B + offset, stride); |
sse_y += Calc_MSE_H(DCT_A, DCT_B, IMG_A + offset, IMG_B + offset, stride); |
335 |
} |
} |
336 |
} |
} |
337 |
|
|
338 |
x = 4*MSE_H / (data->width * data->height); |
for (y = 0; y < data->height>>4; y++) { |
339 |
psnrhvsm->mse_sum += x; |
uint8_t *U_A = (uint8_t *) data->original.plane[1]; |
340 |
|
uint8_t *V_A = (uint8_t *) data->original.plane[2]; |
341 |
|
uint8_t *U_B = (uint8_t *) data->current.plane[1]; |
342 |
|
uint8_t *V_B = (uint8_t *) data->current.plane[2]; |
343 |
|
uint32_t stride_uv = data->current.stride[1]; |
344 |
|
|
345 |
|
for (x = 0; x < data->width>>4; x++) { /* non multiple of 8 handling ?? */ |
346 |
|
int offset = (y<<3)*stride_uv + (x<<3); |
347 |
|
|
348 |
|
emms(); |
349 |
|
|
350 |
|
/* Transfer data */ |
351 |
|
transfer_8to16copy(DCT_A, U_A + offset, stride_uv); |
352 |
|
transfer_8to16copy(DCT_B, U_B + offset, stride_uv); |
353 |
|
|
354 |
|
/* Perform DCT */ |
355 |
|
fdct(DCT_A); |
356 |
|
fdct(DCT_B); |
357 |
|
|
358 |
|
emms(); |
359 |
|
|
360 |
|
/* Calculate MSE_H reduced by contrast masking effect */ |
361 |
|
sse_u += Calc_MSE_H(DCT_A, DCT_B, U_A + offset, U_B + offset, stride_uv); |
362 |
|
|
363 |
|
emms(); |
364 |
|
|
365 |
|
/* Transfer data */ |
366 |
|
transfer_8to16copy(DCT_A, V_A + offset, stride_uv); |
367 |
|
transfer_8to16copy(DCT_B, V_B + offset, stride_uv); |
368 |
|
|
369 |
|
/* Perform DCT */ |
370 |
|
fdct(DCT_A); |
371 |
|
fdct(DCT_B); |
372 |
|
|
373 |
|
emms(); |
374 |
|
|
375 |
|
/* Calculate MSE_H reduced by contrast masking effect */ |
376 |
|
sse_v += Calc_MSE_H(DCT_A, DCT_B, V_A + offset, V_B + offset, stride_uv); |
377 |
|
} |
378 |
|
} |
379 |
|
|
380 |
|
y = (int32_t) ( 4*sse_y / (data->width * data->height)); |
381 |
|
u = (int32_t) (16*sse_u / (data->width * data->height)); |
382 |
|
v = (int32_t) (16*sse_v / (data->width * data->height)); |
383 |
|
|
384 |
|
psnrhvsm->mse_sum_y += y; |
385 |
|
psnrhvsm->mse_sum_u += u; |
386 |
|
psnrhvsm->mse_sum_v += v; |
387 |
psnrhvsm->frame_cnt++; |
psnrhvsm->frame_cnt++; |
388 |
|
|
389 |
printf(" psnrhvsm: %2.2f\n", sse_to_PSNR(x, 1024)); |
printf(" psnrhvsm y: %2.2f, psnrhvsm u: %2.2f, psnrhvsm v: %2.2f\n", sse_to_PSNR(y, 1024), sse_to_PSNR(u, 1024), sse_to_PSNR(v, 1024)); |
390 |
} |
} |
391 |
|
|
392 |
static int psnrhvsm_create(xvid_plg_create_t *create, void **handle) |
static int psnrhvsm_create(xvid_plg_create_t *create, void **handle) |
394 |
psnrhvsm_data_t *psnrhvsm; |
psnrhvsm_data_t *psnrhvsm; |
395 |
psnrhvsm = (psnrhvsm_data_t *) malloc(sizeof(psnrhvsm_data_t)); |
psnrhvsm = (psnrhvsm_data_t *) malloc(sizeof(psnrhvsm_data_t)); |
396 |
|
|
397 |
psnrhvsm->mse_sum = 0; |
psnrhvsm->mse_sum_y = 0; |
398 |
|
psnrhvsm->mse_sum_u = 0; |
399 |
|
psnrhvsm->mse_sum_v = 0; |
400 |
|
|
401 |
psnrhvsm->frame_cnt = 0; |
psnrhvsm->frame_cnt = 0; |
402 |
|
|
403 |
*(handle) = (void*) psnrhvsm; |
*(handle) = (void*) psnrhvsm; |
421 |
break; |
break; |
422 |
case(XVID_PLG_DESTROY): |
case(XVID_PLG_DESTROY): |
423 |
{ |
{ |
424 |
uint32_t MSE_H; |
uint32_t y, u, v; |
425 |
psnrhvsm_data_t *psnrhvsm = (psnrhvsm_data_t *)handle; |
psnrhvsm_data_t *psnrhvsm = (psnrhvsm_data_t *)handle; |
426 |
|
|
427 |
if (psnrhvsm) { |
if (psnrhvsm) { |
428 |
MSE_H = (uint32_t) (psnrhvsm->mse_sum / psnrhvsm->frame_cnt); |
y = (uint32_t) (psnrhvsm->mse_sum_y / psnrhvsm->frame_cnt); |
429 |
|
u = (uint32_t) (psnrhvsm->mse_sum_u / psnrhvsm->frame_cnt); |
430 |
|
v = (uint32_t) (psnrhvsm->mse_sum_v / psnrhvsm->frame_cnt); |
431 |
|
|
432 |
emms(); |
emms(); |
433 |
printf("Average psnrhvsm: %2.2f\n", sse_to_PSNR(MSE_H, 1024)); |
printf("Average psnrhvsm y: %2.2f, psnrhvsm u: %2.2f, psnrhvsm v: %2.2f\n", |
434 |
|
sse_to_PSNR(y, 1024), sse_to_PSNR(u, 1024), sse_to_PSNR(v, 1024)); |
435 |
free(psnrhvsm); |
free(psnrhvsm); |
436 |
} |
} |
437 |
} |
} |