raven/jedioutcast
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
jedioutcast/utils/roq2/mpeg/display.c
James Monroe b2f9cf6f08 Jedi Outcast v056
2013-04-04 13:07:40 -05:00

2436 lines
36 KiB
C
Raw Blame History

/* display.c, X11 interface */
/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
/*
* Disclaimer of Warranty
*
* These software programs are available to the user without any license fee or
* royalty on an "as is" basis. The MPEG Software Simulation Group disclaims
* any and all warranties, whether express, implied, or statuary, including any
* implied warranties or merchantability or of fitness for a particular
* purpose. In no event shall the copyright-holder be liable for any
* incidental, punitive, or consequential damages of any kind whatsoever
* arising from the use of these programs.
*
* This disclaimer of warranty extends to the user of these programs and user's
* customers, employees, agents, transferees, successors, and assigns.
*
* The MPEG Software Simulation Group does not represent or warrant that the
* programs furnished hereunder are free of infringement of any third-party
* patents.
*
* Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
* are subject to royalty fees to patent holders. Many of these patents are
* general enough such that they are unavoidable regardless of implementation
* design.
*
*/
#ifdef DISPLAY
/* the Xlib interface is closely modeled after
* mpeg_play 2.0 by the Berkeley Plateau Research Group
*/
#include <stdio.h>
#include <stdlib.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include "config.h"
#include "global.h"
/* private prototypes */
static void Display_Image _ANSI_ARGS_((XImage *Ximage_Ptr, unsigned char *Dithered_Image));
static void Dither_Frame _ANSI_ARGS_((unsigned char *src[]));
static void Dither_Top_Field _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
static void Dither_Bottom_Field _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
static void Dither_Top_Field420 _ANSI_ARGS_((unsigned char *src[],
unsigned char *dst));
static void Dither_Bottom_Field420 _ANSI_ARGS_((unsigned char *src[],
unsigned char *dst));
/* local data */
static unsigned char *Dithered_Image, *Dithered_Image2;
static unsigned char Y_Table[256+16];
static unsigned char Cb_Table[128+16];
static unsigned char Cr_Table[128+16];
/* X11 related variables */
static Display *Display_Ptr;
static Window Window_Instance;
static GC GC_Instance;
static XImage *Ximage_Ptr, *Ximage_Ptr2;
static unsigned char Pixel[256];
#ifdef SH_MEM
#include <sys/ipc.h>
#include <sys/shm.h>
#include <X11/extensions/XShm.h>
static int HandleXError _ANSI_ARGS_((Display *dpy, XErrorEvent *event));
static void InstallXErrorHandler _ANSI_ARGS_((void));
static void DeInstallXErrorHandler _ANSI_ARGS_((void));
static int Shmem_Flag;
static XShmSegmentInfo Shminfo1, Shminfo2;
static int gXErrorFlag;
static int CompletionType = -1;
static int HandleXError(Dpy, Event)
Display *Dpy;
XErrorEvent *Event;
{
gXErrorFlag = 1;
return 0;
}
static void InstallXErrorHandler()
{
XSetErrorHandler(HandleXError);
XFlush(Display_Ptr);
}
static void DeInstallXErrorHandler()
{
XSetErrorHandler(NULL);
XFlush(Display_Ptr);
}
#endif
/* connect to server, create and map window,
* allocate colors and (shared) memory
*/
void Initialize_Display_Process(name)
char *name;
{
int crv, cbu, cgu, cgv;
int Y, Cb, Cr, R, G, B;
int i;
char dummy;
int screen;
Colormap cmap;
int private;
XColor xcolor;
unsigned int fg, bg;
char *hello = "MPEG-2 Display";
XSizeHints hint;
XVisualInfo vinfo;
XEvent xev;
unsigned long tmp_pixel;
XWindowAttributes xwa;
Display_Ptr = XOpenDisplay(name);
if (Display_Ptr == NULL)
Error("Can not open display\n");
screen = DefaultScreen(Display_Ptr);
hint.x = 200;
hint.y = 200;
hint.width = horizontal_size;
hint.height = vertical_size;
hint.flags = PPosition | PSize;
/* Get some colors */
bg = WhitePixel (Display_Ptr, screen);
fg = BlackPixel (Display_Ptr, screen);
/* Make the window */
if (!XMatchVisualInfo(Display_Ptr, screen, 8, PseudoColor, &vinfo))
{
if (!XMatchVisualInfo(Display_Ptr, screen, 8, GrayScale, &vinfo))
Error("requires 8 bit display\n");
}
Window_Instance = XCreateSimpleWindow (Display_Ptr, DefaultRootWindow (Display_Ptr),
hint.x, hint.y, hint.width, hint.height, 4, fg, bg);
XSelectInput(Display_Ptr, Window_Instance, StructureNotifyMask);
/* Tell other applications about this window */
XSetStandardProperties (Display_Ptr, Window_Instance, hello, hello, None, NULL, 0, &hint);
/* Map window. */
XMapWindow(Display_Ptr, Window_Instance);
/* Wait for map. */
do
{
XNextEvent(Display_Ptr, &xev);
}
while (xev.type != MapNotify || xev.xmap.event != Window_Instance);
XSelectInput(Display_Ptr, Window_Instance, NoEventMask);
/* matrix coefficients */
crv = Inverse_Table_6_9[matrix_coefficients][0];
cbu = Inverse_Table_6_9[matrix_coefficients][1];
cgu = Inverse_Table_6_9[matrix_coefficients][2];
cgv = Inverse_Table_6_9[matrix_coefficients][3];
/* allocate colors */
GC_Instance = DefaultGC(Display_Ptr, screen);
cmap = DefaultColormap(Display_Ptr, screen);
private = 0;
/* color allocation:
* i is the (internal) 8 bit color number, it consists of separate
* bit fields for Y, U and V: i = (yyyyuuvv), we don't use yyyy=0000
* and yyyy=1111, this leaves 32 colors for other applications
*
* the allocated colors correspond to the following Y, U and V values:
* Y: 24, 40, 56, 72, 88, 104, 120, 136, 152, 168, 184, 200, 216, 232
* U,V: -48, -16, 16, 48
*
* U and V values span only about half the color space; this gives
* usually much better quality, although highly saturated colors can
* not be displayed properly
*
* translation to R,G,B is implicitly done by the color look-up table
*/
for (i=16; i<240; i++)
{
/* color space conversion */
Y = 16*((i>>4)&15) + 8;
Cb = 32*((i>>2)&3) - 48;
Cr = 32*(i&3) - 48;
Y = 76309 * (Y - 16); /* (255/219)*65536 */
R = Clip[(Y + crv*Cr + 32768)>>16];
G = Clip[(Y - cgu*Cb - cgv*Cr + 32768)>>16];
B = Clip[(Y + cbu*Cb + 32786)>>16];
/* X11 colors are 16 bit */
xcolor.red = R << 8;
xcolor.green = G << 8;
xcolor.blue = B << 8;
if (XAllocColor(Display_Ptr, cmap, &xcolor) != 0)
Pixel[i] = xcolor.pixel;
else
{
/* allocation failed, have to use a private colormap */
if (private)
Error("Couldn't allocate private colormap");
private = 1;
if (!Quiet_Flag)
fprintf(stderr, "Using private colormap (%d colors were available).\n",
i-16);
/* Free colors. */
while (--i >= 16)
{
tmp_pixel = Pixel[i]; /* because XFreeColors expects unsigned long */
XFreeColors(Display_Ptr, cmap, &tmp_pixel, 1, 0);
}
/* i is now 15, this restarts the outer loop */
/* create private colormap */
XGetWindowAttributes(Display_Ptr, Window_Instance, &xwa);
cmap = XCreateColormap(Display_Ptr, Window_Instance, xwa.visual, AllocNone);
XSetWindowColormap(Display_Ptr, Window_Instance, cmap);
}
}
#ifdef SH_MEM
if (XShmQueryExtension(Display_Ptr))
Shmem_Flag = 1;
else
{
Shmem_Flag = 0;
if (!Quiet_Flag)
fprintf(stderr, "Shared memory not supported\nReverting to normal Xlib\n");
}
if (Shmem_Flag)
CompletionType = XShmGetEventBase(Display_Ptr) + ShmCompletion;
InstallXErrorHandler();
if (Shmem_Flag)
{
Ximage_Ptr = XShmCreateImage(Display_Ptr, None, 8, ZPixmap, NULL,
&Shminfo1,
Coded_Picture_Width, Coded_Picture_Height);
if (!progressive_sequence)
Ximage_Ptr2 = XShmCreateImage(Display_Ptr, None, 8, ZPixmap, NULL,
&Shminfo2,
Coded_Picture_Width, Coded_Picture_Height);
/* If no go, then revert to normal Xlib calls. */
if (Ximage_Ptr==NULL || (!progressive_sequence && Ximage_Ptr2==NULL))
{
if (Ximage_Ptr!=NULL)
XDestroyImage(Ximage_Ptr);
if (!progressive_sequence && Ximage_Ptr2!=NULL)
XDestroyImage(Ximage_Ptr2);
if (!Quiet_Flag)
fprintf(stderr, "Shared memory error, disabling (Ximage error)\n");
goto shmemerror;
}
/* Success here, continue. */
Shminfo1.shmid = shmget(IPC_PRIVATE,
Ximage_Ptr->bytes_per_line * Ximage_Ptr->height,
IPC_CREAT | 0777);
if (!progressive_sequence)
Shminfo2.shmid = shmget(IPC_PRIVATE,
Ximage_Ptr2->bytes_per_line * Ximage_Ptr2->height,
IPC_CREAT | 0777);
if (Shminfo1.shmid<0 || (!progressive_sequence && Shminfo2.shmid<0))
{
XDestroyImage(Ximage_Ptr);
if (!progressive_sequence)
XDestroyImage(Ximage_Ptr2);
if (!Quiet_Flag)
fprintf(stderr, "Shared memory error, disabling (seg id error)\n");
goto shmemerror;
}
Shminfo1.shmaddr = (char *) shmat(Shminfo1.shmid, 0, 0);
Shminfo2.shmaddr = (char *) shmat(Shminfo2.shmid, 0, 0);
if (Shminfo1.shmaddr==((char *) -1) ||
(!progressive_sequence && Shminfo2.shmaddr==((char *) -1)))
{
XDestroyImage(Ximage_Ptr);
if (Shminfo1.shmaddr!=((char *) -1))
shmdt(Shminfo1.shmaddr);
if (!progressive_sequence)
{
XDestroyImage(Ximage_Ptr2);
if (Shminfo2.shmaddr!=((char *) -1))
shmdt(Shminfo2.shmaddr);
}
if (!Quiet_Flag)
{
fprintf(stderr, "Shared memory error, disabling (address error)\n");
}
goto shmemerror;
}
Ximage_Ptr->data = Shminfo1.shmaddr;
Dithered_Image = (unsigned char *)Ximage_Ptr->data;
Shminfo1.readOnly = False;
XShmAttach(Display_Ptr, &Shminfo1);
if (!progressive_sequence)
{
Ximage_Ptr2->data = Shminfo2.shmaddr;
Dithered_Image2 = (unsigned char *)Ximage_Ptr2->data;
Shminfo2.readOnly = False;
XShmAttach(Display_Ptr, &Shminfo2);
}
XSync(Display_Ptr, False);
if (gXErrorFlag)
{
/* Ultimate failure here. */
XDestroyImage(Ximage_Ptr);
shmdt(Shminfo1.shmaddr);
if (!progressive_sequence)
{
XDestroyImage(Ximage_Ptr2);
shmdt(Shminfo2.shmaddr);
}
if (!Quiet_Flag)
fprintf(stderr, "Shared memory error, disabling.\n");
gXErrorFlag = 0;
goto shmemerror;
}
else
{
shmctl(Shminfo1.shmid, IPC_RMID, 0);
if (!progressive_sequence)
shmctl(Shminfo2.shmid, IPC_RMID, 0);
}
if (!Quiet_Flag)
{
fprintf(stderr, "Sharing memory.\n");
}
}
else
{
shmemerror:
Shmem_Flag = 0;
#endif
Ximage_Ptr = XCreateImage(Display_Ptr,None,8,ZPixmap,0,&dummy,
Coded_Picture_Width,Coded_Picture_Height,8,0);
if (!(Dithered_Image = (unsigned char *)malloc(Coded_Picture_Width*
Coded_Picture_Height)))
Error("malloc failed");
if (!progressive_sequence)
{
Ximage_Ptr2 = XCreateImage(Display_Ptr,None,8,ZPixmap,0,&dummy,
Coded_Picture_Width,Coded_Picture_Height,8,0);
if (!(Dithered_Image2 = (unsigned char *)malloc(Coded_Picture_Width*
Coded_Picture_Height)))
Error("malloc failed");
}
#ifdef SH_MEM
}
DeInstallXErrorHandler();
#endif
}
void Terminate_Display_Process()
{
#ifdef SH_MEM
if (Shmem_Flag)
{
XShmDetach(Display_Ptr, &Shminfo1);
XDestroyImage(Ximage_Ptr);
shmdt(Shminfo1.shmaddr);
if (!progressive_sequence)
{
XShmDetach(Display_Ptr, &Shminfo2);
XDestroyImage(Ximage_Ptr2);
shmdt(Shminfo2.shmaddr);
}
}
#endif
}
static void Display_Image(Ximage_Ptr,Dithered_Image)
XImage *Ximage_Ptr;
unsigned char *Dithered_Image;
{
/* display dithered image */
#ifdef SH_MEM
if (Shmem_Flag)
{
XShmPutImage(Display_Ptr, Window_Instance, GC_Instance, Ximage_Ptr,
0, 0, 0, 0, Ximage_Ptr->width, Ximage_Ptr->height, True);
XFlush(Display_Ptr);
while (1)
{
XEvent xev;
XNextEvent(Display_Ptr, &xev);
if (xev.type == CompletionType)
break;
}
}
else
#endif
{
Ximage_Ptr->data = (char *) Dithered_Image;
XPutImage(Display_Ptr, Window_Instance, GC_Instance, Ximage_Ptr, 0, 0, 0, 0, Ximage_Ptr->width, Ximage_Ptr->height);
}
}
void Display_Second_Field()
{
Display_Image(Ximage_Ptr2,Dithered_Image2);
}
/* 4x4 ordered dither
*
* threshold pattern:
* 0 8 2 10
* 12 4 14 6
* 3 11 1 9
* 15 7 13 5
*/
void Initialize_Dither_Matrix()
{
int i, v;
for (i=-8; i<256+8; i++)
{
v = i>>4;
if (v<1)
v = 1;
else if (v>14)
v = 14;
Y_Table[i+8] = v<<4;
}
for (i=0; i<128+16; i++)
{
v = (i-40)>>4;
if (v<0)
v = 0;
else if (v>3)
v = 3;
Cb_Table[i] = v<<2;
Cr_Table[i] = v;
}
}
void dither(src)
unsigned char *src[];
{
/* should this test only the display flag, not progressive_sequence ? --CF */
/* CHANGE 95/05/13: progressive_sequence -> progressive_frame */
if( progressive_frame || Display_Progressive_Flag)
Dither_Frame(src);
else
{
if ((picture_structure==FRAME_PICTURE && top_field_first) || picture_structure==BOTTOM_FIELD)
{
/* top field first */
if (chroma_format==CHROMA420 && hiQdither)
{
Dither_Top_Field420(src,Dithered_Image);
Dither_Bottom_Field420(src,Dithered_Image2);
}
else
{
Dither_Top_Field(src,Dithered_Image);
Dither_Bottom_Field(src,Dithered_Image2);
}
}
else
{
/* bottom field first */
if (chroma_format==CHROMA420 && hiQdither)
{
Dither_Bottom_Field420(src,Dithered_Image);
Dither_Top_Field420(src,Dithered_Image2);
}
else
{
Dither_Bottom_Field(src,Dithered_Image);
Dither_Top_Field(src,Dithered_Image2);
}
}
}
Display_Image(Ximage_Ptr,Dithered_Image);
}
static void Dither_Frame(src)
unsigned char *src[];
{
int i,j;
int y,u,v;
unsigned char *py,*pu,*pv,*dst;
py = src[0];
pu = src[1];
pv = src[2];
dst = Dithered_Image;
for (j=0; j<Coded_Picture_Height; j+=4)
{
/* line j + 0 */
for (i=0; i<Coded_Picture_Width; i+=4)
{
y = *py++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[y]|Cb_Table[u]|Cr_Table[v]];
y = *py++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[y+8]|Cb_Table[u+8]|Cr_Table[v+8]];
y = *py++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[y+2]|Cb_Table[u+2]|Cr_Table[v+2]];
y = *py++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[y+10]|Cb_Table[u+10]|Cr_Table[v+10]];
}
if (chroma_format==CHROMA420)
{
pu -= Chroma_Width;
pv -= Chroma_Width;
}
/* line j + 1 */
for (i=0; i<Coded_Picture_Width; i+=4)
{
y = *py++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[y+12]|Cb_Table[u+12]|Cr_Table[v+12]];
y = *py++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[y+4]|Cb_Table[u+4]|Cr_Table[v+4]];
y = *py++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[y+14]|Cb_Table[u+14]|Cr_Table[v+14]];
y = *py++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[y+6]|Cb_Table[u+6]|Cr_Table[v+6]];
}
/* line j + 2 */
for (i=0; i<Coded_Picture_Width; i+=4)
{
y = *py++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[y+3]|Cb_Table[u+3]|Cr_Table[v+3]];
y = *py++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[y+11]|Cb_Table[u+11]|Cr_Table[v+11]];
y = *py++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[y+1]|Cb_Table[u+1]|Cr_Table[v+1]];
y = *py++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[y+9]|Cb_Table[u+9]|Cr_Table[v+9]];
}
if (chroma_format==CHROMA420)
{
pu -= Chroma_Width;
pv -= Chroma_Width;
}
/* line j + 3 */
for (i=0; i<Coded_Picture_Width; i+=4)
{
y = *py++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[y+15]|Cb_Table[u+15]|Cr_Table[v+15]];
y = *py++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[y+7]|Cb_Table[u+7]|Cr_Table[v+7]];
y = *py++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[y+13]|Cb_Table[u+13]|Cr_Table[v+13]];
y = *py++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[y+5]|Cb_Table[u+5]|Cr_Table[v+5]];
}
}
}
static void Dither_Top_Field(src,dst)
unsigned char *src[];
unsigned char *dst;
{
int i,j;
int y,Y2,u,v;
unsigned char *py,*Y2_ptr,*pu,*pv,*dst2;
py = src[0];
Y2_ptr = src[0] + (Coded_Picture_Width<<1);
pu = src[1];
pv = src[2];
dst2 = dst + Coded_Picture_Width;
for (j=0; j<Coded_Picture_Height; j+=4)
{
/* line j + 0, j + 1 */
for (i=0; i<Coded_Picture_Width; i+=4)
{
y = *py++;
Y2 = *Y2_ptr++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[y]|Cb_Table[u]|Cr_Table[v]];
*dst2++ = Pixel[Y_Table[((y+Y2)>>1)+12]|Cb_Table[u+12]|Cr_Table[v+12]];
y = *py++;
Y2 = *Y2_ptr++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[y+8]|Cb_Table[u+8]|Cr_Table[v+8]];
*dst2++ = Pixel[Y_Table[((y+Y2)>>1)+4]|Cb_Table[u+4]|Cr_Table[v+4]];
y = *py++;
Y2 = *Y2_ptr++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[y+2]|Cb_Table[u+2]|Cr_Table[v+2]];
*dst2++ = Pixel[Y_Table[((y+Y2)>>1)+14]|Cb_Table[u+14]|Cr_Table[v+14]];
y = *py++;
Y2 = *Y2_ptr++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[y+10]|Cb_Table[u+10]|Cr_Table[v+10]];
*dst2++ = Pixel[Y_Table[((y+Y2)>>1)+6]|Cb_Table[u+6]|Cr_Table[v+6]];
}
py += Coded_Picture_Width;
if (j!=(Coded_Picture_Height-4))
Y2_ptr += Coded_Picture_Width;
else
Y2_ptr -= Coded_Picture_Width;
dst += Coded_Picture_Width;
dst2 += Coded_Picture_Width;
if (chroma_format==CHROMA420)
{
pu -= Chroma_Width;
pv -= Chroma_Width;
}
else
{
pu += Chroma_Width;
pv += Chroma_Width;
}
/* line j + 2, j + 3 */
for (i=0; i<Coded_Picture_Width; i+=4)
{
y = *py++;
Y2 = *Y2_ptr++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[y+3]|Cb_Table[u+3]|Cr_Table[v+3]];
*dst2++ = Pixel[Y_Table[((y+Y2)>>1)+15]|Cb_Table[u+15]|Cr_Table[v+15]];
y = *py++;
Y2 = *Y2_ptr++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[y+11]|Cb_Table[u+11]|Cr_Table[v+11]];
*dst2++ = Pixel[Y_Table[((y+Y2)>>1)+7]|Cb_Table[u+7]|Cr_Table[v+7]];
y = *py++;
Y2 = *Y2_ptr++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[y+1]|Cb_Table[u+1]|Cr_Table[v+1]];
*dst2++ = Pixel[Y_Table[((y+Y2)>>1)+13]|Cb_Table[u+13]|Cr_Table[v+13]];
y = *py++;
Y2 = *Y2_ptr++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[y+9]|Cb_Table[u+9]|Cr_Table[v+9]];
*dst2++ = Pixel[Y_Table[((y+Y2)>>1)+5]|Cb_Table[u+5]|Cr_Table[v+5]];
}
py += Coded_Picture_Width;
Y2_ptr += Coded_Picture_Width;
dst += Coded_Picture_Width;
dst2 += Coded_Picture_Width;
pu += Chroma_Width;
pv += Chroma_Width;
}
}
static void Dither_Bottom_Field(src,dst)
unsigned char *src[];
unsigned char *dst;
{
int i,j;
int y,Y2,u,v;
unsigned char *py,*Y2_ptr,*pu,*pv,*dst2;
py = src[0] + Coded_Picture_Width;
Y2_ptr = py;
pu = src[1] + Chroma_Width;
pv = src[2] + Chroma_Width;
dst2 = dst + Coded_Picture_Width;
for (j=0; j<Coded_Picture_Height; j+=4)
{
/* line j + 0, j + 1 */
for (i=0; i<Coded_Picture_Width; i+=4)
{
y = *py++;
Y2 = *Y2_ptr++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[((y+Y2)>>1)]|Cb_Table[u]|Cr_Table[v]];
*dst2++ = Pixel[Y_Table[Y2+12]|Cb_Table[u+12]|Cr_Table[v+12]];
y = *py++;
Y2 = *Y2_ptr++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[((y+Y2)>>1)+8]|Cb_Table[u+8]|Cr_Table[v+8]];
*dst2++ = Pixel[Y_Table[Y2+4]|Cb_Table[u+4]|Cr_Table[v+4]];
y = *py++;
Y2 = *Y2_ptr++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[((y+Y2)>>1)+2]|Cb_Table[u+2]|Cr_Table[v+2]];
*dst2++ = Pixel[Y_Table[Y2+14]|Cb_Table[u+14]|Cr_Table[v+14]];
y = *py++;
Y2 = *Y2_ptr++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[((y+Y2)>>1)+10]|Cb_Table[u+10]|Cr_Table[v+10]];
*dst2++ = Pixel[Y_Table[Y2+6]|Cb_Table[u+6]|Cr_Table[v+6]];
}
if (j==0)
py -= Coded_Picture_Width;
else
py += Coded_Picture_Width;
Y2_ptr += Coded_Picture_Width;
dst += Coded_Picture_Width;
dst2 += Coded_Picture_Width;
if (chroma_format==CHROMA420)
{
pu -= Chroma_Width;
pv -= Chroma_Width;
}
else
{
pu += Chroma_Width;
pv += Chroma_Width;
}
/* line j + 2. j + 3 */
for (i=0; i<Coded_Picture_Width; i+=4)
{
y = *py++;
Y2 = *Y2_ptr++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[((y+Y2)>>1)+3]|Cb_Table[u+3]|Cr_Table[v+3]];
*dst2++ = Pixel[Y_Table[Y2+15]|Cb_Table[u+15]|Cr_Table[v+15]];
y = *py++;
Y2 = *Y2_ptr++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[((y+Y2)>>1)+11]|Cb_Table[u+11]|Cr_Table[v+11]];
*dst2++ = Pixel[Y_Table[Y2+7]|Cb_Table[u+7]|Cr_Table[v+7]];
y = *py++;
Y2 = *Y2_ptr++;
u = *pu++ >> 1;
v = *pv++ >> 1;
*dst++ = Pixel[Y_Table[((y+Y2)>>1)+1]|Cb_Table[u+1]|Cr_Table[v+1]];
*dst2++ = Pixel[Y_Table[Y2+13]|Cb_Table[u+13]|Cr_Table[v+13]];
y = *py++;
Y2 = *Y2_ptr++;
if (chroma_format==CHROMA444)
{
u = *pu++ >> 1;
v = *pv++ >> 1;
}
*dst++ = Pixel[Y_Table[((y+Y2)>>1)+9]|Cb_Table[u+9]|Cr_Table[v+9]];
*dst2++ = Pixel[Y_Table[Y2+5]|Cb_Table[u+5]|Cr_Table[v+5]];
}
py += Coded_Picture_Width;
Y2_ptr += Coded_Picture_Width;
dst += Coded_Picture_Width;
dst2 += Coded_Picture_Width;
pu += Chroma_Width;
pv += Chroma_Width;
}
}
static void Dither_Top_Field420(src,dst)
unsigned char *src[];
unsigned char *dst;
{
int i,j;
int Y1,Cb1,Cr1,Y2,Cb2,Cr2;
unsigned char *Y1_ptr,*Cb1_ptr,*Cr1_ptr,*Y2_ptr,*Cb2_ptr,*Cr2_ptr,*dst2;
Y1_ptr = src[0];
Cb1_ptr = src[1];
Cr1_ptr = src[2];
Y2_ptr = Y1_ptr + (Coded_Picture_Width<<1);
Cb2_ptr = Cb1_ptr + (Chroma_Width<<1);
Cr2_ptr = Cr1_ptr + (Chroma_Width<<1);
dst2 = dst + Coded_Picture_Width;
for (j=0; j<Coded_Picture_Height; j+=4)
{
/* line j + 0, j + 1 */
for (i=0; i<Coded_Picture_Width; i+=4)
{
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
Cb1 = *Cb1_ptr++ >> 1;
Cr1 = *Cr1_ptr++ >> 1;
Cb2 = *Cb2_ptr++ >> 1;
Cr2 = *Cr2_ptr++ >> 1;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)]|Cb_Table[Cb1]|Cr_Table[Cr1]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+12]|Cb_Table[((3*Cb1+Cb2)>>2)+12]
|Cr_Table[((3*Cr1+Cr2)>>2)+12]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+8]|Cb_Table[Cb1+8]|Cr_Table[Cr1+8]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+4]|Cb_Table[((3*Cb1+Cb2)>>2)+4]
|Cr_Table[((3*Cr1+Cr2)>>2)+4]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
Cb1 = *Cb1_ptr++ >> 1;
Cr1 = *Cr1_ptr++ >> 1;
Cb2 = *Cb2_ptr++ >> 1;
Cr2 = *Cr2_ptr++ >> 1;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+2]|Cb_Table[Cb1+2]|Cr_Table[Cr1+2]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+14]|Cb_Table[((3*Cb1+Cb2)>>2)+14]
|Cr_Table[((3*Cr1+Cr2)>>2)+14]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+10]|Cb_Table[Cb1+10]|Cr_Table[Cr1+10]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+6]|Cb_Table[((3*Cb1+Cb2)>>2)+6]
|Cr_Table[((3*Cr1+Cr2)>>2)+6]];
}
Y1_ptr += Coded_Picture_Width;
if (j!=(Coded_Picture_Height-4))
Y2_ptr += Coded_Picture_Width;
else
Y2_ptr -= Coded_Picture_Width;
Cb1_ptr -= Chroma_Width;
Cr1_ptr -= Chroma_Width;
Cb2_ptr -= Chroma_Width;
Cr2_ptr -= Chroma_Width;
dst += Coded_Picture_Width;
dst2 += Coded_Picture_Width;
/* line j + 2, j + 3 */
for (i=0; i<Coded_Picture_Width; i+=4)
{
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
Cb1 = *Cb1_ptr++ >> 1;
Cr1 = *Cr1_ptr++ >> 1;
Cb2 = *Cb2_ptr++ >> 1;
Cr2 = *Cr2_ptr++ >> 1;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+3]|Cb_Table[((Cb1+Cb2)>>1)+3]
|Cr_Table[((Cr1+Cr2)>>1)+3]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+15]|Cb_Table[((Cb1+3*Cb2)>>2)+15]
|Cr_Table[((Cr1+3*Cr2)>>2)+15]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+11]|Cb_Table[((Cb1+Cb2)>>1)+11]
|Cr_Table[((Cr1+Cr2)>>1)+11]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+7]|Cb_Table[((Cb1+3*Cb2)>>2)+7]
|Cr_Table[((Cr1+3*Cr2)>>2)+7]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
Cb1 = *Cb1_ptr++ >> 1;
Cr1 = *Cr1_ptr++ >> 1;
Cb2 = *Cb2_ptr++ >> 1;
Cr2 = *Cr2_ptr++ >> 1;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+1]|Cb_Table[((Cb1+Cb2)>>1)+1]
|Cr_Table[((Cr1+Cr2)>>1)+1]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+13]|Cb_Table[((Cb1+3*Cb2)>>2)+13]
|Cr_Table[((Cr1+3*Cr2)>>2)+13]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+9]|Cb_Table[((Cb1+Cb2)>>1)+9]
|Cr_Table[((Cr1+Cr2)>>1)+9]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+5]|Cb_Table[((Cb1+3*Cb2)>>2)+5]
|Cr_Table[((Cr1+3*Cr2)>>2)+5]];
}
Y1_ptr += Coded_Picture_Width;
Y2_ptr += Coded_Picture_Width;
Cb1_ptr += Chroma_Width;
Cr1_ptr += Chroma_Width;
if (j!=(Coded_Picture_Height-8))
{
Cb2_ptr += Chroma_Width;
Cr2_ptr += Chroma_Width;
}
else
{
Cb2_ptr -= Chroma_Width;
Cr2_ptr -= Chroma_Width;
}
dst += Coded_Picture_Width;
dst2+= Coded_Picture_Width;
}
}
static void Dither_Bottom_Field420(src,dst)
unsigned char *src[];
unsigned char *dst;
{
int i,j;
int Y1,Cb1,Cr1,Y2,Cb2,Cr2;
unsigned char *Y1_ptr,*Cb1_ptr,*Cr1_ptr,*Y2_ptr,*Cb2_ptr,*Cr2_ptr,*dst2;
Y2_ptr = Y1_ptr = src[0] + Coded_Picture_Width;
Cb2_ptr = Cb1_ptr = src[1] + Chroma_Width;
Cr2_ptr = Cr1_ptr = src[2] + Chroma_Width;
dst2 = dst;
for (j=0; j<Coded_Picture_Height; j+=4)
{
/* line j + 0, j + 1 */
for (i=0; i<Coded_Picture_Width; i+=4)
{
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
Cb1 = *Cb1_ptr++ >> 1;
Cr1 = *Cr1_ptr++ >> 1;
Cb2 = *Cb2_ptr++ >> 1;
Cr2 = *Cr2_ptr++ >> 1;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+15]|Cb_Table[((3*Cb1+Cb2)>>2)+15]
|Cr_Table[((3*Cr1+Cr2)>>2)+15]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)]|Cb_Table[((Cb1+Cb2)>>1)]
|Cr_Table[((Cr1+Cr2)>>1)]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+7]|Cb_Table[((3*Cb1+Cb2)>>2)+7]
|Cr_Table[((3*Cr1+Cr2)>>2)+7]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+8]|Cb_Table[((Cb1+Cb2)>>1)+8]
|Cr_Table[((Cr1+Cr2)>>1)+8]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
Cb1 = *Cb1_ptr++ >> 1;
Cr1 = *Cr1_ptr++ >> 1;
Cb2 = *Cb2_ptr++ >> 1;
Cr2 = *Cr2_ptr++ >> 1;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+13]|Cb_Table[((3*Cb1+Cb2)>>2)+13]
|Cr_Table[((3*Cr1+Cr2)>>2)+13]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+2]|Cb_Table[((Cb1+Cb2)>>1)+2]
|Cr_Table[((Cr1+Cr2)>>1)+2]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+5]|Cb_Table[((3*Cb1+Cb2)>>2)+5]
|Cr_Table[((3*Cr1+Cr2)>>2)+5]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+10]|Cb_Table[((Cb1+Cb2)>>1)+10]
|Cr_Table[((Cr1+Cr2)>>1)+10]];
}
if (j!=0)
Y1_ptr += Coded_Picture_Width;
else
Y1_ptr -= Coded_Picture_Width;
Y2_ptr += Coded_Picture_Width;
Cb1_ptr -= Chroma_Width;
Cr1_ptr -= Chroma_Width;
Cb2_ptr -= Chroma_Width;
Cr2_ptr -= Chroma_Width;
if (j!=0)
dst += Coded_Picture_Width;
dst2 += Coded_Picture_Width;
/* line j + 2, j + 3 */
for (i=0; i<Coded_Picture_Width; i+=4)
{
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
Cb1 = *Cb1_ptr++ >> 1;
Cr1 = *Cr1_ptr++ >> 1;
Cb2 = *Cb2_ptr++ >> 1;
Cr2 = *Cr2_ptr++ >> 1;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+12]|Cb_Table[((Cb1+3*Cb2)>>2)+12]
|Cr_Table[((Cr1+3*Cr2)>>2)+12]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+3]|Cb_Table[Cb2+3]
|Cr_Table[Cr2+3]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+4]|Cb_Table[((Cb1+3*Cb2)>>2)+4]
|Cr_Table[((Cr1+3*Cr2)>>2)+4]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+11]|Cb_Table[Cb2+11]
|Cr_Table[Cr2+11]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
Cb1 = *Cb1_ptr++ >> 1;
Cr1 = *Cr1_ptr++ >> 1;
Cb2 = *Cb2_ptr++ >> 1;
Cr2 = *Cr2_ptr++ >> 1;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+14]|Cb_Table[((Cb1+3*Cb2)>>2)+14]
|Cr_Table[((Cr1+3*Cr2)>>2)+14]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+1]|Cb_Table[Cb2+1]
|Cr_Table[Cr2+1]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+6]|Cb_Table[((Cb1+3*Cb2)>>2)+6]
|Cr_Table[((Cr1+3*Cr2)>>2)+6]];
*dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+9]|Cb_Table[Cb2+9]
|Cr_Table[Cr2+9]];
}
Y1_ptr += Coded_Picture_Width;
Y2_ptr += Coded_Picture_Width;
if (j!=0)
{
Cb1_ptr += Chroma_Width;
Cr1_ptr += Chroma_Width;
}
else
{
Cb1_ptr -= Chroma_Width;
Cr1_ptr -= Chroma_Width;
}
Cb2_ptr += Chroma_Width;
Cr2_ptr += Chroma_Width;
dst += Coded_Picture_Width;
dst2+= Coded_Picture_Width;
}
Y2_ptr -= (Coded_Picture_Width<<1);
Cb2_ptr -= (Chroma_Width<<1);
Cr2_ptr -= (Chroma_Width<<1);
/* dither last line */
for (i=0; i<Coded_Picture_Width; i+=4)
{
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
Cb1 = *Cb1_ptr++ >> 1;
Cr1 = *Cr1_ptr++ >> 1;
Cb2 = *Cb2_ptr++ >> 1;
Cr2 = *Cr2_ptr++ >> 1;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+15]|Cb_Table[((3*Cb1+Cb2)>>2)+15]
|Cr_Table[((3*Cr1+Cr2)>>2)+15]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+7]|Cb_Table[((3*Cb1+Cb2)>>2)+7]
|Cr_Table[((3*Cr1+Cr2)>>2)+7]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
Cb1 = *Cb1_ptr++ >> 1;
Cr1 = *Cr1_ptr++ >> 1;
Cb2 = *Cb2_ptr++ >> 1;
Cr2 = *Cr2_ptr++ >> 1;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+13]|Cb_Table[((3*Cb1+Cb2)>>2)+13]
|Cr_Table[((3*Cr1+Cr2)>>2)+13]];
Y1 = *Y1_ptr++;
Y2 = *Y2_ptr++;
*dst++ = Pixel[Y_Table[((3*Y1+Y2)>>2)+5]|Cb_Table[((3*Cb1+Cb2)>>2)+5]
|Cr_Table[((3*Cr1+Cr2)>>2)+5]];
}
}
#endif
Reference in a new issue View git blame Copy permalink