139 lines
4.5 KiB
C
139 lines
4.5 KiB
C
/*
|
|
* Copyright (c) 2013 The WebM project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include <assert.h>
|
|
|
|
#include "./vpx_config.h"
|
|
#include "vpx_scale/yv12config.h"
|
|
#include "vpx_mem/vpx_mem.h"
|
|
#include "vpx_scale/vpx_scale.h"
|
|
|
|
#if HAVE_DSPR2
|
|
static void extend_plane(uint8_t *const src, int src_stride, int width,
|
|
int height, int extend_top, int extend_left,
|
|
int extend_bottom, int extend_right) {
|
|
int i, j;
|
|
uint8_t *left_src, *right_src;
|
|
uint8_t *left_dst_start, *right_dst_start;
|
|
uint8_t *left_dst, *right_dst;
|
|
uint8_t *top_src, *bot_src;
|
|
uint8_t *top_dst, *bot_dst;
|
|
uint32_t left_pix;
|
|
uint32_t right_pix;
|
|
uint32_t linesize;
|
|
|
|
/* copy the left and right most columns out */
|
|
left_src = src;
|
|
right_src = src + width - 1;
|
|
left_dst_start = src - extend_left;
|
|
right_dst_start = src + width;
|
|
|
|
for (i = height; i--;) {
|
|
left_dst = left_dst_start;
|
|
right_dst = right_dst_start;
|
|
|
|
__asm__ __volatile__(
|
|
"lb %[left_pix], 0(%[left_src]) \n\t"
|
|
"lb %[right_pix], 0(%[right_src]) \n\t"
|
|
"replv.qb %[left_pix], %[left_pix] \n\t"
|
|
"replv.qb %[right_pix], %[right_pix] \n\t"
|
|
|
|
: [left_pix] "=&r"(left_pix), [right_pix] "=&r"(right_pix)
|
|
: [left_src] "r"(left_src), [right_src] "r"(right_src));
|
|
|
|
for (j = extend_left / 4; j--;) {
|
|
__asm__ __volatile__(
|
|
"sw %[left_pix], 0(%[left_dst]) \n\t"
|
|
"sw %[right_pix], 0(%[right_dst]) \n\t"
|
|
|
|
:
|
|
: [left_dst] "r"(left_dst), [left_pix] "r"(left_pix),
|
|
[right_dst] "r"(right_dst), [right_pix] "r"(right_pix));
|
|
|
|
left_dst += 4;
|
|
right_dst += 4;
|
|
}
|
|
|
|
for (j = extend_left % 4; j--;) {
|
|
__asm__ __volatile__(
|
|
"sb %[left_pix], 0(%[left_dst]) \n\t"
|
|
"sb %[right_pix], 0(%[right_dst]) \n\t"
|
|
|
|
:
|
|
: [left_dst] "r"(left_dst), [left_pix] "r"(left_pix),
|
|
[right_dst] "r"(right_dst), [right_pix] "r"(right_pix));
|
|
|
|
left_dst += 1;
|
|
right_dst += 1;
|
|
}
|
|
|
|
left_src += src_stride;
|
|
right_src += src_stride;
|
|
left_dst_start += src_stride;
|
|
right_dst_start += src_stride;
|
|
}
|
|
|
|
/* Now copy the top and bottom lines into each line of the respective
|
|
* borders
|
|
*/
|
|
top_src = src - extend_left;
|
|
bot_src = src + src_stride * (height - 1) - extend_left;
|
|
top_dst = src + src_stride * (-extend_top) - extend_left;
|
|
bot_dst = src + src_stride * (height)-extend_left;
|
|
linesize = extend_left + extend_right + width;
|
|
|
|
for (i = 0; i < extend_top; i++) {
|
|
memcpy(top_dst, top_src, linesize);
|
|
top_dst += src_stride;
|
|
}
|
|
|
|
for (i = 0; i < extend_bottom; i++) {
|
|
memcpy(bot_dst, bot_src, linesize);
|
|
bot_dst += src_stride;
|
|
}
|
|
}
|
|
|
|
static void extend_frame(YV12_BUFFER_CONFIG *const ybf, int ext_size) {
|
|
const int c_w = ybf->uv_crop_width;
|
|
const int c_h = ybf->uv_crop_height;
|
|
const int ss_x = ybf->uv_width < ybf->y_width;
|
|
const int ss_y = ybf->uv_height < ybf->y_height;
|
|
const int c_et = ext_size >> ss_y;
|
|
const int c_el = ext_size >> ss_x;
|
|
const int c_eb = c_et + ybf->uv_height - ybf->uv_crop_height;
|
|
const int c_er = c_el + ybf->uv_width - ybf->uv_crop_width;
|
|
|
|
assert(ybf->y_height - ybf->y_crop_height < 16);
|
|
assert(ybf->y_width - ybf->y_crop_width < 16);
|
|
assert(ybf->y_height - ybf->y_crop_height >= 0);
|
|
assert(ybf->y_width - ybf->y_crop_width >= 0);
|
|
|
|
extend_plane(ybf->y_buffer, ybf->y_stride, ybf->y_crop_width,
|
|
ybf->y_crop_height, ext_size, ext_size,
|
|
ext_size + ybf->y_height - ybf->y_crop_height,
|
|
ext_size + ybf->y_width - ybf->y_crop_width);
|
|
|
|
extend_plane(ybf->u_buffer, ybf->uv_stride, c_w, c_h, c_et, c_el, c_eb, c_er);
|
|
|
|
extend_plane(ybf->v_buffer, ybf->uv_stride, c_w, c_h, c_et, c_el, c_eb, c_er);
|
|
}
|
|
|
|
void vpx_extend_frame_borders_dspr2(YV12_BUFFER_CONFIG *ybf) {
|
|
extend_frame(ybf, ybf->border);
|
|
}
|
|
|
|
void vpx_extend_frame_inner_borders_dspr2(YV12_BUFFER_CONFIG *ybf) {
|
|
const int inner_bw = (ybf->border > VP9INNERBORDERINPIXELS)
|
|
? VP9INNERBORDERINPIXELS
|
|
: ybf->border;
|
|
extend_frame(ybf, inner_bw);
|
|
}
|
|
#endif
|