encode.c~

cam ui application for linux

        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 Willam 2007-11-5 14:40:14
    //ql201_osd_exit();
   // ql201_osd_init(LUT1BIT_352X240,VID_ENCODE);
    
    Err= ioctl(hEncDev, VIDIOC_STREAMON, &type);
    if(!Err) 
    {
    	
       //Add By Willam 2007-11-5 14:40:14
 	Enable_VO();  //enable VO manually here 
       //osd_text_show(TIMESTMP_X - FONT_WIDTH, TIMESTMP_Y_0, FName+0x0b,OSD_RED);             
              		
#if 0 //def TEST_OSD
        //test_osd_start(hEncDev);
#endif //TEST_OSD
		
	system("testapp3 wrreg 0 a33f");
        while(!Err) 
        {
            v4lbuf.type 	= V4L2_BUF_TYPE_VIDEO_CAPTURE;
            v4lbuf.memory = V4L2_MEMORY_MMAP;
			
            Err= ioctl(hEncDev, VIDIOC_DQBUF, &v4lbuf);
            if(!Err) 
            {
                retrycnt= 0;
				
#ifdef TEST_OSD
               // test_osd_update();
#endif //TEST_OSD

                ulTotolCaptured += v4lbuf.bytesused;
                if(v4lbuf.bytesused&0xFFF) framescnt++;
                
                ulActuCurrXfer= v4lbuf.bytesused;
                ulActuTotalXfer+= ulActuCurrXfer;

                if(fd) {
                    ql201_endianswap((unsigned long *)v4lbuf.m.userptr, v4lbuf.bytesused);
                    fwrite((void*)v4lbuf.m.userptr, 1, v4lbuf.bytesused, fd);
		#ifdef	FRANK_TEST
		    fflush(fd);
		#endif
                }

                tElapsedTime= time(0)-tStartTime;

	#ifdef	FRANK_TEST
		if ((capturetimeout == 0) && (tElapsedTime != 0)){
			if (v4lbuf.flags == V4L2_BUF_FLAG_KEYFRAME)
				DPrintf("Got I frame\n");
			if ((tElapsedTime%ENCODE_INTERVAL == 0) && (times == 0) ){

			#ifndef	NO_INDX_FILE
    				if(fdIdx) {
        				//fflush(fdIdx);
        				fclose(fdIdx);
        				fdIdx= 0;
    				}
			#endif
			
    				if(fd) {
       				fflush(fd);
        				fclose(fd);
        				fd= 0;
    				}
				times = 1;
				hook_4_encode_file(file_name);
			}else if(fd == 0){
        			fd = fopen( file_name, "w+" );
        			if( fd == NULL ) {
            				DPrintf("Unable to open file %s \n", file_name);
            				exit(1);
        			}

			#ifndef	NO_INDX_FILE	
				strcpy(FNameIdx, file_name);
            			strcat(FNameIdx, ".idx");
            			fdIdx = fopen( FNameIdx, "w+" );

            			if( fdIdx == NULL ) {
                			fclose(fd);
                			DPrintf("Unable to open file %s \n", FNameIdx);
                			exit(1);
            			}
			#endif
			
				hook_4_encode_check();
			}else if((tElapsedTime%ENCODE_INTERVAL != 0) && times){
				times = 0;
			}
			
		}
	#endif

                 DPrintf("\r fm(0x%x) %02d:%02d:%02d - %d MB, ~Rate=%05d Kbps, fps=%d(%d),Idx=%dK,Vbi=%dK ", v4lbuf.flags,
                       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((capturetimeout && (tElapsedTime>=capturetimeout)) /*|| (get_keypad() == KEY_OK)*/) {
                    bCtrlCReceived = TRUE;
                }

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

            }
            
            if(bCtrlCReceived && !bStopped) 
            {
                bStopped= TRUE;
                bCtrlCReceived = FALSE;
                DPrintf("CTRL+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));
                }
                //break;
            }else if(nKey == KEY_MENU)(get_keypad() == KEY_MENU)
            {
                bStopped= TRUE;
                DPrintf("Stop key 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));
                }
		 stop_mode = 1;
            }

            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) {
                        ql201_endianswap((unsigned long *)outbuff, UserIdxData.validsize);
                        fwrite(outbuff, 1, UserIdxData.validsize, fdIdx);
                        indexsize+=  UserIdxData.validsize;
                        fflush(fdIdx);
                        if(capturingmp4) {
                            //qt_process_index_data(0, outbuff, UserIdxData.validsize);
                        }
                    }
                    Err= 0; //Remove any error condition
                }
            }

            if((vbi_format.Enable==1) && fdVbi && vbioutbuff) 
            { //Read and Save VBI Data
                if( (lastvbireadtime!=tElapsedTime) || (bStopped)) 
                {
                    lastvbireadtime= tElapsedTime;
                    Err= ioctl(hEncDev, QL201_ENC_G_VBI_DATA, &UserVbiData);
                    //DPrintf("\nVBI Currsize=%x, Err=%d errnot=%d %s \n", UserVbiData.validsize, Err, errno, strerror(errno));
                    if(errno==-EAGAIN) {
                        lastvbireadtime+= 1;
                    } else {
                        lastvbireadtime= 0; //If data is read, let's try reading again
                    }
                    if(!Err && UserVbiData.validsize) {
                        fwrite(vbioutbuff, 1, UserVbiData.validsize, fdVbi);
                        vbisize+=  UserVbiData.validsize;
                        fflush(fdVbi);
                    }
                    Err= 0; //Remove any error condition
                }
            }	
            
            usleep(10);     // to reduce cpu usage		
        }

    } else {
        DPrintf("STREAMON ioctl failed %d %s\n", errno, strerror(errno));
    }

ravi1:

#if 0 //def TEST_OSD
    test_osd_stop();
#endif //TEST_OSD


#ifdef JPEG_ENC
    if (doJpeg) {
         DPrintf("Wait for jpeg encode thread exit\n");
          if (pthread_join(pidEncodeThreadID, NULL))
         {
                DPrintf("error joining thread.");
         }
         DPrintf("Jpeg encode thread exited\n");
         //pthread_detach(pidEncodeThreadID);
      }
#endif //JPEG_ENC

   //Add by Willam 2007-11-5 14:44:19
  // ql201_osd_exit();
   //ql201_osd_init(RGB24BIT_352X240,VID_BYPASS);
   
    if(capturingmp4) {
        DPrintf("\n");
        //qt_fini(0, ulTotolCaptured, FName);
    }

    if(hEncDev) {
        close(hEncDev);
        hEncDev= 0;
    }

    if(loop_forever) {
        DPrintf("\n");
        DPrintf("\n");
        DPrintf("Moiving on to next iteration\n");
        goto start_again;
    }

    if(fdIdx) {
        fflush(fdIdx);
        fclose(fdIdx);
        fdIdx= 0;
    }

    if(fd) {
        fflush(fd);
        fclose(fd);
        fd= 0;
    }

    DPrintf("\n");
#ifdef JPEG_ENC
    if (doJpeg)   pthread_exit(NULL);
#endif //JPEG_ENC

    if (stop_mode) Err = 16;
    return Err;
}

#else

long EncodeAndStreamv4(char *FName, unsigned int capturetimeout, int doJpeg) 
{
    long Err= 0;
    int  Recording=0;  
    int   nKey=KEY_NO_KEY;
    int   strmnum=QLSTRM_ENC;
    
    char FNameIdx[256]="Disabled";
    char FNameVbi[256]="Disabled";
    unsigned char Time[15];
    
    
    FILE *fd= 0, *fdIdx= 0, *fdVbi;
    unsigned long nCount= 0, ulTotolCaptured= 0;
    int bStopped= FALSE;
    int send_s;              /* Sockets for sending and receiving. */
    struct sockaddr_in mcast_group;
    struct utsname name;
    unsigned long /*ulTotalXfer= 0, ulCurrXfer= 0,*/ ulActuTotalXfer= 0, ulActuCurrXfer= 0, mcastaddr= 0, ulMTU= 1316, pktcnt= 0;
    STREAMING_INFO StrmInfo= { 0 };
    time_t tStartTime, tElapsedTime,prev_time = 0;
    unsigned int framescnt= 0;
    unsigned int lastindexreadtime= 0, indexsize= 0;
    unsigned int lastvbireadtime= 0, vbisize= 0;
    int retrycnt= 0, capturingmp4= 0;
    char *pDevName;
    char *outbuff;
    char *vbioutbuff;
    QL201_INEX_DATA UserIdxData;
    QL201_INEX_DATA UserVbiData;
    QP_VBI_DATAFORMAT vbi_format;

    struct v4l2_buffer v4lbuf;
    int type;
    QL_LATENCY_INFO latency_info;
    unsigned long framesize;
    unsigned long fz;
    unsigned long ftotal;
    

#ifdef JPEG_ENC
    TEncodeTaskParameters tEncodeParam;
    pthread_t pidEncodeThreadID;
    int iPolicy;
#endif //JPEG_ENC


#ifdef Rick_TEST_STORE
	pthread_t pidStoreThreadID;
	int store_case;
	int idx_store_case;
#endif

    int mode;
    int stop_mode = 0;
    
    vbi_format.Enable= 0;

    signal(SIGINT, (void*)SigIntHanlder);

   //Create  the new File to encode 
    if (!doJpeg) 
    {