| 0,0 → 1,1250 |
|---|
| /* |
| This code does smooth scaling of a pixmap. |
| |
| This function returns a new pixmap representing the area starting at (0,0) |
| given by taking the source pixmap src, scaling it to width w, and height h, |
| and then positioning it at (frac(x),frac(y)). |
| */ |
| |
| #include "fitz.h" |
| |
| /* Do we special case handling of single pixel high/wide images? The |
| * 'purest' handling is given by not special casing them, but certain |
| * files that use such images 'stack' them to give full images. Not |
| * special casing them results in then being fainter and giving noticable |
| * rounding errors. |
| */ |
| #define SINGLE_PIXEL_SPECIALS |
| |
| #ifdef DEBUG_SCALING |
| #ifdef WIN32 |
| #include <windows.h> |
| static void debug_print(const char *fmt, ...) |
| { |
| va_list args; |
| char text[256]; |
| va_start(args, fmt); |
| vsprintf(text, fmt, args); |
| va_end(args); |
| OutputDebugStringA(text); |
| printf(text); |
| } |
| #else |
| static void debug_print(const char *fmt, ...) |
| { |
| va_list args; |
| va_start(args, fmt); |
| vfprintf(stderr, fmt, args); |
| va_end(args); |
| } |
| #endif |
| #endif |
| #ifdef DEBUG_SCALING |
| #define DBUG(A) debug_print A |
| #else |
| #define DBUG(A) do {} while(0==1) |
| #endif |
| |
| /* |
| Consider a row of source samples, src, of width src_w, positioned at x, |
| scaled to width dst_w. |
| |
| src[i] is centred at: x + (i + 0.5)*dst_w/src_w |
| |
| Therefore the distance between the centre of the jth output pixel and |
| the centre of the ith source sample is: |
| |
| dist[j,i] = j + 0.5 - (x + (i + 0.5)*dst_w/src_w) |
| |
| When scaling up, therefore: |
| |
| dst[j] = SUM(filter(dist[j,i]) * src[i]) |
| (for all ints i) |
| |
| This can be simplified by noticing that filters are only non zero within |
| a given filter width (henceforth called W). So: |
| |
| dst[j] = SUM(filter(dist[j,i]) * src[i]) |
| (for ints i, s.t. (j*src_w/dst_w)-W < i < (j*src_w/dst_w)+W) |
| |
| When scaling down, each filtered source sample is stretched to be wider |
| to avoid aliasing issues. This effectively reduces the distance between |
| centres. |
| |
| dst[j] = SUM(filter(dist[j,i] * F) * F * src[i]) |
| (where F = dst_w/src_w) |
| (for ints i, s.t. (j-W)/F < i < (j+W)/F) |
| |
| */ |
| |
| typedef struct fz_scale_filter_s fz_scale_filter; |
| |
| struct fz_scale_filter_s |
| { |
| int width; |
| float (*fn)(fz_scale_filter *, float); |
| }; |
| |
| /* Image scale filters */ |
| |
| static float |
| triangle(fz_scale_filter *filter, float f) |
| { |
| if (f >= 1) |
| return 0; |
| return 1-f; |
| } |
| |
| static float |
| box(fz_scale_filter *filter, float f) |
| { |
| if (f >= 0.5f) |
| return 0; |
| return 1; |
| } |
| |
| static float |
| simple(fz_scale_filter *filter, float x) |
| { |
| if (x >= 1) |
| return 0; |
| return 1 + (2*x - 3)*x*x; |
| } |
| |
| static float |
| lanczos2(fz_scale_filter *filter, float x) |
| { |
| if (x >= 2) |
| return 0; |
| return sinf(M_PI*x) * sinf(M_PI*x/2) / (M_PI*x) / (M_PI*x/2); |
| } |
| |
| static float |
| lanczos3(fz_scale_filter *filter, float f) |
| { |
| if (f >= 3) |
| return 0; |
| return sinf(M_PI*f) * sinf(M_PI*f/3) / (M_PI*f) / (M_PI*f/3); |
| } |
| |
| /* |
| The Mitchell family of filters is defined: |
| |
| f(x) = 1 { (12-9B-6C)x^3 + (-18+12B+6C)x^2 + (6-2B) for x < 1 |
| - { |
| 6 { (-B-6C)x^3+(6B+30C)x^2+(-12B-48C)x+(8B+24C) for 1<=x<=2 |
| |
| The 'best' ones lie along the line B+2C = 1. |
| The literature suggests that B=1/3, C=1/3 is best. |
| |
| f(x) = 1 { (12-3-2)x^3 - (-18+4+2)x^2 + (16/3) for x < 1 |
| - { |
| 6 { (-7/3)x^3 + 12x^2 - 20x + (32/3) for 1<=x<=2 |
| |
| f(x) = 1 { 21x^3 - 36x^2 + 16 for x < 1 |
| - { |
| 18{ -7x^3 + 36x^2 - 60x + 32 for 1<=x<=2 |
| */ |
| |
| static float |
| mitchell(fz_scale_filter *filter, float x) |
| { |
| if (x >= 2) |
| return 0; |
| if (x >= 1) |
| return (32 + x*(-60 + x*(36 - 7*x)))/18; |
| return (16 + x*x*(-36 + 21*x))/18; |
| } |
| |
| fz_scale_filter fz_scale_filter_box = { 1, box }; |
| fz_scale_filter fz_scale_filter_triangle = { 1, triangle }; |
| fz_scale_filter fz_scale_filter_simple = { 1, simple }; |
| fz_scale_filter fz_scale_filter_lanczos2 = { 2, lanczos2 }; |
| fz_scale_filter fz_scale_filter_lanczos3 = { 3, lanczos3 }; |
| fz_scale_filter fz_scale_filter_mitchell = { 2, mitchell }; |
| |
| /* |
| We build ourselves a set of tables to contain the precalculated weights |
| for a given set of scale settings. |
| |
| The first dst_w entries in index are the index into index of the |
| sets of weight for each destination pixel. |
| |
| Each of the sets of weights is a set of values consisting of: |
| the minimum source pixel index used for this destination pixel |
| the number of weights used for this destination pixel |
| the weights themselves |
| |
| So to calculate dst[i] we do the following: |
| |
| weights = &index[index[i]]; |
| min = *weights++; |
| len = *weights++; |
| dst[i] = 0; |
| while (--len > 0) |
| dst[i] += src[min++] * *weights++ |
| |
| in addition, we guarantee that at the end of this process weights will now |
| point to the weights value for dst pixel i+1. |
| |
| In the simplest version of this algorithm, we would scale the whole image |
| horizontally first into a temporary buffer, then scale that temporary |
| buffer again vertically to give us our result. Using such a simple |
| algorithm would mean that could use the same style of weights for both |
| horizontal and vertical scaling. |
| |
| Unfortunately, this would also require a large temporary buffer, |
| particularly in the case where we are scaling up. |
| |
| We therefore modify the algorithm as follows; we scale scanlines from the |
| source image horizontally into a temporary buffer, until we have all the |
| contributors for a given output scanline. We then produce that output |
| scanline from the temporary buffer. In this way we restrict the height |
| of the temporary buffer to a small fraction of the final size. |
| |
| Unfortunately, this means that the pseudo code for recombining a |
| scanline of fully scaled pixels is as follows: |
| |
| weights = &index[index[y]]; |
| min = *weights++; |
| len = *weights++; |
| for (x=0 to dst_w) |
| min2 = min |
| len2 = len |
| weights2 = weights |
| dst[x] = 0; |
| while (--len2 > 0) |
| dst[x] += temp[x][(min2++) % tmp_buf_height] * *weights2++ |
| |
| i.e. it requires a % operation for every source pixel - this is typically |
| expensive. |
| |
| To avoid this, we alter the order in which vertical weights are stored, |
| so that they are ordered in the same order as the temporary buffer lines |
| would appear. This simplifies the algorithm to: |
| |
| weights = &index[index[y]]; |
| min = *weights++; |
| len = *weights++; |
| for (x=0 to dst_w) |
| min2 = 0 |
| len2 = len |
| weights2 = weights |
| dst[x] = 0; |
| while (--len2 > 0) |
| dst[x] += temp[i][min2++] * *weights2++ |
| |
| This means that len may be larger than it needs to be (due to the |
| possible inclusion of a zero weight row or two), but in practise this |
| is only an increase of 1 or 2 at worst. |
| |
| We implement this by generating the weights as normal (but ensuring we |
| leave enough space) and then reordering afterwards. |
| |
| */ |
| |
| typedef struct fz_weights_s fz_weights; |
| |
| struct fz_weights_s |
| { |
| int count; |
| int max_len; |
| int n; |
| int flip; |
| int new_line; |
| int index[1]; |
| }; |
| |
| static fz_weights * |
| new_weights(fz_scale_filter *filter, int src_w, float dst_w, int dst_w_i, int n, int flip) |
| { |
| int max_len; |
| fz_weights *weights; |
| |
| if (src_w > dst_w) |
| { |
| /* Scaling down, so there will be a maximum of |
| * 2*filterwidth*src_w/dst_w src pixels |
| * contributing to each dst pixel. */ |
| max_len = (int)ceilf((2 * filter->width * src_w)/dst_w); |
| if (max_len > src_w) |
| max_len = src_w; |
| } |
| else |
| { |
| /* Scaling up, so there will be a maximum of |
| * 2*filterwidth src pixels contributing to each dst pixel. |
| */ |
| max_len = 2 * filter->width; |
| } |
| /* We need the size of the struct, |
| * plus dst_w*sizeof(int) for the index |
| * plus (2+max_len)*sizeof(int) for the weights |
| * plus room for an extra set of weights for reordering. |
| */ |
| weights = fz_malloc(sizeof(*weights)+(max_len+3)*(dst_w_i+1)*sizeof(int)); |
| if (weights == NULL) |
| return NULL; |
| weights->count = -1; |
| weights->max_len = max_len; |
| weights->index[0] = dst_w_i; |
| weights->n = n; |
| weights->flip = flip; |
| return weights; |
| } |
| |
| static void |
| init_weights(fz_weights *weights, int j) |
| { |
| int index; |
| |
| assert(weights->count == j-1); |
| weights->count++; |
| weights->new_line = 1; |
| if (j == 0) |
| index = weights->index[0]; |
| else |
| { |
| index = weights->index[j-1]; |
| index += 2 + weights->index[index+1]; |
| } |
| weights->index[j] = index; /* row pointer */ |
| weights->index[index] = 0; /* min */ |
| weights->index[index+1] = 0; /* len */ |
| } |
| |
| static void |
| add_weight(fz_weights *weights, int j, int i, fz_scale_filter *filter, |
| float x, float F, float G, int src_w, float dst_w) |
| { |
| float dist = j - x + 0.5f - ((i + 0.5f)*dst_w/src_w); |
| float f; |
| int min, len, index, weight; |
| |
| dist *= G; |
| if (dist < 0) |
| dist = -dist; |
| f = filter->fn(filter, dist)*F; |
| weight = (int)(256*f+0.5f); |
| if (weight == 0) |
| return; |
| |
| /* wrap i back into range */ |
| #ifdef MIRROR_WRAP |
| do |
| { |
| if (i < 0) |
| i = -1-i; |
| else if (i >= src_w) |
| i = 2*src_w-1-i; |
| else |
| break; |
| } |
| while (1); |
| #elif defined(WRAP) |
| if (i < 0) |
| i = 0; |
| else if (i >= src_w) |
| i = src_w-1; |
| #else |
| if (i < 0) |
| { |
| i = 0; |
| weight = 0; |
| } |
| else if (i >= src_w) |
| { |
| i = src_w-1; |
| weight = 0; |
| } |
| if (weight == 0) |
| return; |
| #endif |
| |
| DBUG(("add_weight[%d][%d] = %d(%g) dist=%g\n",j,i,weight,f,dist)); |
| |
| if (weights->new_line) |
| { |
| /* New line */ |
| weights->new_line = 0; |
| index = weights->index[j]; /* row pointer */ |
| weights->index[index] = i; /* min */ |
| weights->index[index+1] = 0; /* len */ |
| } |
| index = weights->index[j]; |
| min = weights->index[index++]; |
| len = weights->index[index++]; |
| while (i < min) |
| { |
| /* This only happens in rare cases, but we need to insert |
| * one earlier. In exceedingly rare cases we may need to |
| * insert more than one earlier. */ |
| int k; |
| |
| for (k = len; k > 0; k--) |
| { |
| weights->index[index+k] = weights->index[index+k-1]; |
| } |
| weights->index[index] = 0; |
| min--; |
| len++; |
| weights->index[index-2] = min; |
| weights->index[index-1] = len; |
| } |
| if (i-min >= len) |
| { |
| /* The usual case */ |
| while (i-min >= ++len) |
| { |
| weights->index[index+len-1] = 0; |
| } |
| assert(len-1 == i-min); |
| weights->index[index+i-min] = weight; |
| weights->index[index-1] = len; |
| assert(len <= weights->max_len); |
| } |
| else |
| { |
| /* Infrequent case */ |
| weights->index[index+i-min] += weight; |
| } |
| } |
| |
| static void |
| reorder_weights(fz_weights *weights, int j, int src_w) |
| { |
| int idx = weights->index[j]; |
| int min = weights->index[idx++]; |
| int len = weights->index[idx++]; |
| int max = weights->max_len; |
| int tmp = idx+max; |
| int i, off; |
| |
| /* Copy into the temporary area */ |
| memcpy(&weights->index[tmp], &weights->index[idx], sizeof(int)*len); |
| |
| /* Pad out if required */ |
| assert(len <= max); |
| assert(min+len <= src_w); |
| off = 0; |
| if (len < max) |
| { |
| memset(&weights->index[tmp+len], 0, sizeof(int)*(max-len)); |
| len = max; |
| if (min + len > src_w) |
| { |
| off = min + len - src_w; |
| min = src_w - len; |
| weights->index[idx-2] = min; |
| } |
| weights->index[idx-1] = len; |
| } |
| |
| /* Copy back into the proper places */ |
| for (i = 0; i < len; i++) |
| { |
| weights->index[idx+((min+i+off) % max)] = weights->index[tmp+i]; |
| } |
| } |
| |
| /* Due to rounding and edge effects, the sums for the weights sometimes don't |
| * add up to 256. This causes visible rendering effects. Therefore, we take |
| * pains to ensure that they 1) never exceed 256, and 2) add up to exactly |
| * 256 for all pixels that are completely covered. See bug #691629. */ |
| static void |
| check_weights(fz_weights *weights, int j, int w, float x, float wf) |
| { |
| int idx, len; |
| int sum = 0; |
| int max = -256; |
| int maxidx = 0; |
| int i; |
| |
| idx = weights->index[j]; |
| idx++; /* min */ |
| len = weights->index[idx++]; |
| |
| for(i=0; i < len; i++) |
| { |
| int v = weights->index[idx++]; |
| sum += v; |
| if (v > max) |
| { |
| max = v; |
| maxidx = idx; |
| } |
| } |
| /* If we aren't the first or last pixel, OR if the sum is too big |
| * then adjust it. */ |
| if (((j != 0) && (j != w-1)) || (sum > 256)) |
| weights->index[maxidx-1] += 256-sum; |
| /* Otherwise, if we are the first pixel, and it's fully covered, then |
| * adjust it. */ |
| else if ((j == 0) && (x < 0.0001F) && (sum != 256)) |
| weights->index[maxidx-1] += 256-sum; |
| /* Finally, if we are the last pixel, and it's fully covered, then |
| * adjust it. */ |
| else if ((j == w-1) && ((float)w-wf < 0.0001F) && (sum != 256)) |
| weights->index[maxidx-1] += 256-sum; |
| DBUG(("total weight %d = %d\n", j, sum)); |
| } |
| |
| static fz_weights * |
| make_weights(int src_w, float x, float dst_w, fz_scale_filter *filter, int vertical, int dst_w_int, int n, int flip) |
| { |
| fz_weights *weights; |
| float F, G; |
| float window; |
| int j; |
| |
| if (dst_w < src_w) |
| { |
| /* Scaling down */ |
| F = dst_w / src_w; |
| G = 1; |
| } |
| else |
| { |
| /* Scaling up */ |
| F = 1; |
| G = src_w / dst_w; |
| } |
| window = filter->width / F; |
| DBUG(("make_weights src_w=%d x=%g dst_w=%g dst_w_int=%d F=%g window=%g\n", src_w, x, dst_w, dst_w_int, F, window)); |
| weights = new_weights(filter, src_w, dst_w, dst_w_int, n, flip); |
| if (weights == NULL) |
| return NULL; |
| for (j = 0; j < dst_w_int; j++) |
| { |
| /* find the position of the centre of dst[j] in src space */ |
| float centre = (j - x + 0.5f)*src_w/dst_w - 0.5f; |
| int l, r; |
| l = ceilf(centre - window); |
| r = floorf(centre + window); |
| DBUG(("%d: centre=%g l=%d r=%d\n", j, centre, l, r)); |
| init_weights(weights, j); |
| for (; l <= r; l++) |
| { |
| add_weight(weights, j, l, filter, x, F, G, src_w, dst_w); |
| } |
| check_weights(weights, j, dst_w_int, x, dst_w); |
| if (vertical) |
| { |
| reorder_weights(weights, j, src_w); |
| } |
| } |
| weights->count++; /* weights->count = dst_w_int now */ |
| return weights; |
| } |
| |
| static void |
| scale_row_to_temp(int *dst, unsigned char *src, fz_weights *weights) |
| { |
| int *contrib = &weights->index[weights->index[0]]; |
| int len, i, j, n; |
| unsigned char *min; |
| |
| n = weights->n; |
| if (weights->flip) |
| { |
| dst += (weights->count-1)*n; |
| for (i=weights->count; i > 0; i--) |
| { |
| min = &src[n * *contrib++]; |
| len = *contrib++; |
| for (j = 0; j < n; j++) |
| dst[j] = 0; |
| while (len-- > 0) |
| { |
| for (j = n; j > 0; j--) |
| *dst++ += *min++ * *contrib; |
| dst -= n; |
| contrib++; |
| } |
| dst -= n; |
| } |
| } |
| else |
| { |
| for (i=weights->count; i > 0; i--) |
| { |
| min = &src[n * *contrib++]; |
| len = *contrib++; |
| for (j = 0; j < n; j++) |
| dst[j] = 0; |
| while (len-- > 0) |
| { |
| for (j = n; j > 0; j--) |
| *dst++ += *min++ * *contrib; |
| dst -= n; |
| contrib++; |
| } |
| dst += n; |
| } |
| } |
| } |
| |
| static void |
| scale_row_to_temp1(int *dst, unsigned char *src, fz_weights *weights) |
| { |
| int *contrib = &weights->index[weights->index[0]]; |
| int len, i; |
| unsigned char *min; |
| |
| assert(weights->n == 1); |
| if (weights->flip) |
| { |
| dst += weights->count; |
| for (i=weights->count; i > 0; i--) |
| { |
| int val = 0; |
| min = &src[*contrib++]; |
| len = *contrib++; |
| while (len-- > 0) |
| { |
| val += *min++ * *contrib++; |
| } |
| *--dst = val; |
| } |
| } |
| else |
| { |
| for (i=weights->count; i > 0; i--) |
| { |
| int val = 0; |
| min = &src[*contrib++]; |
| len = *contrib++; |
| while (len-- > 0) |
| { |
| val += *min++ * *contrib++; |
| } |
| *dst++ = val; |
| } |
| } |
| } |
| |
| static void |
| scale_row_to_temp2(int *dst, unsigned char *src, fz_weights *weights) |
| { |
| int *contrib = &weights->index[weights->index[0]]; |
| int len, i; |
| unsigned char *min; |
| |
| assert(weights->n == 2); |
| if (weights->flip) |
| { |
| dst += 2*weights->count; |
| for (i=weights->count; i > 0; i--) |
| { |
| int c1 = 0; |
| int c2 = 0; |
| min = &src[2 * *contrib++]; |
| len = *contrib++; |
| while (len-- > 0) |
| { |
| c1 += *min++ * *contrib; |
| c2 += *min++ * *contrib++; |
| } |
| *--dst = c2; |
| *--dst = c1; |
| } |
| } |
| else |
| { |
| for (i=weights->count; i > 0; i--) |
| { |
| int c1 = 0; |
| int c2 = 0; |
| min = &src[2 * *contrib++]; |
| len = *contrib++; |
| while (len-- > 0) |
| { |
| c1 += *min++ * *contrib; |
| c2 += *min++ * *contrib++; |
| } |
| *dst++ = c1; |
| *dst++ = c2; |
| } |
| } |
| } |
| |
| static void |
| scale_row_to_temp4(int *dst, unsigned char *src, fz_weights *weights) |
| { |
| int *contrib = &weights->index[weights->index[0]]; |
| #ifndef ARCH_ARM |
| int len, i; |
| unsigned char *min; |
| #endif |
| |
| assert(weights->n == 4); |
| if (weights->flip) |
| { |
| dst += 4*weights->count; |
| #ifdef ARCH_ARM |
| asm volatile( |
| "1:" |
| "ldr r4, [%2], #4 @ r4 = *contrib++ \n" |
| "ldr r9, [%2], #4 @ r9 = len = *contrib++ \n" |
| "mov r5, #0 @ r5 = r = 0 \n" |
| "mov r6, #0 @ r6 = g = 0 \n" |
| "mov r7, #0 @ r7 = b = 0 \n" |
| "mov r8, #0 @ r8 = a = 0 \n" |
| "add r4, %1, r4, LSL #2 @ r4 = min = &src[4*r4] \n" |
| "cmp r9, #0 @ while (len-- > 0) \n" |
| "beq 3f @ { \n" |
| "2: \n" |
| "ldr r10,[%2], #4 @ r10 = *contrib++ \n" |
| "ldrb r11,[r4], #1 @ r11 = *min++ \n" |
| "ldrb r12,[r4], #1 @ r12 = *min++ \n" |
| "ldrb r14,[r4], #1 @ r14 = *min++ \n" |
| "mla r5, r10,r11,r5 @ r += r11 * r10 \n" |
| "ldrb r11,[r4], #1 @ r11 = *min++ \n" |
| "mla r6, r10,r12,r6 @ g += r12 * r10 \n" |
| "mla r7, r10,r14,r7 @ b += r14 * r10 \n" |
| "mla r8, r10,r11,r8 @ a += r11 * r10 \n" |
| "subs r9, r9, #1 @ r9 = len-- \n" |
| "bgt 2b @ } \n" |
| "stmdb %0!,{r5,r6,r7,r8} @ *--dst=a;*--dst=b; \n" |
| "3: @ *--dst=g;*--dst=r; \n" |
| "subs %3, %3, #1 @ i-- \n" |
| "bgt 1b @ \n" |
| : |
| : |
| "r" (dst), |
| "r" (src), |
| "r" (contrib), |
| "r" (weights->count) |
| : |
| "r4","r5","r6","r7","r8","r9","r10","r11","r12","r14", |
| "memory","cc" |
| ); |
| #else |
| for (i=weights->count; i > 0; i--) |
| { |
| int r = 0; |
| int g = 0; |
| int b = 0; |
| int a = 0; |
| min = &src[4 * *contrib++]; |
| len = *contrib++; |
| while (len-- > 0) |
| { |
| r += *min++ * *contrib; |
| g += *min++ * *contrib; |
| b += *min++ * *contrib; |
| a += *min++ * *contrib++; |
| } |
| *--dst = a; |
| *--dst = b; |
| *--dst = g; |
| *--dst = r; |
| } |
| #endif |
| } |
| else |
| { |
| #ifdef ARCH_ARM |
| asm volatile( |
| "1:" |
| "ldr r4, [%2], #4 @ r4 = *contrib++ \n" |
| "ldr r9, [%2], #4 @ r9 = len = *contrib++ \n" |
| "mov r5, #0 @ r5 = r = 0 \n" |
| "mov r6, #0 @ r6 = g = 0 \n" |
| "mov r7, #0 @ r7 = b = 0 \n" |
| "mov r8, #0 @ r8 = a = 0 \n" |
| "add r4, %1, r4, LSL #2 @ r4 = min = &src[4*r4] \n" |
| "cmp r9, #0 @ while (len-- > 0) \n" |
| "beq 3f @ { \n" |
| "2: \n" |
| "ldr r10,[%2], #4 @ r10 = *contrib++ \n" |
| "ldrb r11,[r4], #1 @ r11 = *min++ \n" |
| "ldrb r12,[r4], #1 @ r12 = *min++ \n" |
| "ldrb r14,[r4], #1 @ r14 = *min++ \n" |
| "mla r5, r10,r11,r5 @ r += r11 * r10 \n" |
| "ldrb r11,[r4], #1 @ r11 = *min++ \n" |
| "mla r6, r10,r12,r6 @ g += r12 * r10 \n" |
| "mla r7, r10,r14,r7 @ b += r14 * r10 \n" |
| "mla r8, r10,r11,r8 @ a += r11 * r10 \n" |
| "subs r9, r9, #1 @ r9 = len-- \n" |
| "bgt 2b @ } \n" |
| "stmia %0!,{r5,r6,r7,r8} @ *dst++=r;*dst++=g; \n" |
| "3: @ *dst++=b;*dst++=a; \n" |
| "subs %3, %3, #1 @ i-- \n" |
| "bgt 1b @ \n" |
| : |
| : |
| "r" (dst), |
| "r" (src), |
| "r" (contrib), |
| "r" (weights->count) |
| : |
| "r4","r5","r6","r7","r8","r9","r10","r11","r12","r14", |
| "memory","cc" |
| ); |
| #else |
| for (i=weights->count; i > 0; i--) |
| { |
| int r = 0; |
| int g = 0; |
| int b = 0; |
| int a = 0; |
| min = &src[4 * *contrib++]; |
| len = *contrib++; |
| while (len-- > 0) |
| { |
| r += *min++ * *contrib; |
| g += *min++ * *contrib; |
| b += *min++ * *contrib; |
| a += *min++ * *contrib++; |
| } |
| *dst++ = r; |
| *dst++ = g; |
| *dst++ = b; |
| *dst++ = a; |
| } |
| #endif |
| } |
| } |
| |
| static void |
| scale_row_from_temp(unsigned char *dst, int *src, fz_weights *weights, int width, int row) |
| { |
| int *contrib = &weights->index[weights->index[row]]; |
| int len, x; |
| |
| contrib++; /* Skip min */ |
| len = *contrib++; |
| for (x=width; x > 0; x--) |
| { |
| int *min = src; |
| int val = 0; |
| int len2 = len; |
| int *contrib2 = contrib; |
| |
| while (len2-- > 0) |
| { |
| val += *min * *contrib2++; |
| min += width; |
| } |
| val = (val+(1<<15))>>16; |
| if (val < 0) |
| val = 0; |
| else if (val > 255) |
| val = 255; |
| *dst++ = val; |
| src++; |
| } |
| } |
| |
| #ifdef SINGLE_PIXEL_SPECIALS |
| static void |
| duplicate_single_pixel(unsigned char *dst, unsigned char *src, int n, int w, int h) |
| { |
| int i; |
| |
| for (i = n; i > 0; i--) |
| *dst++ = *src++; |
| for (i = (w*h-1)*n; i > 0; i--) |
| { |
| *dst = dst[-n]; |
| dst++; |
| } |
| } |
| |
| static void |
| scale_single_row(unsigned char *dst, unsigned char *src, fz_weights *weights, int src_w, int h) |
| { |
| int *contrib = &weights->index[weights->index[0]]; |
| int min, len, i, j, val, n; |
| int tmp[FZ_MAX_COLORS]; |
| |
| n = weights->n; |
| /* Scale a single row */ |
| if (weights->flip) |
| { |
| dst += (weights->count-1)*n; |
| for (i=weights->count; i > 0; i--) |
| { |
| min = *contrib++; |
| len = *contrib++; |
| min *= n; |
| for (j = 0; j < n; j++) |
| tmp[j] = 0; |
| while (len-- > 0) |
| { |
| for (j = 0; j < n; j++) |
| tmp[j] += src[min++] * *contrib; |
| contrib++; |
| } |
| for (j = 0; j < n; j++) |
| { |
| val = (tmp[j]+(1<<7))>>8; |
| if (val < 0) |
| val = 0; |
| else if (val > 255) |
| val = 255; |
| *dst++ = val; |
| } |
| dst -= 2*n; |
| } |
| dst += n * (weights->count+1); |
| } |
| else |
| { |
| for (i=weights->count; i > 0; i--) |
| { |
| min = *contrib++; |
| len = *contrib++; |
| min *= n; |
| for (j = 0; j < n; j++) |
| tmp[j] = 0; |
| while (len-- > 0) |
| { |
| for (j = 0; j < n; j++) |
| tmp[j] += src[min++] * *contrib; |
| contrib++; |
| } |
| for (j = 0; j < n; j++) |
| { |
| val = (tmp[j]+(1<<7))>>8; |
| if (val < 0) |
| val = 0; |
| else if (val > 255) |
| val = 255; |
| *dst++ = val; |
| } |
| } |
| } |
| /* And then duplicate it h times */ |
| n *= weights->count; |
| while (--h > 0) |
| { |
| memcpy(dst, dst-n, n); |
| dst += n; |
| } |
| } |
| |
| static void |
| scale_single_col(unsigned char *dst, unsigned char *src, fz_weights *weights, int src_w, int n, int w, int flip_y) |
| { |
| int *contrib = &weights->index[weights->index[0]]; |
| int min, len, i, j, val; |
| int tmp[FZ_MAX_COLORS]; |
| |
| if (flip_y) |
| { |
| src_w = (src_w-1)*n; |
| w = (w-1)*n; |
| for (i=weights->count; i > 0; i--) |
| { |
| /* Scale the next pixel in the column */ |
| min = *contrib++; |
| len = *contrib++; |
| min = src_w-min*n; |
| for (j = 0; j < n; j++) |
| tmp[j] = 0; |
| while (len-- > 0) |
| { |
| for (j = 0; j < n; j++) |
| tmp[j] += src[src_w-min+j] * *contrib; |
| contrib++; |
| } |
| for (j = 0; j < n; j++) |
| { |
| val = (tmp[j]+(1<<7))>>8; |
| if (val < 0) |
| val = 0; |
| else if (val > 255) |
| val = 255; |
| *dst++ = val; |
| } |
| /* And then duplicate it across the row */ |
| for (j = w; j > 0; j--) |
| { |
| *dst = dst[-n]; |
| dst++; |
| } |
| } |
| } |
| else |
| { |
| w = (w-1)*n; |
| for (i=weights->count; i > 0; i--) |
| { |
| /* Scale the next pixel in the column */ |
| min = *contrib++; |
| len = *contrib++; |
| min *= n; |
| for (j = 0; j < n; j++) |
| tmp[j] = 0; |
| while (len-- > 0) |
| { |
| for (j = 0; j < n; j++) |
| tmp[j] += src[min++] * *contrib; |
| contrib++; |
| } |
| for (j = 0; j < n; j++) |
| { |
| val = (tmp[j]+(1<<7))>>8; |
| if (val < 0) |
| val = 0; |
| else if (val > 255) |
| val = 255; |
| *dst++ = val; |
| } |
| /* And then duplicate it across the row */ |
| for (j = w; j > 0; j--) |
| { |
| *dst = dst[-n]; |
| dst++; |
| } |
| } |
| } |
| } |
| #endif /* SINGLE_PIXEL_SPECIALS */ |
| |
| fz_pixmap * |
| fz_scale_pixmap_gridfit(fz_pixmap *src, float x, float y, float w, float h, int gridfit) |
| { |
| if (gridfit) { |
| float n; |
| if (w > 0) { |
| /* Adjust the left hand edge, leftwards to a pixel boundary */ |
| n = (float)(int)x; /* n is now on a pixel boundary */ |
| if (n > x) /* Ensure it's the pixel boundary BELOW x */ |
| n -= 1.0f; |
| w += x-n; /* width gets wider as x >= n */ |
| x = n; |
| /* Adjust the right hand edge rightwards to a pixel boundary */ |
| n = (float)(int)w; /* n is now the integer width <= w */ |
| if (n != w) /* If w isn't an integer already, bump it */ |
| w = 1.0f + n;/* up to the next integer. */ |
| } else { |
| /* Adjust the right hand edge, rightwards to a pixel boundary */ |
| n = (float)(int)x; /* n is now on a pixel boundary */ |
| if (n > x) /* Ensure it's the pixel boundary <= x */ |
| n -= 1.0f; |
| if (n != x) /* If x isn't on a pixel boundary already, */ |
| n += 1.0f; /* make n be the pixel boundary above x. */ |
| w -= n-x; /* Expand width (more negative!) as n >= x */ |
| x = n; |
| /* Adjust the left hand edge leftwards to a pixel boundary */ |
| n = (float)(int)w; |
| if (n != w) |
| w = n - 1.0f; |
| } |
| if (h > 0) { |
| /* Adjust the bottom edge, downwards to a pixel boundary */ |
| n = (float)(int)y; /* n is now on a pixel boundary */ |
| if (n > y) /* Ensure it's the pixel boundary BELOW y */ |
| n -= 1.0f; |
| h += y-n; /* height gets larger as y >= n */ |
| y = n; |
| /* Adjust the top edge upwards to a pixel boundary */ |
| n = (float)(int)h; /* n is now the integer height <= h */ |
| if (n != h) /* If h isn't an integer already, bump it */ |
| h = 1.0f + n;/* up to the next integer. */ |
| } else { |
| /* Adjust the top edge, upwards to a pixel boundary */ |
| n = (float)(int)y; /* n is now on a pixel boundary */ |
| if (n > y) /* Ensure it's the pixel boundary <= y */ |
| n -= 1.0f; |
| if (n != y) /* If y isn't on a pixel boundary already, */ |
| n += 1.0f; /* make n be the pixel boundary above y. */ |
| h -= n-y; /* Expand height (more negative!) as n >= y */ |
| y = n; |
| /* Adjust the bottom edge downwards to a pixel boundary */ |
| n = (float)(int)h; |
| if (n != h) |
| h = n - 1.0f; |
| } |
| } |
| return fz_scale_pixmap(src, x, y, w, h); |
| } |
| |
| fz_pixmap * |
| fz_scale_pixmap(fz_pixmap *src, float x, float y, float w, float h) |
| { |
| fz_scale_filter *filter = &fz_scale_filter_simple; |
| fz_weights *contrib_rows = NULL; |
| fz_weights *contrib_cols = NULL; |
| fz_pixmap *output = NULL; |
| int *temp = NULL; |
| int max_row, temp_span, temp_rows, row; |
| int dst_w_int, dst_h_int, dst_x_int, dst_y_int; |
| int flip_x, flip_y; |
| |
| DBUG(("Scale: (%d,%d) to (%g,%g) at (%g,%g)\n",src->w,src->h,w,h,x,y)); |
| |
| /* Find the destination bbox, width/height, and sub pixel offset, |
| * allowing for whether we're flipping or not. */ |
| /* Note that the x and y sub pixel offsets here are different. |
| * The (x,y) position given describes where the bottom left corner |
| * of the source image should be mapped to (i.e. where (0,h) in image |
| * space ends up, not the more logical and sane (0,0)). Also there |
| * are differences in the way we scale horizontally and vertically. |
| * When scaling rows horizontally, we always read forwards through |
| * the source, and store either forwards or in reverse as required. |
| * When scaling vertically, we always store out forwards, but may |
| * feed source rows in in a different order. |
| * |
| * Consider the image rectange 'r' to which the image is mapped, |
| * and the (possibly) larger rectangle 'R', given by expanding 'r' to |
| * complete pixels. |
| * |
| * x can either be r.xmin-R.xmin or R.xmax-r.xmax depending on whether |
| * the image is x flipped or not. Whatever happens 0 <= x < 1. |
| * y is always R.ymax - r.ymax. |
| */ |
| /* dst_x_int is calculated to be the left of the scaled image, and |
| * x (the sub_pixel_offset) is the distance in from either the left |
| * or right pixel expanded edge. */ |
| flip_x = (w < 0); |
| if (flip_x) |
| { |
| float tmp; |
| w = -w; |
| dst_x_int = floor(x-w); |
| tmp = ceilf(x); |
| dst_w_int = (int)tmp; |
| x = tmp - x; |
| dst_w_int -= dst_x_int; |
| } |
| else |
| { |
| dst_x_int = floor(x); |
| x -= (float)dst_x_int; |
| dst_w_int = (int)ceilf(x + w); |
| } |
| flip_y = (h < 0); |
| /* dst_y_int is calculated to be the bottom of the scaled image, but |
| * y (the sub pixel offset) has to end up being the value at the top. |
| */ |
| if (flip_y) |
| { |
| h = -h; |
| dst_y_int = floor(y-h); |
| dst_h_int = (int)ceilf(y) - dst_y_int; |
| } else { |
| dst_y_int = floor(y); |
| y += h; |
| dst_h_int = (int)ceilf(y) - dst_y_int; |
| } |
| /* y is the top edge position in floats. We want it to be the |
| * distance down from the next pixel boundary. */ |
| y = ceilf(y) - y; |
| |
| DBUG(("Result image: (%d,%d) at (%d,%d) (subpix=%g,%g)\n", dst_w_int, dst_h_int, dst_x_int, dst_y_int, x, y)); |
| |
| /* Step 1: Calculate the weights for columns and rows */ |
| #ifdef SINGLE_PIXEL_SPECIALS |
| if (src->w == 1) |
| { |
| contrib_cols = NULL; |
| } |
| else |
| #endif /* SINGLE_PIXEL_SPECIALS */ |
| { |
| contrib_cols = make_weights(src->w, x, w, filter, 0, dst_w_int, src->n, flip_x); |
| if (contrib_cols == NULL) |
| goto cleanup; |
| } |
| #ifdef SINGLE_PIXEL_SPECIALS |
| if (src->h == 1) |
| { |
| contrib_rows = NULL; |
| } |
| else |
| #endif /* SINGLE_PIXEL_SPECIALS */ |
| { |
| contrib_rows = make_weights(src->h, y, h, filter, 1, dst_h_int, src->n, flip_y); |
| if (contrib_rows == NULL) |
| goto cleanup; |
| } |
| |
| assert(contrib_cols == NULL || contrib_cols->count == dst_w_int); |
| assert(contrib_rows == NULL || contrib_rows->count == dst_h_int); |
| output = fz_new_pixmap(src->colorspace, dst_w_int, dst_h_int); |
| output->x = dst_x_int; |
| output->y = dst_y_int; |
| |
| /* Step 2: Apply the weights */ |
| #ifdef SINGLE_PIXEL_SPECIALS |
| if (contrib_rows == NULL) |
| { |
| /* Only 1 source pixel high. */ |
| if (contrib_cols == NULL) |
| { |
| /* Only 1 pixel in the entire image! */ |
| duplicate_single_pixel(output->samples, src->samples, src->n, dst_w_int, dst_h_int); |
| } |
| else |
| { |
| /* Scale the row once, then copy it. */ |
| scale_single_row(output->samples, src->samples, contrib_cols, src->w, dst_h_int); |
| } |
| } |
| else if (contrib_cols == NULL) |
| { |
| /* Only 1 source pixel wide. Scale the col and duplicate. */ |
| scale_single_col(output->samples, src->samples, contrib_rows, src->h, src->n, dst_w_int, flip_y); |
| } |
| else |
| #endif /* SINGLE_PIXEL_SPECIALS */ |
| { |
| void (*row_scale)(int *dst, unsigned char *src, fz_weights *weights); |
| |
| temp_span = contrib_cols->count * src->n; |
| temp_rows = contrib_rows->max_len; |
| if (temp_span <= 0 || temp_rows > INT_MAX / temp_span) |
| goto cleanup; |
| temp = fz_calloc(temp_span*temp_rows, sizeof(int)); |
| if (temp == NULL) |
| goto cleanup; |
| switch (src->n) |
| { |
| default: |
| row_scale = scale_row_to_temp; |
| break; |
| case 1: /* Image mask case */ |
| row_scale = scale_row_to_temp1; |
| break; |
| case 2: /* Greyscale with alpha case */ |
| row_scale = scale_row_to_temp2; |
| break; |
| case 4: /* RGBA */ |
| row_scale = scale_row_to_temp4; |
| break; |
| } |
| max_row = 0; |
| for (row = 0; row < contrib_rows->count; row++) |
| { |
| /* |
| Which source rows do we need to have scaled into the |
| temporary buffer in order to be able to do the final |
| scale? |
| */ |
| int row_index = contrib_rows->index[row]; |
| int row_min = contrib_rows->index[row_index++]; |
| int row_len = contrib_rows->index[row_index++]; |
| while (max_row < row_min+row_len) |
| { |
| /* Scale another row */ |
| assert(max_row < src->h); |
| DBUG(("scaling row %d to temp\n", max_row)); |
| (*row_scale)(&temp[temp_span*(max_row % temp_rows)], &src->samples[(flip_y ? (src->h-1-max_row): max_row)*src->w*src->n], contrib_cols); |
| max_row++; |
| } |
| |
| DBUG(("scaling row %d from temp\n", row)); |
| scale_row_from_temp(&output->samples[row*output->w*output->n], temp, contrib_rows, temp_span, row); |
| } |
| fz_free(temp); |
| } |
| |
| cleanup: |
| fz_free(contrib_rows); |
| fz_free(contrib_cols); |
| return output; |
| } |