play_psfswpvr.c

Sample code for use on smp 863x processor.

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

/**
   @file play_psfdemux.c
   @brief sample application for hardware demux of EM86xx
	
   @author Aurelia Popa-Radu
   @ingroup dccsamplecode
*/

#include "../samples/sample_os.h"

#define ALLOW_OS_CODE 1
#include "../dcc/include/dcc.h"
#include "../samples/common.h"
#include "command_ids.h"

#include "play_psfdemux_helper.h"
#include "psfdemux_common.h"

#include <pthread.h>
#include "play_vdemux.h"


//#define IDENTIFY_CODECS_FIRST /* enable the detection of the codecs from the stream_type */

/* to enable or disable the debug messages of this source file, put 1 or 0 below */
#if 0
#define LOCALDBG ENABLE
#else
#define LOCALDBG DISABLE
#endif

#if 0
#define CALLDBG ENABLE
#else
#define CALLDBG DISABLE
#endif

#define FORCE_MONITOR		0
#define	FORCE_DECRYPTION	1


#define RM_DEVICES_ALL (RM_DEVICES_STC | RM_DEVICES_VIDEO | RM_DEVICES_AUDIO | RM_DEVICES_PSFDEMUX)

#define KEYFLAGS (SET_KEY_DISPLAY | SET_KEY_PLAYBACK | SET_KEY_AUDIO | SET_KEY_DEBUG | SET_KEY_SPI)


#define DMA_BUFFER_SIZE_LOG2	15	// 32k buffer
#define DMA_BUFFER_COUNT	16	// 32*32k = 0x100000 = 1M 
#define DEMUX_FIFO_SIZE		(1<<DMA_BUFFER_SIZE_LOG2) * DMA_BUFFER_COUNT	// match the dma pool for standalone
#define DEMUX_XFER_FIFO_COUNT	DMA_BUFFER_COUNT	// same as dma pool buffers - this application sends complete buffer every time. 

#define VIDEO_FIFO_SIZE		( 1792*1024) /* "-vfifo 1792", default same value as in play_demux and play_hwdemux */
#define AUDIO_FIFO_SIZE		(  128*1024)
#define SPU_FIFO_SIZE		(  104*1024)
#define VIDEO_XFER_FIFO_COUNT   (128) 
#define VIDEO_PTS_FIFO_COUNT    (512) /* ~8 sec fifo for 60 frames/sec */
#define VIDEO_INBAND_FIFO_COUNT (128)



#define MAX_EVENT_COUNT_PER_TASK     5 /* 4 events (demux, video, display, audio) for file playback and 1 receive event per task */
#define CPU_ERROR_EVENT_MASK        (1<<0)
#define DEMUX_RECEIVE_EVENT_MASK(i) (1<<(1+0+i*MAX_EVENT_COUNT_PER_TASK))
#define DEMUX_SEND_EVENT_MASK(i)    (1<<(1+1+i*MAX_EVENT_COUNT_PER_TASK))
#define DEMUX_EOS_EVENT_MASK(i)     (1<<(1+1+i*MAX_EVENT_COUNT_PER_TASK))
#define VIDEO_EOS_EVENT_MASK(i)     (1<<(1+2+i*MAX_EVENT_COUNT_PER_TASK))
#define DISPLAY_EOS_EVENT_MASK(i)   (1<<(1+3+i*MAX_EVENT_COUNT_PER_TASK))
#define AUDIO_EOS_EVENT_MASK(i)     (1<<(1+4+i*MAX_EVENT_COUNT_PER_TASK))


#define VIDEO_PID_FROM_CMDLINE		(1 << 0)
#define PCR_PID_FROM_CMDLINE		(1 << 1)
#define AUDIO_PID_FROM_CMDLINE		(1 << 2)
#define AV_PIDS_ENABLE_FIRST_TIME	(1 << 3)
#define	ECM0_PID_FROM_CMDLINE		(1 << 4)
#define	ECM1_PID_FROM_CMDLINE		(1 << 5)


//#define TEST_APID_SWITCH_WITHOUT_DEMUX_STOP /* keep it FALSE until completely tested */


struct dvb_csa_key arte_dvb_key_table[] = {
	{ TRUE, 0, EMhwlibScramblingBits_10, { 0xfc, 0x32, 0x54, 0x76, 0x94, 0xba, 0xdc, 0xfe },
	 { 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 },
	  ECM0_SECTION_ENTRY }, /* arte key starts from LSB (byte 0) */
};

/* STREAM-4.ts */
struct dvb_csa_key stream_dvb_key_table[] = {
	{ FALSE, 0xffffffff, EMhwlibScramblingBits_None, { 0x99, 0x33, 0x33, 0x33, 0x99, 0x33, 0x33, 0x33 },
	 { 0x20, 0xEA, 0x10, 0x0B, 0x31, 0x37, 0xE3, 0xA2, 0xCB, 0x47, 0x81, 0x72, 0x6A, 0x8D, 0x7C, 0x62 }, },
	{ FALSE, 0xffffffff, EMhwlibScramblingBits_None, { 0xff, 0x55, 0x55, 0x55, 0xff, 0x55, 0x55, 0x55 },
	 { 0x20, 0xEA, 0x10, 0xD2, 0xC1, 0x50, 0x97, 0x5F, 0x29, 0xCD, 0x2A, 0x43, 0xF8, 0x38, 0x81, 0x05 }, },
	{ FALSE, 0xffffffff, EMhwlibScramblingBits_None, { 0x33, 0x11, 0x11, 0x11, 0x33, 0x11, 0x11, 0x11 },
	 { 0x20, 0xEA, 0x10, 0x0B, 0x31, 0x37, 0xE3, 0xA2, 0xCB, 0x47, 0x81, 0x5A, 0x90, 0x63, 0x06, 0x7E }, },
	{ FALSE, 0xffffffff, EMhwlibScramblingBits_None, { 0x66, 0x22, 0x22, 0x22, 0x66, 0x22, 0x22, 0x22 },
	 { 0x20, 0xEA, 0x10, 0xB0, 0xB6, 0xA0, 0x39, 0xCD, 0xFD, 0x4F, 0x7F, 0x5A, 0x6A, 0xC4, 0x7A, 0x56 }, },
};

struct dvb_csa_key cweven_dvb_key_table[] = {
	{ FALSE, 0xffffffff, EMhwlibScramblingBits_None, { 0x34, 0x18, 0x3c, 0xe0, 0x41, 0xc2, 0x03, 0x7c },
	 { 0x00, 0x00, 0x00, 0x00, 0x91, 0x01, 0x02, 0x05, 0xFF, 0x02, 0x00, 0x17, 0x14, 0x00, 0x6E, 0x26 }, },
};

struct dvb_csa_key cwodd_dvb_key_table[] = {
	{ FALSE, 0xffffffff, EMhwlibScramblingBits_None, { 0x7e, 0x7e, 0x00, 0x00, 0xc8, 0x03, 0xc6, 0xff },
	 { 0x00, 0x00, 0x00, 0x00, 0x91, 0x01, 0x02, 0x05, 0xFF, 0x02, 0x00, 0x17, 0x15, 0x00, 0x8F, 0x26 }, },
};
	
struct dvb_csa_key ecm1_dvb_key_table[] = {
	{ TRUE, 0, EMhwlibScramblingBits_11, { 0x8b, 0xbe, 0xba, 0x13, 0x69, 0xb2, 0xfb, 0xbc },
	 { 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 },
	  ECM0_SECTION_ENTRY }, /* 1ECM key starts from LSB (byte 0) */
};
	
struct dvb_csa_key ecm4_dvb_key_table[] = {
	/* to prove that ECM parsing is Ok invalidate key_byte_counter and scrambling settings */
	{  FALSE, 0xffffffff, EMhwlibScramblingBits_None, /*0x00000000, EMhwlibScramblingBits_10,*/ { 0x5e, 0x2d, 0x29, 0x08, 0xbd, 0x2d, 0x61, 0x2f },
	 { 0x00, 0x02, 0x2D, 0x5E, 0xE4, 0x00, 0x49, 0x15, 0x09, 0x04, 0x00, 0x00, 0x01, 0x4D, 0x04, 0x4E }, },
	{  FALSE, 0xffffffff, EMhwlibScramblingBits_None, /*0x00E3F3F0, EMhwlibScramblingBits_11,*/ { 0x5c, 0x2c, 0x28, 0x08, 0xba, 0x2c, 0x60, 0x2e },
	 { 0x00, 0x02, 0x2C, 0x5C, 0xE4, 0x00, 0x45, 0x15, 0x09, 0x04, 0x00, 0x00, 0x01, 0x4D, 0x04, 0x4E }, },
	{  FALSE, 0xffffffff, EMhwlibScramblingBits_None, /*0x01E61c00, EMhwlibScramblingBits_10,*/ { 0x62, 0x2f, 0x2b, 0x08, 0xbf, 0x2f, 0x63, 0x2d },
	 { 0x00, 0x02, 0x2F, 0x62, 0xE4, 0x00, 0x51, 0x15, 0x09, 0x04, 0x00, 0x00, 0x01, 0x4D, 0x04, 0x4E }, },
	{  FALSE, 0xffffffff, EMhwlibScramblingBits_None, /*0x02e56880, EMhwlibScramblingBits_11,*/ { 0x60, 0x2e, 0x2a, 0x08, 0xbc, 0x2e, 0x62, 0x2c },
	 { 0x00, 0x02, 0x2E, 0x60, 0xE4, 0x00, 0x4D, 0x15, 0x09, 0x04, 0x00, 0x00, 0x01, 0x4D, 0x04, 0x4E }, },
};

/* CWtest.trp */
struct dvb_csa_key cwtest_dvb_key_table[] = {
	{ TRUE, 0, EMhwlibScramblingBits_10, { 0x15, 0x83, 0xfa, 0x98, 0xbf, 0x8e, 0xca, 0x67 },
	 { 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 },
	  ECM0_SECTION_ENTRY }, /* CWtest even key starts from LSB (byte 0) */
	{ TRUE, 0, EMhwlibScramblingBits_11, { 0x34, 0x23, 0x48, 0xc9, 0xb3, 0x42, 0xfd, 0x74 },
	 { 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 },
	  ECM0_SECTION_ENTRY }, /* CWtest odd key starts from LSB (byte 0) */
};

/* vgs3.mpg */
struct dvb_csa_key vgs3_dvb_key_table[] = {
	/* to prove that ECM parsing is Ok invalidate key_byte_counter and scrambling settings */
	{  FALSE, 0xffffffff, EMhwlibScramblingBits_None, { 0x7A, 0x03, 0xFF, 0x78, 0x74, 0x80, 0x01, 0xF3 },
	 { 0x00, 0x00, 0x00, 0x00, 0x91, 0x01, 0x02, 0x05, 0xFF, 0x02, 0x00, 0x17, 0x64, 0x00, 0xBA, 0x26 }, },
	{  FALSE, 0xffffffff, EMhwlibScramblingBits_None, { 0x8B, 0x3F, 0x0E, 0x3E, 0x7E, 0x00, 0x78, 0x06 },
	 { 0x00, 0x00, 0x00, 0x00, 0x91, 0x01, 0x02, 0x05, 0xFF, 0x02, 0x00, 0x17, 0x65, 0x00, 0xC0, 0x26 }, },
	{  FALSE, 0xffffffff, EMhwlibScramblingBits_None, { 0x20, 0x60, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00 },
	 { 0x00, 0x00, 0x00, 0x00, 0x91, 0x01, 0x02, 0x05, 0xFF, 0x02, 0x00, 0x17, 0x66, 0x00, 0xC6, 0x26 }, },
	{  FALSE, 0xffffffff, EMhwlibScramblingBits_None, { 0xAF, 0x00, 0xE0, 0xCF, 0xF8, 0x00, 0x00, 0xF8 },
	 { 0x00, 0x00, 0x00, 0x00, 0x91, 0x01, 0x02, 0x05, 0xFF, 0x02, 0x00, 0x17, 0x67, 0x00, 0xCC, 0x26 }, },
};

/* suitei05_KDDI_DRM.m2t */
struct aes_key skf_aes_key_table[] = {
	{ TRUE, 0, EMhwlibScramblingBits_10_11, { 0xEA, 0x0C, 0xC2, 0xAA, 0xFE, 0x98, 0x46, 0xB8, 0x9A, 0xA0, 0xC2, 0xA0, 0xBC, 0x24, 0x1A, 0xB2 },
	 { 0xA8, 0xF6, 0x7F, 0xD7, 0x53, 0x67, 0x64, 0x79, 0xBD, 0xCA, 0x94, 0x13, 0xB7, 0xB1, 0xB6, 0xBE },
	 { 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 },
	  ECM0_SECTION_ENTRY }, /* KDDI_DRM even/odd key starts from LSB (byte 0) */
};

/* dsodd.ts */
struct aes_key dsodd_aes_key_table[] = {
	{ TRUE, 0, EMhwlibScramblingBits_11, { 0xBA, 0x8C, 0x51, 0xC2, 0x84, 0x5D, 0x40, 0xB3, 0xBA, 0x8C, 0x51, 0xC2, 0x84, 0x5D, 0x40, 0xB3 },
	 { 0, },
	 { 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 },
	  ECM0_SECTION_ENTRY }, /* KDDI_DRM even/odd key starts from LSB (byte 0) */

};

/* scrambled.ts */
struct aes_key scrambled_aes_key_table[] = {
	{ FALSE, 0xffffffff, EMhwlibScramblingBits_10, { 0xaa, 0xc0, 0xb9, 0xf4, 0x26, 0xdf, 0x3f, 0xc9, 0xaa, 0xc0, 0xb9, 0xf4, 0x26, 0xdf, 0x3f, 0xc9 },
	 {0,},
	 { 0x75, 0x21, 0x00, 0x00, 0x3A, 0x95, 0x81, 0xAF, 0x00 }, ECM0_SECTION_ENTRY },
};

/* dscps.ts */
struct aes_key dscps_aes_key_table[] = {
	/* 0x81 in bitstream */
	{ FALSE, 0xffffffff, EMhwlibScramblingBits_11, { 0x32, 0xB3, 0x7C, 0x41, 0xF2, 0xFE, 0xE9, 0x30, 0x32, 0xB3, 0x7C, 0x41, 0xF2, 0xFE, 0xE9, 0x30 },
	 {0,},
	 { 0x7F, 0x77, 0x00, 0x00, 0x42, 0xD6, 0x24, 0x99, 0x00 }, ECM0_SECTION_ENTRY },
	
	/* 0x80 in bitstream */
	{ FALSE, 0xffffffff, EMhwlibScramblingBits_10, { 0xA5, 0x2D, 0xA5, 0xF5, 0x45, 0xF3, 0xE4, 0xA7, 0xA5, 0x2D, 0xA5, 0xF5, 0x45, 0xF3, 0xE4, 0xA7 },
	 {0,},
	 { 0x7F, 0x77, 0x00, 0x00, 0x42, 0xD6, 0x25, 0xB7, 0x00 }, ECM0_SECTION_ENTRY },
	
	/* 0x81 in bitstream */
	{ FALSE, 0xffffffff, EMhwlibScramblingBits_11, { 0x5F, 0xDB, 0xFF, 0x19, 0x71, 0x4F, 0x37, 0xBE, 0x5F, 0xDB, 0xFF, 0x19, 0x71, 0x4F, 0x37, 0xBE },
	 {0,},
	 { 0x7F, 0x77, 0x00, 0x00, 0x42, 0xD6, 0x26, 0xD5, 0x00 }, ECM0_SECTION_ENTRY },
};

/* ############## AES_CBC_PRECIPHER TEST CODE BEGIN ############## */
/* hardcoded keys for pre-encrypted test files (ex: mummy.2keys.800000.aes.m2t) */
struct aes_2keys_test precipher_aes_key_table[] = {
	{
	 0x800000,EMhwlibScramblingBits_PreCipher,
	{0x49,0x03,0x29,0xba,0x3d,0x90,0x46,0xbc,0x74,0x89,0x59,0xc5,0x38,0x7a,0xe4,0x56},
	{0xd9,0xb7,0x51,0xdb,0xd7,0x9e,0x69,0x44,0x3c,0xda,0xa0,0xbe,0xef,0x2e,0xe8,0x8c},
	{0xb2,0xea,0x87,0x02,0x53,0x17,0xe8,0x07,0x46,0x44,0x41,0x5e,0xe7,0x59,0xf4,0x72},
	{0xe8,0x8d,0x6f,0xd8,0x7e,0x4d,0xe5,0xe7,0x71,0xe0,0xcd,0x3e,0x2c,0x2c,0x0c,0xa8},
	},
};
/* ############## AES_CBC_PRECIPHER TEST CODE END ############### */

struct dvb_arib_key arib_key_table[] = {
	{ { 0xE2, 0x49, 0xA7, 0x1D, 0xA6, 0x48, 0xBA, 0xBE, 0xF4, 0x29, 0x58, 0x2B, 0x2C, 0x68, 0xC1, 0x81, },
	  { 0x98, 0x7D, 0x2E, 0x0D, 0x84, 0x40, 0x4E, 0xB7, 0xB7, 0x4B, 0x9D, 0x68, 0x21, 0x39, 0x99, 0xEC,
	    0x1B, 0x6C, 0xC3, 0xC4, 0xF5, 0x9C, 0xDF, 0x32, 0x5C, 0xEA, 0x17, 0x4B, 0x66, 0x04, 0x31, 0x36, },
	  { 0x11, 0x09, 0x69, 0x19, 0x99, 0x19, 0x27, 0xFE, },
	  { 0xD0, 0xAF, 0x11, 0xA6, 0xFA, 0x13, 0x1D, 0x34, 0x4E, 0xA0, 0xFA, 0xC4, 0xC2, 0x0C, 0x70, 0x1B, },
	  { 0x63eae700, 0xa1accee6, 0xf71707a4, 0x08f8ace8, 0xf366cfbd, 0x64cfc850, 0x27ff6a62, 0x04126080,
	    0x55fd1194, 0x6e78f387, 0xde6e4a3f, 0x4987d49c, 0x445f67e5, 0xfca95599, 0x2c08bd3e, 0x1447c586,
	    0x7f0a3136, 0x9079cc96, 0x805cbde7, 0x405f4583, 0x4448c1cc, 0xbb59bd71, 0xbbbcf7a6, 0xc6744312,
	    0x6d4ed7ef, 0xb4466128, 0xd529efc9, 0x6f902f5a, 0xf94841f5, 0x44181d60, 0x03842c52, 0x3c4963f5,
	    0xba74a409, 0x605ef98d, 0x845bdf08, 0x06fa2d42, 0x29f56633, 0xa6a8945c, 0x3fd4ff76, 0xa99c247a,
	    0xbdda5524, 0x12a65b7b, 0x88b3bf26, 0x6a78efd1, 0x59a260ba, 0x6fe71a0c, 0x1ac7ff46, 0xcce4ba1b,
	    0x622fd9ce, 0x243142c3, 0x4a039d1e, 0xdc06ddc4, 0xd68789c9, 0xce36a6ff, 0x0c7c5aea, 0x6e59663d,
	    0x8b736213, 0x9b8d35f0, 0x93e7c015, 0x9ac106d5, 0x23f7ee91, 0x23c6fffd, 0x44b99318, 0x00a9e949, }, },
	{ { 0xB4, 0x3E, 0x38, 0xEB, 0xA0, 0x73, 0x62, 0x61, 0xEC, 0x01, 0x7B, 0x88, 0xE2, 0xE9, 0x7F, 0xD5, },
	  { 0x98, 0x7D, 0x2E, 0x0D, 0x84, 0x40, 0x4E, 0xB7, 0xB7, 0x4B, 0x9D, 0x68, 0x21, 0x39, 0x99, 0xEC,
	    0x1B, 0x6C, 0xC3, 0xC4, 0xF5, 0x9C, 0xDF, 0x32, 0x5C, 0xEA, 0x17, 0x4B, 0x66, 0x04, 0x31, 0x36, },
	  { 0x11, 0x09, 0x69, 0x19, 0x99, 0x19, 0x27, 0xFE, },
	  { 0x2A, 0xBC, 0x37, 0x52, 0x30, 0xB5, 0xC9, 0x49, 0x4E, 0xA0, 0xFA, 0xC4, 0xC2, 0x0C, 0x70, 0x1B, },
	  { 0x65eb57ba, 0x19efe18e, 0x9fc5ce64, 0x8d286cbb, 0x79214dc1, 0x1aa382d5, 0x91605333, 0xd80aba03,
	    0x7911579f, 0x21a1408a, 0x0136fa74, 0xdbab6838, 0xaa60e766, 0x0e9f1b3e, 0xc2c03780, 0x4b4b52da,
	    0x98725ee6, 0x80fbd90c, 0x1f258b51, 0x47676ee8, 0xd5ac63ab, 0x75c6f590, 0xae953af9, 0x7976f4c8,
	    0x0dc37560, 0xb155cb06, 0xcf35f63a, 0x42469935, 0xee529072, 0x97e371f2, 0xb479538d, 0x3c89b5aa,
	    0xba74a409, 0x605ef98d, 0x845bdf08, 0x06fa2d42, 0x29f56633, 0xa6a8945c, 0x3fd4ff76, 0xa99c247a,
	    0xbdda5524, 0x12a65b7b, 0x88b3bf26, 0x6a78efd1, 0x59a260ba, 0x6fe71a0c, 0x1ac7ff46, 0xcce4ba1b,
	    0x622fd9ce, 0x243142c3, 0x4a039d1e, 0xdc06ddc4, 0xd68789c9, 0xce36a6ff, 0x0c7c5aea, 0x6e59663d,
	    0x8b736213, 0x9b8d35f0, 0x93e7c015, 0x9ac106d5, 0x23f7ee91, 0x23c6fffd, 0x44b99318, 0x00a9e949, }, },
	{ { 0x6D, 0xB8, 0x47, 0x1E, 0x99, 0xB2, 0xF9, 0xED, 0x7C, 0x91, 0x24, 0x3C, 0x23, 0x3D, 0x2E, 0xEC, },
	  { 0x98, 0x7D, 0x2E, 0x0D, 0x84, 0x40, 0x4E, 0xB7, 0xB7, 0x4B, 0x9D, 0x68, 0x21, 0x39, 0x99, 0xEC,
	    0x1B, 0x6C, 0xC3, 0xC4, 0xF5, 0x9C, 0xDF, 0x32, 0x5C, 0xEA, 0x17, 0x4B, 0x66, 0x04, 0x31, 0x36, },
	  { 0x11, 0x09, 0x69, 0x19, 0x99, 0x19, 0x27, 0xFE, },
	  { 0xA3, 0x4F, 0x87, 0xF8, 0x27, 0x70, 0x3E, 0x3B, 0x44, 0x43, 0x39, 0x8F, 0x9D, 0x30, 0x33, 0x91, },
	  { 0x288d43df, 0x316ed164, 0xc1ede267, 0x0fb8b188, 0x4ad1b17a, 0x8c30d4ab, 0x47c637b1, 0x185055c3,
	    0xa1d2f97b, 0x2efd2e7d, 0x9f2d0f5d, 0x6992fe9a, 0xfb2aad74, 0x133a7135, 0x6f4708fb, 0x1d9a6245,
	    0x3912bb08, 0x5e5621e2, 0x3abf3bba, 0x2d484f41, 0x5f9de0df, 0x8e94cc9c, 0xf3bc4f0c, 0xbd710599,
	    0x6bfdf0f8, 0xed9bce5e, 0x9ac4dcb8, 0xebc22c22, 0xd5962918, 0xb14b3eac, 0x3fe8755b, 0x5a7a9c03,
	    0x2ad75835, 0x4318e00c, 0x9193b6f8, 0x37280cc6, 0x24553178, 0x4dcab08f, 0x1f4e6bdc, 0x5892b3f9,
	    0x1ea42a32, 0xf330848f, 0x7d03226e, 0xc8849a75, 0x556ab275, 0x370a40b7, 0xdda99d69, 0x98eb7590,
	    0x8b9083a2, 0x82a2cab8, 0x272eeac2, 0x39f505f8, 0xaea6bcb1, 0xe8c9d493, 0xcc20afaf, 0x61e9656c,
	    0x7c67c13b, 0x5b5de451, 0x449d1663, 0x28c4d381, 0x76b4a094, 0x542b1b28, 0x193bb0ce, 0x3a586d66, }, },
	{ { 0x6D, 0xB8, 0x47, 0x1E, 0x99, 0xB2, 0xF9, 0xED, 0x82, 0x02, 0x56, 0x11, 0xD0, 0x66, 0x69, 0xF0, },
	  { 0x98, 0x7D, 0x2E, 0x0D, 0x84, 0x40, 0x4E, 0xB7, 0xB7, 0x4B, 0x9D, 0x68, 0x21, 0x39, 0x99, 0xEC,
	    0x1B, 0x6C, 0xC3, 0xC4, 0xF5, 0x9C, 0xDF, 0x32, 0x5C, 0xEA, 0x17, 0x4B, 0x66, 0x04, 0x31, 0x36, },
	  { 0x11, 0x09, 0x69, 0x19, 0x99, 0x19, 0x27, 0xFE, },
	  { 0xA3, 0x4F, 0x87, 0xF8, 0x27, 0x70, 0x3E, 0x3B, 0x23, 0x8D, 0xDD, 0x2A, 0x3D, 0x5F, 0xBF, 0x91, },
	  { 0x288d43df, 0x316ed164, 0xc1ede267, 0x0fb8b188, 0x4ad1b17a, 0x8c30d4ab, 0x47c637b1, 0x185055c3,
	    0xa1d2f97b, 0x2efd2e7d, 0x9f2d0f5d, 0x6992fe9a, 0xfb2aad74, 0x133a7135, 0x6f4708fb, 0x1d9a6245,
	    0x3912bb08, 0x5e5621e2, 0x3abf3bba, 0x2d484f41, 0x5f9de0df, 0x8e94cc9c, 0xf3bc4f0c, 0xbd710599,
	    0x6bfdf0f8, 0xed9bce5e, 0x9ac4dcb8, 0xebc22c22, 0xd5962918, 0xb14b3eac, 0x3fe8755b, 0x5a7a9c03,
	    0x37a9811c, 0x9312c441, 0x21f80679, 0x91a822ce, 0xbe028206, 0xf17e1cde, 0x485be9a8, 0x795f4407,
	    0xf35156ab, 0x49c9bbb1, 0x38690703, 0xde9e18a4, 0xf1bc541c, 0x09d0528f, 0xe5dda66f, 0x0e42d829,
	    0x46bc56d4, 0x423a403f, 0xbd144876, 0xb51f15d0, 0x61f7ec01, 0x214b0079, 0x2ec7a612, 0x6332c283,
	    0x9afa5e02, 0xab5775f6, 0x4779c462, 0x861b61ed, 0x9f84e814, 0xc2f9c1ec, 0x7c7c68e1, 0x082f75f8, }, },
	};



static RMstatus HwPlay(struct context_per_task *context);
static RMstatus HwStop(struct context_per_task *context);
static RMstatus OpenVideoDecoder(struct context_per_task *context);


static void printTimeOfDay(struct timeval now)
{
	RMuint64 secondsPerMinute = 60;
	RMuint64 secondsPerHour = 60 * secondsPerMinute;
	RMuint64 secondsPerDay = 24 * secondsPerHour;
	RMuint64 today, h, m;

	today = (now.tv_sec - ((now.tv_sec / secondsPerDay) * secondsPerDay));

	h = today / secondsPerHour;
	today -= h * secondsPerHour;
	m = today / secondsPerMinute;
	today -= m * secondsPerMinute;
	
	fprintf(stderr, "time is %02llu:%02llu:%02llu.%llu\n", h, m, today, (RMuint64)now.tv_usec);

}


#define GET_DATA_FIFO_INFO(pRUA, ModuleId, checkStarvation)		\
	{								\
		struct DataFIFOInfo DataFIFOInfo;			\
		RMreal fullness;					\
		RUAGetProperty(pRUA, ModuleId, RMGenericPropertyID_DataFIFOInfo, &DataFIFOInfo, sizeof(DataFIFOInfo)); \
		fullness = (RMreal)((100./DataFIFOInfo.Size)*DataFIFOInfo.Readable); \
		fprintf(stderr, "Data %lx: st=%08lx sz=%ld wr=%ld rd=%ld --> f : %.02f\n", ModuleId, DataFIFOInfo.StartAddress,	\
			DataFIFOInfo.Size, DataFIFOInfo.Writable,  DataFIFOInfo.Readable, fullness); \
		if ((fullness < 2) && checkStarvation) {		\
			struct timeval now;				\
									\
			gettimeofday(&now, NULL);			\
			RMDBGLOG((ENABLE, "close to starvation at\n")); \
			printTimeOfDay(now);				\
		}							\
	}								\


#define GET_XFER_FIFO_INFO(pRUA, ModuleId, checkStarvation)		\
	{								\
		struct XferFIFOInfo_type XferFIFOInfo;			\
		RMreal fullness;					\
		RMstatus err;						\
		err = RUAGetProperty(pRUA, ModuleId, RMGenericPropertyID_XferFIFOInfo, &XferFIFOInfo, sizeof(XferFIFOInfo)); \