encode.c~

cam ui application for linux

                                //DPrintf("HSize      = %x\n", idxhdrbufnext.HSize      );
                                //DPrintf("VSize      = %x\n", idxhdrbufnext.VSize      );
                                //DPrintf("Reserved1  = %x\n", idxhdrbufnext.Reserved1  );
                                //DPrintf("FrameRate  = %x\n", idxhdrbufnext.FrameRate  );
                                //DPrintf("Reserved2  = %x\n", idxhdrbufnext.Reserved2  );

                                // read next index
                                ulActuCurrXfer = fread( &idxbufnext, 1, 20, fdrIdx );
                                //DPrintf("\nIndex next  : %x\n", ftell(fdrIdx));
                                //DPrintf("bSlice     = %x\n", idxbufnext.bSlice     );
                                //DPrintf("bReserved  = %x\n", idxbufnext.bReserved  );
                                //DPrintf("bFrameType = %x\n", idxbufnext.bFrameType );
                                //DPrintf("bBlockSize = %x\n", idxbufnext.bBlockSize );
                                //DPrintf("pts        = %x\n", idxbufnext.pts        );
                                //DPrintf("dts        = %x\n", idxbufnext.dts        );
                                //DPrintf("OffsetHigh = %x\n", idxbufnext.OffsetHigh );
                                //DPrintf("OffsetLow  = %x\n", idxbufnext.OffsetLow  );

                                if (idxbufnext.OffsetHigh != idxbuf.OffsetHigh) 
                                {
                                    DPrintf("High update: Next(%x %x) Curr(%x %x)!!\n", idxbufnext.OffsetHigh, idxbufnext.OffsetLow, idxbuf.OffsetHigh, idxbuf.OffsetLow);
                                    ulGOPXferByte = (0xFFFFFFFFUL - idxbuf.OffsetLow);
                                    ulGOPXferByte = ulGOPXferByte + idxbufnext.OffsetLow + 1;
                                } else {
                                    ulGOPXferByte = idxbufnext.OffsetLow - idxbuf.OffsetLow;
                                }

                                // Andy 2007.09.20: commented out due to use new scheme
                                //if (ulGOPXferByte > 0xFFFFF) {
                                //    DPrintf("Error! bitstream length 0x%x bytes of this GOP is too long!\n", ulGOPXferByte);
                                //    DPrintf("Error! Curr offset(H-0x%x L-0x%x) Prev offset(H-0x%x L-0x%x)!!\n", idxbufnext.OffsetHigh, idxbufnext.OffsetLow, idxbuf.OffsetHigh, idxbuf.OffsetLow);
                                //}
                                gopsize[gopsizecnt] = ulGOPXferByte;

                                // Andy 2007.09.20: use new scheme
                                //if ((ulIndexStartNext - ulIndexStart) > 0xFFF) {
                                //    DPrintf("Error! index length 0x%x bytes of this GOP is too long!\n", (ulIndexStartNext - ulIndexStart));
                                //}
                                //gopsize[gopsizecnt] += ((ulIndexStartNext - ulIndexStart) << 20);   // NOTE: only support 12 bits, max 4095 bytes of index data for one GOP

                                fseek( fdrIdx, -40, SEEK_CUR );   // back to the starting point of the next index header
                            } // if (bGOPJumpDir)

                            // if jump
                            if (bGOPJumpSpeed != 0) 
                            {
                                if (bGOPJumpDir) 
                                {
                                    // fast reverse
                                    // FR 1x means 1x reverse
                                    for (bGOPJumpCount=0; bGOPJumpCount<=bGOPJumpSpeed; bGOPJumpCount++) 
                                   {
                                        if (gopsizecnt < 2) 
                                        {
                                            DPrintf("\n Already back to file start!\n");
                                            //bIndexExist = 0;
                                            gopsizecnt = 0;
                                            trickmode.trickmode = 0;
                                            trickmode.dir = 0;
                                            trickmode.gopskip = 0;
                                            trickmode.framerepeat = 0;
                                            bGOPJumpDir = trickmode.dir;   // back to forward
                                            bGOPJumpSpeed = trickmode.gopskip;
                                            bGOPJumpCount = 0;
                                            Err= ioctl(hDecDev, QL201_DEC_S_TRICK_MODE, &trickmode);
                                            fseek( fdrIdx, 0, SEEK_SET );
                                            fseek( fdr, 0, SEEK_SET );
                                            //PBTrickModeProcess(hDecDev,KEY_FUN_0);
                                            goto check_index;
                                        }
                                        gopsizecnt--;
                                        // Andy 2007.09.20: new scheme
                                        fseek( fdrIdx, 16, SEEK_CUR );
                                        fread( &ulGOPXferByte, 1, 4, fdrIdx );
                                        //DPrintf("previous index offset is %x\n", ulGOPXferByte);
                                        fseek( fdrIdx, ulGOPXferByte, SEEK_SET );
                                        ulGOPXferByte = gopsize[gopsizecnt];
                                        //ulGOPXferByte = gopsize[gopsizecnt] >> 20;
                                        //fseek( fdrIdx, 0 - (long)ulGOPXferByte, SEEK_CUR );
                                        //ulGOPXferByte = gopsize[gopsizecnt] & 0xFFFFF;
                                        fseek( fdr, 0 - (long)ulGOPXferByte, SEEK_CUR );
                                    }
                                    // Andy 2007.09.20: new scheme
                                    fseek( fdrIdx, 16, SEEK_CUR );
                                    fread( &ulGOPXferByte, 1, 4, fdrIdx );
                                    //DPrintf("previous index offset is %x\n", ulGOPXferByte);
                                    fseek( fdrIdx, ulGOPXferByte, SEEK_SET );
                                    //ulGOPXferByte = gopsize[gopsizecnt] >> 20;
                                    //fseek( fdrIdx, ulGOPXferByte, SEEK_CUR );
                               } else 
                               {
                                    // fast forward
                                    // FF 1x means normal playback
                                    if (bGOPJumpCount < (bGOPJumpSpeed-1)) 
                                    	{
                                        // Andy 2007.09.20: new scheme
                                        ulGOPXferByte = gopsize[gopsizecnt];
                                        //ulGOPXferByte = gopsize[gopsizecnt] & 0xFFFFF;
                                        fseek( fdr, ulGOPXferByte, SEEK_CUR );
                                        gopsizecnt++;
                                        bGOPJumpCount++;
                                        goto check_index;
                                     } else 
                                     {
                                        bGOPJumpCount = 0;
                                     }
                                }
                                // Andy 2007.09.20: new scheme
                                ulGOPXferByte = gopsize[gopsizecnt];
                                //ulGOPXferByte = gopsize[gopsizecnt] & 0xFFFFF;
                            } // if (bGOPJumpSpeed != 0)

                            //complete this GOP analysis
                            gopsizecnt++;
                            bGOPChecked = 1;

                        } // end of if (bGOPCheck == 0)

                        // Andy 2007.07.28: for trick mode
                        if (ulGOPXferByte > v4lbuf.length) 
                        {
                            if (ulGOPXferByteRemain) 
                            {
                                ulActuCurrXfer = ulGOPByteSkip + fread( (char*)(v4lbuf.m.userptr + ulGOPByteSkip), 1, ulGOPXferByteRemain, fdr);
                                if (ulActuCurrXfer) 
                                {
                                    ulGOPXferByte -= ulGOPXferByteRemain;
                                }
                            } else 
                            {
                                ulActuCurrXfer = fread( (char*)v4lbuf.m.userptr, 1, v4lbuf.length, fdr);
                                if (ulActuCurrXfer) 
                                {
                                    ulGOPXferByte -= ulActuCurrXfer;
                                }
                            }
                            ulGOPXferByteRemain = 0;
                            ulGOPByteSkip = 0;
                        } else 
                        {
                            if (bIndexExist) 
                            {
                                ulActuCurrXfer 		= fread( (char*)v4lbuf.m.userptr, 1, ulGOPXferByte, fdr);
                                ulGOPByteSkip 		= ulActuCurrXfer;   // already read these bytes
                                ulGOPXferByteRemain = v4lbuf.length - ulGOPXferByte;
                                bGOPChecked 		= 0;   // need to check index of the next GOP
                                goto check_index;
                            } else 
                            {
                                ulActuCurrXfer = fread( (char*)v4lbuf.m.userptr, 1, v4lbuf.length, fdr);
                            }
                        }
                    } // end of if (bIndexExist)
                    //DPrintf("Read %d bytes from %s (%x) (ptr=%x, size=%x) \n", ulActuCurrXfer, FName, fdr,
                    //       v4lbuf.m.userptr, v4lbuf.length);

 #else // originally
                    ulActuCurrXfer= fread( (char*)v4lbuf.m.userptr, 1, v4lbuf.length, fdr);
                    //DPrintf("Read %d bytes from %s (%x) (ptr=%x, size=%x) \n", ulActuCurrXfer, FName, fdr,
                    //       v4lbuf.m.userptr, v4lbuf.length);
 #endif

#endif
                }

                if(!ulActuTotalXfer)  time(&tStartTime);

                if(!ulActuCurrXfer) 
                {
                    DPrintf("\n No more data xfer to driver buffer! (%d); UDP max pkt size (%d) \n", ulActuCurrXfer, maxrecdpktsize);
                    stop_immediate= 0; //Stop after decoding all buffers
                    bCtrlCReceived = TRUE;
                    //PBTrickModeProcess(hDecDev,KEY_FUN_0);
                    //sleep(2);
                } else 
                { //Buffer is full enough! let's send it to the driver
                    if(fdw) 
                    {
                        fwrite((void*)v4lbuf.m.userptr, 1, ulActuCurrXfer, fdw);
                    }
                    if(!Err) 
                    {
                        v4lbuf.bytesused= ulActuCurrXfer;
                        Err= ioctl(hDecDev, VIDIOC_QBUF, &v4lbuf);
                        // Dont need to set the VIDIOC_STREAMON again.KEVIN 20070912
                        //if(mcastaddr && !ulActuTotalXfer) Err= ioctl(hDecDev, VIDIOC_STREAMON, &type);
                        ulActuTotalXfer+= ulActuCurrXfer;
                        if(Err) 
                        {
                            DPrintf("QBUF ioctl failed %d %s\n", errno, strerror(errno));
                        }
                        tElapsedTime= time(0)-tStartTime;
                        
#if 0                        
                        print_cnt++;
                        if (print_cnt== 0x08) 
                        {
                            print_cnt= 0;
                            DPrintf("\r%02d:%02d:%02d - %d MB, ~Rate=%05d Kbps,pkt=%05d(%04d) A=%06x,size=%04x", 
                                   tElapsedTime/3600, 
                                   (tElapsedTime/60)%60, 
                                   tElapsedTime%60, 
                                   ulActuTotalXfer/(1024*1024), 
                                   (tElapsedTime ? (DWORD)(((unsigned long long)(ulActuTotalXfer)*8)/(1000*tElapsedTime)) : 0),
                                   pktcnt, 
                                   (pktcnt?(ulActuTotalXfer/pktcnt):0), 
                                   v4lbuf.m.userptr, 
                                   v4lbuf.bytesused);
                        }
#endif
                        snprintf( Time, 9, "%02d:%02d:%02d",tElapsedTime/3600, (tElapsedTime/60)%60, tElapsedTime%60);
                       // osd_text_show(TIMESTMP_X,TIMESTMP_Y_1,Time,OSD_BLACK);
                    }
                }

                if(playbacktimeout && (tElapsedTime>=playbacktimeout)) 
                {
                    bCtrlCReceived = TRUE;
                }
                if(Err) 
                {
                    bCtrlCReceived = TRUE;
                }
                fflush(stdout);

            } else 
            {
#ifdef DEC_TRICK_MODE
                Err= ioctl(hDecDev, QL201_DEC_G_TRICK_MODE, &trickmode);
                if(trickmode.trickmode== 0) 
                {
#endif
                     //break; //EOS
                     if(errno==EAGAIN) 
                     {
                           if(bStopped) 
                           {
                               break; //EOS
                           } else 
                          {
                              Err= 0; //continue if driver doesn't have data
#ifdef FULL_DUPLEX
                              sleep(1);   // Andy 2007.07.20: wait for a while
#endif
                          }
                      }
                      DPrintf("\nDQBUF ioctl failed %d (EAGAIN=%d) %s", errno, EAGAIN, strerror(errno));
   
#ifdef DEC_TRICK_MODE
           	} else //trickmode.trickmode != 0
              {
                     DPrintf("\nBuffer is full due to halt playback by trick mode\n");
                     Err= 0;   // wait
              }
#endif
             
              if(retrycnt++ >= MAX_RETRY_COUNT)  
              { //something is wrong! so exit now
	              bStopped= TRUE;
	              type 	= V4L2_BUF_TYPE_VIDEO_OUTPUT;
	              Err	= ioctl(hDecDev, QL201_DEC_S_STOP_IMMEDIATE, &stop_immediate); //Set to Stop immediate
	              Err	= ioctl(hDecDev, VIDIOC_STREAMOFF, &type);
	              if(Err==-1) 
	              {
	                   DPrintf("STREAMOFF ioctl returns Err=%d, errnot=%d %s\n", Err, errno, strerror(errno));
	              }
	              break;
              }
              
            }
            
pauseloop:            
           //=============== get the key input event ===================
            //key = PBTrickModeProcess(hDecDev,get_keypad());
            /*if(key == 2)//pause
            {
                  usleep(10); 
                  goto  pauseloop;	
            }else
            if(key == 0)	
            {
            	   bCtrlCReceived = TRUE;
            }*/
            
            if(playbacktimeout && (tElapsedTime>=playbacktimeout))  
                bCtrlCReceived = TRUE;

            if(bCtrlCReceived && !bStopped)
           {
                bStopped= TRUE;
                bCtrlCReceived = FALSE;
                Err= ioctl(hDecDev, QL201_DEC_S_STOP_IMMEDIATE, &stop_immediate); //Set to Stop immediate
                type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
                Err= ioctl(hDecDev, VIDIOC_STREAMOFF, &type);
                if(Err==-1) 
                {
                    DPrintf("STREAMOFF ioctl returns Err=%d, errnot=%d %s\n", Err, errno, strerror(errno));
                }
                break;
           }
           usleep(10); 
      }//while
      
      tElapsedTime= time(0)-tStartTime;
      DPrintf("\r%02d:%02d:%02d - %d MB, ~Rate=%05d Kbps,pkt=%05d(%04d) A=%06x,size=%04x", 
               tElapsedTime/3600, 
               (tElapsedTime/60)%60, 
               tElapsedTime%60, 
               ulActuTotalXfer/(1024*1024), 
               (tElapsedTime ? (DWORD)((unsigned long long)(ulActuTotalXfer*8)/(1000*tElapsedTime)) : 0),
               pktcnt, 
               (pktcnt?(ulActuTotalXfer/pktcnt):0), 
               v4lbuf.m.userptr, 
               v4lbuf.bytesused);
    } else 
    {
        DPrintf("STREAMON ioctl failed %d %s\n", errno, strerror(errno));
    }
    
    //osd_text_clear(TIMESTMP_X - 2*FONT_WIDTH, TIMESTMP_Y_0,0,FName+0x0a);
    //osd_text_clear(TIMESTMP_X,TIMESTMP_Y_1,0,Time);
    //QL_clear_PbModeOSD();
    SET_VO_MODE(VID_BYPASS);

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

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

#ifdef DEC_TRICK_MODE
    // Andy 2007.08.20
    if(fdrIdx) {
        fflush(fdrIdx);
        fclose(fdrIdx);
        fdr= 0;
    }
#endif

    if(fdw) {
        fflush(fdw);
        fclose(fdw);
        fdw= 0;
    }
    DPrintf("\n");
    return Err;
}
#else

long DecodeAndStreamv4(char *FName, unsigned int playbacktimeout) 
{
    long Err= 0;
    FILE *fdr= 0, *fdw= 0;