#include "sys_config.h" #include "tx_platform.h" #include "list.h" #include "dev.h" #include "typesdef.h" #include "devid.h" #include "osal/irq.h" #include "osal/string.h" #include "osal/semaphore.h" #include "osal/mutex.h" #include "osal/task.h" #include "osal/work.h" #include "osal/event.h" #include "hal/usb_device.h" #include "dev/usb/hgusb20_v1_dev_api.h" #include "dev/usb/uvc_host.h" #include "osal/semaphore.h" #include "jpgdef.h" #include "lib/lcd/lcd.h" #include "lib/common/common.h" #include "lib/heap/av_heap.h" #include "lib/heap/av_psram_heap.h" #include "stream_frame.h" #include "utlist.h" //兼容有psram和无psram的情况 #ifdef PSRAM_HEAP #define UVC_MALLOC av_psram_malloc #define UVC_FREE av_psram_free #else #define UVC_MALLOC av_malloc #define UVC_FREE av_free #endif #if USB_EN #define UVC_BLANK_LEN 16*1024 #ifdef PSRAM_HEAP #define UVC_BLANK_NUM 8 #else #define UVC_BLANK_NUM 8 #endif #define UVC_FRAME_NUM 2 UVC_BLANK uvc_blank[UVC_BLANK_NUM]; //uint8 blank_space[UVC_BLANK_NUM][UVC_BLANK_LEN+UVC_HEAD_RESERVER]__attribute__ ((aligned(4))); uint8 *blank_space[UVC_BLANK_NUM]; struct list_head free_uvc_tab[UVC_HOST_NUM]; struct list_head *uvc_p[UVC_HOST_NUM]; struct list_head *uvc_bnk[UVC_HOST_NUM]; UVC_MANAGE* uvc_msg[UVC_HOST_NUM]; UVC_MANAGE uvc_msg_frame[UVC_HOST_NUM][UVC_FRAME_NUM]; //2个frame就够了，一个中断处正在收，一个应用正在使用,带宽不足时一个frame的不同blank进行收发处理 #define NEXT_TGL ((uvc_msg[0]->uvc_head[1] & BIT(0)) ^ 1) #define CURT_TGL (uvc_msg[0]->uvc_head[1] & BIT(0)) #define NEXT_TGL2 ((uvc_msg[1]->uvc_head[1] & BIT(0)) ^ 1) #define CURT_TGL2 (uvc_msg[1]->uvc_head[1] & BIT(0)) uint32 frame_num[UVC_HOST_NUM]; volatile uint32 rx_packet_len; volatile uint32 rx_packet_len_2; volatile uint32 head_len; int get_node_uvc_len() { return UVC_BLANK_LEN; } void *get_usb_jpeg_node_buf(void *d) { UVC_BLANK* uvc_b = (UVC_BLANK*)d; return uvc_b->buf_ptr; } /**@brief * 将传入的frame根节点下的buf池都送回空间池（free_uvc_tab）中 */ bool free_get_uvc_node_list(struct list_head *head,struct list_head *free){ if(list_empty(head)){ return 0; } list_splice_init(head,free); return 1; } void del_usb_frame(void *get_f) { free_get_uvc_node_list(get_f,&free_uvc_tab[0]); } void del_usb_frame2(void *get_f) { free_get_uvc_node_list(get_f,&free_uvc_tab[1]); } int get_usb_node_count(struct list_head *head) { int count = 0; struct list_head *first = (struct list_head *)head; while(head->next != first) { head = head->next; count++; } return count; //数量 } /**@brief * 从初始化的frame根节点中抽取其中一个空闲的根节点进行使用，并标记frame的使用状态为正在使用 * @param 是否开启抢占模式，如果开启，则将上一帧已完成的帧节点删掉，并返回 */ struct list_head* get_new_uvc_frame_head(int grab){ uint8 frame_num = 0; for(frame_num = 0;frame_num < UVC_FRAME_NUM;frame_num++){ if(uvc_msg_frame[0][frame_num].state == 0){ uvc_msg_frame[0][frame_num].state = 1; uvc_msg_frame[0][frame_num].frame_end = 0; return &uvc_msg_frame[0][frame_num].list; } } if(grab) //是否开启抢占模式,开启抢占后，肯定有frame返回，上一帧没使用的frame肯定usable为2 { for(frame_num = 0;frame_num < UVC_FRAME_NUM;frame_num++){ if(uvc_msg_frame[0][frame_num].state == 2){ uvc_msg_frame[0][frame_num].state = 1; uvc_msg_frame[0][frame_num].frame_end = 0; free_get_uvc_node_list(&uvc_msg_frame[0][frame_num].list,&free_uvc_tab[0]); return &uvc_msg_frame[0][frame_num].list; } } } return 0; } void set_uvc_frame_ready(UVC_MANAGE* uvc){ if(uvc->state != 3) //表示此frame正在被应用使用，可以使用的状态不用切了 uvc->state = 2; } void set_uvc_frame_using(UVC_MANAGE* uvc){ uvc->state = 3; } void del_uvc_frame(UVC_MANAGE* uvc) { uvc->state = 0; uvc->frame_len = 0; uvc->frame_end = 0; } /*reset所有的frame，包括正在填充的和正在使用的，在填充和获取的线程或中断都关闭后调用*/ void force_reset_uvc_frame() { uint8 frame_num = 0; for(frame_num = 0;frame_num < UVC_FRAME_NUM;frame_num++){ del_usb_frame(&uvc_msg_frame[0][frame_num].list); del_uvc_frame(&uvc_msg_frame[0][frame_num]); } } /**@brief * 从空间池中提取一个节点，放到队列中，并将此节点作为返回值返回 */ struct list_head *get_blank_node(struct list_head *head,struct list_head *del){ if(list_empty(del)){ return 0; } list_move(del->prev,head); return head->next; //返回最新的位置 } bool put_blank_node(struct list_head *head,struct list_head *del){ irq_disable(USB20DMA_IRQn); if(list_empty(del)){ irq_enable(USB20DMA_IRQn); return 0; } list_move(del->prev,head); irq_enable(USB20DMA_IRQn); return 1; } //新增加,将节点归还到节点池 bool free_usb_node(struct list_head *del){ irq_disable(USB20DMA_IRQn); list_move(del,&free_uvc_tab[0]); irq_enable(USB20DMA_IRQn); return 1; } //新增加,将节点归还到节点池 bool free_usb_node2(struct list_head *del){ irq_disable(USB20DMA_IRQn); list_move(del,&free_uvc_tab[1]); irq_enable(USB20DMA_IRQn); return 1; } bool free_node2tab(UVC_BLANK* ubk,struct list_head *head,struct list_head *del) { put_blank_node(head,del); return 0; } struct list_head* get_uvc_frame() { uint8 frame_num = 0; irq_disable(USB20DMA_IRQn); for(frame_num = 0;frame_num < UVC_FRAME_NUM;frame_num++){ if(uvc_msg_frame[0][frame_num].state == 2) //将当前使用frame或者完成frame返回出去，加以使用 { uvc_msg_frame[0][frame_num].state = 1; irq_enable(USB20DMA_IRQn); return &uvc_msg_frame[0][frame_num].list; } } #ifdef PSRAM_HEAP for(frame_num = 0;frame_num < UVC_FRAME_NUM;frame_num++){ if(uvc_msg_frame[0][frame_num].state == 1) //将当前使用frame或者完成frame返回出去，加以使用 { uvc_msg_frame[0][frame_num].state = 1; irq_enable(USB20DMA_IRQn); return &uvc_msg_frame[0][frame_num].list; } } #endif irq_enable(USB20DMA_IRQn); return 0; } struct list_head* get_uvc_frame2() { uint8 frame_num = 0; irq_disable(USB20DMA_IRQn); for(frame_num = 0;frame_num < UVC_FRAME_NUM;frame_num++){ if(uvc_msg_frame[1][frame_num].state == 2) //将当前使用frame或者完成frame返回出去，加以使用 { uvc_msg_frame[1][frame_num].state = 1; irq_enable(USB20DMA_IRQn); return &uvc_msg_frame[1][frame_num].list; } } #ifdef PSRAM_HEAP for(frame_num = 0;frame_num < UVC_FRAME_NUM;frame_num++){ if(uvc_msg_frame[1][frame_num].state == 1) //将当前使用frame或者完成frame返回出去，加以使用 { uvc_msg_frame[1][frame_num].state = 1; irq_enable(USB20DMA_IRQn); return &uvc_msg_frame[1][frame_num].list; } } #endif irq_enable(USB20DMA_IRQn); return 0; } void uvc_blank_init(uint8* buf, uint32 blank_len, uint8 blank_num) { uvc_blank[blank_num].blank_len = 0; uvc_blank[blank_num].re_space = blank_len; uvc_blank[blank_num].blank_loop = 0; uvc_blank[blank_num].buf_ptr = buf;//buf+blank_num*(blank_len+UVC_HEAD_RESERVER)+UVC_HEAD_RESERVER; uvc_blank[blank_num].busy = 0; uvc_blank[blank_num].frame_counter = 0; } void uvc_blank_list_init(struct list_head *ftb,uint8 blank_num) { uint8 bcnt = 0; INIT_LIST_HEAD(ftb); for(bcnt = 0;bcnt < blank_num;bcnt++){ INIT_LIST_HEAD(&uvc_blank[bcnt].list); list_add_tail(&uvc_blank[bcnt].list,ftb); } } void uvc_blank_list_init2(struct list_head *ftb,uint8 blank_num) { uint8 bcnt = 0; INIT_LIST_HEAD(ftb); for(bcnt = 0;bcnt < blank_num;bcnt++){ os_printf("uvc blank list init2:%d\r\n",bcnt+UVC_BLANK_NUM/2); INIT_LIST_HEAD(&uvc_blank[bcnt+UVC_BLANK_NUM/2].list); list_add_tail(&uvc_blank[bcnt+UVC_BLANK_NUM/2].list,ftb); } } void uvc_room_del(){ uint8 bcnt = 0; for(bcnt = 0;bcnt < UVC_BLANK_NUM;bcnt++){ if(blank_space[bcnt]){ os_printf("blank del[%d]\r\n",bcnt); UVC_FREE(blank_space[bcnt]); blank_space[bcnt] = NULL; } } } void uvc_room_del_mjpeg(){ uint8 bcnt = 0; for(bcnt = 0;bcnt < UVC_BLANK_NUM/2;bcnt++){ if(blank_space[bcnt]){ os_printf("h264 blank del[%d]\r\n",bcnt); UVC_FREE(blank_space[bcnt]); blank_space[bcnt] = NULL; } } } void uvc_room_del_h264(){ uint8 bcnt = 0; for(bcnt = UVC_BLANK_NUM/2;bcnt < UVC_BLANK_NUM;bcnt++){ if(blank_space[bcnt]){ os_printf("mjpeg blank del[%d]\r\n",bcnt); UVC_FREE(blank_space[bcnt]); blank_space[bcnt] = NULL; } } } uint8_t *check_uvc_room() { return blank_space[0]; } uint8_t *check_uvc_room2() { return blank_space[UVC_BLANK_NUM/2]; } void uvc_room_malloc(){ uint8 bcnt = 0; for(bcnt = 0;bcnt < UVC_BLANK_NUM;bcnt++){ if(blank_space[bcnt] == NULL){ blank_space[bcnt] = UVC_MALLOC(UVC_BLANK_LEN); if(blank_space[bcnt] == NULL){ os_printf("uvc malloc fail\r\n"); return; } os_printf("blank_space[%d]:%x\r\n",bcnt,(unsigned int)blank_space[bcnt]); } uvc_blank_init(blank_space[bcnt],UVC_BLANK_LEN,bcnt); } } void uvc_room_malloc_mjpeg(){ uint8 bcnt = 0; for(bcnt = 0;bcnt < UVC_BLANK_NUM/2;bcnt++){ if(blank_space[bcnt] == NULL){ blank_space[bcnt] = UVC_MALLOC(UVC_BLANK_LEN); if(blank_space[bcnt] == NULL){ os_printf("uvc malloc fail\r\n"); return; } os_printf("blank_space[%d]:%x\r\n",bcnt,(unsigned int)blank_space[bcnt]); } uvc_blank_init(blank_space[bcnt],UVC_BLANK_LEN,bcnt); } } void uvc_room_malloc_h264(){ uint8 bcnt = 0; for(bcnt = UVC_BLANK_NUM/2;bcnt < UVC_BLANK_NUM;bcnt++){ if(blank_space[bcnt] == NULL){ blank_space[bcnt] = UVC_MALLOC(UVC_BLANK_LEN); if(blank_space[bcnt] == NULL){ os_printf("uvc malloc fail\r\n"); return; } os_printf("blank_space[%d]:%x\r\n",bcnt,(unsigned int)blank_space[bcnt]); } uvc_blank_init(blank_space[bcnt],UVC_BLANK_LEN,bcnt); } } void uvc_reset_dev(uint8_t en){ if(en){ os_sleep_ms(5); uvc_room_malloc(); _os_printf("room set"); }else{ uvc_msg_frame[0][0].frame_end = 2; uvc_msg_frame[0][1].frame_end = 2; uvc_msg_frame[1][0].frame_end = 2; uvc_msg_frame[1][1].frame_end = 2; os_sleep_ms(5); uvc_room_del(); _os_printf("room del"); } } void uvc_reset_dev_mjpeg(uint8_t en){ if(en){ os_sleep_ms(5); uvc_room_malloc_mjpeg(); _os_printf("room mjpeg set"); }else{ uvc_msg_frame[0][0].frame_end = 2; uvc_msg_frame[0][1].frame_end = 2; uvc_room_del_mjpeg(); _os_printf("room mjpeg del"); } } void uvc_reset_dev_h264(uint8_t en){ if(en){ os_sleep_ms(5); uvc_room_malloc_h264(); _os_printf("room h264 set"); }else{ uvc_msg_frame[1][0].frame_end = 2; uvc_msg_frame[1][1].frame_end = 2; uvc_room_del_h264(); _os_printf("room h264 del"); } } extern void uvc_stream_open(struct hgusb20_dev *p_dev,uint8 enable); struct list_head* get_new_uvc_frame_head2(int grab); //初始化双数据流的节点空间 void uvc_room_init(void *p_dev) { os_printf("%s:%d\n",__FUNCTION__,__LINE__); //如果已经申请了空间,则不需要管,如果没有申请空间,则关闭 if(!check_uvc_room()) { uvc_reset_dev(1); } uvc_blank_list_init(&free_uvc_tab[0],UVC_BLANK_NUM/2); INIT_LIST_HEAD(&uvc_msg_frame[0][0].list); INIT_LIST_HEAD(&uvc_msg_frame[0][1].list); uvc_msg_frame[0][0].state = 0; uvc_msg_frame[0][1].state = 0; uvc_msg_frame[0][0].sta = 0; uvc_msg_frame[0][1].sta = 0; uvc_p[0] = get_new_uvc_frame_head(1); uvc_msg[0] = list_entry(uvc_p[0],UVC_MANAGE,list);//&uvc_msg_frame[0]; uvc_blank_list_init2(&free_uvc_tab[1],UVC_BLANK_NUM/2); INIT_LIST_HEAD(&uvc_msg_frame[1][0].list); INIT_LIST_HEAD(&uvc_msg_frame[1][1].list); uvc_msg_frame[1][0].state = 0; uvc_msg_frame[1][1].state = 0; uvc_msg_frame[1][0].sta = 0; uvc_msg_frame[1][1].sta = 0; uvc_p[1] = get_new_uvc_frame_head2(1); uvc_msg[1] = list_entry(uvc_p[1],UVC_MANAGE,list);//&uvc_msg_frame[0]; } //初始化mjpeg的节点空间 void uvc_room_init_mjpeg() { os_printf("%s:%d\n",__FUNCTION__,__LINE__); //如果已经申请了空间,则不需要管,如果没有申请空间,则关闭 if(!check_uvc_room()) { uvc_reset_dev_mjpeg(1); } uvc_blank_list_init(&free_uvc_tab[0],UVC_BLANK_NUM/2); INIT_LIST_HEAD(&uvc_msg_frame[0][0].list); INIT_LIST_HEAD(&uvc_msg_frame[0][1].list); uvc_msg_frame[0][0].state = 0; uvc_msg_frame[0][1].state = 0; uvc_msg_frame[0][0].sta = 0; uvc_msg_frame[0][1].sta = 0; uvc_p[0] = get_new_uvc_frame_head(1); uvc_msg[0] = list_entry(uvc_p[0],UVC_MANAGE,list);//&uvc_msg_frame[0]; } void uvc_room_deinit_mjpeg() { uvc_reset_dev_mjpeg(0); } //初始化h264的节点空间 void uvc_room_init_h264() { os_printf("%s:%d\n",__FUNCTION__,__LINE__); //如果已经申请了空间,则不需要管,如果没有申请空间,则关闭 if(!check_uvc_room2()) { uvc_reset_dev_h264(1); } uvc_blank_list_init2(&free_uvc_tab[1],UVC_BLANK_NUM/2); INIT_LIST_HEAD(&uvc_msg_frame[1][0].list); INIT_LIST_HEAD(&uvc_msg_frame[1][1].list); uvc_msg_frame[1][0].state = 0; uvc_msg_frame[1][1].state = 0; uvc_msg_frame[1][0].sta = 0; uvc_msg_frame[1][1].sta = 0; uvc_p[1] = get_new_uvc_frame_head2(1); uvc_msg[1] = list_entry(uvc_p[1],UVC_MANAGE,list);//&uvc_msg_frame[0]; } void uvc_room_deinit_h264(void) { uvc_reset_dev_h264(0); } static uint8 uvc_irq_redy(UVC_MANAGE *uvc) { UVC_BLANK *blank; uvc->tgl = NEXT_TGL; uvc->sta = 1; uvc->frame_end = 0; uvc_bnk[0] = get_blank_node(&uvc->list,&free_uvc_tab[0]); if(uvc_bnk[0] == NULL){ uvc->tgl = NEXT_TGL; uvc->sta = 0; } else { blank = list_entry(uvc_bnk[0],UVC_BLANK,list); blank->blank_loop = 0; blank->re_space = UVC_BLANK_LEN; blank->busy = 0; blank->blank_len = 0; } return 0; } static uint8 uvc_irq_wait_next_frame(UVC_MANAGE *uvc) { if(uvc->tgl == CURT_TGL) { uvc->sta = 2; } return 0; } /**************************************************** 0:立刻进行kcik(包含一些错误) 1:切换bank,不能立刻kick ******************************************************/ static uint8 uvc_data_handle(UVC_MANAGE *uvc,struct hgusb20_dev *p_dev,uint8_t* rx_buff,uint8 drop) { //static unsigned int uvc_time = 0; //static unsigned int in_times = 0; UVC_BLANK *blank; uint32 data_len; uint32 re_space; uint32 tgl_mark; uint8 blank_loop = 0; uint8 ret = 0; uint8 end_frame = 0; data_len = rx_packet_len-head_len; static uint8 last_frame_end = 0; if(drop == 2){ //printf("_E_"); end_frame = 1; drop = 0; } if(drop) //丢帧处理，帧异常的时候需要处理掉当前帧 { _os_printf("_D3_"); if(uvc->state != 3){ uvc->state = 0; free_get_uvc_node_list(&uvc->list,&free_uvc_tab[0]); } uvc_p[0] = get_new_uvc_frame_head(1); //获取新的frame,然后检测下这个frame是不是已有blank，有的话，要先清 uvc_msg[0] = list_entry(uvc_p[0],UVC_MANAGE,list);//&uvc_msg_frame[0]; uvc_msg[0]->sta = 0; if(uvc_msg[0] == uvc){ free_get_uvc_node_list(&uvc->list,&free_uvc_tab[0]); del_uvc_frame(uvc); uvc_msg[0]->state = 1; }else{ uvc->frame_end = 2; uvc->sta = 0; } return 0; } //in_times++; if((uvc->tgl != CURT_TGL) || (last_frame_end==1)){ last_frame_end = 0; uvc->sta = 2; uvc->tgl = CURT_TGL; tgl_mark = CURT_TGL; #ifdef PSRAM_HEAP set_uvc_frame_ready(uvc); //上一次frame已完成 //_os_printf("_1_"); blank = list_entry(uvc_bnk[0],UVC_BLANK,list); blank->busy = 2; //printf("t1:%d\n",in_times); uvc->frame_end = 1; // 无psram #else if(uvc->state == 1){ //防漏 set_uvc_frame_ready(uvc); blank = list_entry(uvc_bnk[0],UVC_BLANK,list); blank->busy = 2; uvc->frame_end = 1; } #endif // uvc_time = csi_kernel_get_ticks(); uvc_p[0] = get_new_uvc_frame_head(1); //获取新的frame,然后检测下这个frame是不是已有blank，有的话，要先清 uvc_msg[0] = list_entry(uvc_p[0],UVC_MANAGE,list);//&uvc_msg_frame[0]; uvc_msg[0]->frame_counter = frame_num[0]; uvc_msg[0]->sta = 2; uvc_msg[0]->tgl = tgl_mark; uvc_msg[0]->frame_len = 0; uvc_bnk[0] = get_blank_node(&uvc_msg[0]->list,&free_uvc_tab[0]); //提取新的可用blank，旧的blank虽然还有可用空间，但换帧后也直接抛出 // printf("GB"); uvc = uvc_msg[0]; if(uvc_bnk[0] != NULL) { blank = list_entry(uvc_bnk[0],UVC_BLANK,list); blank->blank_len = 0; blank->re_space = UVC_BLANK_LEN; blank->busy = 0; blank->blank_loop = blank_loop; //切换洗一个bank,要延时kick ret = 1; //printf("nblank:%x %x\r\n",blank,blank_loop); }else{ _os_printf("_D2_"); if(uvc->state != 3){ uvc->state = 0; free_get_uvc_node_list(&uvc->list,&free_uvc_tab[0]); } uvc_p[0] = get_new_uvc_frame_head(1); //获取新的frame,然后检测下这个frame是不是已有blank，有的话，要先清 uvc_msg[0] = list_entry(uvc_p[0],UVC_MANAGE,list);//&uvc_msg_frame[0]; uvc_msg[0]->sta = 0; if(uvc_msg[0] == uvc){ free_get_uvc_node_list(&uvc->list,&free_uvc_tab[0]); del_uvc_frame(uvc); uvc_msg[0]->state = 1; }else{ uvc->frame_end = 2; uvc->sta = 0; } return 0; } frame_num[0]++; } //当前frame的数据处理 //1:通过当前frame找到当前blank的结构体 //printf("uvc_bnk:%x\r\n",uvc_bnk); blank = list_entry(uvc_bnk[0],UVC_BLANK,list); blank->busy = 1; if(blank->re_space < data_len){ //当前blank剩余空间不足 //printf("a2:%x %d %d\r\n",blank->buf_ptr+blank->blank_len,blank->blank_len,blank->re_space); hw_memcpy(blank->buf_ptr+blank->blank_len,&rx_buff[head_len],blank->re_space); if((rx_buff[rx_packet_len-2] == 0xFF)&&(rx_buff[rx_packet_len-1] == 0xD9)) { last_frame_end = 1; } //printf("buf:%x\r\n",blank->buf_ptr+blank->blank_len); re_space = blank->re_space; blank->blank_len +=blank->re_space; blank->re_space = 0; blank->busy = 2; //printf("t2:%d\n",in_times); //uvc_time = csi_kernel_get_ticks(); blank_loop = blank->blank_loop; if(uvc == NULL) _os_printf("uvc hehe\r\n"); uvc_bnk[0] = get_blank_node(&uvc->list,&free_uvc_tab[0]); //重新获取一个新的blank，将剩余数据回填进去 // _os_printf("GB"); if(uvc_bnk[0] != 0) { blank = list_entry(uvc_bnk[0],UVC_BLANK,list); blank->blank_len = 0; blank->re_space = UVC_BLANK_LEN; blank->busy = 0; blank_loop++; blank->blank_loop = blank_loop; ret = 1; //_os_printf("blank:%x %x\r\n",blank,blank_loop); }else{ _os_printf("_D1_"); //一个frame就将所有的内存都占光了，没有新的内存可以存放此帧图像了 if(uvc->state != 3){ uvc->state = 0; free_get_uvc_node_list(&uvc->list,&free_uvc_tab[0]); } uvc_p[0] = get_new_uvc_frame_head(1); //获取新的frame,然后检测下这个frame是不是已有blank，有的话，要先清 uvc_msg[0] = list_entry(uvc_p[0],UVC_MANAGE,list);//&uvc_msg_frame[0]; uvc_msg[0]->sta = 0; if(uvc == NULL) _os_printf("hehe\r\n"); if(uvc_msg[0] == uvc){ free_get_uvc_node_list(&uvc->list,&free_uvc_tab[0]); del_uvc_frame(uvc); uvc_msg[0]->state = 1; }else{ uvc->frame_end = 2; uvc->sta = 0; } return 0; } hw_memcpy(blank->buf_ptr+blank->blank_len,&rx_buff[re_space+head_len],data_len - re_space); if((rx_buff[rx_packet_len-2] == 0xFF)&&(rx_buff[rx_packet_len-1] == 0xD9)) { last_frame_end = 1; } blank->re_space -=(data_len - re_space); blank->blank_len +=(data_len - re_space); blank->busy = 1; uvc->frame_len += data_len; }else{ //当前blank剩余空间足够 //printf("a1:%x %d %d\r\n",blank->buf_ptr+blank->blank_len,blank->blank_len,data_len); hw_memcpy(blank->buf_ptr+blank->blank_len,&rx_buff[head_len],data_len); if((rx_buff[rx_packet_len-2] == 0xFF)&&(rx_buff[rx_packet_len-1] == 0xD9)) { last_frame_end = 1; } uvc->frame_len += data_len; blank->re_space -=data_len; blank->blank_len +=data_len; //printf("."); } if(end_frame){ set_uvc_frame_ready(uvc); blank->busy = 2; uvc->frame_end = 1; } return ret; } bool uvc_data_deal(struct hgusb20_dev *p_dev) { uint32 hgusb20_ep_get_dma_rx_len(struct hgusb20_dev *p_dev, uint8 ep); uint32 rx_len = hgusb20_ep_get_dma_rx_len(p_dev, UVC_EP); if(rx_len == 0){ return 1; } rx_packet_len = rx_len; //printf("rx_len:%d ",rx_packet_len); return 0; } struct list_head* get_new_uvc_frame_head2(int grab){ uint8 frame_num = 0; for(frame_num = 0;frame_num < UVC_FRAME_NUM;frame_num++){ if(uvc_msg_frame[1][frame_num].state == 0){ uvc_msg_frame[1][frame_num].state = 1; uvc_msg_frame[1][frame_num].frame_end = 0; return &uvc_msg_frame[1][frame_num].list; } } if(grab) //是否开启抢占模式,开启抢占后，肯定有frame返回，上一帧没使用的frame肯定usable为2 { for(frame_num = 0;frame_num < UVC_FRAME_NUM;frame_num++){ if(uvc_msg_frame[1][frame_num].state == 2){ uvc_msg_frame[1][frame_num].state = 1; uvc_msg_frame[1][frame_num].frame_end = 0; free_get_uvc_node_list(&uvc_msg_frame[1][frame_num].list,&free_uvc_tab[1]); return &uvc_msg_frame[1][frame_num].list; } } } return 0; } bool uvc_data_deal2(struct hgusb20_dev *p_dev) { uint32 hgusb20_ep_get_dma_rx_len(struct hgusb20_dev *p_dev, uint8 ep); uint32 rx_len = hgusb20_ep_get_dma_rx_len(p_dev, UVC2_EP); if(rx_len == 0){ return 1; } rx_packet_len_2 = rx_len; //printf("rx_len:%d ",rx_packet_len_2); return 0; } static uint8 uvc_irq_redy2(UVC_MANAGE *uvc) { UVC_BLANK *blank; uvc->tgl = NEXT_TGL2; uvc->sta = 1; uvc->frame_end = 0; uvc_bnk[1] = get_blank_node(&uvc->list,&free_uvc_tab[1]); if(uvc_bnk[1] == NULL){ uvc->tgl = NEXT_TGL2; uvc->sta = 0; } else { blank = list_entry(uvc_bnk[1],UVC_BLANK,list); blank->blank_loop = 0; blank->re_space = UVC_BLANK_LEN; blank->busy = 0; blank->blank_len = 0; } return 0; } static uint8 uvc_irq_wait_next_frame2(UVC_MANAGE *uvc) { if(uvc->tgl == CURT_TGL2) { uvc->sta = 2; } return 0; } static uint8 uvc_data_handle2(UVC_MANAGE *uvc,struct hgusb20_dev *p_dev,uint8_t* rx_buff,uint8 drop) { //static unsigned int uvc_time = 0; static unsigned int in_times = 0; UVC_BLANK *blank; uint32 data_len; uint32 re_space; uint32 tgl_mark; uint8 blank_loop = 0; uint8 ret = 0; uint8 end_frame = 0; data_len = rx_packet_len_2-head_len; static uint8 last_frame_end = 0; if(drop == 2){ //printf("_E_"); end_frame = 1; drop = 0; } if(drop) //丢帧处理，帧异常的时候需要处理掉当前帧 { _os_printf("_D3_2"); if(uvc->state != 3){ uvc->state = 0; free_get_uvc_node_list(&uvc->list,&free_uvc_tab[1]); } uvc_p[1] = get_new_uvc_frame_head2(1); //获取新的frame,然后检测下这个frame是不是已有blank，有的话，要先清 uvc_msg[1] = list_entry(uvc_p[1],UVC_MANAGE,list);//&uvc_msg_frame[0]; uvc_msg[1]->sta = 0; if(uvc_msg[1] == uvc){ free_get_uvc_node_list(&uvc->list,&free_uvc_tab[1]); del_uvc_frame(uvc); uvc_msg[1]->state = 1; }else{ uvc->frame_end = 2; uvc->sta = 0; } return 0; } in_times++; if((uvc->tgl != CURT_TGL2) || (last_frame_end==1)){ last_frame_end = 0; uvc->sta = 2; uvc->tgl = CURT_TGL2; tgl_mark = CURT_TGL2; #ifdef PSRAM_HEAP set_uvc_frame_ready(uvc); //上一次frame已完成 //_os_printf("_O_"); blank = list_entry(uvc_bnk[1],UVC_BLANK,list); blank->busy = 2; //printf("t1:%d\n",in_times); uvc->frame_end = 1; // 无psram #else if(uvc->state == 1){ //防漏 set_uvc_frame_ready(uvc); blank = list_entry(uvc_bnk[1],UVC_BLANK,list); blank->busy = 2; uvc->frame_end = 1; } #endif //uvc_time = os_jiffies(); uvc_p[1] = get_new_uvc_frame_head2(1); //获取新的frame,然后检测下这个frame是不是已有blank，有的话，要先清 uvc_msg[1] = list_entry(uvc_p[1],UVC_MANAGE,list);//&uvc_msg_frame[0]; uvc_msg[1]->frame_counter = frame_num[1]; uvc_msg[1]->sta = 2; uvc_msg[1]->tgl = tgl_mark; uvc_msg[1]->frame_len = 0; uvc_bnk[1] = get_blank_node(&uvc_msg[1]->list,&free_uvc_tab[1]); //提取新的可用blank，旧的blank虽然还有可用空间，但换帧后也直接抛出 // printf("GB"); uvc = uvc_msg[1]; if(uvc_bnk[1] != NULL) { blank = list_entry(uvc_bnk[1],UVC_BLANK,list); blank->blank_len = 0; blank->re_space = UVC_BLANK_LEN; blank->busy = 0; blank->blank_loop = blank_loop; //切换洗一个bank,要延时kick ret = 1; //printf("nblank:%x %x\r\n",blank,blank_loop); }else{ _os_printf("_D2_2"); if(uvc->state != 3){ uvc->state = 0; free_get_uvc_node_list(&uvc->list,&free_uvc_tab[1]); } uvc_p[1] = get_new_uvc_frame_head2(1); //获取新的frame,然后检测下这个frame是不是已有blank，有的话，要先清 uvc_msg[1] = list_entry(uvc_p[1],UVC_MANAGE,list);//&uvc_msg_frame[0]; uvc_msg[1]->sta = 0; if(uvc_msg[1] == uvc){ free_get_uvc_node_list(&uvc->list,&free_uvc_tab[1]); del_uvc_frame(uvc); uvc_msg[1]->state = 1; }else{ uvc->frame_end = 2; uvc->sta = 0; } return 0; } frame_num[1]++; } //当前frame的数据处理 //1:通过当前frame找到当前blank的结构体 //printf("uvc_bnk:%x\r\n",uvc_bnk); blank = list_entry(uvc_bnk[1],UVC_BLANK,list); blank->busy = 1; if(blank->re_space < data_len){ //当前blank剩余空间不足 //printf("a2:%x %d %d\r\n",blank->buf_ptr+blank->blank_len,blank->blank_len,blank->re_space); hw_memcpy(blank->buf_ptr+blank->blank_len,&rx_buff[head_len],blank->re_space); if((rx_buff[rx_packet_len_2-2] == 0xFF)&&(rx_buff[rx_packet_len_2-1] == 0xD9)) { last_frame_end = 1; } //printf("buf:%x\r\n",blank->buf_ptr+blank->blank_len); re_space = blank->re_space; blank->blank_len +=blank->re_space; blank->re_space = 0; blank->busy = 2; //printf("t2:%d\n",in_times); //uvc_time = csi_kernel_get_ticks(); blank_loop = blank->blank_loop; if(uvc == NULL) _os_printf("uvc hehe\r\n"); uvc_bnk[1] = get_blank_node(&uvc->list,&free_uvc_tab[1]); //重新获取一个新的blank，将剩余数据回填进去 // _os_printf("GB"); if(uvc_bnk[1] != 0) { blank = list_entry(uvc_bnk[1],UVC_BLANK,list); blank->blank_len = 0; blank->re_space = UVC_BLANK_LEN; blank->busy = 0; blank_loop++; blank->blank_loop = blank_loop; ret = 1; //_os_printf("blank:%x %x\r\n",blank,blank_loop); //return 0; }else{ _os_printf("_D1_2"); //一个frame就将所有的内存都占光了，没有新的内存可以存放此帧图像了 if(uvc->state != 3){ uvc->state = 0; free_get_uvc_node_list(&uvc->list,&free_uvc_tab[1]); } uvc_p[1] = get_new_uvc_frame_head2(1); //获取新的frame,然后检测下这个frame是不是已有blank，有的话，要先清 uvc_msg[1] = list_entry(uvc_p[1],UVC_MANAGE,list);//&uvc_msg_frame[0]; uvc_msg[1]->sta = 0; if(uvc == NULL) _os_printf("hehe\r\n"); if(uvc_msg[1] == uvc){ free_get_uvc_node_list(&uvc->list,&free_uvc_tab[1]); del_uvc_frame(uvc); uvc_msg[1]->state = 1; }else{ uvc->frame_end = 2; uvc->sta = 0; } return 0; } hw_memcpy(blank->buf_ptr+blank->blank_len,&rx_buff[re_space+head_len],data_len - re_space); if((rx_buff[rx_packet_len_2-2] == 0xFF)&&(rx_buff[rx_packet_len_2-1] == 0xD9)) { last_frame_end = 1; } blank->re_space -=(data_len - re_space); blank->blank_len +=(data_len - re_space); blank->busy = 1; uvc->frame_len += data_len; //os_printf("1"); }else{ //当前blank剩余空间足够 //printf("a1:%x %d %d\r\n",blank->buf_ptr+blank->blank_len,blank->blank_len,data_len); hw_memcpy(blank->buf_ptr+blank->blank_len,&rx_buff[head_len],data_len); if((rx_buff[rx_packet_len_2-2] == 0xFF)&&(rx_buff[rx_packet_len_2-1] == 0xD9)) { last_frame_end = 1; } uvc->frame_len += data_len; blank->re_space -=data_len; blank->blank_len +=data_len; //printf("."); } if(end_frame){ set_uvc_frame_ready(uvc); blank->busy = 2; uvc->frame_end = 1; } return ret; } int uvc_deal_mjpeg(struct hgusb20_dev *p_dev, uint8_t* rx_buff, uint8_t ep, uint8_t ep_type) { uint8 drop = 0; int ret = 0; uint32 data_len; static uint8_t bulk_head[12]; static uint8_t recv_start = 0; uint8_t *uvc_cache = NULL; static uint32_t uvc_cache_buff[256+3]; if((ep_type & 0X03) == USB_ENDPOINT_XFER_BULK){ uvc_cache = (uint8_t *)&uvc_cache_buff; hw_memcpy(uvc_msg[0]->uvc_head,rx_buff+BULK_HEAD,16); if((uvc_msg[0]->uvc_head[0] == 0x02)&&((uvc_msg[0]->uvc_head[1]&0X80) == 0x80)&&(uvc_msg[0]->uvc_head[2] == 0xFF)&&(uvc_msg[0]->uvc_head[3] == 0xD8)){ _os_printf("P2"); hw_memcpy(bulk_head,rx_buff+BULK_HEAD,BULK_HEAD); hw_memcpy(uvc_cache,rx_buff+BULK_HEAD,rx_packet_len); hw_memcpy(rx_buff,uvc_cache,rx_packet_len); uvc_msg[0]->uvc_head[0] = 12; bulk_head[0] = 12; } else if((uvc_msg[0]->uvc_head[0] == 0x0c)&&((uvc_msg[0]->uvc_head[1]&0XFE) == 0x8c)&&(uvc_msg[0]->uvc_head[12] == 0xFF)&&(uvc_msg[0]->uvc_head[13] == 0xD8)){ _os_printf("P:%x ",uvc_msg[0]->uvc_head[2]); hw_memcpy(bulk_head,rx_buff+BULK_HEAD,BULK_HEAD); hw_memcpy(uvc_cache,rx_buff+BULK_HEAD,rx_packet_len); hw_memcpy(rx_buff,uvc_cache,rx_packet_len); recv_start = 1; }else if((uvc_msg[0]->uvc_head[0] == 0x0c)&&((uvc_msg[0]->uvc_head[1]&0XFE) == 0x82)&& (uvc_msg[0]->uvc_head[12] == 0x00)&&(uvc_msg[0]->uvc_head[13] == 0x00)&& (uvc_msg[0]->uvc_head[14] == 0x00)&&(uvc_msg[0]->uvc_head[15] == 0x01)){ hw_memcpy(bulk_head,rx_buff+BULK_HEAD,BULK_HEAD); hw_memcpy(uvc_cache,rx_buff+BULK_HEAD,rx_packet_len); hw_memcpy(rx_buff,uvc_cache,rx_packet_len); } else{ uint8 same_cnt = 0; if(recv_start==1) { for(uint8 i=0; i<6; i++) { if(uvc_msg[0]->uvc_head[i] == bulk_head[i]) same_cnt++; } } if(same_cnt < 6) { hw_memcpy(rx_buff,bulk_head,12); rx_packet_len+=12; } else { hw_memcpy(uvc_cache+BULK_HEAD,rx_buff+BULK_HEAD*2,rx_packet_len-BULK_HEAD); hw_memcpy(uvc_cache,bulk_head,BULK_HEAD); hw_memcpy(rx_buff, uvc_cache, rx_packet_len); } } } hw_memcpy(uvc_msg[0]->uvc_head,rx_buff,16); head_len = uvc_msg[0]->uvc_head[0]; if(head_len > rx_packet_len){ drop = 1; } data_len = rx_packet_len-head_len; if((data_len == 0) && (uvc_msg[0]->uvc_head[1] & (BIT(6)))) { drop = 1; } else if(data_len == 0) { return ret; } //无psram #ifndef PSRAM_HEAP if(uvc_msg[0]->uvc_head[1]&BIT(1)){ drop = 2; } #endif if (hgusb20_host_is_crc_err(p_dev, ep)) { drop = 1; } if((uvc_msg[0]->uvc_head[0] != 0x0c)&&(uvc_msg[0]->uvc_head[0] != 0x02)){//head[0] is head len drop = 1; } if(uvc_msg[0]->uvc_head[1] & (BIT(6) | BIT(5))){//error packe drop = 1; } switch(uvc_msg[0]->sta){ case 0: uvc_irq_redy(uvc_msg[0]); case 1: ret = uvc_irq_wait_next_frame(uvc_msg[0]); if(uvc_msg[0]->sta != 2) break; case 2: ret = uvc_data_handle(uvc_msg[0],p_dev,rx_buff,drop); break; } return ret; } int uvc_deal_h264(struct hgusb20_dev *p_dev, uint8_t* rx_buff, uint8_t ep, uint8 ep_type) { uint8 drop = 0; int ret = 0; uint32 data_len; static uint8_t bulk_head[12]; static uint8_t recv_start = 0; uint8_t *uvc_cache = NULL; static uint32_t uvc_cache_buff[256+3]; if((ep_type & 0X03) == USB_ENDPOINT_XFER_BULK){ uvc_cache = (uint8_t *)&uvc_cache_buff; hw_memcpy(uvc_msg[1]->uvc_head,rx_buff+BULK_HEAD,16); if((uvc_msg[1]->uvc_head[0] == 0x02)&&((uvc_msg[1]->uvc_head[1]&0X80) == 0x80)&&(uvc_msg[1]->uvc_head[2] == 0xFF)&&(uvc_msg[1]->uvc_head[3] == 0xD8)){ _os_printf("P2"); hw_memcpy(bulk_head,rx_buff+BULK_HEAD,BULK_HEAD); hw_memcpy(uvc_cache,rx_buff+BULK_HEAD,rx_packet_len_2); hw_memcpy(rx_buff,uvc_cache,rx_packet_len_2); uvc_msg[1]->uvc_head[0] = 12; bulk_head[0] = 12; } else if((uvc_msg[1]->uvc_head[0] == 0x0c)&&((uvc_msg[1]->uvc_head[1]&0XFE) == 0x8c)&&(uvc_msg[1]->uvc_head[12] == 0xFF)&&(uvc_msg[1]->uvc_head[13] == 0xD8)){ _os_printf("P:%x ",uvc_msg[1]->uvc_head[2]); hw_memcpy(bulk_head,rx_buff+BULK_HEAD,BULK_HEAD); hw_memcpy(uvc_cache,rx_buff+BULK_HEAD,rx_packet_len_2); hw_memcpy(rx_buff,uvc_cache,rx_packet_len_2); recv_start = 1; }else if((uvc_msg[1]->uvc_head[0] == 0x0c)&&((uvc_msg[1]->uvc_head[1]&0XFE) == 0x82)&& (uvc_msg[1]->uvc_head[12] == 0x00)&&(uvc_msg[1]->uvc_head[13] == 0x00)&& (uvc_msg[1]->uvc_head[14] == 0x00)&&(uvc_msg[1]->uvc_head[15] == 0x01)){ hw_memcpy(bulk_head,rx_buff+BULK_HEAD,BULK_HEAD); hw_memcpy(uvc_cache,rx_buff+BULK_HEAD,rx_packet_len_2); hw_memcpy(rx_buff,uvc_cache,rx_packet_len_2); } else{ uint8 same_cnt = 0; if(recv_start==1) { for(uint8 i=0; i<6; i++) { if(uvc_msg[1]->uvc_head[i] == bulk_head[i]) same_cnt++; } } if(same_cnt < 6) { hw_memcpy(rx_buff,bulk_head,12); rx_packet_len_2+=12; } else { hw_memcpy(uvc_cache+BULK_HEAD,rx_buff+BULK_HEAD*2,rx_packet_len_2-BULK_HEAD); hw_memcpy(uvc_cache,bulk_head,BULK_HEAD); hw_memcpy(rx_buff, uvc_cache, rx_packet_len_2); } } } hw_memcpy(uvc_msg[1]->uvc_head,rx_buff,16); head_len = uvc_msg[1]->uvc_head[0]; if(head_len > rx_packet_len_2){ drop = 1; } data_len = rx_packet_len_2-head_len; if((data_len == 0) && (uvc_msg[1]->uvc_head[1] & (BIT(6)))) { drop = 1; } else if(data_len == 0) { return ret; } //无psram #ifndef PSRAM_HEAP if(uvc_msg[1]->uvc_head[1]&BIT(1)){ drop = 2; } #endif if (hgusb20_host_is_crc_err(p_dev, ep)) { drop = 1; } if((uvc_msg[1]->uvc_head[0] != 0x0c)&&(uvc_msg[1]->uvc_head[0] != 0x02)){//head[0] is head len drop = 1; } if(uvc_msg[1]->uvc_head[1] & (BIT(6) | BIT(5))){//error packe drop = 1; } switch(uvc_msg[1]->sta){ case 0: uvc_irq_redy2(uvc_msg[1]); case 1: ret = uvc_irq_wait_next_frame2(uvc_msg[1]); if(uvc_msg[1]->sta != 2) break; case 2: ret = uvc_data_handle2(uvc_msg[1],p_dev,rx_buff,drop); break; } return ret; } int usb_dma_irq_times= 0; void usb_dma_irq(void * dev, uint8_t* uvc_rx_buff, uint8_t uvc_head_res, uint8_t ep_type) { uint32 ret; usb_dma_irq_times++; struct hgusb20_dev *p_dev = (struct hgusb20_dev *)dev; if (!p_dev) return; ret = uvc_data_deal(p_dev); if(ret == 0){ ret = uvc_deal_mjpeg(p_dev, (uint8_t*)uvc_rx_buff, UVC_EP, ep_type); } hgusb20_ep_rx_kick(p_dev, UVC_EP, (uint32)(uvc_rx_buff+uvc_head_res),0x400); } //暂时会比较简单去实现,定义都是比较随便,如果可以,jpeg与uvc能统一最好 //mjpeg信号量创建 static struct os_semaphore uvc_sem = {0}; static int uvc_sem_init = 0; void uvc_sema_init() { os_sema_init(&uvc_sem,0); uvc_sem_init = 1; } void uvc_sema_down(int32 tmo_ms) { if(!uvc_sem_init) { return; } os_sema_down(&uvc_sem,tmo_ms); //printf("$\n"); } void uvc_sema_up() { if(!uvc_sem_init) { return; } os_sema_up(&uvc_sem); } UVC_MANAGE* uvc_message_gloal; void set_uvc_message_gloal(UVC_MANAGE* uvc_message){ uvc_message_gloal = uvc_message; } UVC_MANAGE* get_uvc_message_gloal(){ return uvc_message_gloal; } void free_uvc_message_gloal(){ uvc_message_gloal = NULL; } uint32 get_uvc_frame_len(){ return uvc_message_gloal->frame_len; } UVC_BLANK* get_uvc_blank(){ UVC_BLANK* uvc_b; if((list_empty(&uvc_message_gloal->list) != TRUE )||(uvc_message_gloal->frame_end == 0)){ uvc_b = list_entry(uvc_message_gloal->list.prev,UVC_BLANK,list); return uvc_b; } return NULL; } uint8 free_uvc_blank(UVC_BLANK* uvc_b){ if(uvc_b == NULL) return 0; free_node2tab(uvc_b,(struct list_head*)&free_uvc_tab,&uvc_message_gloal->list); return 1; } uint8 free_uvc_blank_nopsram(UVC_MANAGE* uvc_message){ UVC_BLANK* uvc_b = NULL; if((list_empty(&uvc_message->list) != TRUE )||(uvc_message->frame_end == 0)){ uvc_b = list_entry(uvc_message->list.prev,UVC_BLANK,list); } if(uvc_b == NULL) return 0; free_node2tab(uvc_b,(struct list_head*)&free_uvc_tab,&uvc_message->list); return 1; } uint8* get_uvc_buf(){ UVC_BLANK* uvc_b; uvc_b = get_uvc_blank(); if(uvc_b == NULL) return NULL; return uvc_b->buf_ptr; } uint8_t uvc_open = 1; #if 0 UVC_BLANK* uvc_global = NULL; UVC_MANAGE*uvc_message_global = NULL; void uvc_stream_open(struct hgusb20_dev *p_dev,uint8 enable); extern volatile uint8 scale2_finish; #if DVP_EN uint8 *psram_uvc_buf[2]; extern uint8 psram_ybuf_src[480*640+480*640/2]; #else __psram_data uint8 psram_uvc_buf[2][200*1024] __aligned(4); #endif #if LCD_EN == 1 void jpg_decode_to_lcd(uint32 photo,uint32 jpg_w,uint32 jpg_h,uint32 video_w,uint32 video_h); void uvc_user4(void *d) { //uint8 msgbuf[10]; //u16* pt; uint8_t uvc_state = 2; os_sleep_ms(5); struct uvc_user_arg *arg = (struct uvc_user_arg*)d; uint32 tick_num = 0; UVC_MANAGE* uvc_message; UVC_BLANK* uvc_b; struct usb_device *dev = (struct usb_device *)dev_get(HG_USBDEV_DEVID); struct list_head* get_f; int del_times = 0; int err = 0; uint32 dnum = 0; uint8* buf = NULL; int irq_time = 0; //struct list_head* get_analy_node = NULL; uint8 pingpang = 0; #if DVP_EN psram_uvc_buf[0] = psram_ybuf_src; psram_uvc_buf[1] = psram_ybuf_src+200*1024; #endif //os_sleep_ms(6000); while(1){ get_f = get_uvc_frame(); if(get_f == 0) { //state=2,代表有通知需要删除任务 if(arg->state == 2) { err = 1; goto uvc_user4_exit; } if(uvc_open==1){ if(uvc_state != uvc_open){ uvc_stream_open((struct hgusb20_dev *)dev,1); uvc_state = uvc_open; } } //释放cpu os_sleep_ms(1); continue; } if(uvc_open==0){ if(uvc_state != uvc_open){ uvc_stream_open((struct hgusb20_dev *)dev,0); uvc_state = uvc_open; } } err = 0; irq_time = 0; tick_num++; uvc_message = list_entry(get_f,UVC_MANAGE,list); set_uvc_frame_using(uvc_message); uvc_message_global = uvc_message; while((list_empty(&uvc_message->list) != TRUE )||(uvc_message->frame_end == 0)){ if(uvc_open==0) break; irq_disable(USB20DMA_IRQn); uvc_b = list_entry(uvc_message->list.prev,UVC_BLANK,list); if(uvc_message->frame_end == 2){ break; } irq_enable(USB20DMA_IRQn); //if(arg->state == 2) //{ // err = 1; // goto uvc_user4_exit; //} if(uvc_message->state != 3) _os_printf("state_err\r\n"); uvc_global = uvc_b; if(uvc_b && uvc_b->busy == 2) { //数据头,所以要申请一帧数据 if(uvc_b->blank_loop == 0) { //正常不可能进来这里的 //获取下一帧 //u = f_get_uvc_frame_current_task(); //get_analy_node = get_app_analyze_node(&uvc_app_analyze); //if(get_analy_node) // buf = get_real_buf_adr(get_analy_node); //else // buf = NULL; if(pingpang == 0){ buf = psram_uvc_buf[0]; //pingpang = 1; }else{ buf = psram_uvc_buf[1]; //pingpang = 0; } } //没有帧,那么只能将bank删除,应该是rtsp处理速度不够 if(1)//(get_analy_node) { #if 0 if(uvc_b->buf_ptr[0] == 0xFF && uvc_b->buf_ptr[1] == 0xD8 && uvc_b->blank_loop != 0) { //printf("loop:%d\t%X\n",uvc_b->blank_loop,get_f); } #endif hw_memcpy0(buf,uvc_b->buf_ptr,uvc_b->blank_len); buf += uvc_b->blank_len; } else { _os_printf("="); } free_node2tab(uvc_b,(struct list_head*)&free_uvc_tab,&uvc_message->list); } else { //释放cpu os_sleep_ms(1); irq_time++; if(irq_time>200) { irq_time = 0; if(!usb_dma_irq_times) { //err = 1; _os_printf("%s usb maybe disconnect\n",__FUNCTION__); uvc_message->frame_end = 2; uvc_message->sta = 0; int32 usb_host_uvc_ioctl(struct usb_device *p_usb_d, uint32 cmd, uint32 param1, uint32 param2); usb_host_uvc_ioctl(dev, USB_HOST_IO_CMD_RESET,0,0); break; } usb_dma_irq_times = 0; } } //continue; } if(err) { #if 0 if(get_analy_node) { //f_del_uvc_frame(u); free_real_msg(get_analy_node,&uvc_app_analyze.free_list); get_analy_node = NULL; } continue; #endif goto uvc_user4_exit; } //异常退出,对应frame也del if(uvc_message->frame_end == 2) { //printf("get_F:%x\r\n",get_f); free_get_uvc_node_list(get_f,&free_uvc_tab[0]); del_uvc_frame(uvc_message); //if(get_analy_node) //{ //f_del_uvc_frame(u); // free_real_msg(get_analy_node,&uvc_app_analyze.free_list); // get_analy_node = NULL; //} } //正常退出 else { //设置状态,等于发送frame // if(get_analy_node) { //关闭usb中断,打印对应的数据出来 //u->frame_len = uvc_message->frame_len; // set_app_buf_len(get_analy_node,uvc_message->frame_len); #if 1 //f_set_uvc_frame_status(u); #else f_set_uvc_frame_status(u); f_del_uvc_frame(u); #endif //printf("frame_len:%d\n",uvc_message->frame_len); del_times++; // map_realnode_2_app_node_msg(&uvc_app_analyze,get_analy_node); if(uvc_open==1){ if(scale2_finish){ scale2_finish = 0; if(pingpang == 0){ jpg_decode_to_lcd((uint32)psram_uvc_buf[0],1280,720,160,120); pingpang = 1; }else{ jpg_decode_to_lcd((uint32)psram_uvc_buf[1],1280,720,160,120); pingpang = 0; } dnum = 0; }else{ dnum++; if(dnum > 8){ scale2_finish = 1; } } } _os_printf("M"); // wake_up_analyze_list_app(&uvc_app_analyze); // get_analy_node = NULL; // uvc_sema_up(); } //printf("del frame:%x %d %d\r\n",uvc_message,uvc_message->frame_len); //printf("="); //printf("?"); del_uvc_frame(uvc_message); } } uvc_user4_exit: if(err) { // if(get_analy_node) { //f_del_uvc_frame(u); // free_real_msg(get_analy_node,&uvc_app_analyze.free_list); // get_analy_node = NULL; } _os_printf("%s exit\n",__FUNCTION__); //代表任务已经被删除,可以重新启动 arg->state = 0; return; } } #endif #endif #if 0 void uvc_user() { UVC_MANAGE* uvc_message; UVC_BLANK* uvc_b; // uint32 len = 0; // uint32 itk = 0; // uint8 printf_uvc_jpg = 0; // struct list_head *uvc_bk; struct list_head* get_f; while(1){ get_f = get_uvc_frame(); if(get_f == 0) { //释放cpu os_sleep_ms(1); continue; } uvc_message = list_entry(get_f,UVC_MANAGE,list); set_uvc_frame_using(uvc_message); set_uvc_message_gloal(uvc_message); uvc_sema_down(-1); while((list_empty(&uvc_message->list) != TRUE )||(uvc_message->frame_end == 0)){ uvc_b = list_entry(uvc_message->list.prev,UVC_BLANK,list); if(uvc_b->busy == 2) { free_node2tab(uvc_b,(struct list_head*)&free_uvc_tab,&uvc_message->list); } } //printf("del frame:%x %d %d\r\n",uvc_message,uvc_message->frame_len,len); free_uvc_message_gloal(); del_uvc_frame(uvc_message); } } #endif #endif