play_multiple_audio.c

Sample code for use on smp 863x processor.

/*
 *
 * Copyright (c) Sigma Designs, Inc. 2002. All rights reserved.
 * Cleanup version
 */

/**
	@file dcc_demo.c
	@brief sample application to access the Mambo chip and test DMA transfers
	
	@author Rex Ching
   	@ingroup dccsamplecode
*/
#include <ctype.h>
#include "../samples/sample_os.h"

#define TMP_FIX_MIX_WEIGHT_KEYS  //Temporary fix the key pressing features of Weight Mixing
#define ALLOW_OS_CODE 1
#include "../dcc/include/dcc.h"
#include "../samples/common.h"

//--------WMA
#include "../rmasfdemux/include/rmasfdemuxapi.h"
#include "../rmasfdemux/include/wmdrm.h"
#include "../rmasfdemux/include/wmdrmopl.h"
#include "../rmwmaprodecoder/include/rmwmaprodefine.h"
#include "../rmwmaprodecoder/include/rmwmaprodecoderapi.h"
//-------WMA
//#define DBX
#include "../dcc/src/dcc_common.h"

#define GETBUFFER_TIMEOUT_US 0 //1000000
#define WAIT_EOS_TIMEOUT_US   10000   //Reduce from 1 min to 10000us to avoid silence at waiting EOS, 
									  //application will keep waiting even its timeout till an EOS event occured	
//#define WAIT_COMMAND_TIMEOUT_US 100000
#define DMA_BUFFER_SIZE_LOG2 17 //16 //15
#define DMA_BUFFER_COUNT     8 //16 //32

#define DMA_PCMX_BUFFER_SIZE_LOG2 17 //16 //15
#define DMA_PCMX_BUFFER_COUNT 2 //4 //8  


#define SENDDATA_TIMEOUT_US 1000000
#define REPACK_SIZE (4096)

#define AUDIO_FIFO_SIZE (1024*1024)
#define XFER_FIFO_COUNT (32)

#define AUDIO_PCMX_FIFO_SIZE (512*1024)
#define XFER_PCMX_FIFO_COUNT (32)


#define KEYFLAGS (SET_KEY_PLAYBACK | SET_KEY_AUDIO)

#define RM_DEVICES_STC 0x1
#define RM_DEVICES_AUDIO 0x4
#define MAX_WMAPRO_INFO 128

//PLAY MUL AUDIO STATUS
#define PMA_GETBUFFER_ERROR		0x00
#define PMA_SENDBUFFER_ERROR	0x01
#define PMA_SENDDATA_ERROR		0xff
#define PMA_ERROR				0xfe
#define PMA_OK					0x02
#define PMA_DECODER_PENDING		0x03
#define PMA_READFILE_ERROR		0x04
#define PMA_READFILE_EOF		0x05
#define PMA_READFILE_EOF_LOOP	0x06
#define PMA_EOS_PENDING			0x07
#define PMA_REDO				0x08	
#define PMA_QUIT				0x09

#define MAX_TASK_COUNT			2
static RMbool rptpcmx=FALSE;
#ifdef TMP_FIX_MIX_WEIGHT_KEYS
//RMuint32 mixing_weights[]={10,20,30,40,50,60,70,80,90,100};
struct AudioDecoder_MixerWeight_type cmdblock;
RMuint32 weight[MAX_TASK_COUNT][8]=
{
  {100,100,100,100,100,100,100,100},
  {100,100,100,100,100,100,100,100}  
};
#endif 

static struct RUAEvent e[MAX_TASK_COUNT];
static RMuint32 nEvents=0;
static RMuint32 pcmx_rcnt=0;
static RMbool	nEOS[MAX_TASK_COUNT]={0,0};
static RMuint32 nStatus[MAX_TASK_COUNT]={0x02,0x02};
static RMbool gMixingMode =FALSE;

//----------PMA protoypes
static void PMAAddEvents(struct RUAEvent e[], RMuint32* nEvents, RMuint32 mask, RMuint32 decoder);

#define ASF_DMA_BUFFER_SIZE_LOG2	15	// 32kB
#define ASF_DMA_BUFFER_COUNT		16	// 16*32kB ~= 512KB
#ifdef WMAPRO_V1
#define AUDIO_DMA_BUFFER_SIZE_LOG2	16		// 64kB
#define AUDIO_DMA_BUFFER_COUNT		2		// 2*64kB ~= 128KB
#else
#define AUDIO_DMA_BUFFER_SIZE_LOG2	17		// 128kB
#define AUDIO_DMA_BUFFER_COUNT		2		// 2*128kB ~= 256KB
#endif

#define VIDEO_XFER_FIFO_COUNT	(ASF_DMA_BUFFER_COUNT * (1<<ASF_DMA_BUFFER_SIZE_LOG2) / 2048)		// average video packet size = 2k
#define AUDIO_XFER_FIFO_COUNT	(AUDIO_DMA_BUFFER_COUNT * (1<<AUDIO_DMA_BUFFER_SIZE_LOG2) / 2048)	// average audio packet size = 2k

/* do NOT increase these values unless you have a reason to, otherwise, curacao wont be able to run due to lack of memory */
#define ASF_VIDEO_FIFO_SIZE		(3*1024*1024)	// 3s @ 1MB/s
#define ASF_AUDIO_FIFO_SIZE		(5*1024*1024)	// 5s @ 1MB/s 
#define ASF_KEYFLAGS (SET_KEY_DISPLAY | SET_KEY_PLAYBACK | SET_KEY_AUDIO | SET_KEY_DEBUG | SET_KEY_SPI)

/*
 * Globals, should be explicitely initialized in init_globals
 */
static RMbool bypass_drm;

static RMuint32 audioStreams;
static RMuint32 audioStreamTable[10];


#define PAYLOADDBG DISABLE
#define TRICKDBG DISABLE
#define SENDDBG DISABLE
#define WMAPRODBG	DISABLE

#define MAX_INDEX_NUMBER 5
#define INDEX_BUFFER_SIZE (200 * 1024)

typedef enum 
{
	RMasfIFrameFSM_Disabled = 0,
	RMasfIFrameFSM_Init,
	RMasfIFrameFSM_WaitIFrameMONChange,
	RMasfIFrameFSM_SkipNext
}RMasfIFrameFSMstates;

#define RM_DEVICES_VIDEO 0x2
#define RM_STREAM_VIDEO 0x1
#define RM_STREAM_AUDIO 0x2
#define RM_SKIP_TO_RESYNC 0x1

#define MAX_NUMBER_OF_AUDIO_STREAMS 16

#define RMAUDIO_4_28_CONVERT (1<<28)
struct wmapro_buffer_info {
	RMbool new_buffer;
	RMuint8 *ptr;
	RMuint32 size;
	struct emhwlib_info Info;
	RMuint32 Stream_Number;
	RMuint32 Media_Object_Number;
	RMuint32 fSendPTS;
	void *pBuffer;
};

struct asf_context 
{
	struct RUA *pRUA;
	struct RUABufferPool *pDMA;
	struct RUABufferPool *pDMAuncompressed;
	unsigned char *UncompressedBuffer;
	unsigned char *SequenceHeaderBuffer;
	RMbool FirstSystemTimeStamp;
	struct dcc_context *dcc_info;
	RMuint32 video_stream_index;
	RMuint32 audio_stream_index;
	RMuint32 cmd;
	RMbool SendVideoData;
	RMuint32 prev_video_media_object_number;
	RMuint32 video_frame_counter;
	RMuint32 VideoByteCounter;
	RMbool SendVideoPts;
	RMuint32 video_last_pts;	// used for video hack
	RMuint32 video_vop_tir;

	RMbool SendAudioData;
	RMuint32 prev_audio_media_object_number;
	RMuint32 audio_frame_counter;
	RMuint32 AudioByteCounter;
	RMbool SendAudioPts;
 	RMuint32 audio_vop_tir;
	RMuint32 start_ms; 	

	ExternWMAProVdecoder vDecoder;

	ExternalRMASFDemux vASFDemux;

	RMbool isIFrameMode;
	RMbool isTrickMode;
	RMint32 IFrameSize;
	RMbool SeekAudio;
	RMbool SeekVideo;
	RMuint32 PrevAudioMON;
	RMuint32 PrevVideoMON;


	struct AudioDecoder_WMAParameters_type wma_params;	
	RMuint32 WMAPROBitsPacketLength;

	RMfile f_bitstream;
	RMbool video_decoder_initialized;
	RMbool audio_decoder_initialized;

	RMuint32 Compression_ID;
	struct VideoDecoder_WMV9VSProp_type wmv9_prop;
	struct VideoDecoder_DIVX3VSProp_type divx3_prop;

	RMuint32 asf_packetSize;
	RMuint64 asf_Header_Object_Size;

	RMasfIFrameFSMstates IFrameFSMState;
	RMuint32 inband_aspect_ratio_x;
	RMuint32 inband_aspect_ratio_y;
	RMuint32 save_inband_aspect_ratio_y;
	RMuint32 save_inband_aspect_ratio_x;	

	RMint32 drmError;
	RMbool isContentEncrypted;
	RMbool unsupported_video;

	struct SurfaceAspectRatio_type InBandAspectRatioParams;
	RMbool setAspectRatio;
	RMuint64 Preroll;
	RMbool PrerollSET;
	RMuint64 Duration;
	RMbool ignoreCallback; 
	RMuint64 CurrentDisplayPTS;
	RMint32 IFrameDirection;
	RMbool VideoStreamFound;
	RMbool AudioStreamFound;
	RMbool isAudioOnlyFile;
	RMuint64 lastSTC;
	RMuint64 accurateAudioSeekTo;
	RMbool IgnoreAudio;

	RMuint32 Video_Codec_Specific_Data_Received;
	RMuint32 Audio_Codec_Specific_Data_Received;

	RMuint32 ContiguousVideoLength;
	RMuint32 ContiguousAudioLength;
	RMuint64 video_time_start;
	RMuint64 video_time_end;
	RMuint64 audio_time_start;
	RMuint64 audio_time_end;
	RMuint64 video_time_stamp;
	RMuint64 audio_time_stamp;
	RMint32 min_diff;
	RMint32 max_diff;
	RMuint32 packet_counter;
	RMuint32 DemuxProgramID;
	RMuint32 STCID;
	struct RMfifo *wmapro_fifo;
	RMuint64 prev_Audio_Presentaion_time;
	RMbool compressed_audio;
};
/* prototypes */
static RMstatus asfStop(struct asf_context *pSendContext, RMuint32 devices);
static RMstatus asfPlay(struct asf_context * pSendContext, RMuint32 devices, enum DCCVideoPlayCommand mode);
static RMstatus setup_audio_decoder(struct asf_context *pSendContext);

struct priv_cmdline 
{
	RMuint32 dummy;
};

static struct audio_cmdline *asf_audio_opt;
static struct playback_cmdline  *asf_play_opt;
static struct priv_cmdline priv_opt;
	


static RMstatus init_private_options(struct priv_cmdline *options)
{
	return RM_OK;
}


static void print_Audio_Stream_Properties
(
 void *context,
 unsigned char Stream_Number, unsigned short Codec_ID,
 unsigned short Number_of_Channels, unsigned long Samples_Per_Second,
 unsigned long Average_Number_of_Bytes_Per_Second,
 unsigned short Block_Alignment, unsigned short Bits_Per_Sample,
 unsigned char *Codec_Specific_Data, unsigned long Partial_Codec_Specific_Data_Size, unsigned long Codec_Specific_Data_Size
 ) {
	struct asf_context *pSendContext = (struct asf_context *) context;
	struct AudioDecoder_WMAParameters_type *wma_params = &(pSendContext->wma_params);
	RMstatus status;

	pSendContext->WMAPROBitsPacketLength = 0;
	pSendContext->Audio_Codec_Specific_Data_Received += Partial_Codec_Specific_Data_Size;

	RMDBGLOG((ENABLE,"print_Audio_Stream_Properties %lu, %lu, %lu\n", 
				pSendContext->Audio_Codec_Specific_Data_Received, 
				Partial_Codec_Specific_Data_Size, 
				Codec_Specific_Data_Size));

	if(Partial_Codec_Specific_Data_Size == Codec_Specific_Data_Size)
		pSendContext->Audio_Codec_Specific_Data_Received = Codec_Specific_Data_Size;
	
	if(pSendContext->Audio_Codec_Specific_Data_Received == Codec_Specific_Data_Size) {

		audioStreamTable[audioStreams++] = Stream_Number;

		RMDBGLOG((ENABLE, "Stream #%hu - Audio - \n", Stream_Number));
		RMDBGLOG((ENABLE, "%hu channel(s), %lu samples/second, %hu bits/sample\n",
			  Number_of_Channels, Samples_Per_Second, Bits_Per_Sample));
		RMDBGLOG((ENABLE, "    Bitrate: %lu bit/s, Block size is 0x%04x bytes [0x%05x bits]\n", 
			  Average_Number_of_Bytes_Per_Second * 8, Block_Alignment, Block_Alignment * 8));

		wma_params->VersionNumber = Codec_ID;
		wma_params->SamplingFrequency = Samples_Per_Second;
		wma_params->NumberOfChannels = Number_of_Channels;
		wma_params->Bitrate = Average_Number_of_Bytes_Per_Second * 8;
		wma_params->PacketSize = Block_Alignment * 8;
		wma_params->EncoderOptions = 0;
		wma_params->BitsPerSample = Bits_Per_Sample;
		wma_params->WMAProValidBitsPerSample = Bits_Per_Sample;
		wma_params->WMAProChannelMask = 0;
		wma_params->WMAProVersionNumber = 0;
		wma_params->OutputChannels = asf_audio_opt->WmaParams.OutputChannels;

		if (Codec_ID == 0x160) { // WMA Audio Version 1
			RMDBGLOG((ENABLE, "error, codec WMA Audio Version 1 not supported, disable audio\n"));
			pSendContext->SendAudioData = FALSE;
			return;
		}
			

		// Audio Codec Type Specific data in ASF
		if ( (Codec_ID == 0x161) || // WMA Audio Version 2
		     (Codec_ID == 0x7A21) ||
		     (Codec_ID == 0x7A22) ) {
			if (10 == Codec_Specific_Data_Size) { // 4 + 2 + 4
				RMuint32      dwSamplesPerBlock;
				RMuint16      wEncodeOptions;
				RMuint32      dwSuperBlockAlign;
				
				dwSamplesPerBlock = 
					  (((RMuint32) Codec_Specific_Data[3]) << 24)
					+ (((RMuint32) Codec_Specific_Data[2]) << 16)
					+ (((RMuint32) Codec_Specific_Data[1]) << 8)
					+  ((RMuint32) Codec_Specific_Data[0]);
				wEncodeOptions = 
					+ (((RMuint16) Codec_Specific_Data[5]) << 8)
					+  ((RMuint16) Codec_Specific_Data[4]);
				dwSuperBlockAlign = 
					  (((RMuint32) Codec_Specific_Data[9]) << 24)
					+ (((RMuint32) Codec_Specific_Data[8]) << 16)
					+ (((RMuint32) Codec_Specific_Data[7]) << 8)
					+  ((RMuint32) Codec_Specific_Data[6]);

				RMDBGLOG((ENABLE, 
					"    Audio codec ID: %04x,\n"
					"    Bits per block: 0x%04x\n"
                                        "    Encode option: 0x%04x \n",
					  (int) Codec_ID, (int) dwSamplesPerBlock, (int) wEncodeOptions));

				wma_params->EncoderOptions = wEncodeOptions;
			}
			else {
				RMDBGLOG((ENABLE, "Error: audio specific data has invalid size (%d)\n",
					  (int) Codec_Specific_Data_Size));
			}
		}

		// WMA pro type specific data (untested yet..)
		if (Codec_ID == 0x162 || Codec_ID == 0x163) { // WMA Audio Pro or WMALSL
			RMuint16      wValidBitsPerSample;
			RMuint32      dwChannelMask;
			RMuint16      wEncodeOptions;
			
			
			wValidBitsPerSample = 
				+ (((RMuint16) Codec_Specific_Data[1]) << 8)
				+  ((RMuint16) Codec_Specific_Data[0]);
			dwChannelMask = 
				  (((RMuint32) Codec_Specific_Data[5]) << 24)
				+ (((RMuint32) Codec_Specific_Data[4]) << 16)
				+ (((RMuint32) Codec_Specific_Data[3]) << 8)
				+  ((RMuint32) Codec_Specific_Data[2]);
			wEncodeOptions = 
				+ (((RMuint16) Codec_Specific_Data[15]) << 8)
				+  ((RMuint16) Codec_Specific_Data[14]);
			
			RMDBGLOG((ENABLE, 
				"    Audio codec ID: %04x,\n"
				"    %u valid bits/sample, %08X channel mask\n"
				"    0x%04x encode options\n",
				(int) Codec_ID,
				  (int) wValidBitsPerSample, (int) dwChannelMask, (int) wEncodeOptions));
			
			wma_params->EncoderOptions = wEncodeOptions;
			wma_params->WMAProValidBitsPerSample = wValidBitsPerSample;
			wma_params->WMAProChannelMask = dwChannelMask;