fileplayer.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 "fileplayer.h"
#include "em86xx.h"
#include "gui/gui.h"
#include "rmasfdemux/include/wmdrmopl.h"
#include "rmlibcw/include/rmlibcw.h"

#ifdef WITH_MONO
//#define USE_SAME_THREAD

#define MONODBG ENABLE

extern RMbool g_useKeyboard;
extern typeCuracaoContext context;

#include "rmdef/rmdef.h"
#include "rmlibcw/include/rmfile.h"
#include "rmvdemux/include/rmvdemuxapi.h"

#define ERROR_CLEANUP(i)	do { error = (i); goto cleanup; }  while(0)

#ifndef USE_SAME_THREAD
static RMthread g_thread = NULL;
static RMthread g_subthread = NULL;
#endif

static struct playback_cmdline play_opt;
static struct video_cmdline video_opt;
static struct audio_cmdline audio_opt;
static struct demux_cmdline demux_opt;

// osd for mp4 subtitles
struct osd_subtitles_context{
	struct DCCVideoSource *pSPU_double_buffer_source;
	struct OSDdoubleBuffer doubleBuffer;
};

static struct osd_subtitles_context osd_subt;

// callback for the application to receive dcc context
void RMDCCInfo(struct dcc_context *dcc_info)
{
	context.decoder->SetDCCInfo(dcc_info);
	context.player->SetState(STATE_PLAY, 0);
	context.player->SetSampleType();
	// notify gui of initialization
	context.gui->Notify(CURACAO_MESSAGE_DECODER_INITIALIZED, NULL);
}

// callback for the application to act upon receiving EOS
void RMEOSCallback()
{
	// notify gui of EOS
	printf("received EOS\n");
	context.gui->Notify(CURACAO_MESSAGE_EOS, NULL);
}

// callback to pass stream information to the application, DRM protected, number of chapters, etc
void RMFileStreamInfoCallback(struct RMFileStreamInfo *streamInfo)
{
	RMDBGLOG((ENABLE, "got stream info!\n"));
	context.player->SetStreamInfo(streamInfo);
}


// these functions need implementations (see mono/mono.c as a sample)
RMstatus RMInitSPU(RMuint32 width, RMuint32 height)
{
	struct DCCOSDProfile osdProfile;
	RMstatus status = RM_OK;

	osdProfile.ColorSpace = EMhwlibColorSpace_YUV_601;
	osdProfile.SamplingMode = EMhwlibSamplingMode_444;
	osdProfile.ColorMode = EMhwlibColorMode_TrueColor;
	osdProfile.ColorFormat = EMhwlibColorFormat_32BPP; // unused
	osdProfile.PixelAspectRatio.X = 1;
	osdProfile.PixelAspectRatio.Y = 1;

	osdProfile.Width = width; // should be the dimensions from the track, but they are wrong, so we hard code
	osdProfile.Height = height;

	RMDBGLOG((ENABLE, "RMinitSPU(%lu x %lu)\n", width, height));

	// make sure we don't already have a buffer
	if (osd_subt.pSPU_double_buffer_source) {
		RMDBGLOG((ENABLE, "doubleBuffer already exists\n"));
		status = RMCloseSPU();
		if (status != RM_OK)
			return status;
	}

	// Init SPU DoubleBuffer OSD
	status = RMInitDoubleBufferOSD(NULL, osdProfile, &(osd_subt.doubleBuffer));
	if (status != RM_OK) {
		RMDBGLOG((ENABLE, "cant init doubleBufferOSD\n"));
		// allow playing even if SPU cannot be shown
		return RMCloseSPU();
	}
	return RM_OK;
}

RMstatus RMInitDoubleBufferOSD(RMuint32 *moduleID, struct DCCOSDProfile osdProfile, struct OSDdoubleBuffer *doubleBuffer)
{
	enum EMhwlibMixerSourceState state;
	RMuint32 mixer, scaler, src_index, mixer_src;
	struct EMhwlibDisplayWindow window;

	RMuint32 pic_luma_addr[2], pic_addr[2], pic_luma_size[2], surface_addr;

	RMuint8 *buf_map;
	RMuint32 buf_addr, buf_size;

	RMstatus err;

	struct RUA *pRUA = (RUA *) context.decoder->GetRUAInstance();
	struct DCC *pDCC = (DCC *) context.decoder->GetDCCInstance();

	RMDBGLOG((ENABLE, "init doubleBuffer OSD, size %lu x %lu\n", osdProfile.Width, osdProfile.Height));

	mixer = EMHWLIB_MODULE(DispMainMixer, 0);
	scaler = EMHWLIB_MODULE(DispGFXMultiScaler,0);

	// set a NULL surface, this will force a full register update when next surface is set
	err = DCCSetSurfaceSource(pDCC, scaler, NULL);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot unset gfx scaler's surface\n"));
		return err;
	}

	err = RUAExchangeProperty(pRUA, mixer, RMGenericPropertyID_MixerSourceIndex, &scaler, sizeof(scaler), &src_index, sizeof(src_index));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot get scaler index\n"));
		return err;
	}

	mixer_src = EMHWLIB_TARGET_MODULE((enum RMcategoryID)mixer, 0 , src_index);
	state = EMhwlibMixerSourceState_Master;

	window.X = 0;
	window.Y = 0;
	window.Width = 4096;
	window.Height = 4096;
	window.XPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
	window.YPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
	window.XMode = EMhwlibDisplayWindowValueMode_Relative;
	window.YMode = EMhwlibDisplayWindowValueMode_Relative;
	window.WidthMode = EMhwlibDisplayWindowValueMode_Relative;
	window.HeightMode = EMhwlibDisplayWindowValueMode_Relative;
	RUASetProperty(pRUA, mixer_src, RMGenericPropertyID_MixerSourceWindow, &window, sizeof(window), 0);

	window.X = 0;
	window.Y = 0;
	window.Width = 4096;
	window.Height = 4096;
	window.XPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
	window.YPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
	window.XMode = EMhwlibDisplayWindowValueMode_Relative;
	window.YMode = EMhwlibDisplayWindowValueMode_Relative;
	window.WidthMode = EMhwlibDisplayWindowValueMode_Relative;
	window.HeightMode = EMhwlibDisplayWindowValueMode_Relative;
	RUASetProperty(pRUA, scaler, RMGenericPropertyID_ScalerInputWindow, &window, sizeof(window), 0);

	while((err =  RUASetProperty(pRUA, mixer_src, RMGenericPropertyID_MixerSourceState, &state, sizeof(state), 0))==RM_PENDING);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot set scaler's state on mixer\n"));
		return err;
	}

	while ((err = RUASetProperty(pRUA, mixer, RMGenericPropertyID_Validate, NULL, 0, 0)) == RM_PENDING);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot validate mixer\n"));
		return err;
	}

	while ((err = RUASetProperty(pRUA, scaler, RMGenericPropertyID_Validate, NULL, 0, 0)) == RM_PENDING);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot validate mixer\n"));
		return err;
	}

	err = DCCOpenMultiplePictureOSDVideoSource(pDCC, &osdProfile, 2, &(osd_subt.pSPU_double_buffer_source));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot open OSD decoder %d\n", err));
		return err;
	}

	err = DCCGetOSDSurfaceInfo(pDCC, osd_subt.pSPU_double_buffer_source, NULL, &surface_addr, NULL);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot get surface address %d\n", err));
		return err;
	}

	err = DCCGetOSDPictureInfo(osd_subt.pSPU_double_buffer_source, 0, &(pic_addr[0]),  &(pic_luma_addr[0]), &(pic_luma_size[0]), NULL, NULL);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot get osd buffer info %d\n", err));
		return err;
	}

	err = DCCGetOSDPictureInfo(osd_subt.pSPU_double_buffer_source, 1, &(pic_addr[1]), &(pic_luma_addr[1]), &(pic_luma_size[1]), NULL, NULL);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot get osd buffer info %d\n", err));
		return err;
	}

	// first pic (for double buffering)
	buf_size = pic_luma_size[0];
	buf_addr = pic_luma_addr[0];

	err = RUALock(pRUA, buf_addr, buf_size);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error locking OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return err;
	}

	buf_map = RUAMap(pRUA, buf_addr, buf_size);
	if (buf_map == NULL) {
		RMDBGLOG((ENABLE, "Error mapping OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return RM_ERROR;
	}

	memset(buf_map, 0x80, buf_size);

	doubleBuffer->buf0 = buf_map;
	doubleBuffer->buf0Size = buf_size;
	doubleBuffer->buf0Addr = buf_addr;
	doubleBuffer->isBuf0inUse = FALSE;
	doubleBuffer->buf0Cleared = FALSE;

	doubleBuffer->width = osdProfile.Width;
	doubleBuffer->height = osdProfile.Height;


	RUAUnMap(pRUA, buf_map, buf_size);
	err = RUAUnLock(pRUA, buf_addr, buf_size);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error unlocking OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return err;
	}

	// second pic
	buf_size = pic_luma_size[1];
	buf_addr = pic_luma_addr[1];

	err = RUALock(pRUA, buf_addr, buf_size);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error locking OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return err;
	}

	buf_map = RUAMap(pRUA, buf_addr, buf_size);
	if (buf_map == NULL) {
		RMDBGLOG((ENABLE, "Error mapping OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return RM_ERROR;
	}

	memset(buf_map, 0x90, buf_size);

	doubleBuffer->buf1 = buf_map;
	doubleBuffer->buf1Size = buf_size;
	doubleBuffer->buf1Addr = buf_addr;
	doubleBuffer->isBuf1inUse = FALSE;
	doubleBuffer->buf1Cleared = FALSE;


	RUAUnMap(pRUA, buf_map, buf_size);
	err = RUAUnLock(pRUA, buf_addr, buf_size);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error unlocking OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return err;
	}

	RMDBGLOG((ENABLE, "bitmap size %lu, buf0 @0x%lx, buf1 @0x%lx\n", buf_size, doubleBuffer->buf0, doubleBuffer->buf1));

	// possibly clean it before this with a fill

	err = DCCSetSurfaceSource(pDCC, scaler, osd_subt.pSPU_double_buffer_source);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot set the surface source %d\n", err));
		return RM_ERROR;
	}
	err = DCCEnableVideoSource(osd_subt.pSPU_double_buffer_source, TRUE);
	if (RMFAILED(err)){
		RMDBGLOG((ENABLE,"Error enabling OSD buffer : %d\n",err));
		return err;
	}
	while ((err = RUASetProperty(pRUA, scaler, RMGenericPropertyID_Validate, NULL, 0, 0)) == RM_PENDING);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot validate scaler input window %d\n", err));
		return err;
	}

	//err = DCCInsertPictureInMultiplePictureOSDVideoSource(osd_subt.pSPU_double_buffer_source, 0);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot insert picture inside surface %d\n", err));
		return err;
	}


	return RM_OK;
}


RMstatus RMCloseSPU(void)
{
	if (osd_subt.pSPU_double_buffer_source) {
		RMstatus status;
		RMDBGLOG((ENABLE, "closing doubleBufferOSD\n"));
		RMuint8 to_try = 0;
		while((status = DCCCloseVideoSource(osd_subt.pSPU_double_buffer_source)) == RM_PENDING && ++to_try < 10 /*arbitrary*/) {
			RMDBGLOG((ENABLE, "oh that sucks\n"));
		}
		if (RMFAILED(status)) {
			RMDBGLOG((ENABLE, "Cannot close SPU doubleBuffer source %d\n", status));
			return status;
		}
		osd_subt.pSPU_double_buffer_source = NULL;
	}

	return RM_OK;
}


RMstatus RMBlendSPU(RMuint8 *buffer)
{
	RMstatus err;
	RMuint8 *buf_map;
	RMuint32 buf_size, buf_addr;
	RMuint32 blendPic = 0;

	struct RUA *pRUA = (RUA *) context.decoder->GetRUAInstance();

	if (!osd_subt.pSPU_double_buffer_source) {
		RMDBGLOG((ENABLE, "there's no double buffer for spu!\n"));
		return RM_ERROR;
	}

	if (!osd_subt.doubleBuffer.isBuf0inUse) {
		//blend buf0: copy *buffer into doublebufffer and activate it

		RMDBGLOG((ENABLE, "blending buf0\n"));

		buf_size = osd_subt.doubleBuffer.buf0Size;
		buf_addr = osd_subt.doubleBuffer.buf0Addr;
		osd_subt.doubleBuffer.isBuf0inUse = TRUE;
		osd_subt.doubleBuffer.buf0Cleared = FALSE;
		blendPic = 0;
		osd_subt.doubleBuffer.isBuf1inUse = FALSE;

	} else if (!osd_subt.doubleBuffer.isBuf1inUse) {
		RMDBGLOG((ENABLE, "blending buf1\n"));

		buf_size = osd_subt.doubleBuffer.buf1Size;
		buf_addr = osd_subt.doubleBuffer.buf1Addr;
		osd_subt.doubleBuffer.isBuf1inUse = TRUE;
		osd_subt.doubleBuffer.buf1Cleared = FALSE;
		blendPic = 1;
		osd_subt.doubleBuffer.isBuf0inUse = FALSE;
	}
	else {
		RMDBGLOG((ENABLE, "no buffer available for double buffer rendering\n"));
		return RM_ERROR;
	}


	err = RUALock(pRUA, buf_addr, buf_size);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error locking OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return err;
	}

	buf_map = RUAMap(pRUA, buf_addr, buf_size);
	if (buf_map == NULL) {
		RMDBGLOG((ENABLE, "Error mapping OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return RM_ERROR;
	}

	// reorder Y,V,U,A planes into UYVA,UYVA,... pixels
	{
		RMuint32 bitmap_size = osd_subt.doubleBuffer.width * osd_subt.doubleBuffer.height;
		RMuint8 *buf_Y = buffer;
		RMuint8 *buf_V = buf_Y + (bitmap_size);
		RMuint8 *buf_U = buf_V + (bitmap_size);
		RMuint8 *buf_A = buf_U + (bitmap_size);
		RMuint32 i = 0;

		while (i < (bitmap_size*4)) {
			*(buf_map+i) = *buf_U++;    // bleu
			*(buf_map+i+1) = *buf_Y++;
			*(buf_map+i+2) = *buf_V++;  // rouge?

			// alpha values are in the [0,16] range, convert them to [0,255]
			if (*buf_A)
				*(buf_map+i+3) = RMmin(*buf_A * 16, 255);
			else
				*(buf_map+i+3) = 0;
			buf_A++;

			i+=4;
		}
	}


	RUAUnMap(pRUA, buf_map, buf_size);
	err = RUAUnLock(pRUA, buf_addr, buf_size);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error unlocking OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return err;
	}

	err = DCCInsertPictureInMultiplePictureOSDVideoSource(osd_subt.pSPU_double_buffer_source, blendPic);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot insert picture inside surface %d\n", err));
		return err;
	}

	return RM_OK;
}


RMstatus RMClearSPU()
{
	RMstatus err;
	RMuint8 *buf_map;
	RMuint32 buf_size, buf_addr;
	RMuint32 blendPic = 0;

	struct RUA *pRUA = (RUA *) context.decoder->GetRUAInstance();

	if (!osd_subt.pSPU_double_buffer_source)
		return RM_ERROR;

	if (osd_subt.doubleBuffer.buf0Cleared)
		return RM_OK;

	RMDBGLOG((ENABLE, "clearSPU\n"));
	buf_size = osd_subt.doubleBuffer.buf0Size;
	buf_addr = osd_subt.doubleBuffer.buf0Addr;
	osd_subt.doubleBuffer.isBuf0inUse = FALSE;
	osd_subt.doubleBuffer.buf0Cleared = TRUE;
	blendPic = 0;
	osd_subt.doubleBuffer.isBuf1inUse = FALSE;

	err = RUALock(pRUA, buf_addr, buf_size);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error locking OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return err;
	}

	buf_map = RUAMap(pRUA, buf_addr, buf_size);
	if (buf_map == NULL) {
		RMDBGLOG((ENABLE, "Error mapping OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return RM_ERROR;
	}

	// clear buffer
	memset(buf_map, 0, buf_size);

	RUAUnMap(pRUA, buf_map, buf_size);
	err = RUAUnLock(pRUA, buf_addr, buf_size);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error unlocking OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return err;