void setHistogram(double *src, int *hist, int width, int height) {
InitHistogram(hist);
for (int j = 0;j<height;j++)
for (int i = 0;i<width;i++) {
int tempv = src[j*width + i];
hist[tempv]++;
}
}
static int MBAnalyzeBestIntra4Mode(VP8EncIterator* const it,
int best_alpha) {
uint8_t modes[16];
const int max_mode = MAX_INTRA4_MODE;
int i4_alpha;
VP8Histogram total_histo;
int cur_histo = 0;
InitHistogram(&total_histo);
VP8IteratorStartI4(it);
do {
int mode;
int best_mode_alpha = DEFAULT_ALPHA;
VP8Histogram histos[2];
const uint8_t* const src = it->yuv_in_ + Y_OFF + VP8Scan[it->i4_];
VP8MakeIntra4Preds(it);
for (mode = 0; mode < max_mode; ++mode) {
int alpha;
InitHistogram(&histos[cur_histo]);
VP8CollectHistogram(src, it->yuv_p_ + VP8I4ModeOffsets[mode],
0, 1, &histos[cur_histo]);
alpha = GetAlpha(&histos[cur_histo]);
if (IS_BETTER_ALPHA(alpha, best_mode_alpha)) {
best_mode_alpha = alpha;
modes[it->i4_] = mode;
cur_histo ^= 1; // keep track of best histo so far.
}
}
// accumulate best histogram
MergeHistograms(&histos[cur_histo ^ 1], &total_histo);
// Note: we reuse the original samples for predictors
} while (VP8IteratorRotateI4(it, it->yuv_in_ + Y_OFF));
i4_alpha = GetAlpha(&total_histo);
if (IS_BETTER_ALPHA(i4_alpha, best_alpha)) {
VP8SetIntra4Mode(it, modes);
best_alpha = i4_alpha;
}
return best_alpha;
}
//均衡直方图，将原图直方图，经过公式得到目标直方图
void EqualizationHist(int *src_hist, double *dst_map) {
int temphist[GRAY_LEVEL];
InitHistogram(temphist);
int max = findHistogramMax(src_hist);
int min = findHistogramMin(src_hist);
temphist[min] = src_hist[min];
for (int i = min + 1;i <= max;i++)
temphist[i] = temphist[i - 1] + src_hist[i];
for (int i = min;i <= max;i++)
temphist[i] -= temphist[min];
int total = temphist[max];
for (int i = min;i <= max;i++) {
dst_map[i] = ((double)GRAY_LEVEL - 1.0)*temphist[i] / total;
}
}
/******************************
直方图归一化
******************************/
void HistogramSpecification(double *src, double *dst, int* hist, int width, int height) {
int src_hist[GRAY_LEVEL];
setHistogram(src, src_hist, width, height);
double srcMap[GRAY_LEVEL];
double histMap[GRAY_LEVEL];
InitMappingTable(srcMap, GRAY_LEVEL, TABLE_DOUBLE);
EqualizationHist(src_hist, srcMap);
EqualizationHist(hist, histMap);
int histMap_[GRAY_LEVEL];
InitHistogram(histMap_);
for (int i = 0;i<GRAY_LEVEL;i++)
histMap_[(int)histMap[i]] = i;
double dstMap[GRAY_LEVEL];
for (int i = 0;i<GRAY_LEVEL;i++) {
dstMap[i] = histMap_[(int)srcMap[i]];
}
fillMaptable(dstMap);
for (int i = 0;i<width;i++)
for (int j = 0;j<height;j++)
dst[j*width + i] = dstMap[(int)src[j*width + i]];
}
static int MBAnalyzeBestUVMode(VP8EncIterator* const it) {
int best_alpha = DEFAULT_ALPHA;
int best_mode = 0;
const int max_mode = MAX_UV_MODE;
int mode;
VP8MakeChroma8Preds(it);
for (mode = 0; mode < max_mode; ++mode) {
VP8Histogram histo;
int alpha;
InitHistogram(&histo);
VP8CollectHistogram(it->yuv_in_ + U_OFF,
it->yuv_p_ + VP8UVModeOffsets[mode],
16, 16 + 4 + 4, &histo);
alpha = GetAlpha(&histo);
if (IS_BETTER_ALPHA(alpha, best_alpha)) {
best_alpha = alpha;
best_mode = mode;
}
}
VP8SetIntraUVMode(it, best_mode);
return best_alpha;
}
static int MBAnalyzeBestIntra16Mode(VP8EncIterator* const it) {
const int max_mode = MAX_INTRA16_MODE;
int mode;
int best_alpha = DEFAULT_ALPHA;
int best_mode = 0;
VP8MakeLuma16Preds(it);
for (mode = 0; mode < max_mode; ++mode) {
VP8Histogram histo;
int alpha;
InitHistogram(&histo);
VP8CollectHistogram(it->yuv_in_ + Y_OFF,
it->yuv_p_ + VP8I16ModeOffsets[mode],
0, 16, &histo);
alpha = GetAlpha(&histo);
if (IS_BETTER_ALPHA(alpha, best_alpha)) {
best_alpha = alpha;
best_mode = mode;
}
}
VP8SetIntra16Mode(it, best_mode);
return best_alpha;
}
