rgb lighting(scene s, ray r, hit_test h)
{
rgb result;
if (h.miss)
return s.bg;
vec hit_position = ray_position(r, h.dist);
if (shadow(hit_position, s.light, s.spheres)) {
result = rgb_modulate(h.surf, s.amb);
}
else {
double dot = vec_dot(h.surf_norm, s.light.direction);
double d = double_max(0, dot);
rgb diffuse_light = rgb_scale(d, s.light.color);
rgb lsum = rgb_add(s.amb, diffuse_light);
result = rgb_modulate(h.surf, lsum);
}
/**** === implement specular reflection here === ****/
if (rgb_nonzero(h.shine)) {
rgb ss;
vec N = h.surf_norm;
vec L = s.light.direction;
rgb S = h.shine;
vec R = vec_sub( vec_scale(2* vec_dot(N,L),N),L);
vec V = vec_neg(r.direction);
if (vec_dot(N,L)>0){
ss = rgb_scale( pow( double_max( vec_dot(R,V),0), 6), S);
//rgb_print(k);
}
else
ss = rgb_expr(0,0,0);
return rgb_add(result,ss);
}
return result;
}
int sw_encode (struct hw_enc_param *param)
{
static unsigned char *pdest = NULL;
static unsigned long dest_size;
static struct jpeg_compress_struct cinfo;
static struct jpeg_error_mgr jerr;
static unsigned long long stamp, stamp2;
int i;
int is_scaled = 0;
int scale_rate;
int scale_rate_div;
static JSAMPROW rowPointer[1];
static int started = 0;
static int started2 = 0;
char *p_in_buf = (char *)in_buf;
char *p_in_buf_qcom = (char *)in_buf_qcom;
int line_bytes = 0;
pdest = out_buf_ptr;
dest_size = MAX_BUFFER_SIZE;
if (param->in_buf == NULL)
{
LOG_D ("JPEG input buffer is NULL!!\n");
return -1;
}
/* discard verbose data for qcom platform */
int pad = 0;
int loop;
if (support_qcom)
pad = (16 - ( param->width % 16 ) ) % 16;
LOG_D("pad = %d, support_qcom = %d\n", pad, support_qcom);
LOG_D("param->height = %d, param->width = %d",
param->height, param->width);
LOG_D("bytes_per_pixel = %d", param->bytes_per_pixel);
memcpy (in_buf, param->in_buf, param->height * (param->width + pad) * param->bytes_per_pixel);
#if 0
//dump in_buf
LOG_D("==========================================================");
for (loop = 0; loop < param->width * param->bytes_per_pixel * 2;)
{
LOG_D("in_buf[%d] = %0X %0X %0X %0X",
loop / 4,
*(in_buf + loop),
*(in_buf + loop + 1),
*(in_buf + loop + 2),
*(in_buf + loop + 3)
);
loop += param->bytes_per_pixel;
}
LOG_D("***********************************************************");
#endif
if(pad)
{
/* in_buf -> in_buf_qcom */
for (loop = 0; loop < param->height; loop++)
{
line_bytes = param->bytes_per_pixel * param->width;
memcpy(p_in_buf_qcom, p_in_buf, line_bytes);
p_in_buf_qcom += line_bytes;
p_in_buf += line_bytes + pad * param->bytes_per_pixel;
}
}
p_in_buf = pad ? (char *)in_buf_qcom : (char *)in_buf;
#if 0
//dump in_buf_qcom
LOG_D("==========================================================");
for (loop = 0; loop < param->width * param->bytes_per_pixel * 2;)
{
LOG_D("in_buf_qcom[%d] = %0X %0X %0X %0X",
loop / 4,
*(in_buf_qcom + loop),
*(in_buf_qcom + loop + 1),
*(in_buf_qcom + loop + 2),
*(in_buf_qcom + loop + 3)
);
loop += param->bytes_per_pixel;
}
LOG_D("***********************************************************");
#endif
/* rgb scale */
out_buf = rgb_buf;
if (param->height > 1024 || param->width > 768)
{
is_scaled = 1;
scale_rate = 3;
scale_rate_div = 5;
}
if (is_scaled)
{
LOG_D("rgb scaling ......\n");
stamp = _get_system_mstime();
rgb_scale((char *)out_buf, (char *)p_in_buf,
(unsigned int)((( param->width ) / scale_rate_div) * scale_rate ) & 0xfffffff0,
(unsigned int)((( param->height ) / scale_rate_div) * scale_rate ) & 0xfffffff0,
(unsigned int)param->width, (unsigned int)param->height);
stamp2 = _get_system_mstime();
LOG_D("scale time: %lldms\n", stamp2 - stamp);
}
if (started2 == 0)
cinfo.err = jpeg_std_error(&jerr);
if (started == 0)
jpeg_create_compress(&cinfo);
cinfo.image_width = is_scaled ?
((param->width / scale_rate_div) * scale_rate ) & 0xfffffff0
:
param->width;
cinfo.image_height = is_scaled ?
((param->height / scale_rate_div) * scale_rate ) & 0xfffffff0
:
param->height;
/* Rotation */
/* WARNING:
* If pad is existed,
* This portion should be added for qualcomm 16-pixels alignment
* Ha, nothing qualcomm phone is available, so addition later...
*/
/* Ratation image from A * B to B * A */
char * pSrc = p_in_buf;
char * pDest = (char *)in_buf_rotation;
int i2,j2;
int _height = cinfo.image_height;
int _width = cinfo.image_width;
int cube = param->bytes_per_pixel;
/*Debug ratation*/
#if 0
param->angle = 270;
#endif
/* 0 -> 90
* */
static int pre_angle = 0;
//if (pre_angle != param->angle) g_clear_screen = 1;
LOGD("pre_angle = %d, param->angle = %d, g_clear_screen = %d",
pre_angle, param->angle, g_clear_screen);
switch (param->angle)
{
case 0:
case 180:
/*
for (i2 = 0; i2 < _height; i2++)
for (j2 = 0; j2 < _width; j2++)
memcpy((pDest + (_width - j2) * _height * cube + i2 * cube),
(pSrc + j2 * cube + i2 * _width * cube), cube);
cinfo.image_height = _width;
cinfo.image_width = _height;
p_in_buf = (char *)in_buf_rotation;
*/
break;
case 90:
for (i2 = 0; i2 < _height; i2++)
for (j2 = 0; j2 < _width; j2++)
memcpy((pDest + (_width - j2) * _height * cube + i2 * cube),
(pSrc + j2 * cube + i2 * _width * cube), cube);
cinfo.image_height = _width;
cinfo.image_width = _height;
p_in_buf = (char *)in_buf_rotation;
break;
case 270:
for (i2 = 0; i2 < _height; i2++)
for (j2 = 0; j2 < _width; j2++)
memcpy((pDest + j2 * _height * cube + (_height - i2) * cube),
(pSrc + j2 * cube + i2 * _width * cube), cube);
cinfo.image_height = _width;
cinfo.image_width = _height;
p_in_buf = (char *)in_buf_rotation;
break;
case 360:
#if 1
for (i2 = 0; i2 < _height; i2++)
for (j2 = 0; j2 < _width; j2++)
memcpy((pDest + (_width - j2) * _height * cube + i2 * cube),
(pSrc + j2 * cube + i2 * _width * cube), cube);
cinfo.image_height = _width;
cinfo.image_width = _height;
p_in_buf = (char *)in_buf_rotation;
break;
#else
for (i2 = 0; i2 < _height; i2++)
{
for (j2 = 0; j2 < _width; j2++)
{
memcpy((pDest + (_height - i2) * _width * cube + (_width - j2) * cube),
(pSrc + j2 * cube + i2 * _width * cube), cube);
}
}
cinfo.image_height = _height;
cinfo.image_width = _width;
p_in_buf = (char *)in_buf_rotation;
break;
#endif
default:
LOGE("ERROR: angle = %d, VOID value\n", param->angle);
break;
}
cinfo.input_components = param->bytes_per_pixel;
#if 0
/* check if should clear screen */
LOGD("g_clear_screen = %d, g_frame_nums = %d\n",
g_clear_screen, g_frame_nums);
if (g_clear_screen || g_frame_nums)
{
LOGD("clear screen! deeply blank, Oh, My God! somebody shut down lights!");
long _height = cinfo.image_height;
long _width = cinfo.image_width;
long unit = param->bytes_per_pixel;
long go_to_cinema = _height * _width * unit;
memset(p_in_buf, 0, go_to_cinema);
if(g_clear_screen == 1)
memset(p_in_buf, 0xFF, 0xF);
if (g_clear_screen)
g_frame_nums = 1;
else
g_frame_nums--;
}
#endif
switch (param->in_format)
{
case SW_RGBX:
cinfo.in_color_space = JCS_EXT_RGBX;
break;
case SW_BGRX:
cinfo.in_color_space = JCS_EXT_BGRX;
break;
case SW_XRGB:
cinfo.in_color_space = JCS_EXT_XRGB;
break;
case SW_XBGR:
cinfo.in_color_space = JCS_EXT_XBGR;
break;
default:
LOGE("unsupport color format param->in_format = %d\n", param->in_format);
cinfo.in_color_space = JCS_UNKNOWN;
}
if (started == 0)
jpeg_set_defaults(&cinfo);
LOG_D("cinfo.in_color_space = %d\n", cinfo.in_color_space);
if (started == 0)
jpeg_default_colorspace(&cinfo);
if (started == 0)
jpeg_set_quality(&cinfo, is_scaled ? 80 : 75, TRUE);
if (started == 0)
jpeg_mem_dest((j_compress_ptr)&cinfo, (unsigned char **)&pdest, &dest_size); // Data written to mem
jpeg_start_compress(&cinfo, TRUE);
rowPointer[0] = is_scaled ? (JSAMPROW)out_buf : (JSAMPROW)p_in_buf;
LOGD("O o O o O o O o O o O o O o");
LOGD("cinfo.image_height = %d, cinfo.image_width = %d\n",
cinfo.image_height, cinfo.image_width);
stamp = _get_system_mstime();
int count = 0;
for (i = 0; i < cinfo.image_height; ++i)
{
++count;
if (is_scaled)
{
LOG_D("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
rowPointer[0] = (out_buf + cinfo.input_components * i * cinfo.image_width);
}
else
{
//LOG_D("%d,%d, --", __LINE__, count);
if (p_in_buf == NULL)
LOG_D("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
rowPointer[0] = (JSAMPROW)((char *)p_in_buf + cinfo.input_components * i * cinfo.image_width);
}
jpeg_write_scanlines(&cinfo, rowPointer, 1);
}
stamp2 = _get_system_mstime();
LOG_D("\t\t sw encode time: %lldms, jpeg size is %d\n", stamp2 - stamp, (int)dest_size);
if (started == 0)
jpeg_finish_compress(&cinfo);
if (started2 == 0)
//jpeg_destroy_compress(&cinfo);
param->out_buf = pdest;
param->outdata_size = dest_size;
out_buf_size = dest_size;
printf("param->out_buf = %X, param->outdata_size = %d\n\n",
(unsigned int)param->out_buf, param->outdata_size);
static int firstIn = 0;
//if(firstIn == 0)
if (g_clear_screen == 1)
{
firstIn = 1;
FILE *pfile = fopen("/sdcard/clear_screen.jpg", "w");
if (pfile == NULL)
{
LOG_D("open file error!\n");
goto AAAA;
}
fwrite(pdest, 1, dest_size, pfile);
fclose(pfile);
}
AAAA:
if(!out_buf_size)
{
LOGE("Out size is 0!\n");
return -1;
}
if (started == 0)
started = 0;
if (started2 == 0)
started2 = 0;
pre_angle = param->angle;
return 0;
}
