playback.c

intel upnp stack source code

#define ALLOW_OS_CODE 1

#include "samples/common.h"

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

struct dcc_context dcc_info = {0,};

struct mono_context{
	RMuint32 gfx_id;
	RMTrtk rtk;
	RMbool recurse_dirs;
	RMbool use_gui;
	struct DCCVideoSource *osd_source;
	RMuint32 osd_scaler;
	struct player_options player_conf;
};

/* returns TRUE to play the file and FALSE to skip it */
RMbool RMPlayNonInterleavedAVI(void)
{
	fprintf(stderr, "AVI file not interleaved. Do not play it!\n");
	return FALSE;
}

/* callback for the application to receive dcc context */
void RMDCCInfo(struct dcc_context *dcc_info)
{
}

/* this is the EOS callback, must be implemented by curacao */
void RMEOSCallback()
{
}

RMstatus RMInitSPU(RMuint32 width, RMuint32 height)
{
	return RM_OK;
}

RMstatus RMClearSPU()
{
	return RM_OK;
}

RMstatus RMCloseSPU()
{
	return RM_OK;
}


RMstatus RMBlendSPU(RMuint8 *buffer)
{
	return RM_OK;
}

/* this is the Subtitle callback */
void RMSubtitleCallback(RMuint8 *string, RMuint64 pts, RMbool usePTS)
{
}

/*always passed to the apps in this order*/
static struct playback_cmdline play_opt;
static struct display_cmdline disp_opt;
static struct video_cmdline video_opt;
static struct audio_cmdline audio_opt;
struct player_options player_conf;

static inline RMstatus init_dcc_info()
{
	RMstatus err;

	err = RUACreateInstance(&(dcc_info.pRUA), play_opt.chip_num);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error creating RUA instance! %d\n", err));
		return err;
	}

	err = DCCOpen(dcc_info.pRUA, &(dcc_info.pDCC));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error Opening DCC! %d\n", err));
		return err;
	}

	err = DCCInitMicroCodeEx(dcc_info.pDCC, disp_opt.init_mode);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot initialize microcode %d\n", err));
		return err;
	}


	dcc_info.chip_num = play_opt.chip_num;
	dcc_info.route = DCCRoute_Main;
	disp_opt.dh_info->pDH = NULL;

	return RM_OK;
}

int start_playback(char **url)
{
	RMstatus err;
	int error = 0;
	struct mono_info app_params;
	struct dh_context dh_info = {0,};

	/* Init static global variables in case we are used in a library, and
	 * it is not the first call */
	RMMemset(&dcc_info, 0, sizeof(dcc_info));
	RMMemset(&play_opt, 0, sizeof(play_opt));
	RMMemset(&disp_opt, 0, sizeof(disp_opt));
	RMMemset(&player_conf, 0, sizeof(struct player_options));
	RMMemset(&app_params, 0, sizeof(struct mono_info));

	app_params.play_opt = &play_opt;
	app_params.video_opt = &video_opt;
	app_params.audio_opt = &audio_opt;
	app_params.osd_scaler = 0;
	app_params.video_scaler = 0;
	
	init_display_options(&disp_opt);
	init_playback_options(&play_opt);

	disp_opt.dh_info = &dh_info;
	audio_opt.dh_info = &dh_info;
	
	err = init_dcc_info();
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Could not create RUA and DCC handles %d\n", err));
		return -1;
	}

	player_conf.forceSD = FALSE;
	player_conf.use_hwdemux = TRUE;
	player_conf.use_avi_push = TRUE;

	err = apply_playback_options(&dcc_info, &play_opt);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot set playback options %d\n", err));
		ERROR_CLEANUP(-1);
	}

	err = DCCGetScalerModuleID(dcc_info.pDCC, dcc_info.route, DCCSurface_Video, app_params.video_scaler, &(dcc_info.SurfaceID));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot get surface to display video source %d\n", err));
		goto cleanup;
	}

	err = apply_display_options(&dcc_info, &disp_opt);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot set display opions %d\n", err));
		ERROR_CLEANUP(-1);
	}

	app_params.pRUA = dcc_info.pRUA;
	app_params.pDCC = dcc_info.pDCC;


	play_opt.filename = (RMascii *) url;

	init_video_options(&video_opt);
	init_audio_options(&audio_opt);

	RMTermInit(TRUE);
	RMSignalInit(NULL, NULL);

	err = play_file(&app_params, &player_conf);
	if(RMFAILED(err)){
		RMDBGLOG((ENABLE, "Could not play file %d\n", err));
		ERROR_CLEANUP(-1);
	}

 cleanup:
	RMTermExit();

	err = clear_display_options(&dcc_info, &disp_opt);
	if (RMFAILED(err))
		RMDBGLOG((ENABLE, "Cannot clear display options %d\n", err));
	
	err = DCCClose(dcc_info.pDCC);
	if (RMFAILED(err))
		RMDBGLOG((ENABLE, "Cannot close DCC %d\n", err));

	err = RUADestroyInstance(dcc_info.pRUA);
	if (RMFAILED(err))
		RMDBGLOG((ENABLE, "Cannot destroy RUA instance %d\n", err));

	return error;
}