OLD | NEW |
(Empty) | |
| 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 i
n 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 i
n 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_st
ep, 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 i
n 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 i
n 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 i
n 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 i
n 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 numer
ator. |
| 219 * unsigned int hratio : Horizontal scale factor denom
inator. |
| 220 * unsigned int vscale : Vertical scale factor numerat
or. |
| 221 * unsigned int vratio : Vertical scale factor denomin
ator. |
| 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, unsigne
d 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 *, unsign
ed 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) ? sour
ce : (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 z
oom */ |
| 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, d
est_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_pitc
h); |
| 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 scale
d. |
| 459 * YV12_BUFFER_CONFIG *dst : Pointer to buffer to hold sc
aled 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 numer
ator. |
| 463 * unsigned int hratio : Horizontal scale factor denom
inator. |
| 464 * unsigned int vscale : Vertical scale factor numerat
or. |
| 465 * unsigned int vratio : Vertical scale factor denomin
ator. |
| 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_h
eight, |
| 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 * d
st->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) * d
st->y_stride, dst->y_width + 1); |
| 506 |
| 507 Scale2D((unsigned char *) src->u_buffer, src->uv_stride, src->uv_width, src->u
v_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->u
v_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 } |
OLD | NEW |