Subversion Repositories shark

/*
 * Project: HARTIK (HA-rd R-eal TI-me K-ernel)
 *
 * Coordinators: Giorgio Buttazzo <giorgio@sssup.it>
 *               Gerardo Lamastra <gerardo@sssup.it>
 *
 * Authors     : Luca Abeni <luca@hartik.sssup.it>
 *               Massimiliano Giorgi <massy@hartik.sssup.it>
 * (see authors.txt for full list of hartik's authors)
 *
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
 *
 * http://www.sssup.it
 * http://retis.sssup.it
 * http://hartik.sssup.it
 */

/*
 * Copyright (C) 1999 Luca Abeni and Massimiliano Giorgi
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/*
 * CVS :        $Id: mplay2.c,v 1.1.1.1 2004-05-24 18:03:39 giacomo Exp $
 *
 * File:        $File$
 * Revision:    $Revision: 1.1.1.1 $
 * Last update: $Date: 2004-05-24 18:03:39 $
 */

#include <ll/sys/types.h>

#include <kernel/func.h>
#include <kernel/const.h>

//#include <hartik.h>
#include <drivers/keyb.h>



#include <trace/trace.h>
#include <trace/queues.h>



#include <stdlib.h>
#include <stdio.h>

//#include <xdos.h>
#include <drivers/glib.h>

#include "mpeg/video.h"
/*#include "proto.h"*/
#include "mpeg/util.h"
#include "mpeg/dither.h"
#include "mpeg/mpeg.h"








//#define NOSHOW 1




#include <drivers/keyb.h>


int mustdied=0;


void ctrlc_exit(KEY_EVT *k)
{
  extern void dump_sem_table(void);
  extern void dump_nop_table(void);
  mustdied=1;
#ifndef NOSHOW
  grx_close();
#endif
  cprintf("CTRL-C pressed!\n");
#ifndef NOSHOW
  grx_modeinfo();
#endif
  sys_end();
}

#include <fs/bdevinit.h>
#include <fs/fsinit.h>
#include <fs/bdev.h>

#include <sys/types.h>
#include <sys/mount.h>

int __register_sub_init_prologue(void)
{
  int id;
  TRC_init_phase1(NULL);
  trc_register_fixed_queue();
  id=trc_create_queue(TRC_FIXED_QUEUE,NULL);
  trc_trace_class(TRC_CLASS_USER);
  trc_assign_class_to_queue(TRC_CLASS_USER,id);
  return 0;
}

int __register_sub_init(void)
{
  return 0;
}

dev_t root_device;
dev_t temp_device;

int choose_root_callback(dev_t dev,u_int8_t fs)
{
  if (fs==FS_MSDOS) return dev;
  return -1;
}

int choose_temp_callback(__dev_t dev,__uint8_t fs)
{
  static int flag=0;
  if (fs==FS_MSDOS) {
    if (flag) return dev;
    flag=1;
  }
  return -1;
}

int __bdev_sub_init(void)
{
  BDEV_PARMS bdev=BASE_BDEV;
 
  bdev_def_showinfo(bdev,FALSE);
  bdev_init(&bdev);

  root_device=bdev_scan_devices(choose_root_callback);
  if (root_device<0) {
    cprintf("can't find root device to mount on /!!!\n");
    sys_end();
    return -1;
  }

  temp_device=bdev_scan_devices(choose_temp_callback);
  if (temp_device<0) {
    cprintf("can't find a filesystem to mount on /TEMP!!!\n");
  }
 
  return 0;
}

extern int libc_initialize(void);

int __fs_sub_init(void)
{
  FILESYSTEM_PARMS fs=BASE_FILESYSTEM;
  struct mount_opts opts;
  int res;
 
  filesystem_def_rootdevice(fs,root_device);
  filesystem_def_fs(fs,FS_MSDOS);
  filesystem_def_showinfo(fs,FALSE);
  filesystem_init(&fs);

  if (temp_device>=0) {
    memset(&opts,0,sizeof(struct mount_opts));
    opts.flags=MOUNT_FLAG_RW;
    res=mount(temp_device,FS_MSDOS,"/TEMP",&opts);
    if (res!=0) {
      cprintf("can't mount XXX on /TEMP (errno: %i)\n",errno);
    } else
      cprintf("mounted /TEMP rw\n");
   
  }
 
  libc_initialize();
 
  TRC_init_phase2();
 
  return 0;
}

int x_fseek(FILE *file, long where, int from)
{
  return fseek(file,where,from);
}

size_t x_fread(void *buffer, size_t size, size_t n, FILE *file)
{
  return fread(buffer,size,n,file);
}























TIME ttt;

DWORD n[10];

///* #define GPHBDIM 4097152 */
//#define GPHBDIM 1000000

//BYTE   gphb[GPHBDIM];           /*  Std Dim:    2M      */
//BYTE   *nextphbyte = gphb;

struct streamdescr {
    FILE *f;
    ImageDesc *i;
    int x1, y1;
} sd[10];

#define SCREENX 800
#define SCREENY 600

void txtreset(void *dummy)
{
#ifndef NOSHOW
  grx_close();
  grx_modeinfo();
  /*    cprintf("Total frames:  %ld\n", i);
        cprintf("Total time:    %lu\n", t);*/
  //cprintf("Frame rate:        %lu\n", (n * 1000) / ttt);
  /*    cprintf("Max frame time:        %lu\n", mft);*/
  /*
    sys_status(READY_RT_STATUS | READY_NRT_STATUS | BLOCKED_STATUS |
    IDLE_STATUS | SLEEP_STATUS | EXEC_STATUS);
    */
#endif
}

#define MAINSLEEP 20000

void drawload(TIME l)
{
    #define LLPWINSIZE 20
    int actl;
//  struct load l;
    #define LOADX 500
    #define LOADY 300
    #define LOADYDIM 50
    #define LOADXDIM 100
    static int th = 0;
    static int x = 0;
    static int hy[LLPWINSIZE];
    static int somma = 0;
    int i;

/*    for (i = 0; i < LLPWINSIZE; i++) hy[i] = 0; */

//    load_actual(&l);
//    actl = (LOADYDIM * l.actual) / l.rif + 1;
//    {
//      char str[80];
//      sprintf(str,"%d",actl);
//      /*grx_text("Ciao", 200, 200, color16(31, 63, 31), 0);*/
//      grx_text("    ", 100, 400, 100, 0);
//      grx_text(str, 100, 400, 100,0);
//    }
/*              LowPass Filter                  */


    actl=((long)l*LOADYDIM)/MAINSLEEP+1;

    somma += actl - hy[th];
    hy[th] = actl;
    th = (th + 1) % LLPWINSIZE;
    actl = somma / LLPWINSIZE;
#ifndef NOSHOW    
    grx_line(LOADX+x,LOADY,LOADX+x,(LOADY+LOADYDIM),0);
    if (actl > LOADYDIM) actl = LOADYDIM;
    grx_line(LOADX+x,(LOADY + actl),LOADX+x,(LOADY+LOADYDIM),255);
#endif
    x = (x + 1) % LOADXDIM;
   
}



TASK play(void *arg)
{
  int i=(int)arg;
    int loop = TRUE;
  BYTE *pixels;
  int moreframes = TRUE;
  FILE *mpeg = sd[i].f;
  ImageDesc *img = sd[i].i;
  int x1, y1, x2, y2;

  /*printf ("Task %d: Movie is %d x %d pixels\n", i, img->Width, img->Height);
    printf ("Required picture rate = %d, required bit rate = %d\n",
    img->PictureRate, img->BitRate);*/

  pixels = (BYTE *) malloc(img->Size * sizeof(BYTE));
  x1 = sd[i].x1;
  y1 = sd[i].y1;
  x2 = x1 + img->Width-1;
  y2 = y1 + img->Height-1;
  while (loop) {                        /* play the whole movie forever */
    loop = 0;
    n[i] = 0;
    ttt = sys_gettime(NULL);
    while (moreframes && n[i]<250) {

      if (mustdied) break;
     
#ifdef NOSHOW            
      cprintf("%c",'°'+i);
#endif
     
      moreframes = GetMPEGFrame (img, pixels);
#ifndef NOSHOW      
      grx_putimage(x1, y1, x2, y2, pixels);
#endif
      n[i]++;
      task_endcycle();
    }
    ttt = sys_gettime(NULL) - ttt;
    if (!loop) break;
    RewindMPEG (mpeg, img);
    SetMPEGOption (img, MPEG_DITHER, GRAY_DITHER);
    moreframes = TRUE;
  }

  return 0;
}



int main(int argc, char *argv[])
{
  //    SYS_PARMS sp = BASE_SYS;
  KEY_EVT k;
  //    MODEL m = BASE_MODEL;
  PID pid;

  //    DOS_FILE *Infile;
//  BYTE *mpegbuff[10], *p;
//  WORD res;
//  DWORD cnt[10];


TIME sum;

  SOFT_TASK_MODEL model;
   
  FILE       *mpeg;
  ImageDesc   img[10];
  int full_color = FALSE;

  int mode;
  int esc;
  int i;
  int actx = 10, acty = 10;
  ColormapEntry *cp;

  //cprintf("file '%s'\n",argv[1]);
 
  if (argc < 2) {
    fprintf (stderr, "Usage: %s mpegfile\n", argv[0]);
    sys_abort(301);
  }

  /*
    for (i = 0; i < argc - 1; i++) {
    Infile = DOS_fopen(argv[i + 1], "r");
    if (!Infile) {
    cprintf("%s not found!!!\n", argv[i + 1]);
    sys_abort(300);
    }
    cprintf("\n %s Opened!!!\n\n", argv[i + 1]);

    mpegbuff[i] = nextphbyte;
    p = mpegbuff[i]; cnt[i] = 0;
    res = 0x1000;
    while (res > 0) {
    res = DOS_fread(p, 0x1000, 1, Infile);
    cnt[i] += res;
    p += res;
    }
    p += res;
    nextphbyte = p;
    }
    */
   
  /* OK, Now we can start the system!!! */
  //sys_init(&sp);
  //keyb_init(SOFT, 100);
  //    keyb_init(NULL);
  //    k.flag = CNTR_BIT;
  //    k.scan = KEY_C;
  //    k.ascii = 'c';
  //keyb_excset(k,endfun);

  //vfs_init();
  /*
    for (i = 0; i < argc - 1; i++) {
    vfs_assign(argv[i + 1], mpegbuff[i], cnt[i]);
    }
    */





 
  /* Init the graph... */
#ifndef NOSHOW
 
  if (grx_init() == -1) {
    cprintf("No init!!!\n");
    sys_abort(255);
  }

  mode = grx_getmode(SCREENX, SCREENY, 8);
  cprintf("Mode num: %x\n", mode);
  grx_cardinfo();
#endif
 
  cprintf("[hit enter to continue]\n");
  esc = FALSE;
  while (!esc) {
    keyb_getcode(&k,BLOCK);
    if (k.ascii == 13) esc = TRUE;
  }

 
  if (mode == -1) {
    cprintf("Mode not present!!!\n");
    sys_abort(255);
  }

#ifndef NOSHOW  
  if (grx_setmode(mode) == -1) {
    cprintf("No SetMode!!!\n");
    sys_abort(255);
  }
#endif
 
  //sys_atexit(txtreset,NULL,AFTER_EXIT);


  //cprintf("Û0Û");

  for (i = 0; i < argc - 1; i++) {
    mpeg = fopen(argv[i + 1], "r");

    if (!mpeg) {
      perror (argv[1]);
      sys_abort(301);
    }

    //cprintf("Û0.5Û");

    /* !!! */
    img[i].vid_stream=NULL;
    img[i].Colormap=NULL;
   
    if (!OpenMPEG(mpeg, &(img[i]))) {
      fprintf (stderr, "OpenMPEG on %s failed\n", argv[i + 1]);
      sys_abort(301);
    }


    //cprintf("Û1Û");


   
    SetMPEGOption (&(img[i]), MPEG_DITHER, GRAY_DITHER);
    //SetMPEGOption (&(img[i]), MPEG_DITHER, FS4_DITHER);


    /*  SetMPEGOption(MPEG_DITHER, GRAY_DITHER);        */

    /* printf ("Movie is %d x %d pixels\n", img[i].Width, img[i].Height);
       printf ("Required picture rate = %d, required bit rate = %d\n",
       img[i].PictureRate, img[i].BitRate); */

    //cprintf("Û2Û");

    if (i == 0) {
      cp = img[i].Colormap;

      if (!full_color) {
        int  ii;

        for (ii = 0; ii < img[i].ColormapSize; ii++) {

#ifndef NOSHOW
         
          grx_setcolor (ii, img[i].Colormap[ii].red / 4,
                        img[i].Colormap[ii].green / 4,
                        img[i].Colormap[ii].blue / 4);

#endif
         
        }

        /*NO!!! Colormap is an array of short, setpalette wants an array of BYTE!!!*/
        /*      grx_setpalette(0, 255, img.Colormap);*/
      }
    }
    if (actx + img[i].Width > SCREENX) {
      actx = 10;
      acty += 200;
    }
    sd[i].x1 = actx;
    sd[i].y1 = acty;
    sd[i].f = mpeg;
    sd[i].i = &(img[i]);

    //cprintf("Û3Û");

    soft_task_default_model(model);    
    ////soft_task_def_system(model);
    //soft_task_def_met(model,9000);
    //soft_task_def_wcet(model,9000);
    //soft_task_def_period(model,50000);  

    soft_task_def_met(model,5000);
    soft_task_def_wcet(model,5000);
    soft_task_def_period(model,40000);  
    soft_task_def_periodic(model);
    soft_task_def_arg(model,(void*)i);
    soft_task_def_ctrl_jet(model);
   
    //task_def_arg(m, i);
    //task_def_wcet(m, 9000);
    pid = task_create("Shower", play, &model, NULL);
    if (pid == -1) {
      cprintf(" task --> Not Guaranteed!!!\n");
      sys_abort(20000);
    }
    task_activate(pid);

    //cprintf("Û4Û");
   
    actx += img[i].Width + 10;
  }

  /*   play(0);*/
  esc = FALSE;
  //jet_delstat(pid);
  while (!esc) {
    if (keyb_getcode(&k,NON_BLOCK) && (k.ascii == 13)) esc = TRUE;
    task_delay(MAINSLEEP);
    //jet_getstat(pid,&sum,NULL,NULL,NULL);
    //jet_delstat(pid);
    //drawload(sum);
  }

  sys_abort(59000);

  return 0;
}