video_comm.c

最新MTK手机软件源码

    prev_vlc_word = DRV_Reg32(MP4_VLC_WORD);

    for (index = 0; index < 75; index++)
    {
        kal_sleep_task(2);

        curr_vlc_word = DRV_Reg32(MP4_VLC_WORD);
        if (prev_vlc_word == curr_vlc_word)
            break;
        else
            prev_vlc_word = curr_vlc_word;
    }
#else  /*(MT6228, MT6229, MT6230)*/
   ASSERT(0);
#endif /*(MT6219, MT6226, MT6227, MT6226M)*/

}


 /* Mpeg4 decode wait done function.
 * @param None
 * @return None                                                        
 */
void mpeg4_dec_wait_done(void)
{
#if ( defined(MT6219) || defined(MT6226) || defined(MT6227) || defined(MT6226M) )
    /*For future development*/ 
    mpeg4_wait_done();
#else /*!(MT6219, MT6226, MT6227, MT6226M)*/

    kal_uint32 prev_vlc_word;
    kal_uint32 curr_vlc_word;
    kal_uint16 index;

    prev_vlc_word = DRV_Reg32(MP4_DEC_VLC_WORD);

    for (index = 0; index < 75; index++)
    {
        kal_sleep_task(2);

        curr_vlc_word = DRV_Reg32(MP4_DEC_VLC_WORD);
        if ((curr_vlc_word != 0) && (prev_vlc_word == curr_vlc_word))
            break;
        else
            prev_vlc_word = curr_vlc_word;
    }
#endif /*(MT6219, MT6226, MT6227, MT6226M)*/

}


 /* Mpeg4 encode wait done function.
 * @param None
 * @return None                                                        
 */
void mpeg4_enc_wait_done(void)
{
#if ( defined(MT6219) || defined(MT6226) || defined(MT6227) || defined(MT6226M) )
    /*For future development*/
    mpeg4_wait_done();
#else /*!(MT6219, MT6226, MT6227, MT6226M)*/

    kal_uint32 prev_vlc_word;
    kal_uint32 curr_vlc_word;
    kal_uint16 index;

    prev_vlc_word = DRV_Reg32(MP4_ENC_VLC_WORD);

    for (index = 0; index < 75; index++)
    {
        kal_sleep_task(2);

        curr_vlc_word = DRV_Reg32(MP4_ENC_VLC_WORD);
        if ((prev_vlc_word == curr_vlc_word) && (curr_vlc_word != 0))
            break;
        else
            prev_vlc_word = curr_vlc_word;
    }
#endif /*(MT6219, MT6226, MT6227, MT6226M)*/

}


 /* Mpeg4 check hardware complete function.
 * @param None
 * @return None                                                        
 */
kal_bool mpeg4_dec_check_complete(void)
{
    if(DRV_Reg32(MP4_DEC_STS) == 1)
    {
        return KAL_TRUE;
    }
    else
    {
        return KAL_FALSE;
    }
}


///////////////////////////////////////////////////////////////////
//                                                                                                    //
//                              Timing information functions                                 //
//////////////////////////////////////////////////////////////////

 /* Get current time function. (32K resolution)
 * @param None
 * @return None                                                        
 */
kal_uint32 video_get_current_time(void)
{
    return drv_get_current_time();
}


 /* Get duration time. (32K resolution)
 * @param previous_time. The previous time get from 32K ticks
 * @param current_time. The current time get from 32K ticks
 * @return time difference. (calculate limit)                                                       
 */
kal_uint32 video_get_duration_tick(kal_uint32 previous_time, kal_uint32 current_time)
{
    return drv_get_duration_tick(previous_time, current_time);
}


/* Get duration time. (ms)
 * @param previous_time. The previous time get from 32K ticks
 * @return time difference from previous to current time. (calculate limit, and translate to ms)                                                       
 */
kal_uint32 video_get_duration_ms(kal_uint32 previous_time)
{
    return drv_get_duration_ms(previous_time);
}


///////////////////////////////////////////////////////////////////
//                                                                                                    //
//                              Error and debug functions                                   //
//////////////////////////////////////////////////////////////////

/* This function will obtain the current video status.
 * @param None.
 * @return Media status, which is based MED_STATUS structure.                                                
 */
MED_STATUS VIDEO_GetLastError(void)
{
    kal_int32 result;

    if (g_video_dec_status.running != KAL_FALSE)
    {
        if (g_video_dec_status.VIDEO_STATUS != VIDEO_DEC_OK)
        {
            result = g_video_dec_status.VIDEO_STATUS;

            g_video_dec_status.VIDEO_STATUS = VIDEO_DEC_OK;
            return result;
        }

        if (g_video_dec_status.FSAL_STATUS != FSAL_OK)
        {
            result = g_video_dec_status.FSAL_STATUS;

            g_video_dec_status.FSAL_STATUS = FSAL_OK;
            result = (kal_int32)FSAL_GetLastError(g_video_dec_status.FSAL_ERROR_FILE);
            return result;
        }
        if (g_video_dec_status.PARSE_STATUS != MP4_PARSER_OK)
        {
            result = g_video_dec_status.PARSE_STATUS;

            g_video_dec_status.PARSE_STATUS = MP4_PARSER_OK;
            return result;
        }
    }

    if (g_video_enc_status.VIDEO_STATUS != VIDEO_ENC_OK)
    {
        result = g_video_enc_status.VIDEO_STATUS;

        g_video_enc_status.VIDEO_STATUS = VIDEO_ENC_OK;
        return result;
    }

    if (g_video_enc_status.FSAL_STATUS != FSAL_OK)
    {
        result = g_video_enc_status.FSAL_STATUS;

        g_video_enc_status.FSAL_STATUS = FSAL_OK;
        result = (kal_int32)FSAL_GetLastError(g_video_enc_status.FSAL_ERROR_FILE);
        return result;
    }

    if (g_video_enc_status.FS_STATUS < 0)
    {
        result = g_video_enc_status.FS_STATUS;

        g_video_enc_status.FS_STATUS = 0;
        return result;
    }

    return MED_STAT_NO_ERROR;
}


 /* Video assert debug function.
 * @param   line      file line number
 * @return  None                                         
 */
void video_assert(kal_uint32 line)
{
    VIDEO_ERROR_LINE[VIDEO_ERROR_LINE_INDEX&(MAX_VIDEO_ERROR_LINE - 1)] = line;

    VIDEO_ERROR_LINE_INDEX++;
}


 /* This function add debug trace information to memory
 * @param  index  VIDEO debug id.
 * @param  time   Time stamp.
 * @return None
 */
void video_dbg_trace(VIDEO_DBG_ID index, kal_uint32 time)
{
    kal_uint32 savedMask;

    savedMask = SaveAndSetIRQMask();

    {
        VIDEO_DBG_INFO_DATA.dbg_data[VIDEO_DBG_INFO_DATA.dbg_data_idx&(MAX_VISIAL_DBG_INFO_SIZE - 1)].tag = index;

        VIDEO_DBG_INFO_DATA.dbg_data[VIDEO_DBG_INFO_DATA.dbg_data_idx&(MAX_VISIAL_DBG_INFO_SIZE - 1)].time = time;
        VIDEO_DBG_INFO_DATA.dbg_data_idx++;
    }

    RestoreIRQMask(savedMask);
}
 

/* This function will obtain the debug information of video driver.
 * @param  data1  video debug information1
 * @param  data2  video debug information2
 * @param  data3  video debug information3
 * @param  data4  video debug information4
 * @param  data_index  video debug information index
 * @return None
 */
void VIDEO_DbgInfo(kal_uint32 * data1, kal_uint32 * data2, kal_uint32 * data3, kal_uint32 * data4,
                   kal_uint32 * data_index)
{
    *data1 = VIDEO_ERROR_LINE[0];

    *data2 = VIDEO_ERROR_LINE[1];
    *data3 = VIDEO_ERROR_LINE[2];
    *data4 = VIDEO_ERROR_LINE[3];
    *data_index = VIDEO_ERROR_LINE_INDEX;
}
#else  /*!MP4_CODEC*/
#include "drv_comm.h"
#include "reg_base.h"
#include "video_hw.h"
void mp4_reset(void)
{
#if ( defined(MT6219) || defined(MT6226) || defined(MT6227) || defined(MT6226M) )
   kal_uint32 savedMask;
   volatile kal_uint32 pdn_reg;
   kal_uint8 index;
   
   savedMask = SaveAndSetIRQMask();
   pdn_reg = DRV_Reg(DRVPDN_CON3);
   
   DRV_Reg(DRVPDN_CON3) &= ~(DRVPDN_CON3_MP4|DRVPDN_CON3_DCT|DRVPDN_CON3_JPEG);

   DRV_WriteReg32(MP4_CODEC_COMD,MP4_CODEC_COMD_ReSeT);
   for(index=0;index<5;index++);
   DRV_WriteReg32(MP4_CODEC_COMD,0);
   
   DRV_WriteReg(DRVPDN_CON3,pdn_reg);
   RestoreIRQMask(savedMask);
#else /*!(MT6219, MT6226, MT6227, MT6226M)*/
   ASSERT(0);
#endif   /*(MT6219, MT6226, MT6227, MT6226M)*/
}
#endif /*MP4_CODEC*/