The Tor Browser / file comparison

comparison: media/libvpx/vpx_scale/generic/vpx_scale.c

media/libvpx/vpx_scale/generic/vpx_scale.c

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:1248d4894fe8
1 /*
2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11
12 /****************************************************************************
13 *
14 * Module Title : scale.c
15 *
16 * Description : Image scaling functions.
17 *
18 ***************************************************************************/
19
20 /****************************************************************************
21 * Header Files
22 ****************************************************************************/
23 #include "./vpx_scale_rtcd.h"
24 #include "vpx_mem/vpx_mem.h"
25 #include "vpx_scale/yv12config.h"
26
27 typedef struct {
28 int expanded_frame_width;
29 int expanded_frame_height;
30
31 int HScale;
32 int HRatio;
33 int VScale;
34 int VRatio;
35
36 YV12_BUFFER_CONFIG *src_yuv_config;
37 YV12_BUFFER_CONFIG *dst_yuv_config;
38
39 } SCALE_VARS;
40
41 /****************************************************************************
42 *
43 * ROUTINE : scale1d_2t1_i
44 *
45 * INPUTS : const unsigned char *source : Pointer to data to be scaled.
46 * int source_step : Number of pixels to step on in source.
47 * unsigned int source_scale : Scale for source (UNUSED).
48 * unsigned int source_length : Length of source (UNUSED).
49 * unsigned char *dest : Pointer to output data array.
50 * int dest_step : Number of pixels to step on in destination.
51 * unsigned int dest_scale : Scale for destination (UNUSED).
52 * unsigned int dest_length : Length of destination.
53 *
54 * OUTPUTS : None.
55 *
56 * RETURNS : void
57 *
58 * FUNCTION : Performs 2-to-1 interpolated scaling.
59 *
60 * SPECIAL NOTES : None.
61 *
62 ****************************************************************************/
63 static
64 void scale1d_2t1_i
65 (
66 const unsigned char *source,
67 int source_step,
68 unsigned int source_scale,
69 unsigned int source_length,
70 unsigned char *dest,
71 int dest_step,
72 unsigned int dest_scale,
73 unsigned int dest_length
74 ) {
75 unsigned int i, j;
76 unsigned int temp;
77 int source_pitch = source_step;
78 (void) source_length;
79 (void) source_scale;
80 (void) dest_scale;
81
82 source_step *= 2;
83 dest[0] = source[0];
84
85 for (i = dest_step, j = source_step; i < dest_length * dest_step; i += dest_step, j += source_step) {
86 temp = 8;
87 temp += 3 * source[j - source_pitch];
88 temp += 10 * source[j];
89 temp += 3 * source[j + source_pitch];
90 temp >>= 4;
91 dest[i] = (char)(temp);
92 }
93 }
94
95 /****************************************************************************
96 *
97 * ROUTINE : scale1d_2t1_ps
98 *
99 * INPUTS : const unsigned char *source : Pointer to data to be scaled.
100 * int source_step : Number of pixels to step on in source.
101 * unsigned int source_scale : Scale for source (UNUSED).
102 * unsigned int source_length : Length of source (UNUSED).
103 * unsigned char *dest : Pointer to output data array.
104 * int dest_step : Number of pixels to step on in destination.
105 * unsigned int dest_scale : Scale for destination (UNUSED).
106 * unsigned int dest_length : Length of destination.
107 *
108 * OUTPUTS : None.
109 *
110 * RETURNS : void
111 *
112 * FUNCTION : Performs 2-to-1 point subsampled scaling.
113 *
114 * SPECIAL NOTES : None.
115 *
116 ****************************************************************************/
117 static
118 void scale1d_2t1_ps
119 (
120 const unsigned char *source,
121 int source_step,
122 unsigned int source_scale,
123 unsigned int source_length,
124 unsigned char *dest,
125 int dest_step,
126 unsigned int dest_scale,
127 unsigned int dest_length
128 ) {
129 unsigned int i, j;
130
131 (void) source_length;
132 (void) source_scale;
133 (void) dest_scale;
134
135 source_step *= 2;
136 j = 0;
137
138 for (i = 0; i < dest_length * dest_step; i += dest_step, j += source_step)
139 dest[i] = source[j];
140 }
141 /****************************************************************************
142 *
143 * ROUTINE : scale1d_c
144 *
145 * INPUTS : const unsigned char *source : Pointer to data to be scaled.
146 * int source_step : Number of pixels to step on in source.
147 * unsigned int source_scale : Scale for source.
148 * unsigned int source_length : Length of source (UNUSED).
149 * unsigned char *dest : Pointer to output data array.
150 * int dest_step : Number of pixels to step on in destination.
151 * unsigned int dest_scale : Scale for destination.
152 * unsigned int dest_length : Length of destination.
153 *
154 * OUTPUTS : None.
155 *
156 * RETURNS : void
157 *
158 * FUNCTION : Performs linear interpolation in one dimension.
159 *
160 * SPECIAL NOTES : None.
161 *
162 ****************************************************************************/
163 static
164 void scale1d_c
165 (
166 const unsigned char *source,
167 int source_step,
168 unsigned int source_scale,
169 unsigned int source_length,
170 unsigned char *dest,
171 int dest_step,
172 unsigned int dest_scale,
173 unsigned int dest_length
174 ) {
175 unsigned int i;
176 unsigned int round_value = dest_scale / 2;
177 unsigned int left_modifier = dest_scale;
178 unsigned int right_modifier = 0;
179 unsigned char left_pixel = *source;
180 unsigned char right_pixel = *(source + source_step);
181
182 (void) source_length;
183
184 /* These asserts are needed if there are boundary issues... */
185 /*assert ( dest_scale > source_scale );*/
186 /*assert ( (source_length-1) * dest_scale >= (dest_length-1) * source_scale );*/
187
188 for (i = 0; i < dest_length * dest_step; i += dest_step) {
189 dest[i] = (char)((left_modifier * left_pixel + right_modifier * right_pixel + round_value) / dest_scale);
190
191 right_modifier += source_scale;
192
193 while (right_modifier > dest_scale) {
194 right_modifier -= dest_scale;
195 source += source_step;
196 left_pixel = *source;
197 right_pixel = *(source + source_step);
198 }
199
200 left_modifier = dest_scale - right_modifier;
201 }
202 }
203
204 /****************************************************************************
205 *
206 * ROUTINE : Scale2D
207 *
208 * INPUTS : const unsigned char *source : Pointer to data to be scaled.
209 * int source_pitch : Stride of source image.
210 * unsigned int source_width : Width of input image.
211 * unsigned int source_height : Height of input image.
212 * unsigned char *dest : Pointer to output data array.
213 * int dest_pitch : Stride of destination image.
214 * unsigned int dest_width : Width of destination image.
215 * unsigned int dest_height : Height of destination image.
216 * unsigned char *temp_area : Pointer to temp work area.
217 * unsigned char temp_area_height : Height of temp work area.
218 * unsigned int hscale : Horizontal scale factor numerator.
219 * unsigned int hratio : Horizontal scale factor denominator.
220 * unsigned int vscale : Vertical scale factor numerator.
221 * unsigned int vratio : Vertical scale factor denominator.
222 * unsigned int interlaced : Interlace flag.
223 *
224 * OUTPUTS : None.
225 *
226 * RETURNS : void
227 *
228 * FUNCTION : Performs 2-tap linear interpolation in two dimensions.
229 *
230 * SPECIAL NOTES : Expansion is performed one band at a time to help with
231 * caching.
232 *
233 ****************************************************************************/
234 static
235 void Scale2D
236 (
237 /*const*/
238 unsigned char *source,
239 int source_pitch,
240 unsigned int source_width,
241 unsigned int source_height,
242 unsigned char *dest,
243 int dest_pitch,
244 unsigned int dest_width,
245 unsigned int dest_height,
246 unsigned char *temp_area,
247 unsigned char temp_area_height,
248 unsigned int hscale,
249 unsigned int hratio,
250 unsigned int vscale,
251 unsigned int vratio,
252 unsigned int interlaced
253 ) {
254 /*unsigned*/
255 int i, j, k;
256 int bands;
257 int dest_band_height;
258 int source_band_height;
259
260 typedef void (*Scale1D)(const unsigned char * source, int source_step, unsigned int source_scale, unsigned int source_length,
261 unsigned char * dest, int dest_step, unsigned int dest_scale, unsigned int dest_length);
262
263 Scale1D Scale1Dv = scale1d_c;
264 Scale1D Scale1Dh = scale1d_c;
265
266 void (*horiz_line_scale)(const unsigned char *, unsigned int, unsigned char *, unsigned int) = NULL;
267 void (*vert_band_scale)(unsigned char *, unsigned int, unsigned char *, unsigned int, unsigned int) = NULL;
268
269 int ratio_scalable = 1;
270 int interpolation = 0;
271
272 unsigned char *source_base; /* = (unsigned char *) ((source_pitch >= 0) ? source : (source + ((source_height-1) * source_pitch))); */
273 unsigned char *line_src;
274
275
276 source_base = (unsigned char *)source;
277
278 if (source_pitch < 0) {
279 int offset;
280
281 offset = (source_height - 1);
282 offset *= source_pitch;
283
284 source_base += offset;
285 }
286
287 /* find out the ratio for each direction */
288 switch (hratio * 10 / hscale) {
289 case 8:
290 /* 4-5 Scale in Width direction */
291 horiz_line_scale = vp8_horizontal_line_5_4_scale;
292 break;
293 case 6:
294 /* 3-5 Scale in Width direction */
295 horiz_line_scale = vp8_horizontal_line_5_3_scale;
296 break;
297 case 5:
298 /* 1-2 Scale in Width direction */
299 horiz_line_scale = vp8_horizontal_line_2_1_scale;
300 break;
301 default:
302 /* The ratio is not acceptable now */
303 /* throw("The ratio is not acceptable for now!"); */
304 ratio_scalable = 0;
305 break;
306 }
307
308 switch (vratio * 10 / vscale) {
309 case 8:
310 /* 4-5 Scale in vertical direction */
311 vert_band_scale = vp8_vertical_band_5_4_scale;
312 source_band_height = 5;
313 dest_band_height = 4;
314 break;
315 case 6:
316 /* 3-5 Scale in vertical direction */
317 vert_band_scale = vp8_vertical_band_5_3_scale;
318 source_band_height = 5;
319 dest_band_height = 3;
320 break;
321 case 5:
322 /* 1-2 Scale in vertical direction */
323
324 if (interlaced) {
325 /* if the content is interlaced, point sampling is used */
326 vert_band_scale = vp8_vertical_band_2_1_scale;
327 } else {
328
329 interpolation = 1;
330 /* if the content is progressive, interplo */
331 vert_band_scale = vp8_vertical_band_2_1_scale_i;
332
333 }
334
335 source_band_height = 2;
336 dest_band_height = 1;
337 break;
338 default:
339 /* The ratio is not acceptable now */
340 /* throw("The ratio is not acceptable for now!"); */
341 ratio_scalable = 0;
342 break;
343 }
344
345 if (ratio_scalable) {
346 if (source_height == dest_height) {
347 /* for each band of the image */
348 for (k = 0; k < (int)dest_height; k++) {
349 horiz_line_scale(source, source_width, dest, dest_width);
350 source += source_pitch;
351 dest += dest_pitch;
352 }
353
354 return;
355 }
356
357 if (interpolation) {
358 if (source < source_base)
359 source = source_base;
360
361 horiz_line_scale(source, source_width, temp_area, dest_width);
362 }
363
364 for (k = 0; k < (int)(dest_height + dest_band_height - 1) / dest_band_height; k++) {
365 /* scale one band horizontally */
366 for (i = 0; i < source_band_height; i++) {
367 /* Trap case where we could read off the base of the source buffer */
368
369 line_src = (unsigned char *)source + i * source_pitch;
370
371 if (line_src < source_base)
372 line_src = source_base;
373
374 horiz_line_scale(line_src, source_width,
375 temp_area + (i + 1)*dest_pitch, dest_width);
376 }
377
378 /* Vertical scaling is in place */
379 vert_band_scale(temp_area + dest_pitch, dest_pitch, dest, dest_pitch, dest_width);
380
381 if (interpolation)
382 vpx_memcpy(temp_area, temp_area + source_band_height * dest_pitch, dest_width);
383
384 /* Next band... */
385 source += (unsigned long) source_band_height * source_pitch;
386 dest += (unsigned long) dest_band_height * dest_pitch;
387 }
388
389 return;
390 }
391
392 if (hscale == 2 && hratio == 1)
393 Scale1Dh = scale1d_2t1_ps;
394
395 if (vscale == 2 && vratio == 1) {
396 if (interlaced)
397 Scale1Dv = scale1d_2t1_ps;
398 else
399 Scale1Dv = scale1d_2t1_i;
400 }
401
402 if (source_height == dest_height) {
403 /* for each band of the image */
404 for (k = 0; k < (int)dest_height; k++) {
405 Scale1Dh(source, 1, hscale, source_width + 1, dest, 1, hratio, dest_width);
406 source += source_pitch;
407 dest += dest_pitch;
408 }
409
410 return;
411 }
412
413 if (dest_height > source_height) {
414 dest_band_height = temp_area_height - 1;
415 source_band_height = dest_band_height * source_height / dest_height;
416 } else {
417 source_band_height = temp_area_height - 1;
418 dest_band_height = source_band_height * vratio / vscale;
419 }
420
421 /* first row needs to be done so that we can stay one row ahead for vertical zoom */
422 Scale1Dh(source, 1, hscale, source_width + 1, temp_area, 1, hratio, dest_width);
423
424 /* for each band of the image */
425 bands = (dest_height + dest_band_height - 1) / dest_band_height;
426
427 for (k = 0; k < bands; k++) {
428 /* scale one band horizontally */
429 for (i = 1; i < source_band_height + 1; i++) {
430 if (k * source_band_height + i < (int) source_height) {
431 Scale1Dh(source + i * source_pitch, 1, hscale, source_width + 1,
432 temp_area + i * dest_pitch, 1, hratio, dest_width);
433 } else { /* Duplicate the last row */
434 /* copy temp_area row 0 over from last row in the past */
435 vpx_memcpy(temp_area + i * dest_pitch, temp_area + (i - 1)*dest_pitch, dest_pitch);
436 }
437 }
438
439 /* scale one band vertically */
440 for (j = 0; j < (int)dest_width; j++) {
441 Scale1Dv(&temp_area[j], dest_pitch, vscale, source_band_height + 1,
442 &dest[j], dest_pitch, vratio, dest_band_height);
443 }
444
445 /* copy temp_area row 0 over from last row in the past */
446 vpx_memcpy(temp_area, temp_area + source_band_height * dest_pitch, dest_pitch);
447
448 /* move to the next band */
449 source += source_band_height * source_pitch;
450 dest += dest_band_height * dest_pitch;
451 }
452 }
453
454 /****************************************************************************
455 *
456 * ROUTINE : vpx_scale_frame
457 *
458 * INPUTS : YV12_BUFFER_CONFIG *src : Pointer to frame to be scaled.
459 * YV12_BUFFER_CONFIG *dst : Pointer to buffer to hold scaled frame.
460 * unsigned char *temp_area : Pointer to temp work area.
461 * unsigned char temp_area_height : Height of temp work area.
462 * unsigned int hscale : Horizontal scale factor numerator.
463 * unsigned int hratio : Horizontal scale factor denominator.
464 * unsigned int vscale : Vertical scale factor numerator.
465 * unsigned int vratio : Vertical scale factor denominator.
466 * unsigned int interlaced : Interlace flag.
467 *
468 * OUTPUTS : None.
469 *
470 * RETURNS : void
471 *
472 * FUNCTION : Performs 2-tap linear interpolation in two dimensions.
473 *
474 * SPECIAL NOTES : Expansion is performed one band at a time to help with
475 * caching.
476 *
477 ****************************************************************************/
478 void vpx_scale_frame
479 (
480 YV12_BUFFER_CONFIG *src,
481 YV12_BUFFER_CONFIG *dst,
482 unsigned char *temp_area,
483 unsigned char temp_height,
484 unsigned int hscale,
485 unsigned int hratio,
486 unsigned int vscale,
487 unsigned int vratio,
488 unsigned int interlaced
489 ) {
490 int i;
491 int dw = (hscale - 1 + src->y_width * hratio) / hscale;
492 int dh = (vscale - 1 + src->y_height * vratio) / vscale;
493
494 /* call our internal scaling routines!! */
495 Scale2D((unsigned char *) src->y_buffer, src->y_stride, src->y_width, src->y_height,
496 (unsigned char *) dst->y_buffer, dst->y_stride, dw, dh,
497 temp_area, temp_height, hscale, hratio, vscale, vratio, interlaced);
498
499 if (dw < (int)dst->y_width)
500 for (i = 0; i < dh; i++)
501 vpx_memset(dst->y_buffer + i * dst->y_stride + dw - 1, dst->y_buffer[i * dst->y_stride + dw - 2], dst->y_width - dw + 1);
502
503 if (dh < (int)dst->y_height)
504 for (i = dh - 1; i < (int)dst->y_height; i++)
505 vpx_memcpy(dst->y_buffer + i * dst->y_stride, dst->y_buffer + (dh - 2) * dst->y_stride, dst->y_width + 1);
506
507 Scale2D((unsigned char *) src->u_buffer, src->uv_stride, src->uv_width, src->uv_height,
508 (unsigned char *) dst->u_buffer, dst->uv_stride, dw / 2, dh / 2,
509 temp_area, temp_height, hscale, hratio, vscale, vratio, interlaced);
510
511 if (dw / 2 < (int)dst->uv_width)
512 for (i = 0; i < dst->uv_height; i++)
513 vpx_memset(dst->u_buffer + i * dst->uv_stride + dw / 2 - 1, dst->u_buffer[i * dst->uv_stride + dw / 2 - 2], dst->uv_width - dw / 2 + 1);
514
515 if (dh / 2 < (int)dst->uv_height)
516 for (i = dh / 2 - 1; i < (int)dst->y_height / 2; i++)
517 vpx_memcpy(dst->u_buffer + i * dst->uv_stride, dst->u_buffer + (dh / 2 - 2)*dst->uv_stride, dst->uv_width);
518
519 Scale2D((unsigned char *) src->v_buffer, src->uv_stride, src->uv_width, src->uv_height,
520 (unsigned char *) dst->v_buffer, dst->uv_stride, dw / 2, dh / 2,
521 temp_area, temp_height, hscale, hratio, vscale, vratio, interlaced);
522
523 if (dw / 2 < (int)dst->uv_width)
524 for (i = 0; i < dst->uv_height; i++)
525 vpx_memset(dst->v_buffer + i * dst->uv_stride + dw / 2 - 1, dst->v_buffer[i * dst->uv_stride + dw / 2 - 2], dst->uv_width - dw / 2 + 1);
526
527 if (dh / 2 < (int) dst->uv_height)
528 for (i = dh / 2 - 1; i < (int)dst->y_height / 2; i++)
529 vpx_memcpy(dst->v_buffer + i * dst->uv_stride, dst->v_buffer + (dh / 2 - 2)*dst->uv_stride, dst->uv_width);
530 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial