Subversion Repositories shark

*** gray.c	Tue Feb  2 23:58:35 1993

--- mpegvga/gray.c	Sun Oct 17 17:19:39 1993

***************

*** 53,58 ****

--- 53,59 ----

    int i, max = w*h/16;

    for (i=0; i<max; i++) {

+ /*

      out[0] = pixel[lum[0]];

      out[1] = pixel[lum[1]];

      out[2] = pixel[lum[2]];

***************

*** 69,74 ****

--- 70,81 ----

      out[13] = pixel[lum[13]];

      out[14] = pixel[lum[14]];

      out[15] = pixel[lum[15]];

+   */

+   /* For VGA, pixel[i] = i */

+     *(unsigned *)(&out[0]) = *(unsigned *)(&lum[0]);

+     *(unsigned *)(&out[4]) = *(unsigned *)(&lum[4]);

+     *(unsigned *)(&out[8]) = *(unsigned *)(&lum[8]);

+     *(unsigned *)(&out[12]) = *(unsigned *)(&lum[12]);

      out += 16;

      lum += 16;

    }

*** proto.h	Wed Feb  3 16:02:59 1993

--- mpegvga/proto.h	Sun Oct 17 16:57:16 1993

***************

*** 49,55 ****

--- 49,57 ----

  /* gdith.c */

  void InitColor P((void ));

+ /*

  int HandleXError P((Display *dpy , XErrorEvent *event ));

+ */

  void InstallXErrorHandler P((void ));

  void DeInstallXErrorHandler P((void ));

  void ResizeDisplay P((int w , int h ));

***************

*** 102,109 ****

--- 104,113 ----

  void ColorDitherImage P((unsigned char *lum , unsigned char *cr , unsigned char *cb , unsigned char *out , int rows , int cols ));

  /* util32.c */

+ /*

  Visual *FindFullColorVisual P((Display *dpy , int *depth ));

  Window CreateFullColorWindow P((Display *dpy , int x , int y , int w , int h ));

+ */

  /* ordered.c */

  void InitOrderedDither P((void ));

*** util.c	Tue Feb  2 23:58:38 1993

--- mpegvga/util.c	Sun Oct 17 16:48:04 1993

***************

*** 20,25 ****

--- 20,26 ----

   */

  #include <stdlib.h>

+ #include <vga.h>

  #include "video.h"

  #include "proto.h"

  #include "util.h"

***************

*** 104,109 ****

--- 105,111 ----

        fprintf (stderr, "\n");

        perror("Unexpected read error.");

      }

+     vga_setmode(TEXT);

      exit(1);

    }

    else if ((status == 0) && (bufLength < 1)) {

***************

*** 119,124 ****

--- 121,127 ----

      if (loopFlag) longjmp(env, 1);

      DestroyVidStream(curVidStream);

+     vga_setmode(TEXT);

      exit(0);

    }

  #ifdef UTIL2

*** video.c	Tue Feb  2 23:58:41 1993

--- mpegvga/video.c	Sat Oct 23 14:04:06 1993

***************

*** 24,30 ****

  #include <stdio.h>

  #include <stdlib.h>

! #include <assert.h>

  #ifndef MIPS

  #include <sys/time.h>

--- 24,31 ----

  #include <stdio.h>

  #include <stdlib.h>

! /* #include <assert.h> */

! #define assert(c)

  #ifndef MIPS

  #include <sys/time.h>

***************

*** 32,37 ****

--- 33,39 ----

  #include <sys/types.h>

  #include <sys/system.h>

  #endif

+ #include <vga.h>

  #include "decoders.h"

  #include "video.h"

***************

*** 985,990 ****

--- 987,993 ----

      if (data != SEQ_START_CODE) {

        fprintf(stderr, "This is not an MPEG stream.");

        DestroyVidStream(curVidStream);

+       vga_setmode(TEXT);

        exit(1);

      }

      first = 0;

***************

*** 1024,1029 ****

--- 1027,1033 ----

        longjmp(env, 1);

      DestroyVidStream(curVidStream);

+     vga_setmode(TEXT);

      exit(0);

      break;

***************

*** 1579,1584 ****

--- 1583,1589 ----

    while (vid_stream->ring[i]->locked != 0) {

      if (++i >= RING_BUF_SIZE) {

        perror("Fatal error. Ring buffer full.");

+       vga_setmode(TEXT);

        exit(1);

      }

    }

*** video.h	Tue Feb  2 23:58:41 1993

--- mpegvga/video.h	Sun Oct 17 16:56:44 1993

***************

*** 21,28 ****

--- 21,30 ----

  #include <stdio.h>

  #include <setjmp.h>

+ /*

  #include <X11/Xlib.h>

  #include <X11/Xutil.h>

+ */

  #ifdef SH_MEM

  #include <sys/ipc.h>

***************

*** 244,250 ****

  extern VidStream *curVidStream;

  /* Declarataion of global display pointer. */

! extern Display *display;

  /* Shared memory flag. */

  extern int shmemFlag;

--- 246,252 ----

  extern VidStream *curVidStream;

  /* Declarataion of global display pointer. */

! /* extern Display *display; */

  /* Shared memory flag. */

  extern int shmemFlag;

*** README.linux	Sun Jan 15 16:44:10 1995

--- mpegvga/README.linux	Sun Jan 15 16:06:09 1995

***************

*** 0 ****

--- 1,49 ----

+

+ This is a port of the Berkeley MPEG Video Software Decoder v2.0 to Linux.

+

+ Two binaries are provided. They require the ld.so shared library loader.

+

+ mpeg_play

+

+ A binary compiled from the stock sources, using the XFree86-2.0 libraries.

+ It was compiled with the flags: -O2 -fomit-frame-pointer -m486 (implicit)

+ using gcc 2.5.4, with some debugging code left out. Uses the X shared memory

+ extension that XFree86 v2.0 provides, which is a big win. The stock sources

+ compile cleanly and trivially.

+

+ mpeg_vga

+

+ A non-X version that uses svgalib. It is slightly faster than the X version

+ with shared memory and can use low resolution graphics modes. Also, with

+ truecolor graphics cards that svgalib supports (Cirrus, ET4000), full color

+ dithering can be used, which is very pretty. The graphics mode to be used can

+ be set with the GSVGAMODE environment variable. Requires svgalib 0.91 or

+ later installed.

+

+ For full color dithering (-dither color), 320x200x16M graphics mode is used

+ if it is available and the picture is small enough; if not, 640x480x16M is

+ used if available. 32K mode probed similarly.

+

+ For most other dithering methods, 320x200x256 standard VGA graphics mode is

+ used if the picture is small enough; 640x480x256 otherwise.

+

+ For mono dithering, 640x480x2 VGA graphics mode is used.

+

+ [NOTE: The previously uploaded version contained patches for some hacked

+ version of the stock sources; sorry for that.]

+ Patches for the stock sources are included (mpegvga.patch). It removes X

+ references, and uses svgalib instead. Also, the speed of gray dithering and

+ full-color dithering has been improved. svgalib v0.91 or later is required to

+ compile; it can be found on sunsite.unc.edu, directory /pub/Linux/libs.

+ [Speed hack have been incorporated into the main source]

+

+ mpeg_play -h (or any other invalid flag) displays dithering and other options.

+

+ Note that with gray dithering, very little time is spent converting from the

+ raw uncompressed data to a screen bitmap suitable for display, making it

+ significantly faster than the other methods.

+

+ The v2.0 source is available on sunsite.unc.edu. For sample MPEG data,

+ mm-ftp.cs.berkeley.edu, /pub/multimedia is one place to look.

+

+ hhanemaa@cs.ruu.nl

*** gdith.c	Sun Jan 29 22:17:25 1995

--- mpegvga/gdith.c	Sun Jan 29 22:44:59 1995

***************

*** 28,33 ****

--- 28,35 ----

   */

  #include <math.h>

+ #include <vga.h>

+ #include <vgagl.h>

  #include "video.h"

  #include "proto.h"

  #include "dither.h"

***************

*** 52,65 ****

  extern int ditherType;

! /* Structures used by the X server. */

!

! Display *display;

!

! static XImage *ximage = NULL;

! static Colormap cmap;

! static Window window;

! static GC gc;

  /* Frame Rate Info */

  extern int framerate;

--- 54,60 ----

  extern int ditherType;

! int vgamode = -1;

  /* Frame Rate Info */

  extern int framerate;

***************

*** 155,351 ****

  }

- #ifdef SH_MEM

-

- int gXErrorFlag = 0;

-

- int HandleXError(dpy, event)

-      Display *dpy;

-      XErrorEvent *event;

- {

-   gXErrorFlag = 1;

-

-   return 0;

- }

-

- void InstallXErrorHandler()

- {

-   int HandleXError();

-

-   XSetErrorHandler(HandleXError);

-   XFlush(display);

- }

- void DeInstallXErrorHandler()

- {

-   XSetErrorHandler(NULL);

-   XFlush(display);

- }

- #endif

- 

- /*

-  *--------------------------------------------------------------

-  *

-  * ResizeDisplay --

-  *

-  *	Resizes display window.

-  *

-  * Results:

-  *	None.

-  *

-  * Side effects:

-  *      None.

-  *

-  *--------------------------------------------------------------

-  */

  void ResizeDisplay(w, h)

       int w, h;

  {

!

!   if (ditherType == NO_DITHER || ditherType == PPM_DITHER) return;

!

!   XResizeWindow(display, window, w, h);

!   XFlush(display);

  }

- 

- /*

-  *--------------------------------------------------------------

-  *

-  * MakeWindow --

-  *

-  *	Create X Window

-  *

-  * Results:

-  *	Read the code.

-  *

-  * Side effects:

-  *      None.

-  *

-  *--------------------------------------------------------------

-  */

! #ifdef SH_MEM

! int CompletionType = -1;

! #endif

  static void

  MakeWindow(name)

  char *name;

  {

!   XSizeHints hint;

!   unsigned int fg, bg;

!   char *hello = "MPEG Play";

!   int screen;

!   Screen *screen_ptr;

!   Window CreateFullColorWindow();

!

!   if (ditherType == NO_DITHER || ditherType == PPM_DITHER) return;

!

!   display = XOpenDisplay(name);

!   if (display == NULL) {

!     fprintf(stderr, "Can not open display\n");

!     exit(-2);

!   }

! #ifdef SH_MEM

!   if(shmemFlag)

!     CompletionType = XShmGetEventBase(display) + ShmCompletion;

! #endif

!   screen = DefaultScreen (display);

!   screen_ptr = XDefaultScreenOfDisplay(display);

!

!   /* Fill in hint structure */

!   hint.x = 200;

!   hint.y = 300;

!   hint.width = 150;

!   hint.height = 150;

!   hint.flags = PPosition | PSize;

!

!   /* Get some colors */

!

!   bg = WhitePixel (display, screen);

!   fg = BlackPixel (display, screen);

!

!   /* Make the window */

!   if (ditherType == FULL_COLOR_DITHER || ditherType==FULL_COLOR2_DITHER) {

!     window = CreateFullColorWindow (display, hint.x, hint.y, hint.width, hint.height);

!     if (window == 0) {

!       fprintf (stderr, "-color option only valid on full color display\n");

!       exit (-1);

!     }

    } else if (ditherType == MONO_DITHER || ditherType == MONO_THRESHOLD) {

!     window = XCreateSimpleWindow (display,

! 				  DefaultRootWindow (display),

! 				  hint.x, hint.y,

! 				  hint.width, hint.height,

! 				  4, fg, bg);

    } else {

!     XVisualInfo vinfo, *vinfo_ptr;

!     Visual *vis;

!     XSetWindowAttributes attrib;

!     unsigned long attrib_flags=0;

!

!     if (!XMatchVisualInfo (display, screen, 8, PseudoColor,

! 			   &vinfo)) {

!       if (!XMatchVisualInfo(display, screen, 8, GrayScale,

! 			    &vinfo)) {

!         fprintf(stderr, "-requires 8 bit display\n");

!         exit(-1);

!       }

!     }

!

!     vis=vinfo.visual;

!     if (XDefaultDepthOfScreen(screen_ptr) != 8) {

!       attrib_flags |= CWColormap;

!       attrib.colormap = XCreateColormap(display, DefaultRootWindow(display),

! 					vis, AllocNone);

!       owncmFlag = TRUE;

!     }

!

!     attrib.background_pixel = bg;

!     attrib.border_pixel = fg;

!     attrib.backing_store = NotUseful;

!     attrib.save_under = False;

!     attrib.background_pixel = bg;

!     attrib.border_pixel = bg;

!     attrib_flags |= CWBackPixel | CWBorderPixel | CWBackingStore | CWSaveUnder;

!     window = XCreateWindow (display,

! 			    DefaultRootWindow (display),

! 			    hint.x, hint.y,

! 			    hint.width, hint.height, 4,

! 			    8, InputOutput, vis,

! 			    attrib_flags, &attrib);

!   }

!

!   XSelectInput(display, window, StructureNotifyMask);

!

!   /* Tell other applications about this window */

!

!   XSetStandardProperties (display, window, hello, hello, None, NULL, 0, &hint);

!

!   /* Map window. */

!

!   XMapWindow(display, window);

!

!   /* Wait for map. */

!   while(1) {

!     XEvent	xev;

!

!     XNextEvent(display, &xev);

!     if(xev.type == MapNotify && xev.xmap.event == window)

!       break;

!   }

!

!   XSelectInput(display, window, NoEventMask);

  }

!

  /*

   *--------------------------------------------------------------

--- 150,286 ----

  }

  void ResizeDisplay(w, h)

       int w, h;

  {

!   vga_modeinfo *modeinfo;

!   /* Check if current VGA mode is big enough. */

!   modeinfo = vga_getmodeinfo(vgamode);

!   if (w > modeinfo->width || h > modeinfo->height) {

!     int fail = 0;

!     if (w > 640 || h > 480)

!       fail = 1;

!     else

!       if (modeinfo->width == 320) {

!         fail = 1;

!         switch (modeinfo->bytesperpixel) {

!         case 1 :

!   	  if (vga_hasmode(G640x480x256)) {

!   	    Palette pal;

!   	    gl_getpalette(&pal);

!   	    vgamode = G640x480x256;

! 	    vga_setmode(vgamode);

! 	    gl_setpalette(&pal);

! 	    gl_setcontextvga(vgamode);

! 	    if (ditherType != GRAY_DITHER)

! 		    gl_clearscreen(255);

! 	    gl_enableclipping();

! 	    fail = 0;

! 	  }

! 	  break;

! 	case 2 :

!   	  if (vga_hasmode(G640x480x32K)) {

!   	    vgamode = G640x480x32K;

! 	    vga_setmode(vgamode);

! 	    gl_setcontextvga(vgamode);

! 	    gl_enableclipping();

! 	    fail = 0;

! 	  }

! 	  break;

! 	case 3 :

!   	  if (vga_hasmode(G640x480x16M)) {

!   	    vgamode = G640x480x16M;

! 	    vga_setmode(vgamode);

! 	    gl_setcontextvga(vgamode);

! 	    gl_enableclipping();

! 	    fail = 0;

! 	  }

! 	  break;

!         }

!       }

!       else

!         fail = 1;

!     if (fail) {

!     	printf("MPEG screen size too big.\n");

!     	vga_setmode(TEXT);

!     	exit(-1);

!     }

!   }

  }

! void

! restoretextmode() {

!   vga_setmode(TEXT);

! }

  static void

  MakeWindow(name)

  char *name;

  {

!   if (ditherType == NO_DITHER) return;

!   /* Make the window */

!   vga_disabledriverreport();

!   vga_init();

!   #define FIRSTRES(c) G320x200x##c

!   #define SECONDRES(c) G640x480x##c

!   if (ditherType == FULL_COLOR_DITHER) {

!     /* Look for hicolor/truecolor mode. */

!     /* 640x480 resolution makes most animations very small. */

!     /* 320x200 is more full-screen, but the distortions are very visible. */

!     /* Check default svgalib mode. */

!     vgamode = vga_getdefaultmode();

!     if (vgamode != -1) {

!        if (vga_getmodeinfo(vgamode)->bytesperpixel == 3)

!          /* Default mode is a truecolor mode. */

!          goto gotvgamode;

!        if (vga_getmodeinfo(vgamode)->colors == 32768)

!          goto gotvgamode;

!     }

!     if (vga_hasmode(FIRSTRES(16M)))

!       vgamode = FIRSTRES(16M);

!     else if (vga_hasmode(SECONDRES(16M)))

!       vgamode = SECONDRES(16M);

!     else if (vga_hasmode(FIRSTRES(32K)))

!       vgamode = FIRSTRES(32K);

!     else if (vga_hasmode(SECONDRES(32K)))

!       vgamode = SECONDRES(32K);

    } else if (ditherType == MONO_DITHER || ditherType == MONO_THRESHOLD) {

!     /* set mode suitable for mono display if available */

!     if (vga_hasmode(G640x480x2))

!       vgamode = G640x480x2;

    } else {

!     /* set 256-color mode */

!     /* Check default svgalib mode. */

!     vgamode = vga_getdefaultmode();

!     if (vgamode != -1)

!        if (vga_getmodeinfo(vgamode)->bytesperpixel == 1)

!          /* Default mode is a 256 color mode. */

!          goto gotvgamode;

!     if (vga_hasmode(FIRSTRES(256)))

!       vgamode = FIRSTRES(256);

!     else if (vga_hasmode(SECONDRES(256)))

!       vgamode = SECONDRES(256);

!   }

!   if (vgamode == -1) {

!   	printf("Cannot find suitable SVGA graphics mode for selected dithering.\n");

!   	exit(-1);

!   }

! gotvgamode:

!   printf("Using mode %s.\n", vga_getmodename(vgamode));

!   vga_setmode(vgamode);

!   gl_setcontextvga(vgamode);

!   gl_enableclipping();

  }

!

  /*

   *--------------------------------------------------------------

***************

*** 366,429 ****

  void InitDisplay(name)

  char *name;

  {

    int ncolors = LUM_RANGE*CB_RANGE*CR_RANGE;

-   XColor xcolor;

    int i, lum_num, cr_num, cb_num;

!   unsigned char r, g, b;

!   Colormap dcmap;

    if (ditherType == NO_DITHER) return;

-   if (noDisplayFlag) return;

    MakeWindow(name);

!   gc = XCreateGC(display, window, 0, 0);

!

!   dcmap = cmap = XDefaultColormap(display, DefaultScreen(display));

!

!   xcolor.flags = DoRed | DoGreen | DoBlue;

-   if (owncmFlag) goto create_map;

-   retry_alloc_colors:

    for (i=0; i<ncolors; i++) {

      lum_num = (i / (CR_RANGE*CB_RANGE))%LUM_RANGE;

      cr_num = (i / CB_RANGE)%CR_RANGE;

      cb_num = i % CB_RANGE;

      ConvertColor(lum_values[lum_num], cr_values[cr_num], cb_values[cb_num], &r, &g, &b);

!     xcolor.red = r * 256;

!     xcolor.green = g * 256;

!     xcolor.blue = b * 256;

!

!     if (XAllocColor(display, cmap, &xcolor) == 0 && cmap == dcmap) {

!       int j;

!       unsigned long tmp_pixel;

!       XWindowAttributes xwa;

!

!       if (!quietFlag) {

!         fprintf(stderr, "Using private colormap.\n");

!       }

!

!       /* Free colors. */

!       for(j = 0; j < i; j ++) {

!         tmp_pixel = pixel[j];

!         XFreeColors(display, cmap, &tmp_pixel, 1, 0);

!       }

!

!       create_map:

!       XGetWindowAttributes(display, window, &xwa);

!       cmap = XCreateColormap(display, window, xwa.visual, AllocNone);

!       XSetWindowColormap(display, window, cmap);

!

!       goto retry_alloc_colors;

      }

!     pixel[i] = xcolor.pixel;

    }

-

-   ximage = NULL;

  }

--- 301,336 ----

  void InitDisplay(name)

  char *name;

  {

+ /* For 256 color modes. */

    int ncolors = LUM_RANGE*CB_RANGE*CR_RANGE;

    int i, lum_num, cr_num, cb_num;

!   int r, g, b;

    if (ditherType == NO_DITHER) return;

    MakeWindow(name);

!   gl_setpalettecolor(255, 0, 0, 0);	/* black */

!   gl_clearscreen(255);

    for (i=0; i<ncolors; i++) {

      lum_num = (i / (CR_RANGE*CB_RANGE))%LUM_RANGE;

      cr_num = (i / CB_RANGE)%CR_RANGE;

      cb_num = i % CB_RANGE;

+     r = g = b = 0;

      ConvertColor(lum_values[lum_num], cr_values[cr_num], cb_values[cb_num], &r, &g, &b);

!     if (i > 256) {

!       printf("mpeg_vga: not enough colors.\n");

!       vga_setmode(TEXT);

!       exit(-1);

      }

!     gl_setpalettecolor(i, r >> 2, g >> 2, b >> 2);

!     pixel[i] = i;

    }

  }

***************

*** 443,572 ****

   *--------------------------------------------------------------

   */

! void InitGrayDisplay(name)

! char *name;

! {

!   int ncolors = 128;

!   XColor xcolor;

!   int i;

!   Colormap dcmap;

!

!   MakeWindow(name);

!

!   gc = XCreateGC(display, window, 0, 0);

!

!   dcmap = cmap = XDefaultColormap(display, DefaultScreen(display));

!

!   xcolor.flags = DoRed | DoGreen | DoBlue;

!

!   if (owncmFlag) goto create_map;

!   retry_alloc_grays:

!   for (i=0; i<ncolors; i++) {

!

!     xcolor.red = (i*2) * 256;

!     xcolor.green = (i*2) * 256;

!     xcolor.blue = (i*2) * 256;

!

!     if(XAllocColor(display, cmap, &xcolor) == 0 && cmap == dcmap) {

!       int j;

!       unsigned long tmp_pixel;

!       XWindowAttributes xwa;

!

!       if (!quietFlag) {

!         fprintf(stderr, "Using private colormap.\n");

!       }

!

!       /* Free colors. */

!       for(j = 0; j < i; j ++) {

!         tmp_pixel = pixel[j*2];

!         XFreeColors(display, cmap, &tmp_pixel, 1, 0);

!       }

!

!       create_map:

!       XGetWindowAttributes(display, window, &xwa);

!       cmap = XCreateColormap(display, window, xwa.visual, AllocNone);

!       XSetWindowColormap(display, window, cmap);

!

!       goto retry_alloc_grays;

!     }

!     pixel[(i*2)] = xcolor.pixel;

!     pixel[(i*2)+1] = xcolor.pixel;

!   }

!   ximage = NULL;

! }

!

! 

! /*

!  *--------------------------------------------------------------

!  *

!  * InitGray256Display --

!  *

!  *	Initialized display for gray scale dither with 256 levels

!  *

!  * Results:

!  *      None.

!  *

!  * Side effects:

!  *      None.

!  *

!  *--------------------------------------------------------------

!  */

!

!

! void InitGray256Display(name)

  char *name;

  {

!   int ncolors = 256;

!   XColor xcolor;

    int i;

-   Colormap dcmap;

-   int result;

-   XWindowAttributes xwa;

    MakeWindow(name);

-   gc = XCreateGC(display, window, 0, 0);

-

-   dcmap = cmap = XDefaultColormap(display, DefaultScreen(display));

-

-   xcolor.flags = DoRed | DoGreen | DoBlue;

-

-   if (owncmFlag) {

-     XGetWindowAttributes(display, window, &xwa);

-     cmap = XCreateColormap(display, window, xwa.visual, AllocNone);

-     XSetWindowColormap(display, window, cmap);

-   }

-

-   retry_alloc_grays:

    for (i=0; i<ncolors; i++) {

!     xcolor.red = i * 256;

!     xcolor.green = i * 256;

!     xcolor.blue = i * 256;

!     if((result=XAllocColor(display, cmap, &xcolor)) == 0 && cmap == dcmap) {

!       int j;

!       unsigned long tmp_pixel;

!

!       if (!quietFlag) {

!         fprintf(stderr, "Using private colormap.\n");

!       }

!

!       /* Free colors. */

!       for(j = 0; j < i; j ++) {

!         tmp_pixel = pixel[j];

!         XFreeColors(display, cmap, &tmp_pixel, 1, 0);

!       }

!

!       XGetWindowAttributes(display, window, &xwa);

!       cmap = XCreateColormap(display, window, xwa.visual, AllocNone);

!       XSetWindowColormap(display, window, cmap);

!

!       goto retry_alloc_grays;

!     }

!     pixel[i] = xcolor.pixel;

    }

-

-   ximage = NULL;

  }

--- 350,374 ----

   *--------------------------------------------------------------

   */

! #define NUM_COLORS 256

! void InitGrayDisplay(name)

  char *name;

  {

!   int ncolors = NUM_COLORS;

    int i;

    MakeWindow(name);

    for (i=0; i<ncolors; i++) {

!     int r, g, b;

!     r = i;

!     g = i;

!     b = i;

!

!     gl_setpalettecolor(i, r / 4, g / 4, b / 4);

!     pixel[i] = i;

    }

  }

***************

*** 589,608 ****

  void InitMonoDisplay(name)

  char *name;

  {

-   XGCValues xgcv;

    MakeWindow(name);

-   xgcv.background = BlackPixel(display, DefaultScreen(display));

-   xgcv.foreground = WhitePixel(display, DefaultScreen(display));

-

-   gc = XCreateGC(display, window, GCForeground | GCBackground, &xgcv);

-

-   ximage = NULL;

  }

- 

  /*

   *--------------------------------------------------------------

   *

--- 391,402 ----

***************

*** 625,632 ****

    MakeWindow(name);

-   gc = XCreateGC(display, window, 0, 0);

-   ximage = NULL;

  }

--- 419,424 ----

***************

*** 650,659 ****

  ExecuteDisplay(vid_stream)

       VidStream *vid_stream;

  {

-   char dummy;

-   Visual *FindFullColorVisual();

-   Visual *fc_visual;

-   int depth;

    static int rate_deal=-1, one_frame_time;

    static struct timeval tftarget, tfnow;

    int zero=0;

--- 442,447 ----

***************

*** 664,669 ****

--- 452,459 ----

      fprintf (stderr, "%d\r", totNumFrames);

    }

+   if (ditherType == NO_DITHER) return;

+

    if (partialFlag)

      if (!((totNumFrames>=startFrame) &&

  	  ((endFrame==-1) || (totNumFrames<=endFrame))))

***************

*** 722,790 ****

      while ((foo=getchar())!='\n');

    }

-   if (ditherType == NO_DITHER) return;

    if (ditherType == PPM_DITHER) {

      ExecutePPM(vid_stream);

      return;

    }

!   if (ximage == NULL) {

!

!     if (ditherType == Twox2_DITHER) {

!       ximage = XCreateImage(display, None, 8, ZPixmap, 0, &dummy,

! 			    vid_stream->mb_width * 32,

! 			    vid_stream->mb_height * 32, 8, 0);

!     } else if (ditherType == FULL_COLOR_DITHER) {

!       fc_visual = FindFullColorVisual(display, &depth);

!       ximage = XCreateImage (display, fc_visual, depth, ZPixmap,

! 			     0, &dummy, vid_stream->mb_width * 16,

! 			     vid_stream->mb_height * 16, 32, 0);

!     } else if (ditherType == FULL_COLOR2_DITHER) {

!       fc_visual = FindFullColorVisual(display, &depth);

!       ximage = XCreateImage (display, fc_visual, depth, ZPixmap,

! 			     0, &dummy, vid_stream->mb_width * 32,

! 			     vid_stream->mb_height * 32, 32, 0);

!     } else if (ditherType == MONO_DITHER || ditherType == MONO_THRESHOLD) {

!       ximage = XCreateImage (display, None, 1, XYBitmap, 0, &dummy,

! 			     vid_stream->mb_width * 16,

! 			     vid_stream->mb_height * 16, 8, 0);

!       ximage->byte_order = MSBFirst;

!       ximage->bitmap_bit_order = MSBFirst;

!     } else {

!       ximage = XCreateImage(display, None, 8, ZPixmap, 0, &dummy,

! 			    vid_stream->mb_width * 16,

! 			    vid_stream->mb_height * 16, 8, 0);

!     }

!   }

!

!   if (!noDisplayFlag) {

! #ifdef SH_MEM

!     if (shmemFlag) {

!       XShmPutImage(display, window, gc, vid_stream->current->ximage,

! 		   0, 0, 0, 0,

! 		   vid_stream->current->ximage->width,

! 		   vid_stream->current->ximage->height, True);

!       XFlush(display);

!

!       while(1) {

! 	XEvent xev;

!

! 	XNextEvent(display, &xev);

! 	if(xev.type == CompletionType)

! 	  break;

!       }

!     }

!     else

! #endif

!

        {

! 	ximage->data = (char *) vid_stream->current->display;

! 	XPutImage(display, window, gc, ximage, 0, 0, 0, 0, ximage->width, ximage->height);

        }

-   }

  }

-

  extern char *inputName;

  extern char *strrchr();

--- 512,623 ----

      while ((foo=getchar())!='\n');

    }

    if (ditherType == PPM_DITHER) {

      ExecutePPM(vid_stream);

      return;

    }

!   if (!noDisplayFlag)

        {

! 	void *data = (char *) vid_stream->current->display;

! 	if (ditherType == Twox2_DITHER) {

! 	  /* Twice the size; 256-color mode */

! 	  gl_putbox(0, 0, vid_stream->h_size * 2,

! 	    vid_stream->v_size * 2, data);

! 	} else if (ditherType == FULL_COLOR_DITHER && BYTESPERPIXEL == 3) {

! 	  /* Tricky conversion. */

! 	  /* The data is padded to 32 bits per pixel, we need 24 bits. */

! 	  int i, w;

! 	  unsigned int *datap;

! 	  void *box;

! 	  unsigned char *boxp;

! 	  datap = data;

! 	  w = vid_stream->h_size;

! 	  box = alloca(vid_stream->v_size * w * 3 + 3);

! 	  boxp = box;

! 	  for (i = 0; i < vid_stream->v_size; i++) {

! 	    int j = 0;

! 	    /* First byte is blue. */

! 	    /* Nasty overlapping memory writes, but it is fast. */

! 	    /* Note that boxp points to bytes, datap to words. */

!             while (j + 7 < w) {

!          	*(unsigned *)boxp = *datap;

!             	*(unsigned *)(boxp + 3) = *(datap + 1);

!             	*(unsigned *)(boxp + 6) = *(datap + 2);

!             	*(unsigned *)(boxp + 9) = *(datap + 3);

!             	*(unsigned *)(boxp + 12) = *(datap + 4);

!             	*(unsigned *)(boxp + 15) = *(datap + 5);

!             	*(unsigned *)(boxp + 18) = *(datap + 6);

!             	*(unsigned *)(boxp + 21) = *(datap + 7);

!             	j += 8;

!             	boxp += 24;

!             	datap += 8;

!             }

!             while (j < w) {

!               *(unsigned *)boxp = *datap;

!               j++;

!               boxp += 3;

!               datap++;

!             }

! 	  }

! 	  gl_putbox(0, 0, vid_stream->h_size, vid_stream->v_size, box);

! 	} else if (ditherType == FULL_COLOR_DITHER && BYTESPERPIXEL == 2) {

! 	  /* The data is 8-8-8 truecolor padded to 32 bits, we need */

! 	  /* 15-bit 5-5-5 truecolor. Pretty slow conversion. */

! 	  int i, w;

! 	  unsigned int *datap;

! 	  void *box;

! 	  unsigned char *boxp;

! 	  datap = data;

! 	  w = vid_stream->h_size;

! 	  box = alloca(vid_stream->v_size * w * 2 + 3);

! 	  boxp = box;

! 	  for (i = 0; i < vid_stream->v_size; i++) {

! 	    int j = 0;

! 	    /* First byte is blue. */

! 	    /* Note that boxp points to bytes, datap to words. */

!             while (j + 1 < w) {

!             	unsigned r, g, b;

!         	b = *((unsigned char *)datap);

!         	g = *((unsigned char *)datap + 1);

!         	r = *((unsigned char *)datap + 2);

!             	*(unsigned short *)boxp =

!             		((r & 0xf8) << 7) + ((g & 0xf8) << 2) + (b >> 3);

!         	b = *((unsigned char *)datap + 4);

!         	g = *((unsigned char *)datap + 5);

!         	r = *((unsigned char *)datap + 6);

!             	*(unsigned short *)(boxp + 2) =

!             		((r & 0xf8) << 7) + ((g & 0xf8) << 2) + (b >> 3);

!             	j += 2;

!             	boxp += 4;

!             	datap += 2;

!             }

!             while (j < w) {

!             	unsigned r, g, b;

!         	r = *((unsigned char *)datap);

!         	g = *((unsigned char *)datap + 1);

!         	g = *((unsigned char *)datap + 2);

!             	*(unsigned short *)boxp =

!             		((r & 0xf8) << 7) + ((g & 0xf8) << 2) + (b >> 3);

!             	j++;

!             	boxp += 2;

!             	datap++;

!             }

! 	  }

! 	  gl_putbox(0, 0, vid_stream->h_size, vid_stream->v_size, box);

!         } else if (ditherType == MONO_DITHER || ditherType == MONO_THRESHOLD) {

!           /* It's MSBFirst, which is what we need. */

!           int i;

!           for (i = 0; i < vid_stream->v_size; i++)

!             vga_drawscansegment(data + i * vid_stream->h_size / 8,

!               0, i, vid_stream->h_size / 8);

!         } else {

!           /* default 256-color dithering */

! 	  gl_putbox(0, 0, vid_stream->h_size, vid_stream->v_size, data);

! 	}

        }

  }

  extern char *inputName;

  extern char *strrchr();

*** main.c	Sun Jan 29 22:17:25 1995

--- mpegvga/main.c	Sun Jan 29 22:48:49 1995

***************

*** 128,133 ****

--- 128,134 ----

    }

    if (curVidStream != NULL)

      DestroyVidStream(curVidStream);

+   restoretextmode();

    exit(1);

  }

  #else

***************

*** 140,145 ****

--- 141,147 ----

    }

    if (curVidStream != NULL)

      DestroyVidStream(curVidStream);

+   restoretextmode();

    exit(1);

  }

  #endif