diff options
Diffstat (limited to 'chromium/third_party/skia/tools/generate_fir_coeff.py')
-rw-r--r-- | chromium/third_party/skia/tools/generate_fir_coeff.py | 119 |
1 files changed, 119 insertions, 0 deletions
diff --git a/chromium/third_party/skia/tools/generate_fir_coeff.py b/chromium/third_party/skia/tools/generate_fir_coeff.py new file mode 100644 index 00000000000..70f521fdafc --- /dev/null +++ b/chromium/third_party/skia/tools/generate_fir_coeff.py @@ -0,0 +1,119 @@ +#!/usr/bin/python + +''' +Copyright 2013 Google Inc. + +Use of this source code is governed by a BSD-style license that can be +found in the LICENSE file. +''' + +import math +import pprint + +def withinStdDev(n): + """Returns the percent of samples within n std deviations of the normal.""" + return math.erf(n / math.sqrt(2)) + +def withinStdDevRange(a, b): + """Returns the percent of samples within the std deviation range a, b""" + if b < a: + return 0; + + if a < 0: + if b < 0: + return (withinStdDev(-a) - withinStdDev(-b)) / 2; + else: + return (withinStdDev(-a) + withinStdDev(b)) / 2; + else: + return (withinStdDev(b) - withinStdDev(a)) / 2; + + +#We have a bunch of smudged samples which represent the average coverage of a range. +#We have a 'center' which may not line up with those samples. +#From the 'center' we want to make a normal approximation where '5' sample width out we're at '3' std deviations. +#The first and last samples may not be fully covered. + +#This is the sub-sample shift for each set of FIR coefficients (the centers of the lcds in the samples) +#Each subpxl takes up 1/3 of a pixel, so they are centered at x=(i/n+1/2n), or 1/6, 3/6, 5/6 of a pixel. +#Each sample takes up 1/4 of a pixel, so the results fall at (x*4)%1, or 2/3, 0, 1/3 of a sample. +samples_per_pixel = 4 +subpxls_per_pixel = 3 +#sample_offsets is (frac, int) in sample units. +sample_offsets = [math.modf((float(subpxl_index)/subpxls_per_pixel + 1.0/(2.0*subpxls_per_pixel))*samples_per_pixel) for subpxl_index in range(subpxls_per_pixel)] + +#How many samples to consider to the left and right of the subpxl center. +sample_units_width = 5 + +#The std deviation at sample_units_width. +std_dev_max = 3 + +#The target sum is in some fixed point representation. +#Values larger the 1 in fixed point simulate ink spread. +target_sum = 0x110 + +for sample_offset, sample_align in sample_offsets: + coeffs = [] + coeffs_rounded = [] + + #We start at sample_offset - sample_units_width + current_sample_left = sample_offset - sample_units_width + current_std_dev_left = -std_dev_max + + done = False + while not done: + current_sample_right = math.floor(current_sample_left + 1) + if current_sample_right > sample_offset + sample_units_width: + done = True + current_sample_right = sample_offset + sample_units_width + current_std_dev_right = current_std_dev_left + ((current_sample_right - current_sample_left) / sample_units_width) * std_dev_max + + coverage = withinStdDevRange(current_std_dev_left, current_std_dev_right) + coeffs.append(coverage * target_sum) + coeffs_rounded.append(int(round(coverage * target_sum))) + + current_sample_left = current_sample_right + current_std_dev_left = current_std_dev_right + + # Now we have the numbers we want, but our rounding needs to add up to target_sum. + delta = 0 + coeffs_rounded_sum = sum(coeffs_rounded) + if coeffs_rounded_sum > target_sum: + # The coeffs add up to too much. Subtract 1 from the ones which were rounded up the most. + delta = -1 + + if coeffs_rounded_sum < target_sum: + # The coeffs add up to too little. Add 1 to the ones which were rounded down the most. + delta = 1 + + if delta: + print "Initial sum is 0x%0.2X, adjusting." % (coeffs_rounded_sum,) + coeff_diff = [(coeff_rounded - coeff) * delta + for coeff, coeff_rounded in zip(coeffs, coeffs_rounded)] + + class IndexTracker: + def __init__(self, index, item): + self.index = index + self.item = item + def __lt__(self, other): + return self.item < other.item + def __repr__(self): + return "arr[%d] == %s" % (self.index, repr(self.item)) + + coeff_pkg = [IndexTracker(i, diff) for i, diff in enumerate(coeff_diff)] + coeff_pkg.sort() + + # num_elements_to_force_round had better be < (2 * sample_units_width + 1) or + # * our math was wildy wrong + # * an awful lot of the curve is out side our sample + # either is pretty bad, and probably means the results will not be useful. + num_elements_to_force_round = abs(coeffs_rounded_sum - target_sum) + for i in xrange(num_elements_to_force_round): + print "Adding %d to index %d to force round %f." % (delta, coeff_pkg[i].index, coeffs[coeff_pkg[i].index]) + coeffs_rounded[coeff_pkg[i].index] += delta + + print "Prepending %d 0x00 for allignment." % (sample_align,) + coeffs_rounded_aligned = ([0] * int(sample_align)) + coeffs_rounded + + print ', '.join(["0x%0.2X" % coeff_rounded for coeff_rounded in coeffs_rounded_aligned]) + print sum(coeffs), hex(sum(coeffs_rounded)) + print |