softidct.c

大名鼎鼎的CE下播放软件,TCPPMP的源代码!!!2410下可以流畅的解QVGA的H264,MPEG4等格式.

		break;
	}

	if (No>=IDCT_FRAMENO && No<IDCT_FRAMENO+p->BufCount)
		SETVALUE(p->BufFrameNo[No-IDCT_FRAMENO],int,ERR_NONE);

	return Result;
}

static int Get(softidct* p, int No, void* Data, int Size)
{
	int Result = ERR_INVALID_PARAM;
	switch (No)
	{
	case FLOW_BUFFERED: GETVALUE(1,bool_t); break;
	case IDCT_OUTPUT|PIN_PROCESS: GETVALUE(p->Out.Process,packetprocess); break;
	case IDCT_OUTPUT|PIN_FORMAT: GETVALUE(p->Out.Format,packetformat); break;
	case IDCT_OUTPUT: GETVALUE(p->Out.Pin,pin); break;
	case IDCT_FORMAT: GETVALUE(p->Out.Format.Format.Video,video); break;
	case IDCT_ROUNDING: GETVALUE(p->Rounding,bool_t); break;
	case IDCT_SHIFT: GETVALUE(p->Shift,int); break;
	case IDCT_MODE: GETVALUE(p->Mode,int); break;
	case IDCT_BUFFERCOUNT: GETVALUE(p->BufCount - p->LastTemp,int); break;
	case IDCT_BUFFERWIDTH: GETVALUE(p->BufferWidth,int); break;
	case IDCT_BUFFERHEIGHT: GETVALUE(p->BufferHeight,int); break;
	case IDCT_SHOW: GETVALUE(p->ShowNext,int); break;
	case IDCT_BACKUP: 
		assert(Size == sizeof(idctbackup));
		Result = IDCTBackup(&p->IDCT,(idctbackup*)Data);
		break;
	}
	if (No>=IDCT_FRAMENO && No<IDCT_FRAMENO+p->BufCount)
		GETVALUE(p->BufFrameNo[No-IDCT_FRAMENO],int);
	return Result;
}

static void Drop(softidct* p)
{
	int i;
	for (i=0;i<p->BufCount;++i)
		p->BufFrameNo[i] = -1;
}

static int Null(softidct* p,const flowstate* State,bool_t Empty)
{
	packet* Packet = NULL;
	packet EmptyPacket;
	flowstate DropState;
	if (!State)
	{
		DropState.CurrTime = TIME_UNKNOWN;
		DropState.DropLevel = 1;
		State = &DropState;
	}
	if (Empty)
	{
		memset(&EmptyPacket,0,sizeof(EmptyPacket));
		EmptyPacket.RefTime = TIME_UNKNOWN;
		Packet = &EmptyPacket;
	}
	return p->Out.Process(p->Out.Pin.Node,Packet,State);
}

static int Send(softidct* p,tick_t RefTime,const flowstate* State)
{
	packet Packet;
	int Result = ERR_INVALID_DATA;

	if (State->DropLevel)
		return p->Out.Process(p->Out.Pin.Node,NULL,State);

	if (p->ShowNext < 0)
		return ERR_NEED_MORE_DATA;

	if (p->ShowCurr == p->ShowNext)
		p->ShowCurr = -1;

	if (Lock(p,p->ShowNext,*(planes*)&Packet.Data,NULL,NULL) == ERR_NONE)
	{
		Lock(p,p->ShowCurr,*(planes*)&Packet.LastData,NULL,NULL);

		Packet.RefTime = RefTime;
		Result = p->Out.Process(p->Out.Pin.Node,&Packet,State);

		Unlock(p,p->ShowCurr);
		Unlock(p,p->ShowNext);
	}

	if (Result != ERR_BUFFER_FULL)
		p->ShowCurr = p->ShowNext;

	return Result;
}

static int FrameStart(softidct* p,int FrameNo,int* OldFrameNo,int DstNo,int BackNo,int FwdNo,int ShowNo,bool_t Drop)
{
#if defined(MIPS64_WIN32) 
	// win32 doesn't support 64bit natively. thread and process
	// changes won't save upper part of 64bit registers.
	// we have to disable interrupt and make sure all 1KB
	// code pages are in memory so no page loading is called
	// during code execution 
	p->KMode = KernelMode(1);
	TouchPages(p);	
	DisableInterrupts();
	p->NextIRQ = 0;
#endif

	if (!p->CopyBlock && (BackNo>=0 || FwdNo>=0))
		return ERR_NOT_SUPPORTED;

#ifdef ARM
	// ShowCurr will be the next "LastData" in output packet
	// we don't want to lose it's content
	if (p->NeedLast && p->ShowCurr == DstNo)
	{
		int SwapNo;
		for (SwapNo=0;SwapNo<p->BufCount;++SwapNo)
			if (SwapNo != DstNo && SwapNo != BackNo && SwapNo != FwdNo && SwapNo != ShowNo)
				break;

		if (SwapNo < p->BufCount || SetBufferCount(p,p->BufCount,1)==ERR_NONE)
		{
			//DEBUG_MSG2("IDCT Swap %d,%d",SwapNo,DstNo);
			block Tmp;
			
			Tmp = p->_Buffer[SwapNo];
			p->_Buffer[SwapNo] = p->_Buffer[DstNo];
			p->_Buffer[DstNo] = Tmp;

			SwapPByte(&p->Buffer[SwapNo],&p->Buffer[DstNo]);
			SwapInt(&p->BufFrameNo[SwapNo],&p->BufFrameNo[DstNo]);
			SwapBool(&p->BufBorder[SwapNo],&p->BufBorder[DstNo]);
			SwapInt(&p->BufAlloc[SwapNo],&p->BufAlloc[DstNo]);

			p->ShowCurr = SwapNo;
		}
	}
#endif

	p->ShowNext = ShowNo;

	if (OldFrameNo)
		*OldFrameNo = p->BufFrameNo[DstNo];
	p->BufFrameNo[DstNo] = FrameNo;

	p->Dst = p->Buffer[DstNo];
	p->Ref[0] = NULL;
	p->Ref[1] = NULL;
	p->RefMin[0] = NULL;
	p->RefMin[1] = NULL;
	p->RefMax[0] = NULL;
	p->RefMax[1] = NULL;

	if (BackNo>=0)
	{
		p->Ref[0] = p->Buffer[BackNo];
		if (!p->BufBorder[BackNo])
		{
			p->BufBorder[BackNo] = 1;
			FillEdgeYUV(p,p->Ref[0]);
		}
		p->RefMin[0] = p->Ref[0];
		p->RefMax[0] = p->Ref[0] + p->BufSize - ((8+8*p->BufWidthUV)>>p->Shift);
	}

	if (FwdNo>=0)
	{
		p->Ref[1] = p->Buffer[FwdNo];
		if (!p->BufBorder[FwdNo])
		{
			p->BufBorder[FwdNo] = 1;
			FillEdgeYUV(p,p->Ref[1]);
		}
		p->RefMin[1] = p->Ref[1];
		p->RefMax[1] = p->Ref[1] + p->BufSize - ((8+8*p->BufWidthUV)>>p->Shift);
	}

	p->BufBorder[DstNo] = 0; //invalidate border for dst

#if !defined(MIPS64)

#if defined(CONFIG_IDCT_LOWRES)
	if (p->Shift == 1)
		p->IDCT.Inter8x8 = p->Ref[1]!=NULL?(idctinter)Inter8x8BackFwdHalf:(idctinter)Inter8x8BackHalf;
	else
#endif
#ifdef CONFIG_IDCT_SWAP
	if (p->Out.Format.Format.Video.Direction & DIR_SWAPXY)
		p->IDCT.Inter8x8 = p->Inter8x8Swap[p->Ref[1]!=NULL];
	else
#endif
		p->IDCT.Inter8x8 = p->Inter8x8[p->Ref[1]!=NULL];
#endif

	p->inter8x8uv = p->IDCT.Inter8x8; // for qpel

#ifdef FREESCALE_MX1
	if (p->MX1)
		p->MX1Pop = MX1PopNone;
#endif

	return ERR_NONE;
} 

static void FrameEnd(softidct* p)
{
#ifdef MIPS64_WIN32
	EnableInterrupts();
	KernelMode(p->KMode);
#endif
#ifdef FREESCALE_MX1
	if (p->MX1)
		p->MX1Pop(p);
#endif
}

static int Create(softidct* p)
{
#if defined(MMX)
	if (!(QueryPlatform(PLATFORM_CAPS) & CAPS_X86_MMX))
		return ERR_NOT_SUPPORTED;
#endif

#if defined(MIPS64)
	if (!QueryAdvanced(ADVANCED_VR41XX))
		return ERR_NOT_SUPPORTED;

#if defined(MIPSVR41XX)
	if (!(QueryPlatform(PLATFORM_CAPS) & CAPS_MIPS_VR4120))
		return ERR_NOT_SUPPORTED;
#endif
#endif

	p->IDCT.Get = (nodeget)Get;
	p->IDCT.Set = (nodeset)Set;
	p->IDCT.Send = (idctsend)Send;
	p->IDCT.Null = (idctnull)Null;
	p->IDCT.Drop = (idctdrop)Drop;
	p->IDCT.Lock = (idctlock)Lock;
	p->IDCT.Unlock = (idctunlock)Unlock;
	p->IDCT.FrameStart = (idctframestart)FrameStart;
	p->IDCT.FrameEnd = (idctframeend)FrameEnd;

#if !defined(MIPS64) && !defined(MIPS32)
	p->AddBlock[0] = AddBlock;
	p->AddBlock[1] = AddBlockHor;
	p->AddBlock[2] = AddBlockVer;
	p->AddBlock[3] = AddBlockHorVer;
#endif

	memcpy(p->AllCopyBlock,AllCopyBlock,sizeof(AllCopyBlock));

	p->Intra8x8 = (idctintra)Intra8x8;

#ifndef MIPS64
	p->Inter8x8[0] = (idctinter)Inter8x8Back;
	p->Inter8x8[1] = (idctinter)Inter8x8BackFwd;
	p->QPELInter = (idctinter)Inter8x8QPEL;
	p->QPELCopyBlockM = (copyblock)CopyBlockM;
	p->Inter8x8GMC = (idctinter)Inter8x8GMC;
#endif

#ifdef CONFIG_IDCT_SWAP
	p->Intra8x8Swap = (idctintra)Intra8x8Swap;

#ifndef MIPS64
	p->Inter8x8Swap[0] = (idctinter)Inter8x8BackSwap;
	p->Inter8x8Swap[1] = (idctinter)Inter8x8BackFwdSwap;
#endif
#endif 

#if defined(MIPS64_WIN32) 
	CodeFindPages(*(void**)&p->IDCT.Enum,&p->CodeBegin,&p->CodeEnd,&p->CodePage);
#endif

#if defined(ARM)

#if defined(FREESCALE_MX1)
	if (QueryPlatform(PLATFORM_MODEL)==MODEL_ZODIAC)
	{
		p->MX1 = (int*)0x80022500;

		p->Intra8x8 = (idctintra)MX1Intra8x8;
		p->Inter8x8[0] = (idctinter)MX1Inter8x8Back;
		p->Inter8x8[1] = (idctinter)MX1Inter8x8BackFwd;

#ifdef CONFIG_IDCT_SWAP
		p->Intra8x8Swap = (idctintra)MX1Intra8x8Swap;
		p->Inter8x8Swap[0] = (idctinter)MX1Inter8x8BackSwap;
		p->Inter8x8Swap[1] = (idctinter)MX1Inter8x8BackFwdSwap;
#endif
	}
	else
#endif

#if (!defined(TARGET_PALMOS) && !defined(TARGET_SYMBIAN)) || (__GNUC__>=4) || (__GNUC__==3 && __GNUC_MINOR__>=4)
	if (!QueryAdvanced(ADVANCED_NOWMMX) && 
		(QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_WMMX))
	{
		p->Intra8x8 = (idctintra)WMMXIntra8x8;
		p->Inter8x8[0] = (idctinter)WMMXInter8x8Back;
		p->Inter8x8[1] = (idctinter)WMMXInter8x8BackFwd;
		p->QPELInter = (idctinter)WMMXInter8x8QPEL;
		p->Inter8x8GMC = (idctinter)WMMXInter8x8GMC;
		p->QPELCopyBlockM = (copyblock)WMMXCopyBlockM;

#ifdef CONFIG_IDCT_SWAP
		p->Intra8x8Swap = (idctintra)WMMXIntra8x8Swap;
		p->Inter8x8Swap[0] = (idctinter)WMMXInter8x8BackSwap;
		p->Inter8x8Swap[1] = (idctinter)WMMXInter8x8BackFwdSwap;
#endif

		p->AllCopyBlock[0][0] = WMMXCopyBlock;
		p->AllCopyBlock[0][1] = WMMXCopyBlockHor;
		p->AllCopyBlock[0][2] = WMMXCopyBlockVer;
		p->AllCopyBlock[0][3] = WMMXCopyBlockHorVer;
		p->AllCopyBlock[1][0] = WMMXCopyBlock;
		p->AllCopyBlock[1][1] = WMMXCopyBlockHorRound;
		p->AllCopyBlock[1][2] = WMMXCopyBlockVerRound;
		p->AllCopyBlock[1][3] = WMMXCopyBlockHorVerRound;
		p->AddBlock[0] = WMMXAddBlock;
		p->AddBlock[1] = WMMXAddBlockHor;
		p->AddBlock[2] = WMMXAddBlockVer;
		p->AddBlock[3] = WMMXAddBlockHorVer;
	}
	else
#endif // TARGET_PALMOS
	{}
/*	if (QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_5E)
	{
		if (QueryPlatform(PLATFORM_ICACHE) >= 32768)
		{
			p->AllCopyBlock[0][0] = FastCopyBlock;
			p->AllCopyBlock[0][1] = FastCopyBlockHor;
			p->AllCopyBlock[0][2] = FastCopyBlockVer;
			p->AllCopyBlock[0][3] = FastCopyBlockHorVer;
			p->AllCopyBlock[0][0] = FastCopyBlock;
			p->AllCopyBlock[1][1] = FastCopyBlockHorRound;
			p->AllCopyBlock[1][2] = FastCopyBlockVerRound;
			p->AllCopyBlock[1][3] = FastCopyBlockHorVerRound;
			p->AddBlock[0] = FastAddBlock;
			p->AddBlock[1] = FastAddBlockHor;
			p->AddBlock[2] = FastAddBlockVer;
			p->AddBlock[3] = FastAddBlockHorVer;
		}
		else
		{
			p->AllCopyBlock[0][0] = PreLoadCopyBlock;
			p->AllCopyBlock[0][1] = PreLoadCopyBlockHor;
			p->AllCopyBlock[0][2] = PreLoadCopyBlockVer;
			p->AllCopyBlock[0][3] = PreLoadCopyBlockHorVer;
			p->AllCopyBlock[0][0] = PreLoadCopyBlock;
			p->AllCopyBlock[1][1] = PreLoadCopyBlockHorRound;
			p->AllCopyBlock[1][2] = PreLoadCopyBlockVerRound;
			p->AllCopyBlock[1][3] = PreLoadCopyBlockHorVerRound;
			p->AddBlock[0] = PreLoadAddBlock;
			p->AddBlock[1] = PreLoadAddBlockHor;
			p->AddBlock[2] = PreLoadAddBlockVer;
			p->AddBlock[3] = PreLoadAddBlockHorVer;
		}
	}
*/

#endif //ARM

	p->Tmp = (uint8_t*)ALIGN16((uintptr_t)p->_Tmp);
	p->MaxCount = MAXBUF;
	p->BufCount = 0;
	p->LastTemp = 0;
	p->ShowCurr = -1;
	p->ShowNext = -1;

	return ERR_NONE;
}

static const nodedef SoftIDCT =
{
	sizeof(softidct),
#if defined(MPEG4_EXPORTS)
	MPEG4IDCT_ID,
	IDCT_CLASS,
	PRI_DEFAULT+20,
#elif defined(MSMPEG4_EXPORTS)
	MSMPEG4IDCT_ID,
	IDCT_CLASS,
	PRI_DEFAULT+10,
#else
	SOFTIDCT_ID,
	IDCT_CLASS,
	PRI_DEFAULT,
#endif
	(nodecreate)Create,
};

void SoftIDCT_Init()
{
	NodeRegisterClass(&SoftIDCT);
}

void SoftIDCT_Done()
{
	NodeUnRegisterClass(SoftIDCT.Class);
}