1 |
#include "../portab.h" |
#include "../portab.h" |
2 |
|
#include "../global.h" |
3 |
#include "adapt_quant.h" |
#include "adapt_quant.h" |
4 |
|
|
5 |
#define MAX(a,b) (((a) > (b)) ? (a) : (b)) |
#include <stdlib.h> /* free, malloc */ |
6 |
|
|
7 |
#define RDIFF(a,b) ((int)(a+0.5)-(int)(b+0.5)) |
#define RDIFF(a,b) ((int)(a+0.5)-(int)(b+0.5)) |
8 |
|
|
9 |
int normalize_quantizer_field(float *in, int *out, int num, int min_quant, int max_quant) |
int |
10 |
|
normalize_quantizer_field(float *in, |
11 |
|
int *out, |
12 |
|
int num, |
13 |
|
int min_quant, |
14 |
|
int max_quant) |
15 |
{ |
{ |
16 |
int i; |
int i; |
17 |
int finished; |
int finished; |
18 |
|
|
19 |
do |
do { |
|
{ |
|
20 |
finished = 1; |
finished = 1; |
21 |
for(i = 1; i < num; i++) |
for (i = 1; i < num; i++) { |
22 |
{ |
if (RDIFF(in[i], in[i - 1]) > 2) { |
|
if(RDIFF(in[i], in[i-1]) > 2) |
|
|
{ |
|
23 |
in[i] -= (float) 0.5; |
in[i] -= (float) 0.5; |
24 |
finished = 0; |
finished = 0; |
25 |
} |
} else if (RDIFF(in[i], in[i - 1]) < -2) { |
|
else if(RDIFF(in[i], in[i-1]) < -2) |
|
|
{ |
|
26 |
in[i-1] -= (float) 0.5; |
in[i-1] -= (float) 0.5; |
27 |
finished = 0; |
finished = 0; |
28 |
} |
} |
29 |
|
|
30 |
if(in[i] > max_quant) |
if (in[i] > max_quant) { |
|
{ |
|
31 |
in[i] = (float) max_quant; |
in[i] = (float) max_quant; |
32 |
finished = 0; |
finished = 0; |
33 |
} |
} |
34 |
if(in[i] < min_quant) |
if (in[i] < min_quant) { |
|
{ |
|
35 |
in[i] = (float) min_quant; |
in[i] = (float) min_quant; |
36 |
finished = 0; |
finished = 0; |
37 |
} |
} |
38 |
if(in[i-1] > max_quant) |
if (in[i - 1] > max_quant) { |
|
{ |
|
39 |
in[i-1] = (float) max_quant; |
in[i-1] = (float) max_quant; |
40 |
finished = 0; |
finished = 0; |
41 |
} |
} |
42 |
if(in[i-1] < min_quant) |
if (in[i - 1] < min_quant) { |
|
{ |
|
43 |
in[i-1] = (float) min_quant; |
in[i-1] = (float) min_quant; |
44 |
finished = 0; |
finished = 0; |
45 |
} |
} |
53 |
return (int) (in[0] + 0.5); |
return (int) (in[0] + 0.5); |
54 |
} |
} |
55 |
|
|
56 |
int adaptive_quantization(unsigned char* buf, int stride, int* intquant, |
int |
57 |
int framequant, int min_quant, int max_quant, |
adaptive_quantization(unsigned char *buf, |
58 |
int mb_width, int mb_height) // no qstride because normalization |
int stride, |
59 |
|
int *intquant, |
60 |
|
int framequant, |
61 |
|
int min_quant, |
62 |
|
int max_quant, |
63 |
|
int mb_width, |
64 |
|
int mb_height) // no qstride because normalization |
65 |
{ |
{ |
66 |
int i,j,k,l; |
int i,j,k,l; |
67 |
|
|
68 |
static float *quant; |
float *quant; |
69 |
unsigned char *ptr; |
unsigned char *ptr; |
70 |
float *val; |
float *val; |
71 |
float global = 0.; |
float global = 0.; |
84 |
const float LowerLimit = 25; |
const float LowerLimit = 25; |
85 |
|
|
86 |
|
|
|
if(!quant) |
|
87 |
if(!(quant = (float *) malloc(mb_width*mb_height * sizeof(float)))) |
if(!(quant = (float *) malloc(mb_width*mb_height * sizeof(float)))) |
88 |
return -1; |
return(-1); |
89 |
|
|
90 |
val = (float *) malloc(mb_width*mb_height * sizeof(float)); |
if(!(val = (float *) malloc(mb_width * mb_height * sizeof(float)))) |
91 |
|
return(-1); |
92 |
|
|
93 |
for(k = 0; k < mb_height; k++) |
for (k = 0; k < mb_height; k++) { |
|
{ |
|
94 |
for(l = 0;l < mb_width; l++) // do this for all macroblocks individually |
for(l = 0;l < mb_width; l++) // do this for all macroblocks individually |
95 |
{ |
{ |
96 |
quant[k*mb_width+l] = (float) framequant; |
quant[k*mb_width+l] = (float) framequant; |
106 |
val[k*mb_width+l] /= 256.; |
val[k*mb_width+l] /= 256.; |
107 |
global += val[k*mb_width+l]; |
global += val[k*mb_width+l]; |
108 |
|
|
109 |
if((val[k*mb_width+l] > LowerLimit) && (val[k*mb_width+l] < UpperLimit)) |
if ((val[k * mb_width + l] > LowerLimit) && |
110 |
|
(val[k * mb_width + l] < UpperLimit)) |
111 |
mid_range++; |
mid_range++; |
112 |
} |
} |
113 |
} |
} |
114 |
|
|
115 |
global /= mb_width*mb_height; |
global /= mb_width*mb_height; |
116 |
|
|
117 |
if((global < GlobalBrightThres) && (global > GlobalDarkThres) |
if (((global <GlobalBrightThres) &&(global >GlobalDarkThres)) |
118 |
|| (mid_range < MidRangeThres)) { |
|| (mid_range < MidRangeThres)) { |
119 |
for(k = 0; k < mb_height; k++) |
for (k = 0; k < mb_height; k++) { |
|
{ |
|
120 |
for(l = 0;l < mb_width; l++) // do this for all macroblocks individually |
for(l = 0;l < mb_width; l++) // do this for all macroblocks individually |
121 |
{ |
{ |
122 |
if(val[k*mb_width+l] < DarkThres) |
if(val[k*mb_width+l] < DarkThres) |
123 |
quant[k*mb_width+l] += DarkAmpl*(DarkThres-val[k*mb_width+l])/DarkThres; |
quant[k * mb_width + l] += |
124 |
|
DarkAmpl * (DarkThres - |
125 |
|
val[k * mb_width + l]) / DarkThres; |
126 |
else if (val[k*mb_width+l]>BrightThres) |
else if (val[k*mb_width+l]>BrightThres) |
127 |
quant[k*mb_width+l] += BrightAmpl*(val[k*mb_width+l]-BrightThres)/(255-BrightThres); |
quant[k * mb_width + l] += |
128 |
|
BrightAmpl * (val[k * mb_width + l] - |
129 |
|
BrightThres) / (255 - BrightThres); |
130 |
} |
} |
131 |
} |
} |
132 |
} |
} |
133 |
|
|
134 |
|
i = normalize_quantizer_field(quant, intquant, |
135 |
|
mb_width * mb_height, |
136 |
|
min_quant, max_quant); |
137 |
|
|
138 |
free(val); |
free(val); |
139 |
return normalize_quantizer_field(quant, intquant, mb_width*mb_height, min_quant, max_quant); |
free(quant); |
140 |
|
|
141 |
|
return(i); |
142 |
|
|
143 |
} |
} |