Chinaunix首页 | 论坛 | 博客
  • 博客访问: 278034
  • 博文数量: 95
  • 博客积分: 2047
  • 博客等级: 大尉
  • 技术积分: 1022
  • 用 户 组: 普通用户
  • 注册时间: 2011-03-14 16:18
文章分类

全部博文(95)

文章存档

2013年(1)

2011年(94)

我的朋友

分类: 嵌入式

2011-08-27 10:59:52

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#define LOG_TAG "copybit"

#include

#include

#include
#include
#include
#include
#include

#include
#include
#include

#include
#include

#include

#include "gralloc_priv.h"
#include "s3c_g2d.h"

#define DEBUG_G2D_ERRORS 0

//#define MEMALLOC_SIZE 0x200000 //2MB for RGBA

#define PMEM_OFFSET 0x56000000 //16MB /dev/pmem ossfet

/** State information for each device instance */
struct copybit_context_t {
    struct copybit_device_t device;

    int fd;
int mem_fd;
char *mem_addr;

    int rotation;
    int alpha;
    int dither;
    int transform;
};

/**
 * Common hardware methods
 */

static int open_copybit(const struct hw_module_t* module, const char* name,
        struct hw_device_t** device);

static struct hw_module_methods_t copybit_module_methods = {
    open:  open_copybit
};

/*
 * The COPYBIT Module
 */
struct copybit_module_t HAL_MODULE_INFO_SYM = {
    common: {
        tag: HARDWARE_MODULE_TAG,
        version_major: 1,
        version_minor: 0,
        id: COPYBIT_HARDWARE_MODULE_ID,
        name: "Ky6410 COPYBIT Module",
        author: "Rockie Cheng.",
        methods: ©bit_module_methods
    }
};

/******************************************************************************/

/** min of int a, b */
static inline int min(int a, int b) {
    return (a
}

/** max of int a, b */
static inline int max(int a, int b) {
    return (a>b) ? a : b;
}

/** scale each parameter by mul/div. Assume div isn't 0 */
static inline void MULDIV(uint32_t *a, uint32_t *b, int mul, int div) {
    if (mul != div) {
        *a = (mul * *a) / div;
        *b = (mul * *b) / div;
    }
}

/** Determine the intersection of lhs & rhs store in out */
static void intersect(struct copybit_rect_t *out,
                      const struct copybit_rect_t *lhs,
                      const struct copybit_rect_t *rhs) {
    out->l = max(lhs->l, rhs->l);
    out->t = max(lhs->t, rhs->t);
    out->r = min(lhs->r, rhs->r);
    out->b = min(lhs->b, rhs->b);
}

/** convert COPYBIT_FORMAT to G2D format */
static int get_format(int format) {

    switch (format) 
{
    case COPYBIT_FORMAT_RGB_565:       return G2D_RGB16;
    case COPYBIT_FORMAT_RGBX_8888:     return G2D_RGBX32;
    case COPYBIT_FORMAT_RGB_888:       return G2D_RGB16;
    case COPYBIT_FORMAT_RGBA_8888:     return G2D_RGBA32;
    case COPYBIT_FORMAT_BGRA_8888:     return G2D_ARGB32;
    //case COPYBIT_FORMAT_YCbCr_422_SP:  return -1;
    //case COPYBIT_FORMAT_YCbCr_420_SP:  return -1;
default :
LOGE("Copybit HAL unsupport format ! ,format is 0x%x",format);
return -1;
}

}

static uint32_t get_rotate(int transform)
{
int g2d_rotate = S3C_G2D_ROTATOR_0;
switch(transform)
{
/* flip source image horizontally */
case COPYBIT_TRANSFORM_FLIP_H:
g2d_rotate = S3C_G2D_ROTATOR_X_FLIP;
break;
/* flip source image vertically */
case COPYBIT_TRANSFORM_FLIP_V:
g2d_rotate = S3C_G2D_ROTATOR_Y_FLIP;
break;

/* rotate source image 90 degres */
case COPYBIT_TRANSFORM_ROT_90:
g2d_rotate = S3C_G2D_ROTATOR_90;
break;
/* rotate source image 180 degres */
case COPYBIT_TRANSFORM_ROT_180:
g2d_rotate = S3C_G2D_ROTATOR_180;
break;

/* rotate source image 270 degres */
case COPYBIT_TRANSFORM_ROT_270:
g2d_rotate = S3C_G2D_ROTATOR_270;
break;
}
return g2d_rotate;
}



/** convert from copybit image to g2d image structure */
static void set_image(struct g2d_img *img, const struct copybit_image_t *rhs) 
{
    private_handle_t* hnd = (private_handle_t*)rhs->handle;
    img->width      = rhs->w;
    img->height     = rhs->h;
    img->format     = get_format(rhs->format);
    img->offset     = hnd->offset;

    img->memory_id  = hnd->fd;


}
/** setup rectangles */
static void set_rects(struct copybit_context_t *dev,
                      struct g2d_blit_req *e,
                      const struct copybit_rect_t *dst,
                      const struct copybit_rect_t *src,
                      const struct copybit_rect_t *scissor) {
    struct copybit_rect_t clip;
    intersect(&clip, scissor, dst);

    e->dst_rect.x  = clip.l;
    e->dst_rect.y  = clip.t;
    e->dst_rect.w  = clip.r - clip.l;
    e->dst_rect.h  = clip.b - clip.t;

    uint32_t W, H;
    if (dev->transform != 0) {
        e->src_rect.x = (clip.t - dst->t) + src->t;
        e->src_rect.y = (dst->r - clip.r) + src->l;
        e->src_rect.w = (clip.b - clip.t);
        e->src_rect.h = (clip.r - clip.l);
        W = dst->b - dst->t;
        H = dst->r - dst->l;
    } else {
        e->src_rect.x  = (clip.l - dst->l) + src->l;
        e->src_rect.y  = (clip.t - dst->t) + src->t;
        e->src_rect.w  = (clip.r - clip.l);
        e->src_rect.h  = (clip.b - clip.t);
        W = dst->r - dst->l;
        H = dst->b - dst->t;
    }
    MULDIV(&e->src_rect.x, &e->src_rect.w, src->r - src->l, W);
    MULDIV(&e->src_rect.y, &e->src_rect.h, src->b - src->t, H);

}

/** setup g2d request */
static void set_infos(struct copybit_context_t *dev, struct g2d_blit_req *req) 
{
    req->alpha = dev->alpha;
    req->transform = get_rotate(dev->transform);
}

/** copy the bits */
static int g2d_copybit(struct copybit_context_t *dev, g2d_blit_req const *blit) 
{
   
   struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
  int err;
s3c_g2d_params *params;

params = (s3c_g2d_params *)malloc(sizeof(s3c_g2d_params));
memset(params, 0, sizeof(s3c_g2d_params));

//pmem_region *region;
//region = (pmem_region *)malloc(sizeof(pmem_region));

struct fb_fix_screeninfo finfo;

//if(blit->src.format != G2D_RGB16)//RGBA or RGBX
//{
// params->src_base_addr = blit->src.memory_id;
// params->pmem_fd = ctx->mem_fd;
//} 
if( ioctl(blit->src.memory_id, FBIOGET_FSCREENINFO, &finfo) < 0) //not fb ,is pmem!
{
params->src_base_addr = PMEM_OFFSET + blit->src.offset;
}
else //is fb!
{
params->src_base_addr = finfo.smem_start + blit->src.offset;
//LOGE("fb smem start is 0x%x ,offset is 0x%x",finfo.smem_start,blit->src.offset );
}

params->bpp        = blit->src.format;

if (ctx->alpha != 255)
{
params->alpha_mode     = 1;
params->alpha_val      = 256-ctx->alpha;
}
else
{
params->alpha_mode     = 0;
params->alpha_val      = 0;
}

//params->src_offset = blit->src.offset;

params->color_key_mode = 0;
params->color_key_val = 0;

params->src_full_width = blit->src.width;
params->src_full_height = blit->src.height;

params->src_start_x     = blit->src_rect.x;
params->src_start_y     = blit->src_rect.y;
params->src_work_width = blit->src_rect.w-1;
params->src_work_height = blit->src_rect.h-1;

if( ioctl(blit->dst.memory_id, FBIOGET_FSCREENINFO, &finfo) < 0) //not fb ,is pmem!
{
params->dst_base_addr = PMEM_OFFSET + blit->dst.offset;
}
else //is fb!
{
params->dst_base_addr = finfo.smem_start + blit->dst.offset;
//LOGE("fb smem start is 0x%x ,offset is 0x%x",finfo.smem_start,blit->src.offset );
}

params->dst_full_width = blit->dst.width;
params->dst_full_height = blit->dst.height;

params->dst_start_x     = blit->dst_rect.x; 
params->dst_start_y     = blit->dst_rect.y; 
params->dst_work_width = blit->dst_rect.w-1;
params->dst_work_height = blit->dst_rect.h-1;
  
//initialize clipping window
params->cw_x1 = 0;
params->cw_y1 = 0;
params->cw_x2 = 800-1;
params->cw_y2 = 480-1;

//LOGI("src fd is 0x%x , dst fd is 0x%x",blit->src.memory_id ,blit->dst.memory_id);
if ( ctx->transform == 4)
{
err =  ioctl(dev->fd, S3C_G2D_ROTATOR_90, params);
}
else
{
err =  ioctl(dev->fd, S3C_G2D_ROTATOR_0, params);
}

    LOGE_IF(err<0, "copyBits failed (%s)", strerror(errno));

#if DEBUG_G2D_ERRORS
            LOGD("    src={w=%d, h=%d, f=%d, rect={%d,%d,%d,%d}}\n"
                 "    dst={w=%d, h=%d, f=%d, rect={%d,%d,%d,%d}}\n"
                    ,
                    blit->src.width,
                    blit->src.height,
                    blit->src.format,
                    blit->src_rect.x,
                    blit->src_rect.y,
                    blit->src_rect.w,
                    blit->src_rect.h,
                    blit->dst.width,
                    blit->dst.height,
                    blit->dst.format,
                    blit->dst_rect.x,
                    blit->dst_rect.y,
                    blit->dst_rect.w,
                    blit->dst_rect.h
            );      
#endif

end:
free(params);
//free(region);
return 0;
}

/*****************************************************************************/

/** Set a parameter to value */
static int set_parameter_copybit(struct copybit_device_t *dev, int name, int value) 
{
    struct copybit_context_t* ctx = (struct copybit_context_t*)dev;

    switch (name) 
{
    case COPYBIT_ROTATION_DEG:
        ctx->rotation = value;
        break;

    case COPYBIT_PLANE_ALPHA:
        ctx->alpha = value;
        break;

    case COPYBIT_DITHER:
        ctx->dither = value;
        break;

    case COPYBIT_TRANSFORM:
        ctx->transform = value;
        break;

    default:
        return -EINVAL;
    }
    return 0;

}

/** Get a static info value */
static int get(struct copybit_device_t *dev, int name) 
{
    struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
    int value;
    if (ctx) {
        switch(name) {
        case COPYBIT_MINIFICATION_LIMIT:
            value = 4;
            break;
        case COPYBIT_MAGNIFICATION_LIMIT:
            value = 4;
            break;
        case COPYBIT_SCALING_FRAC_BITS:
            value = 32;
            break;
        case COPYBIT_ROTATION_STEP_DEG:
            value = 90;
            break;
        default:
            value = -EINVAL;
        }
    } else {
        value = -EINVAL;
    }
    return value;
}

/** do a stretch blit type operation */
static int stretch_copybit(
        struct copybit_device_t *dev,
        struct copybit_image_t const *dst,
        struct copybit_image_t const *src,
        struct copybit_rect_t const *dst_rect,
        struct copybit_rect_t const *src_rect,
        struct copybit_region_t const *region) 
{
    struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
    int status = 0;
struct g2d_blit_req blit_req;

    //LOGI("stretch : src: w=%d, h=%d  fmt:%d dst: w=%d, h=%d fmt:%d alpha:%d transform:%d  \n", 
// src->w, src->h, src->format, dst->w, dst->h, dst->format, ctx->alpha, ctx->transform);

    if (ctx) 
{
        struct {
            uint32_t count;
            struct g2d_blit_req req[12];
        } list;

    int count;
        struct copybit_rect_t clip;
        const struct copybit_rect_t bounds = { 0, 0, dst->w, dst->h };

        count = 0;

        while ((status == 0) && region->next(region, &clip)) 
{

            intersect(&clip, &bounds, &clip);
            
            set_infos(ctx, &blit_req);
set_image(&blit_req.dst, dst);
set_image(&blit_req.src, src);
set_rects(ctx, &blit_req, dst_rect, src_rect, &clip);

count ++; 
    
        if ((status == 0) && count > 0) 
{
status = g2d_copybit(ctx, &blit_req);
        }

}
   
else 
{
        status = -EINVAL;
}
    return status;
}

/** Perform a blit type operation */
static int blit_copybit(
        struct copybit_device_t *dev,
        struct copybit_image_t const *dst,
        struct copybit_image_t const *src,
        struct copybit_region_t const *region) 
{
    struct copybit_rect_t dr = { 0, 0, dst->w, dst->h };
    struct copybit_rect_t sr = { 0, 0, src->w, src->h };
    return stretch_copybit(dev, dst, src, &dr, &sr, region);
}

/*****************************************************************************/

/** Close the copybit device */
static int close_copybit(struct hw_device_t *dev) 
{
    struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
    if (ctx) {
        close(ctx->fd);
//  close(ctx->mem_fd);
//  munmap(ctx->mem_addr,  MEMALLOC_SIZE);
        free(ctx);
    }
    return 0;
}

/** Open a new instance of a copybit device using name */
static int open_copybit(const struct hw_module_t* module, const char* name,
        struct hw_device_t** device)
{
    int status = -EINVAL;

    copybit_context_t *ctx;
    ctx = (copybit_context_t *)malloc(sizeof(copybit_context_t));
    memset(ctx, 0, sizeof(*ctx));

    ctx->device.common.tag = HARDWARE_DEVICE_TAG;
    ctx->device.common.version = 1;
    ctx->device.common.module = const_cast(module);
    ctx->device.common.close = close_copybit;
    ctx->device.set_parameter = set_parameter_copybit;
    ctx->device.get = get;
    ctx->device.blit = blit_copybit;
    ctx->device.stretch = stretch_copybit;

ctx->alpha = 0xff;
ctx->rotation = 0;
ctx->transform = 0;

    ctx->fd = open(S3C_G2D_DEV_NAME, O_RDWR, 0);
    
    if (ctx->fd < 0) 
{
        status = errno;
        LOGE("Error opening frame buffer errno=%d (%s)", status, strerror(status));
        status = -status;
 

// ctx->mem_fd = open("/dev/pmem_adsp", O_RDWR);
// ctx->mem_addr = (char *)mmap(0, MEMALLOC_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, ctx->mem_fd, NULL);

    *device = &ctx->device.common;
status = 0;

    return status;
}

阅读(742) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~