vid_sp4_play.c

凌阳SPCE3200多媒体开发板自带源程序。共安排了32个子目录

        pKFTemp->ulReady = 1;
        pKFTemp = pKFNode->pKFNode_Next;
    }
}

int vidSP4_Preload(int fp, U32 ulLoadAddress,U32 StartOfFrame)
{
    U32  i, ultemp, ulIdxAddr;
    U32  *pAddr;
    int  status;
    
    #ifdef CDROM_DEVICE
    g_pKFOffset = (U32 *) g_pKFOffsetCD;
    #endif

//Add by ww 
    g_ucDataAReady=0;
    g_ucDataBReady=0;
    g_ucABBufferFlag=0;
    g_ulReadPort=0;
    g_ulWritePort=0;
    g_ulCurrentBufferLen=0;
    g_ulDataSize=0; 
    g_ulBufferKFCount=0;    
    g_ulFrameRate = 0;
    g_ulTotalFrame = 0;
    g_ulEOF = 0;
    g_ucDataAReady=0;
    g_ucDataBReady=0;
    gl_FilePtrCur=0;
    g_ulDataASizes=0;
    g_ulDataBSizes=0;
    g_ucABBufferFlag = 0;
    g_ucMP3IrqFlag = 0;
    g_ulKFLength = 0;   
    g_ulTotalKF=0; 
    g_ulWidth=0; 
    g_ulHeight=0;
    g_ulKFIdx=0;
    g_ulFrameIdx=0;
    g_ulNextIdx=0; 
    g_ulStartIdx=0;
    g_ulSP4counter = 0;	
    g_ulFreeNode=0;
    g_ulKFSizes=0;
    MP4_State_Flag = 0;
//End    
    
    //read header and KF offset info to the buffer    
    #ifdef SD_CARD_DEVICE   
    status = read(fp, (void *)ulLoadAddress, 0x100000);
    #endif
    
     #ifdef CDROM_DEVICE   
    status = iso_read(fp, (void *)ulLoadAddress, 0x100000);
    #endif
     
    pAddr = (U32 *)ulLoadAddress;
    
    //Check header flag
     if (*pAddr != SPMP)
    {
        return status = -1;
    } 
    
    pAddr++;
    //Get total KF number
    g_ulTotalKF = *pAddr;
	
    pAddr++;
    //Get width and height
    g_ulWidth = *pAddr;
    pAddr++;
    g_ulHeight = *pAddr;
	
    pAddr++;
    //Get KF length in per sec
    g_ulKFLength = *pAddr;
    
    pAddr++;
    //Parsing ver.
    if (*pAddr == SPver0101)
    {
        pAddr++;
        //Get KF offset flag address
        ulIdxAddr = *pAddr;
        
        #ifdef SD_CARD_DEVICE
        g_ulEOF = ulIdxAddr;
        vidSP4_GetpKFOffset(g_nfp2,g_ulStartFramNum,g_ulEndFramNum,SET_FRAME_START_END_ON, ulIdxAddr+4);    
        #endif
        
        #ifdef CDROM_DEVICE
        ultemp = min(g_ulTotalKF, Max_KF_of_File);
        
        if(StartOfFrame>ultemp)
        {
            StartOfFrame = 0;
        }
        
        //move to KF index address  todo~~~
        
        //Record all KF offset address
        for (i=0; i <(ultemp-StartOfFrame); i++)
        {
            g_pKFOffset[i] = *(pAddr+StartOfFrame);		
            pAddr++;
        }
        
        //To save EOF position.        
        g_ulEOF = ulIdxAddr;        
        g_pKFOffset[i] = g_ulEOF;    
        //~To save EOF position.
        #endif//CDROM_DEVICE
    }
    else
    {
        #ifdef SD_CARD_DEVICE
        status = lseek(fp, 0, SEEK_END);
        g_ulEOF = (U32) (status);
        vidSP4_GetpKFOffset(g_nfp2,g_ulStartFramNum,g_ulEndFramNum,SET_FRAME_START_END_ON, 20);    
        #endif

        #ifdef CDROM_DEVICE
        ultemp = min(g_ulTotalKF, Max_KF_of_File);
        
        if(StartOfFrame>ultemp)
        {
            StartOfFrame = 0;
        }
        
        //Record all KF offset address
        for (i=0; i <(ultemp-StartOfFrame); i++)
        {
            g_pKFOffset[i] = *(pAddr+StartOfFrame);		
            pAddr++;
        }
        
        //To save EOF position.
        status = iso_lseek(fp, 0, SEEK_END);
        g_ulEOF = (U32) (status);
        
        g_pKFOffset[i] = g_ulEOF;    
        //~To save EOF position.
        #endif//CDROM_DEVICE
    }
    
    return status;
}

U32 vidSP4_RequestBuffer(U32 ulBufferAddress, U32 ulDataSize)
{
    U32 ulContinueBufferLen, ulWritePort;
    
    ulContinueBufferLen = MP4_Buffer_Size - g_ulWritePort;
    g_ulCurrentBufferLen =  (g_ulReadPort - g_ulWritePort - BUFFER_GUARD_BAND) & MP4_Buffer_Mask;
    
    if(ulContinueBufferLen >=ulDataSize)
    {
        if (g_ulCurrentBufferLen >=ulDataSize)
        {
            g_ulCurrentBufferLen -= ulDataSize;
            ulWritePort = ulBufferAddress + g_ulWritePort;
            g_ulWritePort = (g_ulWritePort + ulDataSize) & MP4_Buffer_Mask;
            return ulWritePort;
        }
        else
        {
            //Buffer is not enough
            return 0xFFFFFFFF;
        }
    }
    else
    {
        if (g_ulCurrentBufferLen >= ulContinueBufferLen)
        {
            g_ulCurrentBufferLen -= ulContinueBufferLen;
            g_ulWritePort = ulWritePort = 0;
        }
        else
        {
            //Buffer is not enough
            return 0xFFFFFFFF;
        }
        
        if (g_ulCurrentBufferLen >= ulDataSize)
        {
            ulWritePort = ulBufferAddress;
            g_ulWritePort = ulDataSize;
            g_ulCurrentBufferLen -= ulDataSize;
            return ulWritePort;
        }
        else
        {
            //Buffer is not enough
            return 0xFFFFFFFF;
        }
    }
}

void vidSP4_InitKFList(KF_NODE *pKFNode)
{
    U32  i;
    
    //initial KF Node
    memset(pKFNode, 0, (sizeof(KF_NODE)*Max_KF_Amount));
    
    for(i = 0; i < Max_KF_Amount; i++)
    {
        if (i != (Max_KF_Amount-1))
        {
            (pKFNode + i)->pKFNode_Next = (pKFNode + i+1);
        }
        else
        {
            (pKFNode + i)->pKFNode_Next = pKFNode;
        }
    }
}

void vidSP4Stop()
{
    MP4_State_Flag =0;
    SP4_Stop_MP3();
}

void vidSP4Pause()
{
    MP4_State_Flag |= MASK_MP4_PAUSE;
    SP4_Pause_MP3();
}

void vidSP4Resume()
{
     MP4_State_Flag &= ~MASK_MP4_PAUSE;
     MP4_State_Flag |= MASK_MP4_PLAY;
     SP4_Resume_MP3();
     while (!(MP4_State_Flag & MASK_MP4_AUDIO_READY))
     {
         SP4_MP3_Service_Loop();
     }
}

#ifdef SD_CARD_DEVICE

U32 vidSP4_GetpKFOffset(int fp,U32 ulStartFramNum,U32 ulEndFramNum,U8 ucSwithOnOFF, U32 offset)
{
   static U32 i;
   S32 status=0,ret=0;
   static U32  ulResidueKF;
   U32 ultemp;
   U32 ulBufferA=0,ulBufferB=0;
   static U32 ulStartFrame,ulEndFrame;

    if(ucSwithOnOFF==SET_FRAME_START_END_ON)
    {
    	i = ulStartFrame = ulStartFramNum;
    	ulEndFrame = ulEndFramNum;
    }
    
    if((g_ucDataAReady==0) || (g_ucDataBReady==0))
    {
    	
        if(i==ulStartFrame)
        {
            ulResidueKF = g_ulTotalKF - ulStartFrame;
            g_pKFOffset = (U32 *) g_pKFOffset1;
            g_ucABBufferFlag = 0;
            g_ucDataAReady = 0;
            g_ucDataBReady = 0;	 
            status = lseek(fp, offset + i*4, SEEK_SET);	
        }
        else if(i>=ulEndFrame && ulEndFrame!=0)
        {
            i = ulStartFrame;	
            ulResidueKF = g_ulTotalKF - ulStartFrame;
            g_ucABBufferFlag = 0;
            g_ucDataAReady = 0;
            g_ucDataBReady = 0;
            status = lseek(fp, offset + i*4, SEEK_SET);
            ret = MPEG4_B_POINT;	
        }
        else
        {
    	  //
        }
       
        g_ulStartIdx=0;
        g_ulNextIdx=0;
       
        if(ulResidueKF<Max_KF_of_File)
        {
           ultemp = ulResidueKF;
        }
        else
        {
           ultemp = Max_KF_of_File;
        }
        
        //gl_FilePtrCur = lseek(fp, 0, SEEK_CUR);
        
        if(ulResidueKF!=0)
        {  
            //status = lseek(fp, (5+i)*4, SEEK_SET);	
        }
        
        if(g_ucDataAReady==0)
        {
            g_ucDataAReady = 1; 	
            if(ulResidueKF>0)
            {	
         	      ulBufferA = 1;
         	      
         	      if(i==ulStartFrame)
         	      {
                    status = read(fp, (void *) g_pKFOffset1, (ultemp+2)*4);    
                    // g_pKFOffset1[ultemp]=0;                    
                }
                else
                {
                    status = read(fp, (void *) g_pKFOffset1+4, (ultemp+1)*4);	
                    g_pKFOffset1[0] = g_pKFOffset2[g_ulDataBSizes+1];          	 
                }
                
                g_ulDataASizes = ultemp;	
              
                if(i==ulStartFrame) 
                {	                      	           
                    ulResidueKF = ulResidueKF - ultemp;	  
                    i = i + ultemp;
                    
                    if(ulResidueKF<Max_KF_of_File)
                    {
                        ultemp = ulResidueKF;
                    }
                    else
                    {
                        ultemp = Max_KF_of_File;
                    }
                    // status = lseek(fp, (5+i)*4, SEEK_SET);
                }
            }
            
            g_ulKFSizes = g_ulDataBSizes;
            g_pKFOffset = (U32 *) g_pKFOffset2;
        }
        
        if(g_ucDataBReady==0)
        {   
         	  g_ucDataBReady = 1;
         	  
         	  if(ulResidueKF>0)
            {
                ulBufferB = 1; 	         	 
                status = read(fp, (void *) g_pKFOffset2+4, (ultemp+1)*4);
                g_pKFOffset2[0] = g_pKFOffset1[g_ulDataASizes+1];
                g_ulDataBSizes = ultemp;		
            }
         	
         	  if(ulResidueKF==0)
            {
               	g_ucDataBReady = 1;
            }
            
            g_ulKFSizes = g_ulDataASizes;
            g_pKFOffset = (U32 *) g_pKFOffset1;	 
        }		 
  
        if(ulResidueKF!=0)
        {
            ulResidueKF = ulResidueKF - ultemp;
            i = i + ultemp;
        }
        
        if(ulResidueKF==0)
        {
            if(ulBufferA==1 && ulBufferB==0)
           	{
                g_pKFOffset1[g_ulDataASizes+1] = g_ulEOF;
                g_pKFOffset1[g_ulDataASizes+2] = g_ulEOF;
            } 
           	 
            if(ulBufferB==1 && ulBufferA==0)
            {
                g_pKFOffset2[g_ulDataBSizes+1] = g_ulEOF;
                g_pKFOffset2[g_ulDataBSizes+2] = g_ulEOF;
            } 
           	 
            if(ulBufferA==1 && ulBufferB==1)
            {
                g_pKFOffset2[g_ulDataBSizes+1] = g_ulEOF;
                g_pKFOffset2[g_ulDataBSizes+2] = g_ulEOF;	
            }           	 
        }
        //status = lseek(fp, gl_FilePtrCur, SEEK_SET);
    }

    //return status;
    if(ret==MPEG4_B_POINT)
    {
        status = lseek(fp, g_pKFOffset[0], SEEK_SET);
    }