encode.c~

cam ui application for linux

           fd = fopen( FName, "w+" );
           if( fd == NULL ) {
              printf("Unable to open file %s \n", FName);
              exit(1);
           }
           //printf("Opened file %s (handle=%x) \n", FName, fd);
    }

start_again:

    printf("Starting a new capture session \n");
    
    //Now setup capture...
    time(&tStartTime);

    //========== Open the encode Device ================
    pDevName= QlDevEncName[qldevoffset];
    hEncDev = open(pDevName, O_RDWR);
    if(hEncDev < 0) 
    {
        DPrintf("Unable to Open (%s) hEncDev = (0x%08x)\r\n", pDevName, hEncDev);
        return (2);
    }

    if(!doJpeg && (strmnum==QLSTRM_ENC)) 
    {
        enum ql201_v4l2_mpeg_streamtype strmtype= 0xFF;
        
        Err= ioctl(hEncDev, QL201_ENC_G_STRMTYPE, &strmtype);
        if ((strmtype & 0xFFFF) == STREAM_TYPE_MPEG4_STREAM) 
        {
            capturingmp4= 1;
        }
    }

    if(!doJpeg && (strmnum != QLSTRM_YUVOUT) && FName) 
    {
        if (1 || capturingmp4) 
        {
            strcpy(FNameIdx, FName);
            strcat(FNameIdx, ".idx");
            fdIdx = fopen( FNameIdx, "w+" );
            if( fdIdx == NULL ) 
            {
                fclose(fd);
                DPrintf("Unable to open file %s \n", FNameIdx);
                exit(1);
            }
            outbuff= malloc(36*8);
            UserIdxData.addr= (unsigned long) outbuff;
            UserIdxData.buffsize= (36*8);
            UserIdxData.allornone= 1;
            if(!outbuff) 
            {
                DPrintf("Unable to allocate memory for index data\n");
                fclose(fd);
                fclose(fdIdx);
                return (2);
            }
        }
        DPrintf("Clip=%s, Index=%s, Vbi=%s \n", FName, FNameIdx, FNameVbi);
    }


#ifdef Rick_TEST_STORE
    if (fd) 
    {
		bStoreStopped=FALSE;

//------- setup/init Store_buf
//		Store_buf= ((volatile unsigned char *)(0x3600000));
		Store_buf= malloc(STORE_BUF_SIZE);
		store_wr_ptr=0;
		store_rd_ptr=0;
		store_end_ptr=0;

//------- setup/init Idx_Store_buf
		Idx_Store_buf= malloc(IDX_STORE_BUF_SIZE);
		idx_store_wr_ptr=0;
		idx_store_rd_ptr=0;
		idx_store_end_ptr=0;

// ------ init StoreThreadProc
		store_param.data_fd=fd;
		store_param.idx_fd=fdIdx;
		store_param.mp4_cap=capturingmp4;
		store_param.capturetimeout=capturetimeout;
		store_param.FName=FName;
//rick debug
		store_param.MP4_init_done=0;


		pthread_mutex_init(&store_lock,NULL);
		Err= pthread_create(&pidStoreThreadID,NULL,(void *)StoreThreadProc, &store_param);
		if (Err)
		{
			DPrintf("\nCreate Store thread fail");
			exit(1);
		}
		
//		while (store_param.MP4_init_done ==0)
//			usleep(30000);
    }
#endif

    mode = 0;
    type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    Err     = ioctl(hEncDev, QL201_ENC_S_AVSEP, &mode);
    //DPrintf("ioctl 0x%08x QL201_ENC_S_AVSEP return %d\n", hEncDev, Err);

/* Added by James for test */
#ifdef JPEG_ENC
    if (doJpeg) 
    {
        DPrintf("Create jpeg thread...\n");
        tEncodeParam.hEncDev = hEncDev;
        tEncodeParam.dwQuality = 80;
        ioctl(hEncDev, QL201_ENC_G_ENC_WIDTH, &tEncodeParam.dwWidth);
        ioctl(hEncDev, QL201_ENC_G_ENC_HEIGHT, &tEncodeParam.dwHeight);
        tEncodeParam.dwWidth = tEncodeParam.dwWidth & 0xFFF0;
        tEncodeParam.dwHeight = tEncodeParam.dwHeight & 0xFFF0;
        tEncodeParam.dwHeight = (tEncodeParam.dwHeight<144) ? 144 : tEncodeParam.dwHeight;
        tEncodeParam.sub_en = 0;
        tEncodeParam.nameBase = argv[cnt++];
        tEncodeParam.period = strtoul(argv[cnt++], 0, 10);

        DPrintf("JPEG encoding size %dx%d...\n", tEncodeParam.dwWidth, tEncodeParam.dwHeight);
        Err = pthread_create(&pidEncodeThreadID, NULL/*&attr*/, (void *)EncodeJPEGThreadProc, &tEncodeParam);
        if (Err)
        {
            DPrintf("error creating thread. (%d)", Err);
            goto ravi1;
        }
    }
#endif //JPEG_ENC

    //Add By Michael
    //ql201_osd_exit();
    //ql201_osd_init(LUT1BIT_352X240,VID_ENCODE);
    
    //////////////////////////////////////////////////////////////
    //rick debug performance
    //DRAM_LOG_START;
    Err= ioctl(hEncDev, VIDIOC_STREAMON, &type);
    if(!Err) 
    {
        Enable_VO();  //enable VO manually here 
        //osd_text_show(TIMESTMP_X - FONT_WIDTH, TIMESTMP_Y_0, FName+0x0b,OSD_RED);  
       
        //JAMES_20070117
        while(!Err) 
        {
        	if(!Recording){
        		Recording=1;
			sprintf (aCmdBuf, "<%s_%02d%02d%02d%02d.%s>", aFileType[iFileType], tmTimeNow.tm_mon + 1, tmTimeNow.tm_mday, tmTimeNow.tm_hour, tmTimeNow.tm_min, aExtNmae[iFileType]);
            		PANEL_Output (LCM_LINE_1, FName);
        	}
            v4lbuf.type 	= V4L2_BUF_TYPE_VIDEO_CAPTURE;
            v4lbuf.memory = V4L2_MEMORY_MMAP;
            Err= ioctl(hEncDev, VIDIOC_DQBUF, &v4lbuf);

            if(!Err) 
            {
                retrycnt= 0;

                //DPrintf(" dqbuf buf %d, drvaddr=%x, usraddr=%x, size=%x \n", v4lbuf.index, v4lbuf.m.userptr, 
                //       (DWORD)appv4lbuf[v4lbuf.index].addr, v4lbuf.bytesused);

                ulTotolCaptured += v4lbuf.bytesused;
                if(v4lbuf.bytesused&0xFFF) framescnt++;
                // Andy 2007.09.20: patch the case of TCP terminated by client
                //if (capturetimeout != 1) {

                ulActuCurrXfer= v4lbuf.bytesused;
                if(!ulActuTotalXfer) 
                {
                    ioctl(hEncDev, QL201_ENC_S_QL_LATENCY_INFO, &latency_info);
                    //DPrintf("\nCalled driver to let know that the 1st frame has been streamed (%d)\n", pktcnt);
                }
                 ulActuTotalXfer+= ulActuCurrXfer;

                if(fd) 
                {
                    ql201_endianswap((unsigned long *)v4lbuf.m.userptr, v4lbuf.bytesused);
//rick debug
#ifdef Rick_TEST_STORE
		        store_case=0;
		        pthread_mutex_lock(&store_lock);
		        if ((store_wr_ptr + v4lbuf.bytesused) > STORE_BUF_SIZE)
		        {
			   store_case=1;
			   store_wr_ptr=0;	//wrap around "write" point
		        } else
		       {
		 	  store_case =2;
		       }
		    
		       if ((store_wr_ptr < store_end_ptr) && ((store_wr_ptr + v4lbuf.bytesused) > store_rd_ptr))
		       {
			   store_case = 3;
			   DPrintf("\n Store buffer overflow\n");
			   bCtrlCReceived = TRUE;
		       }
		       pthread_mutex_unlock(&store_lock);

			if (store_case !=3)
				memcpy((void*)(Store_buf+store_wr_ptr), (void*)v4lbuf.m.userptr, v4lbuf.bytesused);

			pthread_mutex_lock(&store_lock);
			if (store_case ==1)		//"write" wrap around
			{
				store_wr_ptr +=v4lbuf.bytesused;
			} else if (store_case ==2)
			{
				store_wr_ptr +=v4lbuf.bytesused;
				if (store_wr_ptr > store_end_ptr)
					store_end_ptr =store_wr_ptr;
			}
			pthread_mutex_unlock(&store_lock);
//			DPrintf("\nwr=0x%x,rd=0x%x,end=0x%x,len=0x%x\n",store_wr_ptr,store_rd_ptr,store_end_ptr,						v4lbuf.bytesused);
#else
                    fwrite((void*)v4lbuf.m.userptr, 1, v4lbuf.bytesused, fd);
#endif//Rick_TEST_STORE
	
                }

                tElapsedTime= time(0)-tStartTime;
                

                if ((framescnt & 0x0F) == 1) 
                {
                  DPrintf("\r%02d:%02d:%02d - %d MB, ~Rate=%05d Kbps, fps=%d(%d),Idx=%dK,Vbi=%dK ", 
                              tElapsedTime/3600, (tElapsedTime/60)%60, tElapsedTime%60, ulActuTotalXfer/(1024*1024), 
                             //(tElapsedTime ? (DWORD)((unsigned long long)(ulActuTotalXfer*8)/(1000*tElapsedTime)) : 0),
                             (tElapsedTime ? (((ulActuTotalXfer/tElapsedTime)*8)/1000) : 0),
                             (tElapsedTime ? (framescnt/tElapsedTime) : 0), framescnt,
                             (indexsize/1024), (vbisize/1024) );

                  if(pktcnt) 
                  {
                    DPrintf("pkt=%05d(%04d) ", pktcnt, (ulActuTotalXfer/pktcnt));
                  }
                }
 
                if(tElapsedTime%60 != prev_time || !prev_time)
                {     
                    prev_time = tElapsedTime%60;
                    snprintf( Time, 9, "%02d:%02d:%02d",tElapsedTime/3600, (tElapsedTime/60)%60, tElapsedTime%60);
                    //osd_text_show(TIMESTMP_X, TIMESTMP_Y_1,Time,OSD_RED);
                }
                
                fflush(stdout);

                // done with the buffer, return it back to the driver
                Err= ioctl(hEncDev, VIDIOC_QBUF, &v4lbuf);
                if(Err) 
                {
                    DPrintf("QBUF ioctl failed %d %s\n", errno, strerror(errno));
                }

            } else 
            {

                if(errno==EAGAIN) 
                {
                    if(bStopped)
                    {
                        Err= 0;
                        break; //EOS
                    } else {
                        Err= 0; //continue if driver doesn't have data
                    }
                }
                DPrintf("\nDQBUF ioctl failed errno=%d, %s", errno, strerror(errno));
                if(retrycnt++ >= MAX_RETRY_COUNT)  
                { //something is wrong! so exit now
                    bStopped= TRUE;
                    type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                    Err= ioctl(hEncDev, VIDIOC_STREAMOFF, &type);
                    if(Err==-1) {
                        DPrintf("\nSTREAMOFF ioctl returns Err=%d, errnot=%d %s\n", Err, errno, strerror(errno));
                    }
                    Err= 1; //We have to return an error condition
                    break;
                }

            }
            
            nKey = PANEL_KeyScan ();
            if((capturetimeout && (tElapsedTime>=capturetimeout))  || (nKey == KEY_KEY2))
            {
                  bCtrlCReceived = TRUE;
                  iStateNext = STATE_STANDBY;
            }
                            
            if(bCtrlCReceived && !bStopped)
            {
                bStopped= TRUE;
                iStateNext = STATE_STANDBY;
#ifdef Rick_TEST_STORE
		 bStoreStopped=TRUE;
#endif
                bCtrlCReceived = FALSE;
                
                if(nKey == KEY_KEY2) 
                {
                	DPrintf("\nStop key received. Calling STREAMOFF \n");
                	 stop_mode = 1;
                	 iStateNext = STATE_STANDBY;
                }else
                {
                      DPrintf("\nCTRL+C  received. Calling STREAMOFF \n");
                }
                type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                Err     = ioctl(hEncDev, VIDIOC_STREAMOFF, &type);
                if(Err==-1) 
                    DPrintf("STREAMOFF ioctl returns Err=%d, errnot=%d %s\n", Err, errno, strerror(errno));
                
                //ht1621_disp_string("STOP");
		 //LCD_REFRESH;    
            }

            if(fdIdx && outbuff)  //Read and Save Index Data
            {
                if( (lastindexreadtime!=tElapsedTime) || (bStopped)) 
                {
                    lastindexreadtime= tElapsedTime;
                    Err= ioctl(hEncDev, QL201_DIAG_G_INDEX, &UserIdxData);
                    if(errno==-EAGAIN) 
                    {
                        lastindexreadtime+= 1;
                    } else 
                    {
                        lastindexreadtime= 0; //If data is read, let's try reading again
                    }
                    
                    if(!Err && UserIdxData.validsize) 
                    {
			 #if SD_DIRECT_MODE
                        ql201_endianswap((unsigned long *)outbuff, UserIdxData.validsize);
			 #endif

#ifdef Rick_TEST_STORE
			indexsize+=  UserIdxData.validsize;

			idx_store_case=0;
			pthread_mutex_lock(&store_lock);
			if ((idx_store_wr_ptr + UserIdxData.validsize) > IDX_STORE_BUF_SIZE)
			{
				idx_store_case=1;
				idx_store_wr_ptr=0;	//wrap around "write" point
			} else
			{
				idx_store_case =2;
			}

			if ((idx_store_wr_ptr < idx_store_end_ptr) && ((idx_store_wr_ptr + UserIdxData.validsize) > idx_store_rd_ptr))
			{
				idx_store_case = 3;
				DPrintf("\n Idx Store buffer overflow\n");
				bCtrlCReceived = TRUE;