hwlprivate.c

这是一个SIGMA方案的PMP播放器的UCLINUX程序,可播放DVD,VCD,CD MP3...有很好的参考价值.

	if ((pDp->PropSet == VIDEO_SET) && (pDp->PropId == evDestinationWindow))
	{
		if (pQ->destination_pending)
		{
			QLOCK ();
			memcpy (pDp->pValue, &pQ->destination_wnd, sizeof(pQ->destination_wnd));
			QUNLOCK ();
		}
		return 0;
	}

	rc=(IDecoderBoard_GetProperty(pQ->H.pIDecoderBoard,pDp->PropSet,pDp->PropId,0,pDp->pValue,pDp->PropTypeLength,NULL)==Q_OK)?0:-1;

	return rc;
}

int hwlprivate_play(struct quasarprivate *pQ,unsigned int mode)
{
	int rc=-EINVAL;
	
	// XXX vincent
	// we have to serialize IDecoderBoard_VideoHwPlay with the ISR
	// or else we will randomly get garbage osd on the display
	QLOCK();
	if (mode == VideoHwPlayIFrameReverse)
	{
		// we have to send VideoHwPlayIFrameReverse command before setting
		// the initial scr or else the command will not work
		IDecoderBoard_AudioHwPlay(pQ->H.pIDecoderBoard);
		IDecoderBoard_VideoHwPlay(pQ->H.pIDecoderBoard, VideoHwPlayIFrameReverse, 0);
		pQ->play_pending = 0;
		rc = 0;
	}
	else
	{			
		rc = 0;
		pQ->play_pending = 1;
		pQ->play_mode = mode;
	}
	QUNLOCK();
	

	if (rc==0) {
		pQ->H.decoder_stopped=0;
		pQ->H.decoder_paused=0;
	}
	
	return rc;
}

int hwlprivate_stop(struct quasarprivate *pQ)
{
	int rc=-EINVAL, i;
	feedpacket *pP;

	QLOCK();

	// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
	// do this to synchronize the video stop with the osd drawing
	// if you do not do this, you can potentially see osd garbage 
	// on the display
	// we have a timeout of 12*15ms = 90ms
	for (i=0; i<12; i++)
	{
		IDecoderBoard_FreeConsumedData (pQ->H.pIDecoderBoard, OSD, &pQ->H.OsdEventPending);
		if (osdfb_refresh(pQ))
			break;
		mdelay (15);
	}
	// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

	pQ->play_pending = 0;
	if (pQ->H.is_mpeg4 && pQ->O.active)
		IDecoderBoard_OsdWriteCommand (pQ->H.pIDecoderBoard, OSD_OFF);
	rc=(IDecoderBoard_VideoHwStop(pQ->H.pIDecoderBoard)==Q_OK)?0:-1;
	if (pQ->H.is_mpeg4 && pQ->O.active)
		IDecoderBoard_OsdWriteCommand (pQ->H.pIDecoderBoard, OSD_ON);
	IDecoderBoard_FlushPacketsFifo(pQ->H.pIDecoderBoard,VIDEO,
				       &pQ->H.VideoEventPending);
	IDecoderBoard_AudioHwStop(pQ->H.pIDecoderBoard);
	IDecoderBoard_FlushPacketsFifo(pQ->H.pIDecoderBoard,AUDIO,
				       &pQ->H.AudioEventPending);
	IDecoderBoard_FlushPacketsFifo(pQ->H.pIDecoderBoard,SUBPICTURE,
				       &pQ->H.SpuEventPending);

	pQ->H.VideoByteCounter=0;
	pQ->H.SetSTC=1;
	pQ->H.VideoEventPending=0;
	pQ->H.AudioByteCounter=0;
	pQ->H.AudioEventPending=0;
	pQ->H.SpuByteCounter=0;
	pQ->H.SpuEventPending=0;

	IDecoderBoard_InitPacketsFifo(pQ->H.pIDecoderBoard,VIDEO);
	IDecoderBoard_InitPacketsFifo(pQ->H.pIDecoderBoard,AUDIO);
	IDecoderBoard_InitPacketsFifo(pQ->H.pIDecoderBoard,SUBPICTURE);

	// Flush packets Qs
	while((pP=getFeedPacket(pVideoQ))) {
		OSCompleteIo(0,pP->packet.pOverlapped);
		nextFeedPacket(pVideoQ);
	}
	while((pP=getFeedPacket(pAudioQ))) {
		OSCompleteIo(0,pP->packet.pOverlapped);
		nextFeedPacket(pAudioQ);
	}
	while((pP=getFeedPacket(pSpuQ))) {
		OSCompleteIo(0,pP->packet.pOverlapped);
		nextFeedPacket(pSpuQ);
	}
	
	pQ->H.pts_delay = 0;
	pQ->H.pts_delay_valid = 0;	

	QUNLOCK();

	pQ->H.decoder_stopped = 1;

	return rc;
}

int hwlprivate_pause(struct quasarprivate *pQ)
{
	int rc=-EINVAL;	

	QLOCK();
	rc=(IDecoderBoard_VideoHwPause(pQ->H.pIDecoderBoard)==Q_OK)?0:-1;
	IDecoderBoard_AudioHwPause(pQ->H.pIDecoderBoard);
	pQ->play_pending = 0;
	QUNLOCK();
	
	if (rc==0) {
		pQ->H.decoder_paused=1;
		pQ->H.decoder_stopped=0;
	}
	
	return rc;
}

int hwlprivate_audioswitch(struct quasarprivate *pQ,int activate)
{  
	int rc=-EINVAL;
	feedpacket *pP;
	CQuasarBoard *this = (CQuasarBoard*)pQ->H.pIDecoderBoard;
	
	if(pQ->H.decoder_stopped)
		return Q_OK;

	if (activate) {
		QLOCK ();
		if(pQ->H.decoder_paused) {
			rc=(IDecoderBoard_AudioHwPause(pQ->H.pIDecoderBoard)
			    ==Q_OK)?0:-1;
		}else{
			rc=(IDecoderBoard_AudioHwPlay(pQ->H.pIDecoderBoard)
			    ==Q_OK)?0:-1;
		}
//XXX we shouldnt have this 
//		IDecoderBoard_AudioHwPlay(pQ->H.pIDecoderBoard);

		// XXX vincent - this is a hack so that audio discontinities
		// will not cause the scr to be reset - this makes the
		// transistion from normal playback to slow much better.
		// actually the hwlibrary should take care of this		
		//this->FirstSystemSCR = TRUE;
		QUNLOCK ();
	} else {
		QLOCK ();
		rc=(IDecoderBoard_AudioHwStop(pQ->H.pIDecoderBoard)
		    ==Q_OK)?0:-1;
		IDecoderBoard_FlushPacketsFifo(pQ->H.pIDecoderBoard,AUDIO,
					       &pQ->H.AudioEventPending);
		pQ->H.AudioByteCounter=0;
		pQ->H.AudioEventPending=0;
		IDecoderBoard_InitPacketsFifo(pQ->H.pIDecoderBoard,AUDIO);

		// XXX - flush our FeedQ
		while((pP=getFeedPacket(pAudioQ))) {
			OSCompleteIo(0,pP->packet.pOverlapped);
			nextFeedPacket(pAudioQ);
		}
		// XXX vincent - this is a hack so that audio discontinities
		// will not cause the scr to be reset - this makes the
		// transistion from normal playback to slow much better.
		// actually the hwlibrary should take care of this
		if (pQ->H.VideoByteCounter)
			this->FirstSystemSCR = FALSE;
		pQ->H.pts_delay = 0;
		pQ->H.pts_delay_valid = 0;
		QUNLOCK ();
	}

	return rc;
}

//XXX do we need this?
#if 0 
int hwlprivate_seek(struct quasarprivate *pQ,struct SEEK_s *pS)
{
	return (IDecoderBoard_VideoHwSeek(pQ->H.pIDecoderBoard,
					  pS->FrameNumberInGop,
					  pS->NumberOfGopsSent,
					  pS->Backward)==Q_OK)?0:-1;
}

int hwlprivate_discard_remaining(struct quasarprivate *pQ)
{
	BYTE FrameNumberInGop;

	FrameNumberInGop=IDecoder_GetFrameNumberInGOP(pQ->H.pIDecoder);
	IDecoderBoard_SetFrameEvent(pQ->H.pIDecoderBoard,1);
	IDecoderBoard_VideoWriteCommand(pQ->H.pIDecoderBoard,VIDEO_STOP);
	pQ->H.VideoByteCounter=0;
	pQ->H.SetSTC=1;
	IDecoderBoard_InitPacketsFifo(pQ->H.pIDecoderBoard,VIDEO);

	return FrameNumberInGop;
}
#endif

int hwlprivate_clearscreen(struct quasarprivate *pQ)
{
	int qr;
	qr= IDecoderBoard_VideoWriteCommand(pQ->H.pIDecoderBoard,
					    VIDEO_BLACKFRAME_UNPACKED);
	if(qr != Q_OK) {
		pQprintk("clearscreen: BlackFrame failed !!\n");
		return -1;
	}
	return 0;
}

int hwlprivate_displayYUV(struct quasarprivate *pQ, YUVframe *pF)
{
	unsigned char *pY, *pUV;
	unsigned long i,n,offset;

	IDecoder_WriteDisplayFrameYUV(pQ->H.pIDecoder,
				      pF->Yaddr, pF->pY, pF->nYbytes,
				      pF->UVaddr, pF->pUV, pF->nUVbytes);

//FIXME Should we check WriteDisplayYUV return value

	return 0;
}

int hwlprivate_freeconsumeddata(struct quasarprivate *pQ)
{
	feedpacket *pP;

	QLOCK ();
	IDecoderBoard_FreeConsumedData (pQ->H.pIDecoderBoard, VIDEO, &pQ->H.VideoEventPending);
	IDecoderBoard_FreeConsumedData (pQ->H.pIDecoderBoard, AUDIO, &pQ->H.AudioEventPending);
	IDecoderBoard_FreeConsumedData (pQ->H.pIDecoderBoard, SPU, &pQ->H.SpuEventPending);

	while(((pP=getFeedPacket(pVideoQ))!=NULL) 
	      && (hwlprivate_feedme(pQ,pP)==0))
		nextFeedPacket(pVideoQ);

	while(((pP=getFeedPacket(pAudioQ))!=NULL)
	      && (hwlprivate_feedme(pQ,pP)==0))
		nextFeedPacket(pAudioQ);

	while(((pP=getFeedPacket(pSpuQ))!=NULL)
	      && (hwlprivate_feedme(pQ,pP)==0))
		nextFeedPacket(pSpuQ);

	QUNLOCK ();
	return 0;
}

int hwlprivate_getdebuginfo(struct quasarprivate *pQ, em84xxdebuginfo *pI)
{
	DATA_FIFO vdf, adf, sdf;
	PACKETS_FIFO vpf, apf, spf;
	unsigned long i, j, k;
	CQuasar *this = (CQuasar*)pQ->H.pIDecoder;
	Q4SymbolTable *pQ4 = (Q4SymbolTable*)this->pQ;
	PTS_FIFO *vptsf = &(this->PtsFifo[VIDEO]);
	PTS_FIFO *aptsf = &(this->PtsFifo[AUDIO]);
	PTS_FIFO *sptsf = &(this->PtsFifo[SUBPICTURE]);

	QLOCK ();

	// fifo information
	IDecoder_GetDataFifoInfo (pQ->H.pIDecoder, VIDEO, &vdf);
	IDecoder_GetDataFifoInfo (pQ->H.pIDecoder, AUDIO, &adf);
	IDecoder_GetDataFifoInfo (pQ->H.pIDecoder, SUBPICTURE, &sdf);
	IDecoder_GetPacketsFifoInfo (pQ->H.pIDecoder, VIDEO, &vpf);
	IDecoder_GetPacketsFifoInfo (pQ->H.pIDecoder, AUDIO, &apf);
	IDecoder_GetPacketsFifoInfo (pQ->H.pIDecoder, SUBPICTURE, &spf);

	// video information
	pI->video_command = IDecoder_GetCommand (pQ->H.pIDecoder, VIDEO);
	pI->video_status = IDecoder_GetStatus (pQ->H.pIDecoder, VIDEO);

	// audio information
	pI->audio_command = IDecoder_GetCommand (pQ->H.pIDecoder, AUDIO);
	pI->audio_status = IDecoder_GetStatus (pQ->H.pIDecoder, AUDIO);

	// spu information
	pI->subpi_command = IDecoder_GetCommand (pQ->H.pIDecoder, SUBPICTURE);
	pI->subpi_status = IDecoder_GetStatus (pQ->H.pIDecoder, SUBPICTURE);

	// misc information
	pI->microcode_overlay_address = IDecoder_GetMicrocodeOverlayAddr (pQ->H.pIDecoder);
	pI->microcode_error_code = IDecoder_GetErrorCode (pQ->H.pIDecoder);
	pI->irq_mask = IDecoder_GetIrqMask (pQ->H.pIDecoder);
	pI->irq_status = IDecoder_GetIrqStatus (pQ->H.pIDecoder);
	pI->irq_divider = IDecoder_GetIrqDivider (pQ->H.pIDecoder);
	
	pI->last_video_pts_sent	= pQ->last_video_pts_sent;
	pI->scr_when_last_video_pts_was_sent = pQ->scr_when_last_video_pts_was_sent;
	pI->last_audio_pts_sent	= pQ->last_audio_pts_sent;
	pI->scr_when_last_audio_pts_was_sent = pQ->scr_when_last_audio_pts_was_sent;
	pI->video_pts_last_pts_decoded = IDecoderBoard_ReadHwPts45k (pQ->H.pIDecoder);

	// pts fifo info
	k = 0;
	for (i=0; i<vptsf->Size; i++)
	{
		for (j=0; j<vptsf->EntrySize; j++)
		{
			pI->video_pts_fifo[k] = IDecoder_ReadDM (pQ->H.pIDecoder, vptsf->Start + k);
			if (++k > 38*4)
				break;
		}
	}
	k = 0;
	for (i=0; i<aptsf->Size; i++)
	{
		for (j=0; j<aptsf->EntrySize; j++)
		{
			pI->audio_pts_fifo[k] = IDecoder_ReadDM (pQ->H.pIDecoder, aptsf->Start + k);
			if (++k > 32*5)
				break;
		}
	}
	k = 0;
	for (i=0; i<sptsf->Size; i++)
	{
		for (j=0; j<sptsf->EntrySize; j++)
		{
			pI->subpi_pts_fifo[k] = IDecoder_ReadDM (pQ->H.pIDecoder, sptsf->Start + k);
			if (++k > 8*2)
				break;
		}
	}

	pI->video_pts_fifo_start		= vptsf->Start;
	pI->video_pts_fifo_entrysize	= vptsf->EntrySize;
	pI->video_pts_fifo_size			= vptsf->Size;
	pI->video_pts_fifo_rdptr		= vptsf->RdPtr;
	pI->video_pts_fifo_wrptr		= vptsf->WrPtr;
	pI->video_pts_fifo_emptiness	= vptsf->Emptiness;
	pI->video_pts_fifo_hw_wrptr		= CQuasar__ReadDM (pQ->H.pIDecoder, pQ4->MV_PTSWrPtr.addr);

	pI->audio_pts_fifo_start		= aptsf->Start;
	pI->audio_pts_fifo_entrysize	= aptsf->EntrySize;
	pI->audio_pts_fifo_size			= aptsf->Size;
	pI->audio_pts_fifo_rdptr		= aptsf->RdPtr;
	pI->audio_pts_fifo_wrptr		= aptsf->WrPtr;
	pI->audio_pts_fifo_emptiness	= aptsf->Emptiness;
	pI->audio_pts_fifo_hw_wrptr		= CQuasar__ReadDM (pQ->H.pIDecoder, pQ4->Audio_PTSWrPtr.addr);

	pI->subpi_pts_fifo_start		= sptsf->Start;
	pI->subpi_pts_fifo_entrysize	= sptsf->EntrySize;
	pI->subpi_pts_fifo_size			= sptsf->Size;
	pI->subpi_pts_fifo_rdptr		= sptsf->RdPtr;
	pI->subpi_pts_fifo_wrptr		= sptsf->WrPtr;
	pI->subpi_pts_fifo_emptiness	= sptsf->Emptiness;	

	pI->video_fifo_start			= vdf.Start;
	pI->video_fifo_size				= vdf.Size;
	pI->video_fifo_emptiness		= vdf.Emptiness;
	pI->video_fifo_rdptr			= vdf.Start + vdf.RdPtr;
	pI->video_fifo_wrptr			= vdf.Start + vdf.WrPtr;
	pI->video_packet_fifo_start		= vpf.Start;
	pI->video_packet_fifo_size		= vpf.Size;
	pI->video_packet_fifo_emptiness	= vpf.Emptiness;
	pI->video_packet_fifo_rdptr		= vpf.RdPtr;
	pI->video_packet_fifo_wrptr		= vpf.WrPtr;

	pI->audio_fifo_start			= adf.Start;
	pI->audio_fifo_size				= adf.Size;             
	pI->audio_fifo_emptiness		= adf.Emptiness;        
	pI->audio_fifo_rdptr			= adf.Start + adf.RdPtr;
	pI->audio_fifo_wrptr			= adf.Start + adf.WrPtr;
	pI->audio_packet_fifo_start		= apf.Start;            
	pI->audio_packet_fifo_size		= apf.Size;             
	pI->audio_packet_fifo_emptiness	= apf.Emptiness;        
	pI->audio_packet_fifo_rdptr		= apf.RdPtr;
	pI->audio_packet_fifo_wrptr		= apf.WrPtr;

	pI->subpi_fifo_start			= sdf.Start;            
	pI->subpi_fifo_size				= sdf.Size;             
	pI->subpi_fifo_emptiness		= sdf.Emptiness;        
	pI->subpi_fifo_rdptr			= sdf.Start + sdf.RdPtr;
	pI->subpi_fifo_wrptr			= sdf.Start + sdf.WrPtr;
	pI->subpi_packet_fifo_start		= spf.Start;            
	pI->subpi_packet_fifo_size		= spf.Size;             
	pI->subpi_packet_fifo_emptiness	= spf.Emptiness;        
	pI->subpi_packet_fifo_rdptr		= spf.RdPtr;
	pI->subpi_packet_fifo_wrptr		= spf.WrPtr;

	pI->interrupt_counter			= pQ->interrupt_counter;
	pI->video_pts_last_pts_displayed= 
		CQuasar__ReadDM (pQ->H.pIDecoder, pQ4->DisplayPTSLo.addr) |
		(CQuasar__ReadDM (pQ->H.pIDecoder, pQ4->DisplayPTSHi.addr) << 16);		
	pI->hw_audio_byte_counter		= pQ->H.AudioByteCounter; //hw_audio_byte_counter;
	pI->hw_video_byte_counter		= hw_video_byte_counter;
	pI->uc_video_byte_counter_lo	= CQuasar__ReadDM (pQ->H.pIDecoder, pQ4->MV_WrPtr_Hi.addr + 3);
	pI->uc_video_byte_counter_hi	= CQuasar__ReadDM (pQ->H.pIDecoder, pQ4->MV_WrPtr_Hi.addr + 4);
	pI->uc_audio_byte_counter_lo	= CQuasar__ReadDM (pQ->H.pIDecoder, pQ4->DeltaSCR_APTSFrac.addr + 2);
	pI->uc_audio_byte_counter_hi	= CQuasar__ReadDM (pQ->H.pIDecoder, pQ4->DeltaSCR_APTSFrac.addr + 3);
	pI->audio_pts_last_pts_accepted	= 
		CQuasar__ReadDM (pQ->H.pIDecoder, pQ4->PicPTSLo.addr) |
		(CQuasar__ReadDM (pQ->H.pIDecoder, pQ4->PicPTSHi.addr) << 16);
	pI->hw_scr						= (unsigned long)(IDecoder_ReadSCR (pQ->H.pIDecoder) >> 1);
	pI->pts_delay					= pQ->H.pts_delay;

	QUNLOCK ();

	return 0;
}