Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 1563 → Rev 1562

/demos/trunk/sharkDecoderWithFSF/getbits.c
73,6 → 73,7
 
struct readDecodeMessage msg;
extern void *start_file;
if(initfaseFlag)
{
memcpy(Rdbfr, start_file, rdsize);
/demos/trunk/sharkDecoderWithFSF/initfile.c
84,15 → 84,15
}
 
int device_drivers_init() {
//KEYB_PARMS kparms = BASE_KEYB;
KEYB_PARMS kparms = BASE_KEYB;
LINUXC26_register_module();
PCI26_init();
//INPUT26_init();
INPUT26_init();
 
/*keyb_def_map(kparms, KEYMAP_IT);*/
//keyb_def_ctrlC(kparms, NULL);
//KEYB26_init(&kparms);
keyb_def_ctrlC(kparms, NULL);
KEYB26_init(&kparms);
 
 
return 0;
/demos/trunk/sharkDecoderWithFSF/decoder.c
98,30 → 98,20
hard_task_def_wcet(ht,18000);
nrt_task_def_group(ht,3);
 
/*
err = pthread_create(&j, NULL, displayTask, NULL);
if (err) {
grx_close();
grx_text("failed to create displayTask",0,0,rgb16(255,255,255),0);
exit(err);
}
err=fsf_bind_local_thread_to_server(server, j,(fsf_sched_params_t *)(&pr));
if (err) {
grx_close();
exit(err);
}
*/
err = fsf_create_local_thread(server,(fsf_sched_params_t *)(&pr), &j,NULL,
displayTask,NULL);
if (err) {
grx_close();
grx_text("failed to create displayTask",0,0,rgb16(255,255,255),0);
grx_text("failed to create displayTask",0,0,rgb16(255,255,255),0);
exit(err);
}
task_activate(j);
 
err=fsf_bind_local_thread_to_server(server, j,(fsf_sched_params_t *)(&pr));
if (err) {
grx_close();
exit(err);
}
}
 
/*********************************************************************'
145,30 → 135,20
nrt_task_default_model(ht);
nrt_task_def_group(ht,1);
 
/*
err = pthread_create(&j, NULL, readTask, NULL);
if (err) {
grx_close();
perror("Could not create task...");
exit(err);
grx_close();
perror("Could not create task...");
exit(err);
}
err=fsf_bind_local_thread_to_server(server, j,(fsf_sched_params_t *)(&pr));
if (err) {
 
err=fsf_bind_local_thread_to_server(server, j,(fsf_sched_params_t *)(&pr));
if (err) {
grx_close();
//perror("Could not bind task..");
exit(err);
}
*/
err = fsf_create_local_thread(server,(fsf_sched_params_t *)(&pr), &j,NULL,
readTask,NULL);
if (err) {
grx_close();
grx_text("failed to create displayTask",0,0,rgb16(255,255,255),0);
exit(err);
}
task_activate(j);
}
 
/**********************************************************************
194,30 → 174,21
nrt_task_default_model(ht);
nrt_task_def_group(ht,1);
/*
err = pthread_create(&j, NULL, mpeg2decoder, NULL);
if (err) {
 
err = pthread_create(&j, NULL, mpeg2decoder, NULL);
if (err) {
grx_close();
perror("Could not create task...");
exit(err);
}
err=fsf_bind_local_thread_to_server(server, j,(fsf_sched_params_t *)(&pr));
}
 
err=fsf_bind_local_thread_to_server(server, j,(fsf_sched_params_t *)(&pr));
if (err) {
grx_close();
//perror("Could not bind task..");
exit(err);
}
*/
err = fsf_create_local_thread(server,(fsf_sched_params_t *)(&pr), &j,NULL,
mpeg2decoder,NULL);
if (err) {
grx_close();
grx_text("failed to create displayTask",0,0,rgb16(255,255,255),0);
exit(err);
}
task_activate(j);
//perror("Could not bind task..");
exit(err);
}
}
 
 
/***************************************************************************
257,7 → 228,7
//perror("Could not bind task..");
exit(err);
}
 
return 1;
}
void ending_system(KEY_EVT *e) {
275,28 → 246,24
int err;
int i = 1;
char tmp[100];
struct timespec simtime;
//KEY_EVT k;
union sigval no_sigval = {0};
 
PI_mutexattr_t a;
KEY_EVT ev;
 
/* 10% */
struct timespec decoderPeriod = {0,30000000};
struct timespec decoderBudget = {0,3000000};
 
/* 10% */
struct timespec readTaskPeriod = {0,30000000};
struct timespec readTaskBudget = {0,3000000};
/* 45% */
struct timespec displayPeriod = {0,40000000};
struct timespec displayBudget = {0,18000000};
 
// 5 %
// 30 %
struct timespec overloadPeriod = {0,10000000};
struct timespec overloadBudget = {0,500000};
struct timespec overloadBudget = {0,3000000};
 
fsf_server_id_t decoderServer;
fsf_server_id_t readTaskServer;
311,83 → 278,42
union sigval sval;
 
//ev.ascii = 'c';
//ev.scan = KEY_C;
//ev.status = KEY_PRESSED;
//ev.flag = CNTR_BIT;
//keyb_hook(ev, ending_system, FALSE);
ev.ascii = 'c';
ev.scan = KEY_C;
ev.status = KEY_PRESSED;
ev.flag = CNTR_BIT;
keyb_hook(ev, ending_system, FALSE);
 
PI_mutexattr_default(a);
fsf_init();
FSF_start_service_task();
mutex_init(&mux,&a);
// Set up the different servers
fsf_initialize_contract(&readTaskContract);
err=fsf_set_contract_basic_parameters(&readTaskContract,&readTaskBudget,&readTaskPeriod,FSF_DEFAULT_WORKLOAD);
if (err) {
exit(err);
}
err=fsf_set_contract_reclamation_parameters(&readTaskContract,&readTaskBudget,&readTaskPeriod,FSF_DEFAULT_GRANULARITY, NULL, 1,1);
if (err) exit(err);
err=fsf_set_contract_timing_requirements(&readTaskContract,true,NULL,0,no_sigval,0,no_sigval);
if (err) exit(err);
 
fsf_set_contract_basic_parameters(&readTaskContract,&readTaskBudget,&readTaskPeriod,FSF_DEFAULT_WORKLOAD);
fsf_set_contract_scheduling_policy(&readTaskContract, FSF_RR);
 
fsf_initialize_contract(&decoderContract);
err=fsf_set_contract_basic_parameters(&decoderContract,&decoderBudget,&decoderPeriod,FSF_DEFAULT_WORKLOAD);
if (err) {
grx_close();
exit(err);
}
 
err=fsf_set_contract_reclamation_parameters(&decoderContract,&decoderBudget,&decoderPeriod,FSF_DEFAULT_GRANULARITY, NULL, 1,1);
if (err) exit(err);
err=fsf_set_contract_timing_requirements(&decoderContract,true,NULL,0,no_sigval,0,no_sigval);
if (err) exit(err);
 
fsf_set_contract_basic_parameters(&decoderContract,&decoderBudget,&decoderPeriod,FSF_DEFAULT_WORKLOAD);
fsf_set_contract_scheduling_policy(&decoderContract, FSF_RR);
 
fsf_initialize_contract(&displayContract);
err=fsf_set_contract_basic_parameters(&displayContract,&displayBudget,&displayPeriod,FSF_DEFAULT_WORKLOAD);
if (err) {
exit(err);
}
 
err=fsf_set_contract_reclamation_parameters(&displayContract,&displayBudget,&displayPeriod,FSF_DEFAULT_GRANULARITY, NULL, 1,1);
if (err) exit(err);
err=fsf_set_contract_timing_requirements(&displayContract,true,NULL,0,no_sigval,0,no_sigval);
if (err) exit(err);
 
fsf_set_contract_basic_parameters(&displayContract,&displayBudget,&displayPeriod,FSF_DEFAULT_WORKLOAD);
fsf_set_contract_scheduling_policy(&displayContract, FSF_EDF);
 
fsf_initialize_contract(&overloadContract);
err=fsf_set_contract_basic_parameters(&overloadContract,&overloadBudget,&overloadPeriod,FSF_DEFAULT_WORKLOAD);
if (err) {
exit(err);
}
 
fsf_set_contract_basic_parameters(&overloadContract,&overloadBudget,&overloadPeriod,FSF_DEFAULT_WORKLOAD);
fsf_set_contract_scheduling_policy(&overloadContract, FSF_EDF);
err = fsf_negotiate_contract(&readTaskContract,&readTaskServer);
if (err) {
exit(err);
}
 
if (err) cprintf("(FSF ERROR %d)",err);
err = fsf_negotiate_contract(&decoderContract,&decoderServer);
if (err) {
exit(err);
}
if (err) cprintf("(FSF ERROR %d)",err);
err = fsf_negotiate_contract(&displayContract,&displayServer);
if (err) {
exit(err);
}
 
if (err) cprintf("(FSF ERROR %d)",err);
err = fsf_negotiate_contract(&overloadContract,&overloadServer);
if (err) {
exit(err);
}
if (err) cprintf("(FSF ERROR %d)",err);
 
 
// Create and bind different ports to communication links (This ports a declared in global.h)
398,7 → 324,7
}
if((decoderTaskPort->displayTaskPort = port_create(displayPortName, sizeof(struct decodeDisplayMessage), NUMBER_OF_MESSAGE, STREAM, WRITE)) == -1)
{
grx_text("failed to create displayTask Port",0,0,rgb16(255,255,255),0);
grx_text("failed to create displayTask Port",0,0,rgb16(255,255,255),0);
exit(-1);
}
if((decoderTaskPort->readTaskPort = port_connect(readFilePortName, sizeof(struct readDecodeMessage), STREAM, READ)) == -1)
409,11 → 335,11
if((displayTaskPort = port_connect(displayPortName, sizeof(struct decodeDisplayMessage), STREAM, READ)) == -1)
{
grx_text("failed to connect to displayTask Port",0,0,rgb16(255,255,255),0);
exit(-1);
exit(-1);
}
 
//graphic card Initialization
if (grx_init() < 1) {
if (grx_init() < 1) {
exit(-1);
}
 
420,12 → 346,10
if (grx_open(800, 600, 16) < 0) {
cprintf("GRX Err\n");
exit(-1);
}
kern_gettime(&simtime);
simtime.tv_sec+=20;
kern_event_post(&simtime,(void *)((void *)(ending_system)), NULL);
/*ch = keyb_getch(BLOCK);
}
 
 
ch = keyb_getch(BLOCK);
while(ch != ESC) {
 
432,11 → 356,10
switch (ch)
{
 
case '1': */
case '1':
addReadTaskToServer(readTaskServer);
addDecoderThreadToServer(decoderServer);
addDisplayTaskToServer(displayServer);
/*
break;
case '2':
sprintf(tmp,"Number of dummy task: %d", i);
452,9 → 375,8
ch = keyb_getch(BLOCK);
}
*/
//ending_system(NULL);
while(1);
 
ending_system(NULL);
return 0;
 
/demos/trunk/sharkDecoderWithFSF/global.h
504,7 → 504,7
* Author: Robert Bäckgren
****************************************************************************/
 
#define NUMBER_OF_MESSAGE 3
#define NUMBER_OF_MESSAGE 3
#define BUFFERSIZE 2048
 
// The message that goes between the read task and decoder task
/demos/trunk/sharkDecoderWithFSF/systems.c
127,7 → 127,7
}
else
{
//cprintf("Unexpected startcode %08x in system layer\n",code);
cprintf("Unexpected startcode %08x in system layer\n",code);
}
break;
}
/demos/trunk/sharkDecoderWithFSF/gvideo.c
82,6 → 82,7
memcpy(msg.buffer, actual_file, msg.size);
actual_file += msg.size;
}
 
if(!port_send(p, (void*)&msg,BLOCK))
{
grx_text("\n\n readTask ******************** E R R O R E R R O R E R R O R **********************\n",0,0,rgb16(255,255,255),0);
107,15 → 108,16
msg.src[0] = NULL;
msg.src[1] = NULL;
msg.src[2] = NULL;
 
while(1)
{
// if(port_receive(p, (void*)&msg, NON_BLOCK))
if(port_receive(p, (void*)&msg, BLOCK))
{
if (initflag == 0)
if(initflag == 0)
grx_text("",20,20,rgb16(255,255,255),0);
 
displayTaskFunction(msg.src, msg.frame);
//cprintf("Display");
for(i = 0; i < 3; i++)
{
131,8 → 133,7
grx_text(" displayTask ******************** E R R O R E R R O R E R R O R **********************",20,20,rgb16(255,255,255),0);
initflag = 0;
}
//fsf_schedule_timed_job(NULL, NULL, NULL, NULL, NULL);
task_endcycle();
fsf_schedule_timed_job(NULL, NULL, NULL, NULL, NULL);
}
}
 
/demos/trunk/sharkDecoderWithFSF/gethdr.c
113,7 → 113,7
break;
default:
if (!Quiet_Flag)
;//cprintf("Unexpected next_start_code %08x (ignored)\n",code);
cprintf("Unexpected next_start_code %08x (ignored)\n",code);
break;
}
}
/demos/trunk/sharkDecoderWithFSF/mpeg2dec.c
385,6 → 385,7
 
Bitstream_Framenum = *Bitstream_Framenumber;
Sequence_Framenum=0;
 
Initialize_Sequence();
 
/* decode picture whose header has already been parsed in
404,6 → 405,7
Sequence_Framenum++;
}
 
//fsf_schedule_next_timed_job(NULL, NULL, NULL, NULL, NULL);
 
/* loop through the rest of the pictures in the sequence */
410,11 → 412,13
while ((Return_Value=Headers()))
{
Decode_Picture(Bitstream_Framenum, Sequence_Framenum);
 
if (!Second_Field)
{
Bitstream_Framenum++;
Sequence_Framenum++;
}
 
//fsf_schedule_next_timed_job(NULL, NULL, NULL, NULL, NULL);
}