play_multiple_audio.c

1. 8623L平台

		else {
			RMDBGLOG((ENABLE, "Error: audio decoder index %d out of range!!! Should be < %d\n",
					  (int) dcc_profile->AudioDecoderID, (int) (nb_audio_decoders / nb_audio_engines)));
			err = RM_PARAMETER_OUT_OF_RANGE;
			return err;
		}
	}

	audio_engine = EMHWLIB_MODULE(AudioEngine, dcc_profile->AudioEngineID);
	(*ppAudioSource)->engine_moduleID = audio_engine;

	{
		int i = 0;
		for (i = 0; i <= 11; i++) {
			volume.Channel = i;
			volume.Volume = 0x10000000;
			DCCSP(pDCC->pRUA, audio_engine, RMAudioEnginePropertyID_Volume, &volume, sizeof(volume));
		}
	}

	// !!Hack!! We assume there are an equal amount of decoders per engine; (nb_audio_decoders / nb_audio_engines)
	// gives the number of decoders per engine. This is always better then hardcoding number to 2 like before.
	audio_decoder = EMHWLIB_MODULE(AudioDecoder, dcc_profile->AudioEngineID * (nb_audio_decoders / nb_audio_engines) + 
								   dcc_profile->AudioDecoderID);
	(*ppAudioSource)->decoder_moduleID = audio_decoder;
	RMDBGLOG((ENABLE, "AudioDecoder: 0x%08lX\n", audio_decoder));

	sample_rate = 44100;
	DCCSP(pDCC->pRUA, audio_engine, RMAudioEnginePropertyID_SampleFrequency, &sample_rate, sizeof(sample_rate));

	/* we need 8 x 0x300(0x180) for Ac3, 8 x 0xF00 for WMA, 8 x 0x400 for WMAPRO => allocate maximum=8 x 0xF00 */
	dram_in.BitstreamFIFOSize0 = dcc_profile->BitstreamFIFOSize;
	dram_in.XferFIFOCount0 = dcc_profile->XferFIFOCount;
	dram_in.BitstreamFIFOSize1 = dcc_profile->BitstreamFIFOSize;
	dram_in.XferFIFOCount1 = dcc_profile->XferFIFOCount;
	dram_in.BitstreamFIFOSize2 = dcc_profile->BitstreamFIFOSize;
	dram_in.XferFIFOCount2 = dcc_profile->XferFIFOCount;
	dram_in.BitstreamFIFOSize3 = dcc_profile->BitstreamFIFOSize;
	dram_in.XferFIFOCount3 = dcc_profile->XferFIFOCount;
	dram_in.BitstreamFIFOSize4= dcc_profile->BitstreamFIFOSize;
	dram_in.XferFIFOCount4 = dcc_profile->XferFIFOCount;
	dram_in.BitstreamFIFOSize5= dcc_profile->BitstreamFIFOSize;
	dram_in.XferFIFOCount5 = dcc_profile->XferFIFOCount;
	dram_in.BitstreamFIFOSize6 = dcc_profile->BitstreamFIFOSize;
	dram_in.XferFIFOCount6 = dcc_profile->XferFIFOCount;
	dram_in.BitstreamFIFOSize7 = dcc_profile->BitstreamFIFOSize;
	dram_in.XferFIFOCount7 = dcc_profile->XferFIFOCount;
	dram_in.BitstreamFIFOSize8 = dcc_profile->BitstreamFIFOSize;
	dram_in.XferFIFOCount8 = dcc_profile->XferFIFOCount;

	err = RUAExchangeProperty(pDCC->pRUA, audio_decoder, RMAudioDecoderPropertyID_DRAMSizePCMX, &dram_in, 
							  sizeof(dram_in), &dram_out, sizeof(dram_out));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error getting property RMAudioDecoderPropertyID_DRAMSize! %s\n", RMstatusToString(err)));
		return err;
	}

	profile.BitstreamFIFOSize0  = dram_in.BitstreamFIFOSize0;
	profile.XferFIFOCount0 = dram_in.XferFIFOCount0;
	profile.BitstreamFIFOSize1  = dram_in.BitstreamFIFOSize1;
	profile.XferFIFOCount1 = dram_in.XferFIFOCount1;
	profile.BitstreamFIFOSize2  = dram_in.BitstreamFIFOSize2;
	profile.XferFIFOCount2 = dram_in.XferFIFOCount2;
	profile.BitstreamFIFOSize3  = dram_in.BitstreamFIFOSize3;
	profile.XferFIFOCount3 = dram_in.XferFIFOCount3;
	profile.BitstreamFIFOSize4  = dram_in.BitstreamFIFOSize4;
	profile.XferFIFOCount4 = dram_in.XferFIFOCount4;
	profile.BitstreamFIFOSize5  = dram_in.BitstreamFIFOSize5;
	profile.XferFIFOCount5 = dram_in.XferFIFOCount5;
	profile.BitstreamFIFOSize6  = dram_in.BitstreamFIFOSize6;
	profile.XferFIFOCount6 = dram_in.XferFIFOCount6;
	profile.BitstreamFIFOSize7  = dram_in.BitstreamFIFOSize7;
	profile.XferFIFOCount7 = dram_in.XferFIFOCount7;
	profile.BitstreamFIFOSize8  = dram_in.BitstreamFIFOSize8;
	profile.XferFIFOCount8 = dram_in.XferFIFOCount8;
	profile.UnProtectedAddress = 0;
	profile.UnProtectedSize = dram_out.UnProtectedSize;
	tmp = (RMuint32)MixingMode;

	err = RUASetProperty(pDCC->pRUA, audio_decoder, RMAudioDecoderPropertyID_PCMXMix, &tmp, sizeof(tmp), 0);

	if (profile.UnProtectedSize > 0) {
		profile.UnProtectedAddress = DCCMalloc(pDCC, pDCC->dram, RUA_DRAM_UNCACHED, profile.UnProtectedSize);
		if (!profile.UnProtectedAddress) {
			RMDBGLOG((ENABLE, "ERROR: could not allocate 0x%08lX bytes in uncached DRAM %lu!\n", profile.UnProtectedSize, 0L));
			return RM_FATALOUTOFMEMORY;
		}
		RMDBGLOG((ENABLE, "(audio decoder : %lu) audio uncached addr: 0x%08lX, size 0x%08lX, end: 0x%08lX\n", (*ppAudioSource)->decoder_moduleID, profile.UnProtectedAddress, profile.UnProtectedSize, profile.UnProtectedAddress + profile.UnProtectedSize));
	}
	(*ppAudioSource)->uncached_address = profile.UnProtectedAddress;

	DCCSP(pDCC->pRUA, audio_decoder, RMAudioDecoderPropertyID_OpenPCMX, &profile, sizeof(profile));

	return RM_OK;
}


static void init_globals(void)
{
	int i = 0;
	for (i = 0 ; i< MAX_TASK_COUNT; i++)
		SendContext[i].compressed_audio = FALSE;
	bypass_drm = FALSE;
	audioStreams = 0;
}


static void setcmd(struct RM_PSM_Context PSMcontex,RMbool sw)
{
	if (PSMcontext.currentActivePSMContext > 0) {
		sw ? (context[0].cmd_ex |=   (RMuint32)(0x01) << (PSMcontext.currentActivePSMContext-1)) : 
			 (context[0].cmd_ex &= ~((RMuint32)(0x01) << (PSMcontext.currentActivePSMContext-1)));
	}
}


static int iscmd(int decoder)
{
	return  ((context[decoder].status == 0x00) && ((decoder == 0)? (context[0].cmd_ex & 0x01) : (context[0].cmd_ex & 0x02)));

}


static void show_mixing_options()
{
	fprintf(stderr,"\n[Audio Mixing and Selection Commands]");
	fprintf(stderr,"\n----------------------");
	fprintf(stderr,"\nPAUSE: ? <dec#> space");
	fprintf(stderr,"\nPLAY:  ? <dec#> p");
	fprintf(stderr,"\nSTOP:  ? <dec#> s");
	fprintf(stderr,"\nQUIT:  q q");
	fprintf(stderr,"\nq k decrease weight 1st decoder");
	fprintf(stderr,"\nq l increase weight 1st decoder");
	fprintf(stderr,"\nq , decrease weight 2nd decoder");
	fprintf(stderr,"\nq . increase weight 2nd decoder\n");

}


static void show_usage(char *progname)
{
	show_playback_options();
	show_audio_options();
	show_mixing_options();
	fprintf(stderr, "--------------------------------\n");
	fprintf(stderr, "Minimum cmd line: %s -task <task count> -c <codec> <file name>\n", progname);
	fprintf(stderr, "Minimum cmd line PCMX: %s -task 0 -c pcmx [stream count] [mode1] [bps1] [endian1] [gain1] [panx1] [pany1]... [file1.pcm]... -task 1 -c <codec> <file name>\n", progname);
	fprintf(stderr, "\t\tNote: Range for gain[i] is [-51, 12], -51 is muting, -50 = -50dB, -49 is -49dB, and so on\n");
	fprintf(stderr, "\t\tNote: Range for panx[i] and pany[i] is [-1.0, 1.0]\n");
	fprintf(stderr, "\nExample: %s -task 0 -ae 0 -ad 0 -c ac3 /media/elementary/ac3/SUZVGA1.AC3 -task 1 -ae 0 -ad 1 -c wma /media/asf/wma/music.wma", progname);
	fprintf(stderr, "\n1 channel PCMX/AC3 Mix Example: %s -task 0 -ae 0 -ad 0 -afreq 48000 -c ac3 /media/elementary/ac3/DOLBY.AC3 -task 1 -ae 0 -ad 1 -afreq 48000 -c pcmx 1 1 16 0 0 -1.0 -1.0 /media/elementary/pcm/pcm_greeting_16bit_msb_2ch_48k.pcm", progname);

	fprintf(stderr, "--------------------------------\n");

	exit(1);
}

#define	FILENAME_MAXLENGTH (9)

static char* pcmx_filenames[FILENAME_MAXLENGTH];
static int pcmx_fcnt = 0;
static int parse_cmdline(int argc, char *argv[])
{
	int i;
	RMstatus err;
	int task_count = 0;

	if (task_count == 0) {
		play_opt = &playback_options[0];
		context[0].id = 0;
	}

	if (argc < 2)
		show_usage(argv[0]);

	i = 1;
	while ((argc > i)) {
		if (argv[i][0] != '-') {
			if ((audio_opt->Codec != AudioDecoder_Codec_PCMX) && (play_opt->filename == NULL)) {
				play_opt->filename = argv[i];
				i++;
			}
			else if ((audio_opt->Codec == AudioDecoder_Codec_PCMX) && (pcmx_fcnt < FILENAME_MAXLENGTH)) {
				pcmx_filenames[pcmx_fcnt] = argv[i];
				pcmx_fcnt++;
				i++;
			}
			else {
				fprintf(stderr,"\nError Parse FILE "); fflush(stdout);
				show_usage(argv[0]);
			}
		}
#if (EM86XX_CHIP == EM86XX_CHIPID_TANGO2)
		else if ( ! strcmp(argv[i], "-mix")) {
			MixingMode = EMhwlibAudioEngineMixMode_All;
			i++;
		}
		else if ( ! strcmp(argv[i], "-master")) {

			if (argc > i+1) {
				MixingEngineMaster = strtol(argv[i+1], NULL, 10);
				if (MixingEngineMaster > 2) {
					fprintf(stderr,"only 2 engines supported for mixing");
					show_usage(argv[0]);
				}
				i+=2;
			}
			else
				show_usage(argv[0]);
		}
#endif // (EM86XX_CHIP == EM86XX_CHIPID_TANGO2)
		else if ( ! strcmp(argv[i], "-task")) {
			if (argc > i+1) {
				int j = 0;
				RMuint32 task_index;
				task_index = strtol(argv[i+1], NULL, 10);
				i+=2;
				if (task_count > MAX_TASK_COUNT) {
					fprintf(stderr,"\nError Parse task-cnt "); fflush(stdout);
					show_usage(argv[0]);

				}
				for (j = 0; j < task_count; j++) {
					if ( task_index != context[j].id)
						continue;
				}
				if ( (task_count == 0) || (j >= task_count)) {
					play_opt = &playback_options[task_count];
					audio_opt = &audio_options[task_count];
					context[task_count].id = task_index;
					task_count++;
				}
			}
			else {
				fprintf(stderr,"\nError Parse task "); fflush(stdout);
				show_usage(argv[0]);
			}
		}
		else {
			err = parse_playback_cmdline(argc, argv, &i, play_opt);
			if (err == RM_ERROR) {
				fprintf(stderr,"\nError Parse play_opt\n"); fflush(stdout);
				show_usage(argv[0]);
			}

			if (!argv[i]) break;
			err = parse_audio_cmdline(argc, argv, &i, audio_opt);
			if (RMFAILED(err)) {
				fprintf(stderr,"\nError Parse audio_opt\n"); fflush(stdout);
				show_usage(argv[0]);
			}
			//Special for PCMX
			if (audio_opt->Codec == AudioDecoder_Codec_PCMX) {
				int max_stream = (int) strtol(argv[i], NULL, 10);
				int k = 0;
				i++;
				for (k = 0;k<max_stream;k++) {
					context[task_count-1].pcmx_mode[k] = strtol(argv[i], NULL, 10);
					i++;
					context[task_count-1].pcmx_bps[k] = strtol(argv[i], NULL, 10);
					i++;
					context[task_count-1].pcmx_endian[k] = strtol(argv[i], NULL, 10);
					i++;
					context[task_count-1].pcmx_gain[k] = strtol(argv[i], NULL, 10);
					RMDBGLOG((ENABLE, "^^^^^^^^ Gain[%d]=%ld\n", k, context[task_count-1].pcmx_gain[k]));
					i++;
					//context[task_count-1].pcmx_pan[k] = strtol(argv[i], NULL, 10);
					{
						float tempf;
						sscanf((const char*)argv[i], (const char*)"%f", &tempf);
						context[task_count-1].pcmx_panx[k] = (RMreal)tempf;
						RMDBGLOG((ENABLE, "^^^^^^^^^^^ pan_x = %f\n", k, context[task_count-1].pcmx_panx[k]));
						i++;
						sscanf((const char*)argv[i], (const char*)"%f", &tempf);
						context[task_count-1].pcmx_pany[k] = (RMreal)tempf;
						RMDBGLOG((ENABLE, "^^^^^^^^^^^ pan_y = %f\n", k, context[task_count-1].pcmx_pany[k]));
						i++;
					}
				}
			}

			if (err != RM_PENDING)
				continue;
		}
	}
	return task_count;
}


static int Process_Key(RMbool release)
{
	RMstatus err = process_command(&PSMcontext, pdcc_info, &actions);

	if (RMFAILED(err)) {
		fprintf(stderr, "Error while processing key %d\n", (unsigned int)err);
		return PMA_QUIT;
	}

	if ((actions.cmd == RM_QUIT) && (!actions.cmdProcessed)) {
		RMDBGLOG((DISABLE, " RM_QUIT  %d\n", actions.cmd));

#if (TMP_FIX_MIX_WEIGHT_KEYS)
		{
			RMascii k;
			k = RMGetKey();
			switch (k) {
				case 'k':
					mixer_set_weight_index(0, -1);
					mixer_set_weight(0);
					break;
				case 'l':
					mixer_set_weight_index(0, 1);
					mixer_set_weight(0);
					break;
				case ',':
					mixer_set_weight_index(1, -1);
					mixer_set_weight(1);
					break;
				case '.':
					mixer_set_weight_index(1, 1);
					mixer_set_weight(1);
					break;
				default:
					RMDBGLOG((ENABLE, "PMA_QUIT\n"));
	
					if (release) {
						RMDBGLOG((ENABLE,"RUAReleaseBuffer\n"));

						RUAReleaseBuffer(context[0].pDMA, context[0].buf);
						RUAReleaseBuffer(context[1].pDMA, context[1].buf);
					}
					return PMA_QUIT;
					break;
	
			}
			return 0x55;
		}
 #endif  // TMP_FIX_MIX_WEIGHT_KEYS
		RMDBGLOG((DISABLE, "PMA_QUIT\n"));
		RMDBGLOG((ENABLE,"RUAReleaseBuffer\n"));

			if (context[0].pDMA) RUAReleaseBuffer(context[0].pDMA, context[0].buf);
			if (context[1].pDMA) RUAReleaseBuffer(context[1].pDMA, context[1].buf);

		return PMA_QUIT;
	}


	if ((actions.cmd == RM_PAUSED) && (!actions.cmdProcessed)) {
		setcmd(PSMcontext,0x00);
		return PMA_REDO;
	}
	if ((actions.cmd == RM_PLAY) && (!actions.cmdProcessed)) {
		setcmd(PSMcontext,0x01);
		return PMA_REDO;
	}
	return PMA_OK;
}


static RMstatus StartAudioCapture(struct dcc_context *dcc_info, RMuint32 audio_capture, RMuint32 align, RMbool LSB_first,RMuint8 i)
{
	struct AudioCapture_Open_type capture_open;
	enum AudioCapture_Source_type capture_source;
	enum AudioCapture_SpdifDataType_type capture_type;
	enum AudioCapture_Capture_type cmd = AudioCapture_Capture_On;
	RMstatus err;
	struct PLL_Frequency_type f;
	RMuint32 SampleClock;

#if 1					       //(EM86XX_CHIP == EM86XX_CHIPID_TANGO2)
	{
		//printf("start set RCLK2...\n");
		SampleClock = 48000;
		f.PLL = PLLGen_cd_6;
		f.PLLOutput = PLLOut_1;		       // or _1 or _2
		f.MaxM = 31;
		f.Clock = ClockSignal_RClk2;
		f.Frequency = SampleClock * 256;
		RUASetProperty(dcc_info->pRUA, PLL, RMPLLPropertyID_Frequency, &f, sizeof(f), 0);
		//printf("finish set RCLK2...\n");
	}
#endif

	memset(&capture_open, 0, sizeof(struct AudioCapture_Open_type));

	capture_open.CaptureMode = 1;		       // Pass-through
						       // Delay is 45000 Hz based start PTS
	capture_open.Delay = audio_options[i].C