em86xx.cpp.svn-base

sigmadesign smp8623 gui source code ,bingo

/*****************************************
 Copyright (c) 2001-2003
 Sigma Designs, Inc. All Rights Reserved
 Proprietary and Confidential
 *****************************************/
#ifndef ALLOW_OS_CODE
#define ALLOW_OS_CODE 1
#endif //ALLOW_OS_CODE

#include "common.h"
#include "em86xx.h"

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>

#include "rmcore/include/rmstatustostring.h"
#include "rmcore/include/rmascii.h"

//#include "dvdaudio/audiostreamconverter.h"
#include "rmasfdemux/include/wmdrmopl.h"

#if 1
#define QBDBG ENABLE
#else
#define QBDBG DISABLE
#endif

#ifndef WITH_MONO

RMstatus WaitForRuaEvents(struct RUA *pInstance,
	struct RUAEvent** ppEventsIn,
	RMuint32* pnEvents,
	RMuint32 timeout)
{
#define EM8XXX_EVENTCOUNT_MAX 6
	RMstatus err = RM_OK;
	RMuint32 index, i;
	struct RUAEvent Events[EM8XXX_EVENTCOUNT_MAX];

	if(*pnEvents > EM8XXX_EVENTCOUNT_MAX)
		return RM_ERROR;

	RMMemcpy(Events, *ppEventsIn, *pnEvents * sizeof(struct RUAEvent));

	while (*pnEvents) {
		RMDBGLOG((QBDBG, "   wait %lx events\n", *pnEvents));
		for(i=0;i<(*pnEvents);i++)
			RMDBGLOG((QBDBG, "[0x%lx = 0x%08lx]\n", Events[i].ModuleID, Events[i].Mask));
//		RMDBGLOG((QBDBG, "\n"));

		err = RUAWaitForMultipleEvents(pInstance, Events, *pnEvents, timeout, &index);
		if ( err != RM_OK) {
			// basically timeout
			goto over;
		}
		if( index >= *pnEvents) {
			RMDBGLOG((QBDBG, "RUAWaitForMultipleEvents ERROR - ??????\n"));
			err = RM_ERROR;
			goto over;
		}
		RMDBGLOG((QBDBG, "   get #%i 0x%lx = 0x%08lx\n", index, Events[index].ModuleID, Events[index].Mask));
		if (Events[index].Mask & RUAEVENT_INBAND_COMMAND) {
			struct InbandCommand_type InbandCmd;
			err = RUAGetProperty(pInstance, Events[index].ModuleID, RMGenericPropertyID_InbandCommand, &InbandCmd, sizeof(InbandCmd));
			if ( err != RM_OK) {
				RMDBGLOG((QBDBG, "   user get inband command failed - hwlib already process it\n"));
			}
		}

		(*ppEventsIn)[index].Mask &= ~Events[index].Mask;
		if ((*ppEventsIn)[index].Mask == 0) {
			RMMemcpy(Events+index, Events+index+1, sizeof(struct RUAEvent) * (*pnEvents - index - 1));
			RMMemcpy((*ppEventsIn)+index, (*ppEventsIn)+index+1, sizeof(struct RUAEvent) * (*pnEvents - index - 1));
			*pnEvents = (*pnEvents) - 1;
		}
		else
			Events[index].Mask = (*ppEventsIn)[index].Mask;
	}
over:
	return err;
}

#else // WITH_MONO

#include "samples/common.h"
#undef TIMEOUT_1SEC

#endif // WITH_MONO

#define CMD_TIMEOUT 200000
#define TIMEOUT_1SEC    0x000F4240

#define MAX_EPROM_READ_ATTEMPTS 6 // 1 attempt every 1/2 second for 3 seconds

//#define DVD_SECTOR_SIZE 2048

///////////////////////////////////////
#define DMA_BUFFER_SIZE_LOG2		15  // (1 << 15) = 32 KBytes
#define DMA_BUFFER_COUNT		16  // 16 * 32 = 512 KBytes

#ifdef WITH_DALLAS_DEMUX
#define DEMUX_XFER_BUFFER_COUNT	(((1 << DMA_BUFFER_SIZE_LOG2) / DVD_SECTOR_SIZE) * DMA_BUFFER_COUNT * 8)
#else
#define DEMUX_XFER_BUFFER_COUNT	(((1 << DMA_BUFFER_SIZE_LOG2) / DVD_SECTOR_SIZE) * DMA_BUFFER_COUNT)
#endif

#define DEMUX_BITSTREAM_FIFO_SIZE	((1 << DMA_BUFFER_SIZE_LOG2) * DMA_BUFFER_COUNT)

#define VIDEO_XFER_FIFO_BUFFER_COUNT	(((1 << DMA_BUFFER_SIZE_LOG2) / DVD_SECTOR_SIZE) * DMA_BUFFER_COUNT)
#define AUDIO_XFER_FIFO_BUFFER_COUNT	(((1 << DMA_BUFFER_SIZE_LOG2) / DVD_SECTOR_SIZE) * DMA_BUFFER_COUNT)
#define SPU_XFER_FIFO_BUFFER_COUNT	(((1 << DMA_BUFFER_SIZE_LOG2) / DVD_SECTOR_SIZE) * DMA_BUFFER_COUNT)

// file playback has different dma requirements
#define FILE_DMA_BUFFER_SIZE_LOG2		17 // (1 << 17) = 128 KBytes
#define FILE_DMA_BUFFER_COUNT			14  // 14 * 128K  = 1792 KBytes
#define FILE_DMA_BUFFER_COUNT4VIDEO		12
#define FILE_DMA_BUFFER_COUNT4AUDIO		FILE_DMA_BUFFER_COUNT - FILE_DMA_BUFFER_COUNT4VIDEO

#define FILE_VIDEO_XFER_FIFO_BUFFER_COUNT	(((1 << FILE_DMA_BUFFER_SIZE_LOG2) / DVD_SECTOR_SIZE) * FILE_DMA_BUFFER_COUNT)
#define FILE_AUDIO_XFER_FIFO_BUFFER_COUNT	(((1 << FILE_DMA_BUFFER_SIZE_LOG2) / DVD_SECTOR_SIZE) * FILE_DMA_BUFFER_COUNT)
#define FILE_SPU_XFER_FIFO_BUFFER_COUNT	(((1 << FILE_DMA_BUFFER_SIZE_LOG2) / DVD_SECTOR_SIZE) * FILE_DMA_BUFFER_COUNT)

#define AUDIO_BITSTREAM_FIFO_SIZE	( 6 * 256 * 1024) // 1.5MBytes 6*
#define VIDEO_BITSTREAM_FIFO_SIZE	( 10 * 256 * 1024) // 2.5MBytes 10*
#define SPU_BITSTREAM_FIFO_SIZE		( 104 * 1024 )

#define ASV_DMA_BUFFER_SIZE_LOG2 15
#define ASV_DMA_BUFFER_COUNT     64

//////////////////////////////

//timeout is now defined by the caller
//#define WAIT_EOS_TIMEOUT_US 30000000	// 30 sec

/*
#define DEMUX_POOL_BUFFER_SIZE_LOG2 15
#define DEMUX_POOL_BUFFER_COUNT 32
#define DEMUX_BTS_FIFO_SIZE ((1 << DEMUX_POOL_BUFFER_SIZE_LOG2) * DEMUX_POOL_BUFFER_COUNT)
#define DEMUX_BTS_FIFO_BUFFER_COUNT_DISC (DEMUX_BTS_FIFO_SIZE / DVD_SECTOR_SIZE)

#define VIDEO_POOL_BUFFER_SIZE_LOG2 14
#define VIDEO_POOL_BUFFER_COUNT 16
#define VIDEO_BTS_FIFO_SIZE_FILE ((1 << VIDEO_POOL_BUFFER_SIZE_LOG2) * VIDEO_POOL_BUFFER_COUNT)
#define VIDEO_BTS_FIFO_SIZE_DISC ((1 << DEMUX_POOL_BUFFER_SIZE_LOG2) * (DEMUX_POOL_BUFFER_COUNT/2))
#define VIDEO_BTS_FIFO_BUFFER_COUNT_DISC (VIDEO_BTS_FIFO_SIZE_DISC / DVD_SECTOR_SIZE)
#define VIDEO_BTS_FIFO_BUFFER_COUNT_FILE VIDEO_POOL_BUFFER_COUNT

#define AUDIO_POOL_BUFFER_SIZE_LOG2 13
#define AUDIO_POOL_BUFFER_COUNT 10
#define AUDIO_BTS_FIFO_SIZE_FILE ((1 << AUDIO_POOL_BUFFER_SIZE_LOG2) * AUDIO_POOL_BUFFER_COUNT)
#define AUDIO_BTS_FIFO_SIZE_DISC ((1 << DEMUX_POOL_BUFFER_SIZE_LOG2) * (DEMUX_POOL_BUFFER_COUNT/4))
#define AUDIO_BTS_FIFO_BUFFER_COUNT_DISC (AUDIO_BTS_FIFO_SIZE_DISC / DVD_SECTOR_SIZE)
#define AUDIO_BTS_FIFO_BUFFER_COUNT_FILE AUDIO_POOL_BUFFER_COUNT

#define SPU_POOL_BUFFER_SIZE_LOG2 13
#define SPU_POOL_BUFFER_COUNT 10
#define SPU_BTS_FIFO_SIZE_FILE ((1 << SPU_POOL_BUFFER_SIZE_LOG2) * SPU_POOL_BUFFER_COUNT)
#define SPU_BTS_FIFO_SIZE_DISC ((1 << DEMUX_POOL_BUFFER_SIZE_LOG2) * (DEMUX_POOL_BUFFER_COUNT/4))
#define SPU_BTS_FIFO_BUFFER_COUNT_DISC (SPU_BTS_FIFO_SIZE_DISC / DVD_SECTOR_SIZE)
#define SPU_BTS_FIFO_BUFFER_COUNT_FILE SPU_POOL_BUFFER_COUNT
*/
#define MPEG2_TIR 90000

RMuint64 LocalGetTimeInMicroSeconds(void);
extern "C" void LocalMicroSecondSleep(RMuint64 microsec); // Used in dvi_hdmi.c

void LocalMicroSecondSleep(RMuint64 microsec)
{
	if (microsec>=20000) {
		struct timespec usleep_req = { 0 };
		usleep_req.tv_sec = microsec / 1000000;
		usleep_req.tv_nsec = (microsec % 1000000) * 1000;

		nanosleep(&usleep_req, 0);
	}
	else {
		RMuint64 start_date = LocalGetTimeInMicroSeconds();

		// busy wait, no other way.
		while ((LocalGetTimeInMicroSeconds() - start_date) < microsec);
	}
}

RMuint64 LocalGetTimeInMicroSeconds(void)
{
	static RMbool firsttimehere=TRUE;
	static struct timeval timeorigin;

	struct timeval now;

	// the first time, set the origin.
	if (firsttimehere) {
		gettimeofday(&timeorigin,NULL);
		firsttimehere=FALSE;
	}

	gettimeofday(&now,NULL);

	return
		(RMuint64)(
		 (
		  (RMint64)now.tv_sec
		  -(RMint64)timeorigin.tv_sec
		  )*1000000LL
		 +
		 (
		  (RMint64)now.tv_usec
		  -(RMint64)timeorigin.tv_usec
		  )
		 );
}

RMem86xxDecoder::RMem86xxDecoder(typeCuracaoContext *context, RMbool useHDProfile)
	: RMdecoderIface(context),
	m_isOSDEnabled (FALSE)
{
	RMstatus status;

	RMDBGLOG((QBDBG, "*********************************** Em86xx decoder : Construct ***********************************\n"));
	m_boardNumber = context->boardNumber;

	m_pDCC = NULL;
	m_pVideoSource = NULL;
	m_pAudioSource = NULL;
	m_pDemuxSource = NULL;
	m_CC.UncachedAddress = 0;

	m_surfaceID = 0;
	m_video_decoder = 0;
	m_audio_decoder = 0;
	m_audio_engine = 0;
	m_video_timer = 0;
	m_audio_timer = 0;
	m_hw_demux = 0;
	m_hw_demux_program0 = 0;
	m_hw_demux_program1 = 0;
	m_spu_decoder = 0;

	m_muteOn = 0;
	m_volume = 0x80000000;
	m_brightness = 0;
	m_contrast = 128;
	m_saturation = 128;

	m_scalingMode = EMhwlibScalingMode_LetterBox;
	m_blackstrip.Horizontal = 4096;
	m_blackstrip.Vertical = 4096;
	m_tvType = RM_TV_4_3;
	m_AudioChannels = 6;	// 5.1

	m_bAutoModeOn = FALSE;
	m_standard = EMhwlibTVStandard_NTSC_M;
	m_connector = DCCVideoConnector_SVIDEO;
	m_color_space = EMhwlibColorSpace_YUV_601;
	m_pDH = NULL;
	m_bEnableHDCP = FALSE;
	m_bHDCP_tv = FALSE;
	m_auto_edid = TRUE; // Does user want us to set the TV resolution according to EDID preferred mode?
	m_valid_edid = FALSE; // Not yet found a valid EDID...
	m_cable = DH_disconnected;
	m_bHDMItv = FALSE; // FALSE unless we find a CEA-861B EDID v2.3
	m_tv_basic_support = 0;
	m_nb_read_EPROM_attempts = 0; // Number of attempts
	RMMemset(&m_tv_aud_pcm, 0, sizeof(m_tv_aud_pcm));
	// Following are initialization only used for HDMI
	m_hdmi_audio_format.NumChannel = 2; // We only enable 2 channels
	m_audioFormat.sampleRate = 48000; // Default for DVD...
	m_hdmi_audio_format.SampleFrequency = m_audioFormat.sampleRate;
	m_hdmi_audio_format.I2S0_Enable = TRUE; // We only enable 2 channels
	m_hdmi_audio_format.I2S1_Enable = FALSE;
	m_hdmi_audio_format.I2S2_Enable = FALSE;
	m_hdmi_audio_format.I2S3_Enable = FALSE;
	m_hdmi_audio_format.SPDIF_Enable = FALSE;
	m_hdmi_audio_info_frame.Version = 0x01;
	m_hdmi_audio_info_frame.CodingType = DH_AudioCodingType_FromStreamHeader;
	m_hdmi_audio_info_frame.ChannelCount = DH_AudioChannelCount_2;  // change according to source
	m_hdmi_audio_info_frame.SampleFrequency = DH_AudioSampleFrequency_FromStreamHeader;
	m_hdmi_audio_info_frame.SampleSize = DH_AudioSampleSize_FromStreamHeader;
	m_hdmi_audio_info_frame.LFE_Ch3_Enable = FALSE; // change according to source
	m_hdmi_audio_info_frame.FC_Ch4_Enable = FALSE; // change according to source
	m_hdmi_audio_info_frame.CA = DH_Audio_CA_none; // change according to source
	m_hdmi_audio_info_frame.DownMixInhibit = FALSE; // change only if source is DVD-Audio
	m_hdmi_audio_info_frame.LevelShift = 0;  // change according to user setting
	m_hdmi_audio_info_frame.MaxBitRate = 0;  // ignored with DH_AudioCodingType_FromStreamHeader
	m_hdmi_AVI_info_frame.Version = 0x02;
	m_hdmi_AVI_info_frame.color_space = EMhwlibColorSpace_RGB_0_255;
	m_hdmi_AVI_info_frame.sampling = EMhwlibSamplingMode_444;  // Always 4:4:4
	m_hdmi_AVI_info_frame.scan_info = DH_underscanned;  // TODO
	m_hdmi_AVI_info_frame.aspect_ratio.X = 4;
	m_hdmi_AVI_info_frame.aspect_ratio.Y = 3;
	m_hdmi_AVI_info_frame.active_format_valid = FALSE;
	m_hdmi_AVI_info_frame.VIC = 0;
	m_hdmi_AVI_info_frame.active_aspect_ratio = DH_af_same_as_picture;  // ignored unless active_format_valid
	m_hdmi_AVI_info_frame.non_linear_scaling.Level = m_hdmi_AVI_info_frame.non_linear_scaling.Width = 0;
	m_hdmi_AVI_info_frame.pixel_repetition = DH_no_repetition;
	m_hdmi_AVI_info_frame.info_bars = DH_bar_data_not_valid;
	m_hdmi_AVI_info_frame.end_top_bar_line_num = 0;
	m_hdmi_AVI_info_frame.start_bottom_bar_line_num = 0;
	m_hdmi_AVI_info_frame.end_left_bar_pixel_num = 0;
	m_hdmi_AVI_info_frame.start_right_bar_pixel_num = 0;

	m_outputModule = DispMainAnalogOut;
	m_DVI_RxPresent = FALSE;  // will be TRUE if hardware supports Rx signal
	m_DVI_Rx = FALSE;
	m_DVI_HPD = FALSE;
	m_nDBC = sizeof(m_DBC) / sizeof(struct CEA861BDataBlockCollection);

	if (RUACreateInstance(&m_pInstance, m_boardNumber) != RM_OK) {
		RMDBGLOG((ENABLE, "!!!!! Error creating instance !!!!!\n"));
		exit(1);
	}

	status = DCCOpen(m_pInstance, &m_pDCC);
	if (status != RM_OK) {
		RMDBGLOG((ENABLE, "!!!!! Error Opening DCC : %s !!!!!\n", RMstatusToString(status)));
		CleanallAndExit();
	}

	status = DCCInitMicroCodeEx(m_pDCC, DCCInitMode_InitDisplay);
	if (status != RM_OK) {
		RMDBGLOG((ENABLE, "Cannot initialize microcode %s\n", RMstatusToString(status)));
		CleanallAndExit();
	}

	//status = DCCSetStandard(m_pDCC, DCCRoute_Main, EMhwlibTVStandard_NTSC_M);
	//if (RMFAILED(status)) {
	//		RMDBGLOG((ENABLE, "Cannot set standard %s\n", RMstatusToString(status)));
	//}

	status = DCCSetRouteDisplayAspectRatio(m_pDCC, DCCRoute_Main, 4, 3);
	if (RMFAILED(status)) {
		RMDBGLOG((ENABLE, "Cannot set display aspect ratio %s\n", RMstatusToString(status)));
	}

//	m_audioStreamConverter = new audioStreamConverter();

	m_audioFormat.audioType = CURACAO_AUDIO_UNKNOWN;
	m_isFirstSystemTimeStamp = TRUE;

	m_pBufferPool = 0;
	m_pAudioBufferPool = 0;
	m_pVideoBufferPool = 0;
	m_pAsvBufferPool = 0;

	m_initialized = FALSE;
	m_finished = FALSE;

	m_HighlightOn = FALSE;
	m_SubpictureOn = FALSE;

//	m_cssDecoderCallBackTable.GetChallenge = RMem86xxDecoder::GetChallengeEm86xx;
//	m_cssDecoderCallBackTable.RecordChallengeResponse = RMem86xxDecoder::RecordChallengeResponseEm86xx;
//	m_cssDecoderCallBackTable.SendChallenge = RMem86xxDecoder::SendChallengeEm86xx;
//	m_cssDecoderCallBackTable.GetChallengeResponse = RMem86xxDecoder::GetChallengeResponseEm86xx;
//	m_cssDecoderCallBackTable.SendDiscKey = RMem86xxDecoder::SendDiscKeyEm86xx;
//	m_cssDecoderCallBackTable.SendTitleKey = RMem86xxDecoder::SendTitleKeyEm86xx;
//	m_cssDecoderCallBackTable.Decrypt = RMem86xxDecoder::DecryptEm86xx;

	m_useHDProfile = useHDProfile;
	m_dualMode = DualMode_Stereo;
	m_SPDIFMode = OutputSpdif_Uncompressed;
	m_SPDIFModeReq = OutputSpdif_Uncompressed;

	RMDBGLOG((QBDBG, "*********************************** Em86xx decoder : finish Construct *********************************** \n"));
}