vidinj.c

ST5100 driver files for ST chipset

    /* Free injection access */
    semaphore_signal(&VID_Injection[FifoNb-1].Access);

	return(ErrCode);

} /* end of VID_MemInject() */

/*-------------------------------------------------------------------------
 * Function : VID_Load
 *            Load an mpeg file in memory
 * Input    : char *FileName, S32 LVar
 * Output   : 
 * Return   : ST_ErrorCode_t ErrCode
 * ----------------------------------------------------------------------*/
ST_ErrorCode_t VID_Load(char *FileName, S32 LVar)
{
	ST_ErrorCode_t ErrCode = ST_NO_ERROR;
    void * AllocatedBuffer_p = NULL;
    long int FileDescriptor, FileSize;
    BOOL Truncated;
    ST_Partition_t* Partition_p;
    U8 *Ptr;
    char *local_filename_p;    

    if ((LVar < 1) || (LVar > VID_MAX_BUFFER_LOAD))
    {
        STTBX_Print(("Error occured: expected load buffer number (default is 1. max is %d)", VID_MAX_BUFFER_LOAD));  
        return(ST_ERROR_BAD_PARAMETER);
    }

    if(VID_BufferLoad[LVar-1].UsedCounter != 0)
    {
        STTBX_Print(( "Buffer cannot be loaded because already in use !!\n" ));
		return(ST_ERROR_BAD_PARAMETER);
    }

    if (VID_BufferLoad[LVar-1].AllocatedBuffer_p != NULL)
    {
        memory_deallocate(VID_BufferLoad[LVar-1].Partition_p, VID_BufferLoad[LVar-1].AllocatedBuffer_p);
        /* remark : no result is returned by this void function */
        VID_BufferLoad[LVar-1].AllocatedBuffer_p = NULL;
    }

	STTBX_Print(("Looking for %s ... \n", FileName));  

	if ( !strncmp(FileName,"$REF",4) )
    {
        local_filename_p = memory_allocate(NcachePartition,
             				(U32)(strlen(STDM_ReferencePath) + strlen(FileName)));
        if (local_filename_p == NULL)
        {
            STTBX_Report((STTBX_REPORT_LEVEL_ERROR,
                          "VID_Load() unable to allocate memory"));
            return(ST_ERROR_NO_MEMORY);
        }
        strcpy(local_filename_p, STDM_ReferencePath);
        strcat(local_filename_p, FileName+4);
    }
    else
    {
        local_filename_p = memory_allocate (NcachePartition,
                                            (U32)(strlen(FileName)));
        if (local_filename_p == NULL)
        {
            STTBX_Report((STTBX_REPORT_LEVEL_ERROR,
                          "VID_Load() unable to allocate memory"));
            return(ST_ERROR_NO_MEMORY);
        }
        strcpy(local_filename_p, FileName);
    }

	FileName = local_filename_p;

    /* Get memory to store file data */
    FileDescriptor = debugopen(FileName, "rb" );

    if (FileDescriptor < 0)
    {
		STTBX_Print(("<<< ERROR : Unable to open file '%s' ! >>>\n", FileName));
		return(ST_ERROR_BAD_PARAMETER);
    }

    STTBX_Print(("Loading in buffer no %d ...\n", LVar));
    FileSize = debugfilesize(FileDescriptor);

    /* ---  allocated buffer will be aligned later. Manage room to round up to a multiple of 16 bytes --- */
    Truncated = FALSE;
    while ((FileSize > 0) && (AllocatedBuffer_p == NULL ))
    {
        AllocatedBuffer_p = (char *)memory_allocate(/*DataPartition*/NcachePartition, (U32)((FileSize + 15) ));
        Partition_p = /*DataPartition*/NcachePartition;

        if (AllocatedBuffer_p == NULL)
        {
            Truncated = TRUE;
            FileSize -= 200000; /* file too big : truncate the size */
            if ( FileSize < 0 )
            {                     
				STTBX_Print(("Not enough memory for file loading\n"));
				return(ST_ERROR_NO_MEMORY);
            }
        }
    }
    if (Truncated)
    {
        STTBX_Print(("Not enough memory for file loading : truncated to %ld \n", FileSize));
    }

    /* --- Setup the alligned buffer, load file and return --- */
    VID_BufferLoad[LVar-1].AllocatedBuffer_p = AllocatedBuffer_p;

    VID_BufferLoad[LVar-1].Partition_p = Partition_p;
    VID_BufferLoad[LVar-1].AlignedBuffer_p =
        (void *)(((unsigned int) VID_BufferLoad[LVar-1].AllocatedBuffer_p));

    VID_BufferLoad[LVar-1].NbBytes = (U32) FileSize;
    strcpy(VID_BufferLoad[LVar-1].StreamName, FileName);
    (void)debugread(FileDescriptor, VID_BufferLoad[LVar-1].AlignedBuffer_p, (size_t) FileSize);

    (void)debugclose( FileDescriptor );

    /* parse again the loaded buffer to force the Data Cache to flush */
    for ( Ptr = (U8 *) VID_BufferLoad[LVar-1].AlignedBuffer_p;
          Ptr < ((U8 *) VID_BufferLoad[LVar-1].AlignedBuffer_p + VID_BufferLoad[LVar-1].NbBytes); )
    {
        vid_DummyRead = *Ptr++;
    }
	vid_DummyRead = vid_DummyRead; /*lint*/

    STTBX_Print(("File [%s] loaded : size %ld at address %x \n",
            	 FileName, FileSize, (int)VID_BufferLoad[LVar-1].AlignedBuffer_p));

    return(ErrCode);
}  /* end of VID_Load */

/*-------------------------------------------------------------------------
 * Function : VID_DecodeFromMemory
 *            Inject Video in Memory to DMA
 * Input    : STVID_Handle_t VidHandle, S32 FifoNb, S32 InjectLoop, S32 BufferNb
 * Output   : 
 * Return   : ST_ErrorCode_t ErrCode
 * ----------------------------------------------------------------------*/
ST_ErrorCode_t VID_DecodeFromMemory(STVID_Handle_t VidHandle, S32 FifoNb, S32 NbLoops, S32 BuffNb)
{
    ST_ErrorCode_t ErrCode = ST_NO_ERROR;
    S32 i;    
    U32 InputBuffersize;

	if ((NbLoops < 1) || (NbLoops > 9999))
    {
		STTBX_Print(("Error occured: expected # of loops (1 to 9999)\n"));  
        return(ST_ERROR_BAD_PARAMETER);
    }

    if ((FifoNb < 1) || (FifoNb > VIDEO_MAX_DEVICE))
    {
		STTBX_Print(("Error occured: expected fifo number (1 to %d)\n", VIDEO_MAX_DEVICE));  
        return(ST_ERROR_BAD_PARAMETER);
    }
	
    if ((BuffNb < 1) || (BuffNb > VID_MAX_BUFFER_LOAD))
    {
		STTBX_Print(("Error occured: expected load buffer number (default is 1. max is %d)", VID_MAX_BUFFER_LOAD));  
        return(ST_ERROR_BAD_PARAMETER);
    }

    if(VID_BufferLoad[BuffNb-1].AllocatedBuffer_p == NULL)
    {
        STTBX_Print(( "No file loaded in memory buffer !!\n" ));
        return(ST_ERROR_BAD_PARAMETER);
    }

	VID_Injection[FifoNb-1].Driver.Handle = VidHandle;
    
    /* Lock injection access */
    (void)semaphore_wait(&VID_Injection[FifoNb-1].Access);
    if(VID_Injection[FifoNb-1].Type != NO_INJECTION)
    {
        VID_ReportInjectionAlreadyOccurs(FifoNb);
        return(ST_ERROR_BAD_PARAMETER);
    }
    else
    {
        if(VID_Injection[FifoNb-1].BitBufferSize == 0)
        {
            /* No injection occured. Bit buffer should be empty */
            ErrCode = STVID_GetBitBufferFreeSize(VID_Injection[FifoNb-1].Driver.Handle, &VID_Injection[FifoNb-1].BitBufferSize);
            if(ErrCode != ST_NO_ERROR)
            {
                STTBX_Print(("Error occured : STVID_GetBitBufferFreeSize() = %d !!\n", ErrCode));                
                VID_Injection[FifoNb-1].BitBufferSize = 0;
				return(ST_ERROR_BAD_PARAMETER);
            }
        }
        VID_Injection[FifoNb-1].Type = VID_MEMORY_INJECTION;
    }

    /* Free injection access */
    semaphore_signal(&VID_Injection[FifoNb-1].Access);

    VID_Injection[FifoNb-1].Config.Memory.SrcBuffer_p = VID_BufferLoad[BuffNb-1].AlignedBuffer_p;
    VID_Injection[FifoNb-1].Config.Memory.CurrentSrcPtr_p = VID_BufferLoad[BuffNb-1].AlignedBuffer_p;
    VID_Injection[FifoNb-1].Config.Memory.SrcSize = VID_BufferLoad[BuffNb-1].NbBytes;
    VID_Injection[FifoNb-1].Config.Memory.LoadBufferNb = BuffNb;
    VID_Injection[FifoNb-1].Config.Memory.LoopNbr = NbLoops;
    VID_Injection[FifoNb-1].Config.Memory.LoopNbrDone = 0;
    VID_Injection[FifoNb-1].Config.Memory.SynchronizedByUnderflowEvent = FALSE;
    for(i=0;i<VID_INJECTEDSIZEHISTORYSIZE;i++)
    {
        VID_Injection[FifoNb-1].Config.Memory.InjectedSizeHistory[i] = VID_INVALID_INJECTEDSIZE;
    }
    VID_Injection[FifoNb-1].Config.Memory.InjectedSizeHistoryIndex = 0;

    /* Get Input buffer characteristics     */
    ErrCode = STVID_GetDataInputBufferParams(VID_Injection[FifoNb-1].Driver.Handle,
        									 &VID_Injection[FifoNb-1].Base_p, 
        									 &InputBuffersize);
    /* Update injection pointer.            */
    VID_Injection[FifoNb-1].Top_p =	(void *)((U32)VID_Injection[FifoNb-1].Base_p + InputBuffersize - 1);

    /* Test if it's the first use of injection. */
    if (VID_Injection[FifoNb-1].Write_p == NULL)
    {
        /* Affect default values to Read/Write pointers.        */
        VID_Injection[FifoNb-1].Write_p = VID_Injection[FifoNb-1].Base_p;
        VID_Injection[FifoNb-1].Read_p  = VID_Injection[FifoNb-1].Base_p;
    }
    else
    {
        /* This injecter was already used. Test previous write pointer position. */
        if ( ((U32)VID_Injection[FifoNb-1].Write_p > (U32)VID_Injection[FifoNb-1].Top_p) ||
             ((U32)VID_Injection[FifoNb-1].Write_p < (U32)VID_Injection[FifoNb-1].Base_p) )
        {
            /* This injecter was probably used with an other video instance.    */
            /* Take write pointer to input buffer base address.                 */
            VID_Injection[FifoNb-1].Write_p = VID_Injection[FifoNb-1].Base_p;;
        }
        VID_Injection[FifoNb-1].Read_p  = VID_Injection[FifoNb-1].Write_p;
    }

    /* Configure the interface-object */
    ErrCode = STVID_SetDataInputInterface(VID_Injection[FifoNb-1].Driver.Handle,
	                            GetWriteAddress,InformReadAddress,(void*)(FifoNb-1));

    VID_Injection[FifoNb-1].Type = VID_MEMORY_INJECTION;
    /* Launch injection */
    semaphore_signal(&VidMemInjection);

    /* Launch Injection */
    if (VID_Injection[FifoNb-1].Driver.DriverState != STATE_DRIVER_STOPPED)
    {
        /* Video Load Buffer in use */
        VID_BufferLoad[BuffNb-1].UsedCounter++;
        if( VIDTid == NULL )
        {
            DoVideoInject();
        }
        /* else the inject task exists: it will execute the injection by itself */
    }
    /*else
    {
        STTBX_Print(("Cannot launch a decode until end of buffer while decoder is stopped !\n" ));
    }*/

    /* Lock injection access */
    semaphore_wait(&VID_Injection[FifoNb-1].Access);

    VID_Injection[FifoNb-1].Type = NO_INJECTION;

    /* Free injection access */
    semaphore_signal(&VID_Injection[FifoNb-1].Access);

    return(ErrCode);

} /* end of VIDDecodeFromMemory() */


/*#######################################################################*/