slicemae.c

au1200 linux2.6.11 硬件解码mae驱动和maiplayer播放器源码

/* <LIC_AMD_STD>
 * Copyright (c) 2005 Advanced Micro Devices, Inc.
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * The full GNU General Public License is included in this distribution in the
 * file called COPYING
 * </LIC_AMD_STD>  */
/* <CTL_AMD_STD>
 * </CTL_AMD_STD>  */
/* <DOC_AMD_STD>
 * </DOC_AMD_STD>  */
#include "config.h"

#include <inttypes.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "mpeg2.h"
#include "attributes.h"
#include "mpeg2_internal.h"
// $PP
#include "mae_pass_thru.h"
#include "defines.h"
#include "sliceMAE.h"

#define CLIP_DCT(x) \
( (x > 255 ? 255 : (x < 0 ? 0 : x)) ) \

int gBlockZeroIdct [64]   = {0};
int gBlockZeroIquant [64] = {0};
int nDMVUpdate = 0;

#ifdef NEW_MAE_DRIVER
int nDMVUpdate1 = 0;
int nDMVUpdate2 = 0;
int prog_frame = 0; // KK - rev2
#endif

extern header_words local_header;

#ifndef  NEW_MAE_DRIVER
void initialize_mcomp_ref_pointers (mpeg2_decoder_t * decoder , unsigned char ucField)
{
	reg_info                     RegisterSet;
	reg_info                     *pRegisterSet = &RegisterSet;
	int							 iBottom = 1;
	int							 offset, bottom_field;

    bottom_field	= (decoder->picture_structure == BOTTOM_FIELD);
    offset			= decoder->stride_frame;

#ifdef NO_PERF
	// clear out the valid bit mask
	memset ((void*)&RegisterSet, 0, sizeof(reg_info));
#endif //#ifdef NO_PERF

    memset ((void*)&RegisterSet, 0, sizeof(reg_info));
    pRegisterSet->regmask = 0;

    // Let us set the current pointers right here so that we can put these into the extra info in the wrapper.
    pRegisterSet->cur_y_frame_ptr = decoder->pict_dest[0];
    pRegisterSet->cur_cb_frame_ptr = decoder->pict_dest[1];
    pRegisterSet->cur_cr_frame_ptr = decoder->pict_dest[2];

	// top pointers
	pRegisterSet->fwd_y_top_ptr  = (uint32)decoder->f_motion.ref[0][0]; // forward Y top
	pRegisterSet->fwd_cb_top_ptr = (uint32)decoder->f_motion.ref[0][1]; // forward Cb top
	pRegisterSet->fwd_cr_top_ptr = (uint32)decoder->f_motion.ref[0][2]; // forward Cr top
	
	pRegisterSet->bwd_y_top_ptr  = (uint32)decoder->b_motion.ref[0][0]; // backward Y top
	pRegisterSet->bwd_cb_top_ptr = (uint32)decoder->b_motion.ref[0][1]; // backward Cb top
	pRegisterSet->bwd_cr_top_ptr = (uint32)decoder->b_motion.ref[0][2]; // backward Cr top

	// bottom pointers
	pRegisterSet->fwd_y_bot_ptr  = (uint32)decoder->f_motion.ref[0][0]  + offset;		 // forward Y bottom
	pRegisterSet->fwd_cb_bot_ptr = (uint32)decoder->f_motion.ref[0][1] + (offset >> 1); // forward Cb bottom
	pRegisterSet->fwd_cr_bot_ptr = (uint32)decoder->f_motion.ref[0][2] + (offset >> 1); // forward Cr bottom

	pRegisterSet->bwd_y_bot_ptr  = (uint32)decoder->b_motion.ref[0][0]  + offset;		 // backward Y bottom
	pRegisterSet->bwd_cb_bot_ptr = (uint32)decoder->b_motion.ref[0][1] + (offset >> 1); // backward Y bottom
	pRegisterSet->bwd_cr_bot_ptr = (uint32)decoder->b_motion.ref[0][2] + (offset >> 1); // backward Y bottom

	if (decoder->picture_structure != FRAME_PICTURE)
	{
		// Since CModel is doing the OOF calculation @ the start of each frame
		// pass all pointers here

		// forward top pointers
		pRegisterSet->fwd_y_top_ptr		= (uint32)decoder->f_motion.ref2[0][0];
		pRegisterSet->fwd_cb_top_ptr	= (uint32)decoder->f_motion.ref2[0][1];
		pRegisterSet->fwd_cr_top_ptr	= (uint32)decoder->f_motion.ref2[0][2];

		// forward bot pointers
		pRegisterSet->fwd_y_bot_ptr		= (uint32)decoder->f_motion.ref2[1][0];
		pRegisterSet->fwd_cb_bot_ptr	= (uint32)decoder->f_motion.ref2[1][1];
		pRegisterSet->fwd_cr_bot_ptr	= (uint32)decoder->f_motion.ref2[1][2];

		// backward top pointers
		pRegisterSet->bwd_y_top_ptr		= (uint32)decoder->b_motion.ref2[0][0];
		pRegisterSet->bwd_cb_top_ptr	= (uint32)decoder->b_motion.ref2[0][1];
		pRegisterSet->bwd_cr_top_ptr	= (uint32)decoder->b_motion.ref2[0][2];

		// backward bot pointers
		pRegisterSet->bwd_y_bot_ptr		= (uint32)decoder->b_motion.ref2[1][0];
		pRegisterSet->bwd_cb_bot_ptr	= (uint32)decoder->b_motion.ref2[1][1];
		pRegisterSet->bwd_cr_bot_ptr	= (uint32)decoder->b_motion.ref2[1][2];
	}

#ifndef DRV_ENABLED
	pRegisterSet->regmask =	CONFIG0_MASK      | PICTURE_SIZE_MASK |
							FWD_Y_TOP_MASK    | BWD_Y_TOP_MASK    |
							FWD_CB_TOP_MASK   | BWD_CB_TOP_MASK   |    
							FWD_CR_TOP_MASK   | BWD_CR_TOP_MASK   | 
							FWD_Y_BOT_MASK    | BWD_Y_BOT_MASK    |
							FWD_CB_BOT_MASK   | BWD_CB_BOT_MASK   |
							FWD_CR_BOT_MASK   | BWD_CR_BOT_MASK;
#else
    pRegisterSet->regmask =	CONFIG0_MASK | PICTURE_SIZE_MASK | CUR_Y_MASK | CUR_CB_MASK | CUR_CR_MASK;

#ifdef NEW_MAE_DRIVER
    if (prog_frame == 1) // KK - rev2 - Even for the case of frame picture - field prediction, we need to send the bottom reference pointers
#else
    if (decoder->picture_structure == FRAME_PICTURE)
#endif
    {
        if( decoder->coding_type == P_TYPE)
            pRegisterSet->regmask |= FWD_Y_TOP_MASK   |	FWD_CB_TOP_MASK   |  FWD_CR_TOP_MASK;
        else if(decoder->coding_type == B_TYPE)
             pRegisterSet->regmask |=   FWD_Y_TOP_MASK    | BWD_Y_TOP_MASK    |
                            							FWD_CB_TOP_MASK   | BWD_CB_TOP_MASK   |    
                            							FWD_CR_TOP_MASK   | BWD_CR_TOP_MASK ;
    }
    else
    {
        if( decoder->coding_type == P_TYPE)
            pRegisterSet->regmask |= FWD_Y_TOP_MASK   |	FWD_CB_TOP_MASK   |  FWD_CR_TOP_MASK | 
                                                       FWD_Y_BOT_MASK   | FWD_CB_BOT_MASK   |  FWD_CR_BOT_MASK;
         else if(decoder->coding_type == B_TYPE)
             pRegisterSet->regmask |=  FWD_Y_TOP_MASK    | BWD_Y_TOP_MASK    |
                                                         FWD_CB_TOP_MASK   | BWD_CB_TOP_MASK   |    
                                                         FWD_CR_TOP_MASK   | BWD_CR_TOP_MASK   | 
                                                         FWD_Y_BOT_MASK    | BWD_Y_BOT_MASK    |
                                                         FWD_CB_BOT_MASK   | BWD_CB_BOT_MASK   |
                                                         FWD_CR_BOT_MASK   | BWD_CR_BOT_MASK;
    }
#endif

	// PPKK - this may be optimized later
#ifndef NEW_MAE_DRIVER
    pRegisterSet->regmask |=	CONFIG0_MASK      | PICTURE_SIZE_MASK |
							CUR_Y_MASK | CUR_CB_MASK | CUR_CR_MASK |
                            FWD_Y_TOP_MASK    | BWD_Y_TOP_MASK    |
                            FWD_CB_TOP_MASK   | BWD_CB_TOP_MASK   |    
                            FWD_CR_TOP_MASK   | BWD_CR_TOP_MASK   | 
                            FWD_Y_BOT_MASK    | BWD_Y_BOT_MASK    |
                            FWD_CB_BOT_MASK   | BWD_CB_BOT_MASK   |
                            FWD_CR_BOT_MASK   | BWD_CR_BOT_MASK;
#endif
	// picture height and width
	pRegisterSet->picture_size.height	= decoder->height;
	pRegisterSet->picture_size.linesiz	= decoder->width;

#ifndef NO_PREF
     *((unsigned long*)&(pRegisterSet->config0)) = 0;
#endif //#ifndef NO_PREF

	// frame coding type 4:2:0 or 4:2:2
	pRegisterSet->config0.bc = decoder->chroma_format;

	// mismatch
	pRegisterSet->config0.mis	= (decoder->mpeg1 == 1) ? MAE_MISMATCH_OFF : MAE_MISMATCH_ON; 
	
    // Picture level mb mode
	pRegisterSet->config0.picture_level_mbmode = 0;

	if (nDMVUpdate)
	 {
		printf("DMV flag set: WrapSetRegisters has already been called\n");
		 return;
	 }
	WrapSetRegisters (pRegisterSet, ucField);
}


void initialize_mcomp_ref_pointers_dmv (mpeg2_decoder_t * decoder, unsigned char ucField)
{
	reg_info                 RegisterSet;
	reg_info                *pRegisterSet = &RegisterSet;

	 if (nDMVUpdate)
	 {
		 //printf("initialize_mcomp_ref_pointers_dmv: DMV flag set\n");
		 return;
	 }

    memset ((void*)&RegisterSet, 0, sizeof(reg_info));
	// clear out the valid bit mask
	pRegisterSet->regmask = 0;

	// Let us set the current pointers right here so that we can put these into the extra info in the wrapper.
    pRegisterSet->cur_y_frame_ptr = decoder->pict_dest[0];
    pRegisterSet->cur_cb_frame_ptr = decoder->pict_dest[1];
    pRegisterSet->cur_cr_frame_ptr = decoder->pict_dest[2];

	if (decoder->picture_structure != FRAME_PICTURE)
	{
		//printf("DMV: Field picture - ireftype %d\n",decoder->iRefType);  // PPKK
		if (decoder->iRefType == FORWARD_REFERENCES)
		{
			// Fake bidirectional using forward references	
			pRegisterSet->fwd_y_top_ptr  = (uint32)decoder->f_motion.ref[0][0]; // forward Y top
			pRegisterSet->fwd_cb_top_ptr = (uint32)decoder->f_motion.ref[0][1]; // forward Cb top
			pRegisterSet->fwd_cr_top_ptr = (uint32)decoder->f_motion.ref[0][2]; // forward Cr top

			pRegisterSet->bwd_y_top_ptr  = (uint32)decoder->f_motion.ref[1][0]; // backward Y top
			pRegisterSet->bwd_cb_top_ptr = (uint32)decoder->f_motion.ref[1][1]; // backward Cb top
			pRegisterSet->bwd_cr_top_ptr = (uint32)decoder->f_motion.ref[1][2]; // backward Cr top
		}
		else
		{
			// Fake bidirectional using forward references	
			pRegisterSet->fwd_y_top_ptr  = (uint32)decoder->b_motion.ref[0][0]; // forward Y top
			pRegisterSet->fwd_cb_top_ptr = (uint32)decoder->b_motion.ref[0][1]; // forward Cb top
			pRegisterSet->fwd_cr_top_ptr = (uint32)decoder->b_motion.ref[0][2]; // forward Cr top

			pRegisterSet->bwd_y_top_ptr  = (uint32)decoder->b_motion.ref[1][0]; // backward Y top
			pRegisterSet->bwd_cb_top_ptr = (uint32)decoder->b_motion.ref[1][1]; // backward Cb top
			pRegisterSet->bwd_cr_top_ptr = (uint32)decoder->b_motion.ref[1][2]; // backward Cr top
		}
	}
	else
	{
		//printf("DMV: Frame picture - ireftype %d\n", decoder->iRefType);  // PPKK
		if (decoder->iRefType == FORWARD_REFERENCES)
		{
			// Fake bidirectional using forward references	
			pRegisterSet->fwd_y_top_ptr  = (uint32)decoder->f_motion.ref[0][0]; // forward Y top
			pRegisterSet->fwd_cb_top_ptr = (uint32)decoder->f_motion.ref[0][1]; // forward Cb top
			pRegisterSet->fwd_cr_top_ptr = (uint32)decoder->f_motion.ref[0][2]; // forward Cr top

			pRegisterSet->fwd_y_bot_ptr  = pRegisterSet->fwd_y_top_ptr  + decoder->stride;     // backward Y top
			pRegisterSet->fwd_cb_bot_ptr = pRegisterSet->fwd_cb_top_ptr + decoder->uv_stride;  // backward Cb top
			pRegisterSet->fwd_cr_bot_ptr = pRegisterSet->fwd_cr_top_ptr + decoder->uv_stride;  // backward Cr top

			pRegisterSet->bwd_y_top_ptr  = pRegisterSet->fwd_y_top_ptr;
			pRegisterSet->bwd_cb_top_ptr = pRegisterSet->fwd_cb_top_ptr;
			pRegisterSet->bwd_cr_top_ptr = pRegisterSet->fwd_cr_top_ptr;

			pRegisterSet->bwd_y_bot_ptr  = pRegisterSet->fwd_y_bot_ptr;
			pRegisterSet->bwd_cb_bot_ptr = pRegisterSet->fwd_cb_bot_ptr;
			pRegisterSet->bwd_cr_bot_ptr = pRegisterSet->fwd_cr_bot_ptr;

		}
		else
		{
			// Fake bidirectional using forward references	
			pRegisterSet->fwd_y_top_ptr  = (uint32)decoder->b_motion.ref[0][0]; // forward Y top
			pRegisterSet->fwd_cb_top_ptr = (uint32)decoder->b_motion.ref[0][1]; // forward Cb top
			pRegisterSet->fwd_cr_top_ptr = (uint32)decoder->b_motion.ref[0][2]; // forward Cr top

			pRegisterSet->fwd_y_bot_ptr  = pRegisterSet->fwd_y_top_ptr  + decoder->stride;     // backward Y top
			pRegisterSet->fwd_cb_bot_ptr = pRegisterSet->fwd_cb_top_ptr + decoder->uv_stride; // backward Cb top
			pRegisterSet->fwd_cr_bot_ptr = pRegisterSet->fwd_cr_top_ptr + decoder->uv_stride; // backward Cr top

			pRegisterSet->bwd_y_top_ptr  = pRegisterSet->fwd_y_top_ptr;
			pRegisterSet->bwd_cb_top_ptr = pRegisterSet->fwd_cb_top_ptr;
			pRegisterSet->bwd_cr_top_ptr = pRegisterSet->fwd_cr_top_ptr;

			pRegisterSet->bwd_y_bot_ptr  = pRegisterSet->fwd_y_bot_ptr;
			pRegisterSet->bwd_cb_bot_ptr = pRegisterSet->fwd_cb_bot_ptr;
			pRegisterSet->bwd_cr_bot_ptr = pRegisterSet->fwd_cr_bot_ptr;
		}
	}

	nDMVUpdate = 1; // We have encountered atleast one macroblock with DMV in this frame

#ifdef NEW_MAE_DRIVER
    if(ucField)
        nDMVUpdate2 = 1;
    else
        nDMVUpdate1 = 1;
#endif

    pRegisterSet->regmask |=	CONFIG0_MASK      | PICTURE_SIZE_MASK |
							CUR_Y_MASK | CUR_CB_MASK | CUR_CR_MASK |
                            FWD_Y_TOP_MASK    | BWD_Y_TOP_MASK    |
                            FWD_CB_TOP_MASK   | BWD_CB_TOP_MASK   |    
                            FWD_CR_TOP_MASK   | BWD_CR_TOP_MASK   | 
                            FWD_Y_BOT_MASK    | BWD_Y_BOT_MASK    |
                            FWD_CB_BOT_MASK   | BWD_CB_BOT_MASK   |
                            FWD_CR_BOT_MASK   | BWD_CR_BOT_MASK;

	//printf("\n *******dmv : mask = %08x",pRegisterSet->regmask);

	// picture height and width
	pRegisterSet->picture_size.height	= decoder->height;
	pRegisterSet->picture_size.linesiz	= decoder->width;

	// frame coding type 4:2:0 or 4:2:2
	pRegisterSet->config0.bc = decoder->chroma_format;

	// mismatch
	pRegisterSet->config0.mis	= (decoder->mpeg1 == 1) ? MAE_MISMATCH_OFF : MAE_MISMATCH_ON; 

    // Picture level mb mode
	pRegisterSet->config0.picture_level_mbmode = 0;

    printf("DUAL PRIME\n"); // PPKK
	WrapSetRegisters (pRegisterSet, ucField);
}
#endif


uint32 initialize_mcomp_motion_vectors_dmv (wrap_context *pWrapContext,  mpeg2_decoder_t * decoder, int macroblock_modes)
{
	int iXShift, iYShift;
	int iYSpec = 0;
	uint32 uiNumMVs = 0;
    header_words *pHeader;
    uint32 *pMV;
	uint32 *pWrapMB;


	if (!pWrapContext)
		return 0;

	pHeader = &local_header;//pWrapContext->pHeader;

    /* Get a pointer to the motion vectors */
	pWrapMB = pWrapContext->pMB;
    //pMV		= pWrapContext->pMV = WRAPSKIPMVS(pWrapMB, (decoder->bInterMatrixChanged ? 2 : 0), 0);
    pMV		= pWrapContext->pMV;

	// Macro Block mode							
	// fake bidirectional
	pHeader->header_word2.mbmode = MBMODE_BID_ALL_420;

	// DCT type
	if (macroblock_modes & DCT_TYPE_INTERLACED)
		pHeader->header_word3.dctt = MAE_DCT_TYPE_FIELD;
	else
		pHeader->header_word3.dctt = MAE_DCT_TYPE_FRAME;

	if (decoder->picture_structure != FRAME_PICTURE)
	{
		// special case; FIELD PICTURE with DMV
		
		// enable field prediction
		pHeader->header_word3.fp = MAE_FIELD_PREDICTION;

		// mbtype
		pHeader->header_word3.mbtype = MBT_16x16;

		// set as if BiDirectional
		pHeader->header_word3.ft = 
		pHeader->header_word3.fb = 
		pHeader->header_word3.bt = 
		pHeader->header_word3.bb = 1;
	}
	else
	{
		// special case; FRAME PICTURE with DMV
		
		// enable field prediction
		pHeader->header_word3.fp = MAE_FIELD_PREDICTION;

		// mbtype
		pHeader->header_word3.mbtype = MBT_16x8;

		// Set as BiDirectional
		pHeader->header_word3.ft = (decoder->fwd_top_motion_vertical_field_select == 0) ? 1 : 0;
		pHeader->header_word3.fb = (decoder->fwd_bot_motion_vertical_field_select == 0) ? 1 : 0;
		pHeader->header_word3.bt = (decoder->bwd_top_motion_vertical_field_select == 0) ? 1 : 0;
		pHeader->header_word3.bb = (decoder->bwd_bot_motion_vertical_field_select == 0) ? 1 : 0;
	}
	

    iXShift = iYShift = 1;

	// CHROMA motion vectors
	switch (decoder->chroma_format)
	{
		// 4:2:0
		case 0:
			iXShift = iYShift = 2;
			break;

		// 4:2:2
		case 1:
			iXShift = 2;
			iYShift = 1;
			break;

		// 4:4:4
		case 2:
		    // no change	
			break;
	};

    switch(pHeader->header_word3.mbtype)
    {
        case MBT_16x8:
            if (pHeader->header_word2.mbmode == MBMODE_BID_ALL_420)
            {
				uiNumMVs = 8;
            }
            else
            {
                // FWD or BWD
				uiNumMVs = 6;
            }
            break;

        case MBT_16x16:
            if (pHeader->header_word2.mbmode == MBMODE_BID_ALL_420)
            {
				uiNumMVs = 6;
            }
            else
            {
                // FWD or BWD
				uiNumMVs = 5;
            }
            break;
    }

	// special case; FIELD PICTURE with DMV
	// handled as if 16x16 BiDirectional
	if (decoder->picture_structure != FRAME_PICTURE)
	{
		pMV[0] =
		pMV[1] = ( ((decoder->f_motion.pmv[0][0] << 16) & 0xFFFF0000) |
			       ((decoder->f_motion.pmv[0][1]) & 0x0000FFFF) );

		pMV[2] =
		pMV[3] = ( ((decoder->other_x << 16) & 0xFFFF0000) |
				   ((decoder->other_y) & 0x0000FFFF) );


		pMV[4] = ( (( (decoder->f_motion.pmv[0][0]/iXShift) << 16) & 0xFFFF0000) |
				   ( ((decoder->f_motion.pmv[0][1])/iYShift) & 0x0000FFFF) );

		pMV[5] = ( (( (decoder->other_x/iXShift) << 16) & 0xFFFF0000) |
				   ( ((decoder->other_y)/iYShift) & 0x0000FFFF) );
	}