video_enc_isr.c

最新MTK手机软件源码

    return;
#else /*__VIDEO_GET_YUV_DATA__*/

   video_enc_fr_evalutaion_init();

    time_stamp = video_enc_get_timestamp();
    delay_offset = g_video_enc_info_ptr->const_delay + VIDEO_ANYBASE_TO_ANYBASE(
                                                           get_camera_frame_period(),
                                                           1000,
                                                           Media_A2V_GetAudioInterruptTimeScale(
                                                               video_enc_audio_format, 0x0b));

    video_enc_lisr_process(encode_work_yuv, time_stamp, delay_offset);
#endif /*__VIDEO_GET_YUV_DATA__*/

}

void MPEG4_ENC_LISR(void)
{
#if ( defined(MT6219) || defined(MT6226) || defined(MT6227) || defined(MT6226M) )
   IRQMask(IRQ_MPEG4_CODE);
#else  /*!(MT6219, MT6226, MT6227, MT6226M)*/
   IRQMask(IRQ_MPEG4_ENC_CODE);
#endif /*(MT6219, MT6226, MT6227, MT6226M)*/

    visual_active_hisr(VISUAL_MPEG4_ENC_HISR_ID);
    video_dbg_trace(MP4_ENC_MP4LISR_ENTRY, video_get_current_time());
}

void MPEG4_ENC_HISR(void)
{
#ifdef __VIDEO_GET_YUV_DATA__
    ASSERT(g_video_enc_info_ptr->video_enc_callback != NULL);

    if (video_yuv.send_ilm)
    {
#if defined(__VIDEO_EDITOR__)
        if (g_video_enc_status.scenario == VIDEO_SCENARIO_EDITOR)
        {
            g_video_enc_info_ptr->video_enc_callback(VIDEO_EDITOR_ENC_EVENT_VIDEO_BUFFER_AVAIL);
        }
        else
#endif /*__VIDEO_EDITOR__*/
        {
            g_video_enc_info_ptr->video_enc_callback(VIDEO_ENC_EVENT_VIDEO_BUFFER_AVAIL);
        }
        video_yuv.send_ilm = KAL_FALSE;
    }

    return;
#else /*__VIDEO_GET_YUV_DATA__*/

    kal_uint32 temp_ptr;
    kal_uint32 temp_int;
    kal_uint32 bitcnt;
    kal_uint32 frame_length;
    kal_uint32 length;
    kal_uint32 status;
    kal_bool isr_error = KAL_TRUE;
    MEDIA_STATUS_CODE result;
#if ( defined(MT6219) || defined(MT6226) || defined(MT6227) || defined(MT6226M) )
    status = DRV_Reg32(MP4_IRQ_STS);
    DRV_WriteReg32(MP4_IRQ_ACK, status);
#else /*!(MT6219, MT6226, MT6227, MT6226M)*/
    status = DRV_Reg32(MP4_ENC_IRQ_STS);
    DRV_WriteReg32(MP4_ENC_IRQ_ACK, status);
#endif /*(MT6219, MT6226, MT6227, MT6226M)*/

    if (status == 0)
    {
        VIDEO_ASSERT(0);

        video_dbg_trace(MP4_MAY_ISR_ERROR, video_get_current_time());
        return;
    }

    if (g_video_enc_info_ptr->is_send_ilm)
    {
        ASSERT(g_video_enc_info_ptr->video_enc_callback != NULL);

        if (g_video_enc_info_ptr->is_task_prepare_video_data == KAL_FALSE)
        {
#if defined(__VIDEO_EDITOR__)
            if (g_video_enc_status.scenario == VIDEO_SCENARIO_EDITOR)
            {
                g_video_enc_info_ptr->video_enc_callback(VIDEO_EDITOR_ENC_EVENT_VIDEO_BUFFER_AVAIL);
            }
            else
#endif /*__VIDEO_EDITOR__*/
            {
                g_video_enc_info_ptr->video_enc_callback(VIDEO_ENC_EVENT_VIDEO_BUFFER_AVAIL);
            }
            g_video_enc_info_ptr->is_task_prepare_video_data = KAL_TRUE;
        }
        g_video_enc_info_ptr->is_send_ilm = KAL_FALSE;
    }
#if ( defined(MT6219) || defined(MT6226) || defined(MT6227) || defined(MT6226M) )
    if (status & MP4_IRQ_STS_ENC)
#else  /*!(MT6219, MT6226, MT6227, MT6226M)*/
    if (status & MP4_ENC_IRQ_STS_ENC)
#endif /*(MT6219, MT6226, MT6227, MT6226M)*/

    {
        video_dbg_trace(MP4_ENC_HISR_OK, video_get_current_time());

        isr_error = KAL_FALSE;
#if ( defined(MT6219) || defined(MT6226) || defined(MT6227) || defined(MT6226M) )
        DRV_WriteReg32(MP4_CODEC_COMD, 0x04); // Video Object Plane Level start
        temp_ptr = DRV_Reg32(MP4_VLC_WORD);
        temp_int = DRV_Reg32(MP4_VLC_BITCNT);
        bitcnt = (temp_ptr - (kal_int32)g_video_enc_info_ptr->current_bitstream_addr) * 8 + temp_int;
        DRV_WriteReg32(MP4_VLC_COMD, MP4_VLC_COMD_STOP);
#else /*!(MT6219, MT6226, MT6227, MT6226M)*/
        temp_ptr = DRV_Reg32(MP4_ENC_VLC_WORD);
        temp_int = DRV_Reg32(MP4_ENC_VLC_BITCNT);
        bitcnt = (temp_ptr - (kal_int32)g_video_enc_info_ptr->current_bitstream_addr) * 8 + temp_int;
#endif /*(MT6219, MT6226, MT6227, MT6226M)*/

        if (g_video_enc_info_ptr->drop_bitstream == KAL_TRUE)
        {
            g_video_enc_info_ptr->force_I_frame = KAL_TRUE;

            g_video_enc_info_ptr->drop_bitstream = KAL_FALSE;
            g_video_enc_info_ptr->total_frames--;
        }
        else
        {
            if (g_video_enc_info_ptr->im.short_header == 0 && (bitcnt & 7) != 0) //??
                putbits((kal_uint8 *)g_video_enc_info_ptr->current_bitstream_addr, (kal_int32 *)&bitcnt,
                        (1 << (8 - (bitcnt % 8))) - 1,                             (8 - (bitcnt % 8)));

            g_video_enc_info_ptr->im.quantizer = RC_UPdated(g_video_enc_info_ptr->bit_rate,
                                                            g_video_enc_info_ptr->im.frame_rate,
                                                            g_video_enc_info_ptr->im.quantizer,
                                                            (kal_int32)(bitcnt + (video_toal_save_bytes * 8)),
                                                            (kal_int32)g_video_enc_info_ptr->im.predition_type,
                                                            (g_video_enc_info_ptr->hisr_total_frames + 1));

            if (g_video_enc_info_ptr->im.quantizer > 31)
                g_video_enc_info_ptr->large_quant_count++;

            frame_length = (bitcnt / 8) + (((bitcnt & 7) == 0) ? 0 : 1);

            video_enc_buffer_update_offset(frame_length);

            /*Set total file size, for size limit*/
            g_video_enc_info_ptr->total_file_size += frame_length;
#if defined(__VIDEO_EDITOR__)
            if (g_video_enc_status.scenario == VIDEO_SCENARIO_EDITOR)
            {
                g_video_enc_info_ptr->video_enc_callback(VIDEO_EDITOR_ENC_EVENT_COUNT_FILE_SIZE);
            }
            else
#endif /*__VIDEO_EDITOR__*/
            {
                g_video_enc_info_ptr->video_enc_callback(VIDEO_ENC_EVENT_COUNT_FILE_SIZE);
            }

            //time_stamp = video_enc_get_timestamp();
            result = mp4_video_enc_push_tableinfo_to_buffer(g_video_enc_info_ptr->time_stamp,
                                                            (frame_length
                                                             + video_toal_save_bytes)); //store to another buffer

            if (result != MEDIA_STATUS_OK)
            {
                VIDEO_ASSERT(0);

                MPEG4ENC_ISR_ERROR_REPORT_HANDLER();
                return;
            }

            video_enc_trigger_limit = 0;
            video_toal_save_bytes = 0;
            //address exchange
#if ( defined(MT6219) || defined(MT6226) || defined(MT6227) || defined(MT6226M) )
            temp_int = DRV_Reg32(MP4_REF_ADDR);
            DRV_WriteReg32(MP4_REF_ADDR, DRV_Reg32(MP4_REC_ADDR));
            DRV_WriteReg32(MP4_REC_ADDR, temp_int);
#else /*!(MT6219, MT6226, MT6227, MT6226M)*/
            temp_int = DRV_Reg32(MP4_ENC_REF_ADDR);
            DRV_WriteReg32(MP4_ENC_REF_ADDR, DRV_Reg32(MP4_ENC_REC_ADDR));
            DRV_WriteReg32(MP4_ENC_REC_ADDR, temp_int);
#endif /*(MT6219, MT6226, MT6227, MT6226M)*/
            g_video_enc_info_ptr->hisr_total_frames++;
        }
#if defined(__VIDEO_EDITOR__)
        if (g_video_enc_status.scenario == VIDEO_SCENARIO_EDITOR)
        {
            if (VIDEO_EDITOR_DATA.check_end_call_back() == KAL_TRUE)
            {
                video_enc_done_send_ilm(g_video_enc_info_ptr);
            }
        }
#endif /*__VIDEO_EDITOR__*/
#ifdef __L1_STANDALONE__
#ifndef __VIDEO_EDITOR__
        if (((g_video_enc_info_ptr->hisr_total_frames == TOTAL_frame_num) && (video_next == KAL_FALSE))
                || ((video_next == KAL_TRUE) && (g_video_enc_info_ptr->hisr_total_frames == (TOTAL_frame_num * 2))))
        {
            video_enc_done_send_ilm(g_video_enc_info_ptr);
        }
#endif
#endif /*__L1_STANDALONE__*/

    }
#if ( defined(MT6219) || defined(MT6226) || defined(MT6227) || defined(MT6226M) )    
    else if (status & MP4_IRQ_STS_DMA)
#else /*!(MT6219, MT6226, MT6227, MT6226M)*/
   else if(status&MP4_ENC_IRQ_STS_DMA)
#endif   /*(MT6219, MT6226, MT6227, MT6226M)*/    
    {
        video_dbg_trace(MP4_ENC_HISR_DMA, video_get_current_time());

        isr_error = KAL_FALSE;

#ifdef MT6219
        if (g_video_enc_info_ptr->im.predition_type == I_VOP)
#else  /*!MT6219*/
        if (1)
#endif /*MT6219*/
            {
                video_toal_save_bytes += video_enc_trigger_limit;

                video_enc_buffer_update_offset(video_enc_trigger_limit);
                //sendilm & switch buffer
                if (video_enc_switch_buffer(g_video_enc_info_ptr))
                {
                    ASSERT(g_video_enc_info_ptr->video_enc_callback != NULL);

                    if (g_video_enc_info_ptr->is_task_prepare_video_data == KAL_FALSE)
                    {

#if defined(__VIDEO_EDITOR__)
                        if (g_video_enc_status.scenario == VIDEO_SCENARIO_EDITOR)
                        {
                            g_video_enc_info_ptr->video_enc_callback(VIDEO_EDITOR_ENC_EVENT_VIDEO_BUFFER_AVAIL);
                        }
                        else
#endif /*__VIDEO_EDITOR__*/
                        {
                            g_video_enc_info_ptr->video_enc_callback(VIDEO_ENC_EVENT_VIDEO_BUFFER_AVAIL);
                        }
                        g_video_enc_info_ptr->is_task_prepare_video_data = KAL_TRUE;
                    }

                    //Restart this transation by assigning another buffer
                    length = video_enc_buffer_get_roomleft(g_video_enc_info_ptr);
                    g_video_enc_info_ptr->current_bitstream_addr = video_enc_buffer_get_memaddr(g_video_enc_info_ptr);

#if ( defined(MT6219) || defined(MT6226) || defined(MT6227) || defined(MT6226M) )
                    //VIDEO_ENC_WRITE_VLCLIMIT_REG(length/4);

                    DRV_WriteReg32(MP4_VLC_LIMIT, (length / 4));

                    video_enc_trigger_limit = ((length / 4) * 4);

                    DRV_WriteReg32(MP4_VLC_ADDR, g_video_enc_info_ptr->current_bitstream_addr);
                    DRV_WriteReg32(MP4_VLC_COMD, MP4_VLC_COMD_RELOAD);
#else /*!(MT6219, MT6226, MT6227, MT6226M)*/
                    DRV_WriteReg32(MP4_CORE_VLC_LIMIT, (length / 4));
                    video_enc_trigger_limit = ((length / 4) * 4);
                    DRV_WriteReg32(MP4_CORE_VLC_ADDR, g_video_enc_info_ptr->current_bitstream_addr);
                    DRV_WriteReg32(MP4_VLC_DMA_COMD, MP4_VLC_DMA_COMD_RELOAD);
#endif /*(MT6219, MT6226, MT6227, MT6226M)*/
                }
                else
                {
                    g_video_enc_info_ptr->is_need_to_check_buffer = KAL_TRUE;
                    g_video_enc_info_ptr->switch_buffer_callback = video_enc_switch_buffer_dma_callback;
                }
            }
            else /*if (g_video_enc_info_ptr->im.predition_type == I_VOP)*/
            {
                g_video_enc_info_ptr->force_I_frame = KAL_TRUE;

                g_video_enc_info_ptr->drop_bitstream = KAL_TRUE;

#if ( defined(MT6219) || defined(MT6226) || defined(MT6227) || defined(MT6226M) )
                DRV_WriteReg32(MP4_VLC_LIMIT, (512 / 4));
                DRV_WriteReg32(MP4_VLC_ADDR, (kal_uint32)resume_buffer_temp);
                DRV_WriteReg32(MP4_VLC_COMD, MP4_VLC_COMD_RELOAD);
#else /*!(MT6219, MT6226, MT6227, MT6226M)*/
                DRV_WriteReg32(MP4_CORE_VLC_LIMIT, (512 / 4));
                DRV_WriteReg32(MP4_CORE_VLC_ADDR, (kal_uint32)resume_buffer_temp);
                DRV_WriteReg32(MP4_VLC_DMA_COMD, MP4_VLC_DMA_COMD_RELOAD);
#endif /*(MT6219, MT6226, MT6227, MT6226M)*/
            }
    }

    if (isr_error)
    {
        VIDEO_ASSERT(0);

        g_video_enc_info_ptr->encode_stop = KAL_TRUE;
        g_video_enc_status.VIDEO_STATUS = VIDEO_ENC_NOT_SUPPORT;
#if ( defined(MT6219) || defined(MT6226) || defined(MT6227) || defined(MT6226M) )
        IRQMask(IRQ_MPEG4_CODE);
#else  /*!(MT6219, MT6226, MT6227, MT6226M)*/
        IRQMask(IRQ_MPEG4_ENC_CODE);
#endif /*(MT6219, MT6226, MT6227, MT6226M)*/
        VISUAL_Register_HISR(VISUAL_MPEG4_ENC_HISR_ID, MPEG4_ENC_ERROR_REPORT_HISR);
        visual_active_hisr(VISUAL_MPEG4_ENC_HISR_ID);
        return;
    }

    video_dbg_trace(MP4_ENC_HISR_END, video_get_current_time());
#if ( defined(MT6219) || defined(MT6226) || defined(MT6227) || defined(MT6226M) )
   IRQUnmask(IRQ_MPEG4_CODE);
#else  /*!(MT6219, MT6226, MT6227, MT6226M)*/
   IRQUnmask(IRQ_MPEG4_ENC_CODE);
#endif /*(MT6219, MT6226, MT6227, MT6226M)*/
#endif /*__VIDEO_GET_YUV_DATA__*/
}
#else  /*!MP4_CODEC*/
#include "drv_comm.h"
#endif /*MP4_CODEC*/