Uint8 restore_screen ()
{
copy_surface (screen_copy, NULL, screen, NULL);
SDL_FreeSurface (screen_copy);
screen_copy = NULL;
update_screen ();
return (TRUE);
}
int
shveu_wait(SHVEU *veu)
{
void *base_addr = veu->uio_mmio.iomem;
uint32_t vevtr;
uint32_t vstar;
int complete = 0;
uiomux_sleep(veu->uiomux, veu->uiores);
vevtr = read_reg(base_addr, VEVTR);
write_reg(base_addr, 0, VEVTR); /* ack interrupts */
/* End of VEU operation? */
if (vevtr & 1) {
dbg(__func__, __LINE__, "src_hw", &veu->src_hw);
dbg(__func__, __LINE__, "dst_hw", &veu->dst_hw);
copy_surface(&veu->dst_user, &veu->dst_hw);
/* free locally allocated surfaces */
if (veu->src_hw.py != veu->src_user.py) {
size_t len = size_y(veu->src_hw.format, veu->src_hw.h * veu->src_hw.w);
len += size_c(veu->src_hw.format, veu->src_hw.h * veu->src_hw.w);
uiomux_free(veu->uiomux, veu->uiores, veu->src_hw.py, len);
}
if (veu->dst_hw.py != veu->dst_user.py) {
size_t len = size_y(veu->dst_hw.format, veu->dst_hw.h * veu->dst_hw.w);
len += size_c(veu->dst_hw.format, veu->dst_hw.h * veu->dst_hw.w);
uiomux_free(veu->uiomux, veu->uiores, veu->dst_hw.py, len);
}
uiomux_unlock(veu->uiomux, veu->uiores);
complete = 1;
}
return complete;
}
int
shveu_setup(
SHVEU *veu,
const struct ren_vid_surface *src_surface,
const struct ren_vid_surface *dst_surface,
shveu_rotation_t filter_control)
{
float scale_x, scale_y;
uint32_t temp;
uint32_t Y, C;
const struct veu_format_info *src_info;
const struct veu_format_info *dst_info;
struct ren_vid_surface local_src;
struct ren_vid_surface local_dst;
struct ren_vid_surface *src = &local_src;
struct ren_vid_surface *dst = &local_dst;
void *base_addr;
if (!veu || !src_surface || !dst_surface) {
debug_info("ERR: Invalid input - need src and dest");
return -1;
}
src_info = fmt_info(src_surface->format);
dst_info = fmt_info(dst_surface->format);
dbg(__func__, __LINE__, "src_user", src_surface);
dbg(__func__, __LINE__, "dst_user", dst_surface);
/* scale factors */
scale_x = (float)dst_surface->w / src_surface->w;
scale_y = (float)dst_surface->h / src_surface->h;
if (!format_supported(src_surface->format) || !format_supported(dst_surface->format)) {
debug_info("ERR: Invalid surface format!");
return -1;
}
/* Scaling limits */
if (veu_is_veu2h(veu)) {
if ((scale_x > 8.0) || (scale_y > 8.0)) {
debug_info("ERR: Outside scaling limits!");
return -1;
}
} else {
if ((scale_x > 16.0) || (scale_y > 16.0)) {
debug_info("ERR: Outside scaling limits!");
return -1;
}
}
if ((scale_x < 1.0/16.0) || (scale_y < 1.0/16.0)) {
debug_info("ERR: Outside scaling limits!");
return -1;
}
/* source - use a buffer the hardware can access */
if (get_hw_surface(veu->uiomux, veu->uiores, src, src_surface) < 0) {
debug_info("ERR: src is not accessible by hardware");
return -1;
}
copy_surface(src, src_surface);
/* destination - use a buffer the hardware can access */
if (get_hw_surface(veu->uiomux, veu->uiores, dst, dst_surface) < 0) {
debug_info("ERR: dest is not accessible by hardware");
return -1;
}
uiomux_lock (veu->uiomux, veu->uiores);
base_addr = veu->uio_mmio.iomem;
/* Keep track of the requested surfaces */
veu->src_user = *src_surface;
veu->dst_user = *dst_surface;
/* Keep track of the actual surfaces used */
veu->src_hw = local_src;
veu->dst_hw = local_dst;
/* Software reset */
if (read_reg(base_addr, VESTR) & 0x1)
write_reg(base_addr, 0, VESTR);
while (read_reg(base_addr, VESTR) & 1)
;
/* Clear VEU end interrupt flag */
write_reg(base_addr, 0, VEVTR);
/* VEU Module reset */
write_reg(base_addr, 0x100, VBSRR);
/* default to not using bundle mode */
write_reg(base_addr, 0, VBSSR);
/* source */
Y = uiomux_all_virt_to_phys(src->py);
C = uiomux_all_virt_to_phys(src->pc);
write_reg(base_addr, Y, VSAYR);
write_reg(base_addr, C, VSACR);
write_reg(base_addr, (src->h << 16) | src->w, VESSR);
write_reg(base_addr, size_y(src->format, src->pitch), VESWR);
/* destination */
Y = uiomux_all_virt_to_phys(dst->py);
C = uiomux_all_virt_to_phys(dst->pc);
if (filter_control & 0xFF) {
if ((filter_control & 0xFF) == 0x10) {
/* Horizontal Mirror (A) */
Y += size_y(dst->format, src->w);
C += size_y(dst->format, src->w);
} else if ((filter_control & 0xFF) == 0x20) {
/* Vertical Mirror (B) */
Y += size_y(dst->format, (src->h-1) * dst->pitch);
C += size_c(dst->format, (src->h-2) * dst->pitch);
} else if ((filter_control & 0xFF) == 0x30) {
/* Rotate 180 (C) */
Y += size_y(dst->format, src->w);
C += size_y(dst->format, src->w);
Y += size_y(dst->format, src->h * dst->pitch);
C += size_c(dst->format, src->h * dst->pitch);
} else if ((filter_control & 0xFF) == 1) {
/* Rotate 90 (D) */
Y += size_y(dst->format, src->h-16);
C += size_y(dst->format, src->h-16);
} else if ((filter_control & 0xFF) == 2) {
/* Rotate 270 (E) */
Y += size_y(dst->format, (src->w-16) * dst->pitch);
C += size_c(dst->format, (src->w-16) * dst->pitch);
} else if ((filter_control & 0xFF) == 0x11) {
/* Rotate 90 & Mirror Horizontal (F) */
/* Nothing to do */
} else if ((filter_control & 0xFF) == 0x21) {
/* Rotate 90 & Mirror Vertical (G) */
Y += size_y(dst->format, src->h-16);
C += size_y(dst->format, src->h-16);
Y += size_y(dst->format, (src->w-16) * dst->pitch);
C += size_c(dst->format, (src->w-16) * dst->pitch);
}
}
write_reg(base_addr, Y, VDAYR);
write_reg(base_addr, C, VDACR);
write_reg(base_addr, size_y(dst->format, dst->pitch), VEDWR);
/* byte/word swapping */
temp = 0;
#ifdef __LITTLE_ENDIAN__
temp |= src_info->vswpr;
temp |= dst_info->vswpr << 4;
#endif
write_reg(base_addr, temp, VSWPR);
/* transform control */
temp = src_info->vtrcr_src;
temp |= dst_info->vtrcr_dst;
if (is_rgb(src_surface->format))
temp |= VTRCR_RY_SRC_RGB;
if (different_colorspace(src_surface->format, dst_surface->format))
temp |= VTRCR_TE_BIT_SET;
if (veu->bt709)
temp |= VTRCR_BT709;
if (veu->full_range)
temp |= VTRCR_FULL_COLOR_CONV;
write_reg(base_addr, temp, VTRCR);
if (veu_is_veu2h(veu)) {
/* color conversion matrix */
write_reg(base_addr, 0x0cc5, VMCR00);
write_reg(base_addr, 0x0950, VMCR01);
write_reg(base_addr, 0x0000, VMCR02);
write_reg(base_addr, 0x397f, VMCR10);
write_reg(base_addr, 0x0950, VMCR11);
write_reg(base_addr, 0x3cdd, VMCR12);
write_reg(base_addr, 0x0000, VMCR20);
write_reg(base_addr, 0x0950, VMCR21);
write_reg(base_addr, 0x1023, VMCR22);
write_reg(base_addr, 0x00800010, VCOFFR);
}
/* Clipping */
write_reg(base_addr, 0, VRFSR);
set_clip(base_addr, 0, dst->w);
set_clip(base_addr, 1, dst->h);
/* Scaling */
write_reg(base_addr, 0, VRFCR);
if (!(filter_control & 0x3)) {
/* Not a rotate operation */
set_scale(veu, base_addr, 0, src->w, dst->w, 0);
set_scale(veu, base_addr, 1, src->h, dst->h, 0);
}
/* Filter control - directly pass user arg to register */
write_reg(base_addr, filter_control, VFMCR);
return 0;
fail:
uiomux_unlock(veu->uiomux, veu->uiores);
return -1;
}
void
setup_tile (gint w, gint h)
{
cairo_status_t status;
cairo_t* cr = NULL;
cairo_surface_t* cr_surf = NULL;
cairo_surface_t* tmp = NULL;
cairo_surface_t* dummy_surf = NULL;
cairo_surface_t* norm_surf = NULL;
cairo_surface_t* blur_surf = NULL;
gdouble width = (gdouble) w;
gdouble height = (gdouble) h;
raico_blur_t* blur = NULL;
cr_surf = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
3 * BUBBLE_SHADOW_SIZE,
3 * BUBBLE_SHADOW_SIZE);
status = cairo_surface_status (cr_surf);
if (status != CAIRO_STATUS_SUCCESS)
g_print ("Error: \"%s\"\n", cairo_status_to_string (status));
cr = cairo_create (cr_surf);
status = cairo_status (cr);
if (status != CAIRO_STATUS_SUCCESS)
{
cairo_surface_destroy (cr_surf);
g_print ("Error: \"%s\"\n", cairo_status_to_string (status));
}
// clear and render drop-shadow and bubble-background
cairo_scale (cr, 1.0f, 1.0f);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
if (g_composited)
{
draw_shadow (cr,
width,
height,
BUBBLE_SHADOW_SIZE,
CORNER_RADIUS);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
draw_round_rect (cr,
1.0f,
(gdouble) BUBBLE_SHADOW_SIZE,
(gdouble) BUBBLE_SHADOW_SIZE,
(gdouble) CORNER_RADIUS,
(gdouble) (width - 2.0f * BUBBLE_SHADOW_SIZE),
(gdouble) (height - 2.0f* BUBBLE_SHADOW_SIZE));
cairo_fill (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
cairo_set_source_rgba (cr,
BUBBLE_BG_COLOR_R,
BUBBLE_BG_COLOR_G,
BUBBLE_BG_COLOR_B,
0.95f);
}
else
cairo_set_source_rgb (cr,
BUBBLE_BG_COLOR_R,
BUBBLE_BG_COLOR_G,
BUBBLE_BG_COLOR_B);
draw_round_rect (cr,
1.0f,
BUBBLE_SHADOW_SIZE,
BUBBLE_SHADOW_SIZE,
CORNER_RADIUS,
(gdouble) (width - 2.0f * BUBBLE_SHADOW_SIZE),
(gdouble) (height - 2.0f * BUBBLE_SHADOW_SIZE));
cairo_fill (cr);
tmp = cairo_image_surface_create_for_data (
cairo_image_surface_get_data (cr_surf),
cairo_image_surface_get_format (cr_surf),
3 * BUBBLE_SHADOW_SIZE,
3 * BUBBLE_SHADOW_SIZE,
cairo_image_surface_get_stride (cr_surf));
dummy_surf = copy_surface (tmp);
cairo_surface_destroy (tmp);
tmp = cairo_image_surface_create_for_data (
cairo_image_surface_get_data (dummy_surf),
cairo_image_surface_get_format (dummy_surf),
2 * BUBBLE_SHADOW_SIZE,
2 * BUBBLE_SHADOW_SIZE,
cairo_image_surface_get_stride (dummy_surf));
norm_surf = copy_surface (tmp);
cairo_surface_destroy (tmp);
blur = raico_blur_create (RAICO_BLUR_QUALITY_LOW);
raico_blur_set_radius (blur, 6);
raico_blur_apply (blur, dummy_surf);
raico_blur_destroy (blur);
tmp = cairo_image_surface_create_for_data (
cairo_image_surface_get_data (dummy_surf),
cairo_image_surface_get_format (dummy_surf),
2 * BUBBLE_SHADOW_SIZE,
2 * BUBBLE_SHADOW_SIZE,
cairo_image_surface_get_stride (dummy_surf));
blur_surf = copy_surface (tmp);
cairo_surface_destroy (tmp);
cairo_surface_destroy (dummy_surf);
g_tile = tile_new_for_padding (norm_surf, blur_surf);
cairo_surface_destroy (norm_surf);
cairo_surface_destroy (blur_surf);
cairo_surface_destroy (cr_surf);
cairo_destroy (cr);
}
void
setup_tile (gint w, gint h)
{
cairo_status_t status;
cairo_t* cr = NULL;
cairo_surface_t* cr_surf = NULL;
gdouble width = (gdouble) w;
gdouble height = (gdouble) h;
cairo_surface_t* tmp = NULL;
cairo_surface_t* dummy_surf = NULL;
cairo_surface_t* norm_surf = NULL;
cairo_surface_t* blur_surf = NULL;
raico_blur_t* blur = NULL;
tile_t* tile = NULL;
// create tmp. surface for scratch
cr_surf = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
3 * BUBBLE_SHADOW_SIZE,
3 * BUBBLE_SHADOW_SIZE);
status = cairo_surface_status (cr_surf);
if (status != CAIRO_STATUS_SUCCESS)
g_print ("Error: \"%s\"\n", cairo_status_to_string (status));
// create context for that tmp. scratch surface
cr = cairo_create (cr_surf);
status = cairo_status (cr);
if (status != CAIRO_STATUS_SUCCESS)
{
cairo_surface_destroy (cr_surf);
g_print ("Error: \"%s\"\n", cairo_status_to_string (status));
}
// clear, render drop-shadow and bubble-background in scratch-surface
cairo_scale (cr, 1.0f, 1.0f);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
if (g_composited)
{
draw_shadow (cr,
width,
height,
BUBBLE_SHADOW_SIZE,
CORNER_RADIUS);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
draw_round_rect (cr,
1.0f,
(gdouble) BUBBLE_SHADOW_SIZE,
(gdouble) BUBBLE_SHADOW_SIZE,
(gdouble) CORNER_RADIUS,
(gdouble) (width - 2.0f * BUBBLE_SHADOW_SIZE),
(gdouble) (height - 2.0f* BUBBLE_SHADOW_SIZE));
cairo_fill (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
cairo_set_source_rgba (cr,
BUBBLE_BG_COLOR_R,
BUBBLE_BG_COLOR_G,
BUBBLE_BG_COLOR_B,
0.95f);
}
else
cairo_set_source_rgb (cr,
BUBBLE_BG_COLOR_R,
BUBBLE_BG_COLOR_G,
BUBBLE_BG_COLOR_B);
draw_round_rect (cr,
1.0f,
BUBBLE_SHADOW_SIZE,
BUBBLE_SHADOW_SIZE,
CORNER_RADIUS,
(gdouble) (width - 2.0f * BUBBLE_SHADOW_SIZE),
(gdouble) (height - 2.0f * BUBBLE_SHADOW_SIZE));
cairo_fill (cr);
// create tmp. copy of scratch-surface
tmp = cairo_image_surface_create_for_data (
cairo_image_surface_get_data (cr_surf),
cairo_image_surface_get_format (cr_surf),
3 * BUBBLE_SHADOW_SIZE,
3 * BUBBLE_SHADOW_SIZE,
cairo_image_surface_get_stride (cr_surf));
dummy_surf = copy_surface (tmp);
cairo_surface_destroy (tmp);
// create normal-state surface for tile from copy of scratch-surface
tmp = cairo_image_surface_create_for_data (
cairo_image_surface_get_data (dummy_surf),
cairo_image_surface_get_format (dummy_surf),
2 * BUBBLE_SHADOW_SIZE,
2 * BUBBLE_SHADOW_SIZE,
cairo_image_surface_get_stride (dummy_surf));
norm_surf = copy_surface (tmp);
cairo_surface_destroy (tmp);
// blur tmp. copy of scratch-surface
blur = raico_blur_create (RAICO_BLUR_QUALITY_LOW);
raico_blur_set_radius (blur, 6);
raico_blur_apply (blur, dummy_surf);
raico_blur_destroy (blur);
// create blurred-state surface for tile
tmp = cairo_image_surface_create_for_data (
cairo_image_surface_get_data (dummy_surf),
cairo_image_surface_get_format (dummy_surf),
2 * BUBBLE_SHADOW_SIZE,
2 * BUBBLE_SHADOW_SIZE,
cairo_image_surface_get_stride (dummy_surf));
blur_surf = copy_surface (tmp);
cairo_surface_destroy (tmp);
// actually create the tile with padding in mind
tile = tile_new_for_padding (norm_surf, blur_surf);
destroy_cloned_surface (norm_surf);
destroy_cloned_surface (blur_surf);
destroy_cloned_surface (dummy_surf);
cairo_destroy (cr);
cairo_surface_destroy (cr_surf);
norm_surf = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, w, h);
cr = cairo_create (norm_surf);
cairo_scale (cr, 1.0f, 1.0f);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
tile_paint_with_padding (tile, cr, 0.0f, 0.0f, w, h, 1.0f, 0.0f);
cairo_destroy (cr);
blur_surf = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, w, h);
cr = cairo_create (blur_surf);
cairo_scale (cr, 1.0f, 1.0f);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
tile_paint_with_padding (tile, cr, 0.0f, 0.0f, w, h, 0.0f, 1.0f);
cairo_destroy (cr);
g_tile = tile_new_for_padding (norm_surf, blur_surf);
// clean up
tile_destroy (tile);
cairo_surface_destroy (norm_surf);
cairo_surface_destroy (blur_surf);
}
void copy_screen (void)
{
create_screen_copy_surface ();
copy_surface (screen, NULL, screen_copy, NULL);
}
