void handle_file(void *ctx, piu_msg_p msg)
{
piufile_t *fmsg;
void *cmdbuf;
FILE *fd;
int freadbyte,fwritebyte;
int ret;
int i;
// printf(" 2");
// fflush(stdout);
memcpy(&file_piu_msg, msg, sizeof(file_piu_msg));
fmsg = (piufile_t *)file_piu_msg.p;
// printf("m %x, a %x\n", fmsg->msgid, fmsg->addr);
// fflush(stdout);
#if 1
#if 0 /* Artemis */
if (fmsg->addr < 0x420000)
{
if (fmsg->addr < 0x10000)
{
cmdbuf = pL1 + fmsg->addr;
}
else if (fmsg->addr < 0x220000)
{
cmdbuf = pL20 + fmsg->addr - 0x200000;
}
else
{
cmdbuf = pL21 + fmsg->addr - 0x400000;
}
#else /* Aphrodite */
if (fmsg->addr <= 0x5FFFFF)
{
if (fmsg->addr < 0x100000)
{
cmdbuf = pL1 + fmsg->addr;
}
else if (fmsg->addr < 0x400000)
{
cmdbuf = pL20 + fmsg->addr - 0x200000;
}
else
{
cmdbuf = pL21 + fmsg->addr - 0x400000;
}
#endif
//printf("cmdbuf addr %X", (uint32_t)cmdbuf);
}
else
#endif
{
cmdbuf = mapm(fmsg->addr, fmsg->len);
}
//printf("msgid=%X paddr=%X len=%d vaddr=%X\n", fmsg->msgid, fmsg->addr, fmsg->len, (unsigned int)cmdbuf);
switch (fmsg->msgid)
{
case PIUMSG_FILE_OPEN:
{
fopen_t *focmd = (fopen_t *)cmdbuf;
//clean
#if 1
// 2009.04.21 :
// avldr request the *.dlist *.dlm files directly without absolute path
// we need to add the absolute path before these file names
unsigned char name[strlen(focmd->name) + strlen(DSP_BIN_PATH) + 2];
strcpy(name, focmd->name);
if (strrchr(focmd->name, '/') == NULL &&
((strlen(focmd->name) >= 4 &&
strncasecmp(&focmd->name[strlen(focmd->name) - 4], ".dlm", 4)) ||
(strlen(focmd->name) >= 5 &&
strncasecmp(&focmd->name[strlen(focmd->name) - 5], ".dlist", 5))))
{
strcpy(name, DSP_BIN_PATH);
strcpy(name + strlen(DSP_BIN_PATH), "/");
strcpy(name + strlen(DSP_BIN_PATH) + 1, focmd->name);
///#ifdef HANDLE_FILE_DEBUG
printf("%s(): dsp file : %s\n", __FUNCTION__, name);
///#endif
}
//
if (strcmp("r",focmd->mode) == 0 ||
strcmp("rb",focmd->mode) == 0 ||
strcmp("rt",focmd->mode) == 0)
fd = fopen(name/*focmd->name*/, "rb");
else fd = fopen(name/*focmd->name*/,focmd->mode);
#else
if ((strcmp("r",focmd->mode)==0||
strcmp("rb",focmd->mode)==0||
strcmp("rt",focmd->mode)==0))
fd = fopen(focmd->name, "rb");
else fd = fopen(focmd->name,focmd->mode);
#endif
if (fd)
{
//clean 071128 to avoid twice fclose problem
for (i = 0 ; i<10; i++)
{
if (filestatus[i]== 0xffffffff)
{
filestatus[i]=(uint32_t)fd;
break;
}
}
if (i==10) printf("filestatus arrany full\n");
//endclean
file_piu_repmsg.fd = (uint32_t)fd;
//printf("fo %s mode %s fd %d\n", focmd->name, focmd->mode, file_piu_repmsg.fd);
if (0 == strcmp(focmd->name, g_filename))
{
isplaying = (uint32_t)fd;
printf("Media file is playing\n");
}
}
else
{
file_piu_repmsg.fd = -1;
printf("can not open file %s\n", focmd->name);
}
file_piu_repmsg.msgid = fmsg->msgid;
file_piu_r.type = PIU_REP;
file_piu_r.len = sizeof(piufile_rep_t);
memcpy(file_piu_r.p, &file_piu_repmsg, file_piu_r.len);
break;
}
case PIUMSG_FILE_CLOSE:
{
fclose_t *fccmd = (fclose_t *)cmdbuf;
fd = (FILE *)fccmd->fd;
if (!fd)
{
printf("fc invalid file number %d\n", *((int *)(cmdbuf + 4)));
file_piu_repmsg.ret = -1;
}
else
{
//printf("fc %d\n", fccmd->fd);
if(isplaying == fccmd->fd)
{
isplaying = 0;
printf("Media file is closed\n");
}
//clean 071128 to avoid twice fclose problem
for (i = 0 ; i<10; i++)
{
if (filestatus[i]== (uint32_t)fd)
{
fclose(fd);
filestatus[i]= 0xffffffff;
break;
}
}
if (i==10) printf("error : fclose file twice\n");
// fclose(fd);
//endclean
file_piu_repmsg.ret = 1;
}
file_piu_repmsg.msgid = fmsg->msgid;
file_piu_r.type = PIU_REP;
file_piu_r.len = sizeof(piufile_rep_t);
memcpy(file_piu_r.p, &file_piu_repmsg, file_piu_r.len);
break;
}
case PIUMSG_FILE_READ:
///printf("%s():READ %d\n", __FUNCTION__, fmsg->len);
fd = (FILE *)fmsg->fd;
if (!fd)
{
printf("invalid file number %d\n", fmsg->fd);
file_piu_repmsg.ret = -3;
}
else
{
#ifdef OPTIMIZE_FILEIO
if(fmsg->bFileSeek == 1)
{
// printf("fsk, fd %d, loc %d\n",fd, fmsg->offset);
fseek(fd, fmsg->offset, fmsg->where);
}
#endif
// printf("fr l %d",fmsg->len);
// fflush(stdout);
freadbyte = fread(cmdbuf, 1, fmsg->len, fd);
// printf("%d rl %d\n",fread_ctr,freadbyte);
// fflush(stdout);
if (freadbyte)
{
file_piu_repmsg.ret = freadbyte;
}
else
{
if (feof(fd))
{
printf("end of file\n");
file_piu_repmsg.ret = -1;
}
else if (ferror(fd))
{
printf("fread error\n");
printf("file error\n");
file_piu_repmsg.ret = -2;
}
else
{
printf("fread error\n");
printf("read 0 byte of data\n");
file_piu_repmsg.ret = -1;
}
}
}
file_piu_repmsg.msgid = fmsg->msgid;
file_piu_r.type = PIU_REP;
file_piu_r.len = sizeof(piufile_rep_t);
memcpy(file_piu_r.p, &file_piu_repmsg, file_piu_r.len);
break;
//clean
case PIUMSG_FILE_WRITE:
fd = (FILE *)fmsg->fd;
if (!fd)
{
printf("invalid file number %d\n", fmsg->fd);
file_piu_repmsg.ret = -3;
}
else
{
// printf("fd= %d, start fwrite\n",fd);
// printf ("bufer = %s",cmdbuf);
fwritebyte= fwrite(cmdbuf, 1, fmsg->len, fd);
//printf("fr fd %d, l %d rl %d\n",fmsg->fd, fmsg->len, freadbyte);
//printf(".");
//fflush(stdout);
if (fwritebyte)
{
// printf("write %d bytes data\n",fwritebyte);
file_piu_repmsg.ret = fwritebyte;
}
else
{
printf("write 0 byte of data\n");
//*((int *)cmdbuf) = -1;
file_piu_repmsg.ret = -1;
}
}
file_piu_repmsg.msgid = fmsg->msgid;
file_piu_r.type = PIU_REP;
file_piu_r.len = sizeof(piufile_rep_t);
memcpy(file_piu_r.p, &file_piu_repmsg, file_piu_r.len);
break;
case PIUMSG_FILE_SEEK:
{
fseek_t *fscmd = (fseek_t *)cmdbuf;
fd = (FILE *)fmsg->fd;
if (!fd)
{
printf("invalid file number %d\n", *((int *)(cmdbuf + 4)));
file_piu_repmsg.ret = -1;
}
else
{
printf("fs fd %d off %ld whence %d\n", fscmd->fd, (long int)fscmd->offset, fscmd->whence);
fflush(stdout);
fseek(fd, fscmd->offset, fscmd->whence);
file_piu_repmsg.ret = 1;
}
file_piu_repmsg.msgid = fmsg->msgid;
file_piu_r.type = PIU_REP;
file_piu_r.len = sizeof(piufile_rep_t);
memcpy(file_piu_r.p, &file_piu_repmsg, file_piu_r.len);
break;
}
case PIUMSG_FILE_TELL:
{
ftell_t *ftcmd = (ftell_t *)cmdbuf;
fd = (FILE *)fmsg->fd;
if (fd == NULL)
{
printf("invalid file number %d\n", ftcmd->fd);
file_piu_repmsg.ret = -1;
}
else
{
#ifdef OPTIMIZE_FILEIO
//printf("ftell %d %d %d %d\n", fmsg->bFileSeek, fmsg->fd, fmsg->offset, fmsg->where);
if(fmsg->bFileSeek == 1)
fseek(fd, fmsg->offset, fmsg->where);
#endif
//fseek(fd, 0, SEEK_END);
file_piu_repmsg.ret = ftell(fd);
if (file_piu_repmsg.ret == 0)
{
file_piu_repmsg.ret = -1;
}
//printf("ft fd %d off %ld\n", ftcmd->fd, (long int)file_piu_repmsg.ret);
}
file_piu_repmsg.msgid = fmsg->msgid;
file_piu_r.type = PIU_REP;
file_piu_r.len = sizeof(piufile_rep_t);
memcpy(file_piu_r.p, &file_piu_repmsg, file_piu_r.len);
break;
}
case PIUMSG_MSFILE_NAME:
{
//printf("ms file name\n");
if (g_filename)
{
strcpy(cmdbuf, g_filename);
printf("file name %s.\n", g_filename);
}
else
{
printf("please enter file name\n");
fgets(g_filename, FILENAME_LEN, stdin);
g_filename[strlen(g_filename) - 1] = '\0';
printf("your file: %s.\n", g_filename);
}
file_piu_repmsg.msgid = fmsg->msgid;
file_piu_repmsg.ret = 1;
file_piu_r.type = PIU_REP;
file_piu_r.len = sizeof(piufile_rep_t);
memcpy(file_piu_r.p, &file_piu_repmsg, file_piu_r.len);
break;
}
default:
printf("unknown msg id %x\n", fmsg->msgid);
break;
}
if (fmsg->addr >= 0x420000)
{
// printf("um\n");
unmapm(cmdbuf, fmsg->len);
}
// printf("TX\n");
// fflush(stdout);
// send reply
ret = piu_tx(PIU_FILE_QID, &file_piu_r);
if (ret)
{
printf("piu tx error\n");
}
// printf(" 4");
// fflush(stdout);
// if(fmsg->msgid == PIUMSG_FILE_READ)
// fread_ctr++;
}
int main(int argc, char * argv[])
{
int base_addr = 0, nbytes = 64;
int v_addr = 0;
void * p;
int i, size = 1;
unsigned char linebuf[16], line_len;
if(argc < 2)
{
printf("usage:\r\n md [-b|-w|-l] address [-c count]\r\n");
return (-1);
}
for(i=1; i<argc; i++)
{
if( !strcmp(argv[i],"-b") )
size = 1;
else if( !strcmp(argv[i],"-w") )
size = 2;
else if( !strcmp(argv[i],"-l") )
size = 4;
else if( !strcmp(argv[i],"-c") && (argc > i+1))
{
nbytes = strtoul(argv[i+1], NULL, 0);
i++;
}
else if(*argv[i] == '-')
{
printf("md: invalid option '%s'\r\n", argv[i]);
printf("usage:\r\n md [-b|-w|-l] address [-c count]\r\n");
return (-1);
}
else if(*argv[i] != '-' && strcmp(argv[i], "-") != 0)
{
base_addr = strtoul(argv[i], NULL, 0);
}
}
if(size == 2)
{
base_addr = base_addr & (~0x00000001);
}
else if(size == 4)
{
base_addr = base_addr & (~0x00000003);
}
nbytes = nbytes * size;
p = mapm(base_addr, nbytes);
if(p == MAPM_ERR_FILE)
{
printf("open error\n");
return -2;
}
if (p == MAPM_ERR_MAP)
{
printf(" map addr=0x%08x len=0x%08x error\n", base_addr, nbytes);
return -3;
}
v_addr = (int)p;
while(nbytes > 0)
{
line_len = (nbytes > 16) ? 16:nbytes;
printf("%08x: ", base_addr);
if(size == 1)
{
for(i=0; i<line_len; i+= size)
*((unsigned char *)(&linebuf[i])) = *((unsigned char *)(v_addr+i));
for(i=0; i<line_len; i+= size)
printf(" %02x", *((unsigned char *)(&linebuf[i])));
}
else if(size == 2)
{
for(i=0; i<line_len; i+= size)
*((unsigned short *)(&linebuf[i])) = *((unsigned short *)(v_addr+i));
for(i=0; i<line_len; i+= size)
printf(" %04x", *((unsigned short *)(&linebuf[i])));
}
else if(size == 4)
{
for(i=0; i<line_len; i+= size)
*((unsigned int *)(&linebuf[i])) = *((unsigned int *)(v_addr+i));
for(i=0; i<line_len; i+= size)
printf(" %08x", *((unsigned int *)(&linebuf[i])));
}
printf("%*s", (16-line_len)*2+(16-line_len)/size+4, "");
for(i=0; i<line_len; i++)
{
if( (linebuf[i] < 0x20) || (linebuf[i] > 0x7e) )
printf(".");
else
printf("%c", linebuf[i]);
}
base_addr += line_len;
v_addr += line_len;
nbytes -= line_len;
printf("\r\n");
}
unmapm(p, nbytes);
return 0;
}
/* display piu isr handler */
void disp_handler(void *ctx, piu_msg_p msg)
{
uint16_t cmd_id;
memcpy(&disp_rx, msg, sizeof(piu_msg_t));
cmd_id = DISP_U8_TO_U16(disp_rx.p);
dbg("V %x\n", cmd_id);
if ((cmd_id & 0xFF) == DISP_GET)
{
switch (cmd_id&0xFF00)
{
case DISP_IMAGE_PROPERTY:
{
disp_tx.len = 6;
DISP_U8_TO_U16(disp_tx.p) = cmd_id;
DISP_U8_TO_U16(disp_tx.p+2) = cfg.output.size.w;
DISP_U8_TO_U16(disp_tx.p+4) = cfg.output.size.h;
dbg("DISP: rx DISP_GET_IMAGE_PROPERTY ->tx [%d,%d] \n", cfg.output.size.w, cfg.output.size.h);
break;
}
case DISP_IMAGE_START:
{
disp_tx.len = 6;
DISP_U8_TO_U16(disp_tx.p) = cmd_id;
DISP_U8_TO_U16(disp_tx.p+2) = 0; //offset[0];
DISP_U8_TO_U16(disp_tx.p+4) = 0; //offset[1];
dbg("DISP: rx DISP_GET_IMAGE_START -> tx [%d,%d] \n", 0,0); //offset[0], offset[1]);
break;
}
default:
{
printf("rx Unkwown DISP_GET\n");
return;
}
piu_tx(PIU_DISP_QID, &disp_tx);
}
}
else if (cmd_id == (DISP_CFG | DISP_CFG_BUF))
{
// DO NOT send back response because ceva can't receive it due to nested interrupt
uint32_t *addr = (uint32_t *)(disp_rx.p+4);
cfg.input.ybuf[0] = addr[0];
cfg.input.cbbuf[0] = addr[1];
cfg.input.crbuf[0] = addr[2];
// check if there is partial display mode or not
if((g_disp_mode == DISP_IMAGE_MODE) &&(g_partial_disp_mode == 1))
{
//update VPP output buffer pointor
cfg.output.ybuf[0] = vpp_output[0] + g_jpg_slices_index;
cfg.output.cbbuf[0] = 0;
cfg.output.crbuf[0] = 0;
g_jpg_slices_index += g_jpg_slices_height*g_rgb_elem_size*cfg.output.size.w;
dbg("DISP: output ybuf: %x, buf index: %x\n", cfg.output.ybuf[0], g_jpg_slices_index);
}
cfg.flag = VPP_F_ADDR;
dbg("DISP: rx DISP_CFG_BUF: (%x, %x, %x)\n", addr[0], addr[1], addr[2]);
if (vpp_cfg(&vpp, &cfg, DISP_VPP_CH))
{
printf("DISP: VPP_CFG failed\n");
return;
}
dbg("DISP: DISP_START\n");
if (vpp_start(&vpp, DISP_VPP_CH))
{
printf("DISP: VPP_START failed\n");
return;
}
dbg("DISP: DISP_START done\n");
}
else
{
if ((cmd_id & 0xFF) == DISP_CFG)
{
if (piu_vpp_cfg(cmd_id&0xFF00, (char *)disp_rx.p + 4))
{
printf("DISP: VPP_CFG failed\n");
}
}
else if ((cmd_id & 0xFF) == DISP_SET)
{
switch (cmd_id&0xFF00)
{
case DISP_IMAGE_PROPERTY:
{
uint16_t *p = (uint16_t *)(disp_rx.p+2);
cfg.input.size.w = p[0];
cfg.input.size.h = p[1];
cfg.input.stride_y = p[2];
cfg.input.stride_cb = p[3];
cfg.input.stride_cr = p[3];
// check for partial image display mode
if((g_disp_mode == DISP_IMAGE_MODE) && (cfg.input.size.h < g_jpg_height))
{
g_partial_disp_mode = 1;
g_jpg_slices_height = (fbp[1]*cfg.input.size.h)/g_jpg_height;
dbg("DISP: partial input height = %d, output height = %d, orig image height = %d\n",cfg.input.size.h,g_jpg_slices_height,g_jpg_height);
}
//clean 080104
if (disp_rx.len >= 12) //added 2 bytes for yuv format
{
switch (p[4])
{
case 0: cfg.input.format = VPP_PIC_YUV444P;break;
case 1: cfg.input.format = VPP_PIC_YUV422P;break;
case 2: cfg.input.format = VPP_PIC_YUV420P;break;
case 3: cfg.input.format = VPP_PIC_YUV411P;break;
case 4: cfg.input.format = VPP_PIC_YUV400P;break;
default:printf("error yuv format\n");
}
dbg("DISP: output format = %d\n", cfg.input.format);
}
if (disp_rx.len == 16)
{
cfg.input.pixel.w = p[5];
cfg.input.pixel.h = p[6];
if (p[5] == 0 || p[6] == 0)
{
cfg.input.pixel.w = 1;
cfg.input.pixel.h = 1;
}
}
//endclean
cfg.flag |= VPP_F_IN;
dbg("DISP: rx DISP_SET_IMAGE_PROPERTY: size=[%d,%d], stride=[%d %d]\n", p[0], p[1], p[2], p[3]);
#ifdef TV_UNDERRUN_BUG
{
void *stat = mapm(0x8009008, 36);
uint32_t val= 0;
if (stat == (void *)-1)
{
printf("mapm fail\n");
return;
}
val = *((uint32_t *)stat + 8);
printf("image un=%x\n", val);
if (val == 3)
{
int i= 500;
*(uint32_t *)stat = 3;
while (i--);
*((uint32_t *)stat + 1) = 0x38004F;
*((uint32_t *)stat + 5) = 0x93e00000;
*((uint32_t *)stat + 6) = 0x93e54600;
*((uint32_t *)stat + 7) = 0x93e7e900;
*(uint32_t *)stat = 5;
printf("image un=%x\n", *((uint32_t *)stat + 8) );
}
unmapm(stat, 36);
}
#endif
break;
}
default:
{
printf("DISP: rx Unknown DISP_SET\n");
return;
}
}
}
else
{
switch (cmd_id)
{
case DISP_INIT:
{
dbg("DISP: rx DISP_INIT\n");
#if 0
if (disp_init())
{
printf("DISP_INIT failed\n");
return;
}
#endif
if (piu_vpp_init())
{
printf("DISP: VPP_INIT failed\n");
return;
}
dbg("DISP: VPP OPEN\n");
disp_tx.len = 6;
DISP_U8_TO_U16(disp_tx.p) = cmd_id;
DISP_U8_TO_U16(disp_tx.p+2) = cfg.output.size.w;
DISP_U8_TO_U16(disp_tx.p+4) = cfg.output.size.h;
piu_tx(PIU_DISP_QID, &disp_tx);
return;
}
case DISP_START:
{
dbg("DISP: rx DISP_START\n");
if (vpp_start(&vpp, DISP_VPP_CH))
{
printf("DISP: VPP_START failed\n");
return;
}
break;
}
case DISP_CLOSE:
{
g_disp_mode = DISP_VIDEO_MODE;
g_partial_disp_mode = 0;
g_jpg_slices_index = 0;
//vpp_exit(&vpp);
disp_done = 1;
#ifdef TV_UNDERRUN_BUG
{
void *stat = mapm(0x8009028, 4);
uint32_t val= 0;
if (stat == (void *)-1)
{
printf("mapm fail\n");
return;
}
val = *(uint32_t *)stat;
printf("close un=%x\n", val);
if (val == 3)
{
*(uint32_t *)stat = 3;
}
unmapm(stat, 4);
}
#endif
printf("DISP: VPP CLOSE\n");
#if 0
disp_exit();
printf("???disp_exit() done???\n");
#endif
break;
}
default:
{
printf("Unkwown DISP command 0x%x\n", cmd_id);
return;
}
}
}
#ifdef NEED_RESP
printf("\n%x\n", cmd_id);
disp_tx.len = 2;
DISP_U8_TO_U16(disp_tx.p) = cmd_id;
piu_tx(PIU_DISP_QID, &disp_tx);
#endif
}
}
int disp_init(uint16_t w, uint16_t h, uint16_t stride, uint32_t vpp_out_buf[3], int fmt)
{
uint32_t sz;
if (!stride)
{
printf("Framebuffer stride must be larger than 0\n");
return -1;
}
fbp[0] = w; /* width of region of display (ROD */
fbp[1] = h; /* height of ROD */
fbp[2] = stride; /* stride of framebuffer */
vpp_output[0] = vpp_out_buf[0];/* Y starting address */
vpp_output[1] = vpp_out_buf[1];/* U starting address */
vpp_output[2] = vpp_out_buf[2];/* V starting address */
sz = fbp[1]*fbp[2];
disp_done = 0;
g_rgb_elem_size = fmt/8;
/* tvo, tve init & cfg*/
memset(&disp_tx, 0, sizeof(piu_msg_t));
memset(&disp_rx, 0, sizeof(piu_msg_t));
memset(&vpp, 0, sizeof(vpp_t));
memset(&cfg, 0, sizeof(vpp_cfg_t));
/* In this task, disp_tx always to be response to ceva, and disp_rx always contains cmd from ceva */
disp_tx.type = PIU_REP;
disp_rx.type = PIU_CMD;
#if DISP_TVO_MODE == DISP_LCD
switch (fmt)
{
case 8:
cfg.output.format = VPP_PIC_YUV420P;
#ifdef BUFFER_INIT_CLEAR
g_yuvsz[0] = sz;
g_yuvsz[1] = sz/2;
g_yuvsz[2] = sz/2;
#endif
break;
case 16:
cfg.output.format = VPP_PIC_RGB16;
#ifdef BUFFER_INIT_CLEAR
g_yuvsz[0] = 2*sz;
g_yuvsz[1] = 0;
g_yuvsz[2] = 0;
#endif
break;
case 32:
cfg.output.format = VPP_PIC_RGB32;
#ifdef BUFFER_INIT_CLEAR
g_yuvsz[0] = 4*sz;
g_yuvsz[1] = 0;
g_yuvsz[2] = 0;
#endif
break;
default:
printf("Output color format error, choose only 8, 16, 32\n");
return -2;
}
#else
cfg.output.format = VPP_PIC_YUV422P;
#ifdef BUFFER_INIT_CLEAR
g_yuvsz[0] = sz;
g_yuvsz[1] = sz/2;
g_yuvsz[2] = sz;
#endif
#endif
#ifdef BUFFER_INIT_CLEAR
g_y = mapm(vpp_output[0], g_yuvsz[0]);
if (g_yuvsz[1])
{
g_u = mapm(vpp_output[1], g_yuvsz[1]);
}
if (g_yuvsz[2])
{
g_v = mapm(vpp_output[2], g_yuvsz[2]);
}
if ((g_y == (void *)-1) || (g_u == (void *)-1) || (g_y == (void *)-1))
{
printf("mapm fail\n");
ret = -3;
goto l_init_exit;
}
// clear display
/* clear vpp output buffer (framebuffer) to black */
{
int i=0;
for (i=0; i<fbp[1]; i++)
{
memset((uint8_t *)(g_y + i*w), 0, w);
}
}
dbg("DISP: black background\n");
#endif
printf("lcd init done\n");
return 0;
#ifdef BUFFER_INIT_CLEAR
l_init_exit:
unmapm(g_y, g_yuvsz[0]);
if (g_yuvsz[1])
{
unmapm(g_u, g_yuvsz[1]);
}
if (g_yuvsz[2])
{
unmapm(g_v, g_yuvsz[2]);
}
printf("DISP: INIT failed\n");
return ret;
#endif
}
/* width/height: vpp output image*/
static int piu_vpp_init(void)
{
// init global variables
g_partial_disp_mode = 0;
g_jpg_slices_height = 0;
g_jpg_slices_index = 0;
/* Configure VPP */
vpp.reg = (void *)DISP_VPP_BASE;
cfg.input.pixel.w = 1;
cfg.input.pixel.h = 1;
cfg.input.format = VPP_PIC_YUV420P;
cfg.trigger = VPP_TRIG_POLL; /* polling mode, manual re-start */
cfg.display = VPP_DISPLAY_FIT;
cfg.flag = VPP_F_IN | VPP_F_OUT; // | VPP_F_ADDR;
cfg.output.size.w = fbp[0];
cfg.output.size.h = fbp[1];
if ((cfg.output.format== VPP_PIC_RGB16)
|| (cfg.output.format == VPP_PIC_YUV422I_YUYV)
|| (cfg.output.format == VPP_PIC_YUV422I_UYVY))
{
cfg.output.stride_y = fbp[2] * 2; //TVO_INP_WIDTH;
}
else if (cfg.output.format == VPP_PIC_RGB32)
{
cfg.output.stride_y = fbp[2] * 4; //TVO_INP_WIDTH;
}
else
{
cfg.output.stride_y = fbp[2]; //TVO_INP_WIDTH;
cfg.output.stride_cb = fbp[2]; //TVO_INP_WIDTH;
cfg.output.stride_cr = fbp[2]; //TVO_INP_WIDTH;
}
cfg.output.pixel.w = 1;
cfg.output.pixel.h = 1;
cfg.output.ybuf[0] = vpp_output[0];
cfg.output.cbbuf[0] = vpp_output[1];
cfg.output.crbuf[0] = vpp_output[2];
// black out the display for jpeg display
if(g_disp_mode == DISP_IMAGE_MODE)
{
void *addr = 0;
int size = fbp[0]*fbp[1]*g_rgb_elem_size;
int index = 0;
#if 0
// black out the last 10 line
if(fbp[1] > 10)
{
index = (fbp[1] - 10)* fbp[0]*g_rgb_elem_size;
size = fbp[0]*10*g_rgb_elem_size;
}
#endif
dbg("DISP: disp buffer mapm %x, size %d\n",vpp_output[0]+index, size);
addr = mapm(vpp_output[0]+index, size);
if(addr != 0)
{
// clear display
/* clear vpp output buffer (framebuffer) to black */
memset((uint8_t *)addr, 0, size);
unmapm(addr, size);
}
else
printf("failed to mapm %x, size %d\n",vpp_output[0], size);
}
return vpp_init(&vpp);
}
