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); }