display.c
上传用户:hkgotone
上传日期:2013-02-17
资源大小:293k
文件大小:33k
源码类别:

Windows Mobile

开发平台:

C/C++

  1. /* display.c, X11 interface                                                 */
  2. /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
  3. /*
  4.  * Disclaimer of Warranty
  5.  *
  6.  * These software programs are available to the user without any license fee or
  7.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  8.  * any and all warranties, whether express, implied, or statuary, including any
  9.  * implied warranties or merchantability or of fitness for a particular
  10.  * purpose.  In no event shall the copyright-holder be liable for any
  11.  * incidental, punitive, or consequential damages of any kind whatsoever
  12.  * arising from the use of these programs.
  13.  *
  14.  * This disclaimer of warranty extends to the user of these programs and user's
  15.  * customers, employees, agents, transferees, successors, and assigns.
  16.  *
  17.  * The MPEG Software Simulation Group does not represent or warrant that the
  18.  * programs furnished hereunder are free of infringement of any third-party
  19.  * patents.
  20.  *
  21.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  22.  * are subject to royalty fees to patent holders.  Many of these patents are
  23.  * general enough such that they are unavoidable regardless of implementation
  24.  * design.
  25.  *
  26.  */
  27. #ifdef DISPLAY
  28.  /* the Xlib interface is closely modeled after
  29.   * mpeg_play 2.0 by the Berkeley Plateau Research Group
  30.   */
  31. #include <stdio.h>
  32. #include <stdlib.h>
  33. #include <X11/Xlib.h>
  34. #include <X11/Xutil.h>
  35. #include "config.h"
  36. #include "global.h"
  37. /* private prototypes */
  38. static void Display_Image _ANSI_ARGS_((XImage *Ximage_Ptr, unsigned char *Dithered_Image));
  39. static void Dither_Frame _ANSI_ARGS_((unsigned char *src[]));
  40. static void Dither_Top_Field _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  41. static void Dither_Bottom_Field _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  42. static void Dither_Top_Field420 _ANSI_ARGS_((unsigned char *src[],
  43.                                       unsigned char *dst));
  44. static void Dither_Bottom_Field420 _ANSI_ARGS_((unsigned char *src[],
  45.                                       unsigned char *dst));
  46. /* local data */
  47. static unsigned char *Dithered_Image, *Dithered_Image2;
  48. static unsigned char Y_Table[256+16];
  49. static unsigned char Cb_Table[128+16];
  50. static unsigned char Cr_Table[128+16];
  51. /* X11 related variables */
  52. static Display *Display_Ptr;
  53. static Window Window_Instance;
  54. static GC GC_Instance;
  55. static XImage *Ximage_Ptr, *Ximage_Ptr2;
  56. static unsigned char Pixel[256];
  57. #ifdef SH_MEM
  58. #include <sys/ipc.h>
  59. #include <sys/shm.h>
  60. #include <X11/extensions/XShm.h>
  61. static int HandleXError _ANSI_ARGS_((Display *dpy, XErrorEvent *event));
  62. static void InstallXErrorHandler _ANSI_ARGS_((void));
  63. static void DeInstallXErrorHandler _ANSI_ARGS_((void));
  64. static int Shmem_Flag;
  65. static XShmSegmentInfo Shminfo1, Shminfo2;
  66. static int gXErrorFlag;
  67. static int CompletionType = -1;
  68. static int HandleXError(Dpy, Event)
  69. Display *Dpy;
  70. XErrorEvent *Event;
  71. {
  72.   gXErrorFlag = 1;
  73.   return 0;
  74. }
  75. static void InstallXErrorHandler()
  76. {
  77.   XSetErrorHandler(HandleXError);
  78.   XFlush(Display_Ptr);
  79. }
  80. static void DeInstallXErrorHandler()
  81. {
  82.   XSetErrorHandler(NULL);
  83.   XFlush(Display_Ptr);
  84. }
  85. #endif
  86. /* connect to server, create and map window,
  87.  * allocate colors and (shared) memory
  88.  */
  89. void Initialize_Display_Process(name)
  90. char *name;
  91. {
  92.   int crv, cbu, cgu, cgv;
  93.   int Y, Cb, Cr, R, G, B;
  94.   int i;
  95.   char dummy;
  96.   int screen;
  97.   Colormap cmap;
  98.   int private;
  99.   XColor xcolor;
  100.   unsigned int fg, bg;
  101.   char *hello = "MPEG-2 Display";
  102.   XSizeHints hint;
  103.   XVisualInfo vinfo;
  104.   XEvent xev;
  105.   unsigned long tmp_pixel;
  106.   XWindowAttributes xwa;
  107.   Display_Ptr = XOpenDisplay(name);
  108.   if (Display_Ptr == NULL)
  109.     Error("Can not open displayn");
  110.   screen = DefaultScreen(Display_Ptr);
  111.   hint.x = 200;
  112.   hint.y = 200;
  113.   hint.width = horizontal_size;
  114.   hint.height = vertical_size;
  115.   hint.flags = PPosition | PSize;
  116.   /* Get some colors */
  117.   bg = WhitePixel (Display_Ptr, screen);
  118.   fg = BlackPixel (Display_Ptr, screen);
  119.   /* Make the window */
  120.   if (!XMatchVisualInfo(Display_Ptr, screen, 8, PseudoColor, &vinfo))
  121.   {
  122.     if (!XMatchVisualInfo(Display_Ptr, screen, 8, GrayScale, &vinfo))
  123.       Error("requires 8 bit displayn");
  124.   }
  125.   Window_Instance = XCreateSimpleWindow (Display_Ptr, DefaultRootWindow (Display_Ptr),
  126.              hint.x, hint.y, hint.width, hint.height, 4, fg, bg);
  127.   XSelectInput(Display_Ptr, Window_Instance, StructureNotifyMask);
  128.   /* Tell other applications about this window */
  129.   XSetStandardProperties (Display_Ptr, Window_Instance, hello, hello, None, NULL, 0, &hint);
  130.   /* Map window. */
  131.   XMapWindow(Display_Ptr, Window_Instance);
  132.   /* Wait for map. */
  133.   do
  134.   {
  135.     XNextEvent(Display_Ptr, &xev);
  136.   }
  137.   while (xev.type != MapNotify || xev.xmap.event != Window_Instance);
  138.   XSelectInput(Display_Ptr, Window_Instance, NoEventMask);
  139.   /* matrix coefficients */
  140.   crv = Inverse_Table_6_9[matrix_coefficients][0];
  141.   cbu = Inverse_Table_6_9[matrix_coefficients][1];
  142.   cgu = Inverse_Table_6_9[matrix_coefficients][2];
  143.   cgv = Inverse_Table_6_9[matrix_coefficients][3];
  144.   /* allocate colors */
  145.   GC_Instance = DefaultGC(Display_Ptr, screen);
  146.   cmap = DefaultColormap(Display_Ptr, screen);
  147.   private = 0;
  148.   /* color allocation:
  149.    * i is the (internal) 8 bit color number, it consists of separate
  150.    * bit fields for Y, U and V: i = (yyyyuuvv), we don't use yyyy=0000
  151.    * and yyyy=1111, this leaves 32 colors for other applications
  152.    *
  153.    * the allocated colors correspond to the following Y, U and V values:
  154.    * Y:   24, 40, 56, 72, 88, 104, 120, 136, 152, 168, 184, 200, 216, 232
  155.    * U,V: -48, -16, 16, 48
  156.    *
  157.    * U and V values span only about half the color space; this gives
  158.    * usually much better quality, although highly saturated colors can
  159.    * not be displayed properly
  160.    *
  161.    * translation to R,G,B is implicitly done by the color look-up table
  162.    */
  163.   for (i=16; i<240; i++)
  164.   {
  165.     /* color space conversion */
  166.     Y  = 16*((i>>4)&15) + 8;
  167.     Cb = 32*((i>>2)&3)  - 48;
  168.     Cr = 32*(i&3)       - 48;
  169.     Y = 76309 * (Y - 16); /* (255/219)*65536 */
  170.     R = Clip[(Y + crv*Cr + 32768)>>16];
  171.     G = Clip[(Y - cgu*Cb - cgv*Cr + 32768)>>16];
  172.     B = Clip[(Y + cbu*Cb + 32786)>>16];
  173.     /* X11 colors are 16 bit */
  174.     xcolor.red   = R << 8;
  175.     xcolor.green = G << 8;
  176.     xcolor.blue  = B << 8;
  177.     if (XAllocColor(Display_Ptr, cmap, &xcolor) != 0)
  178.       Pixel[i] = xcolor.pixel;
  179.     else
  180.     {
  181.       /* allocation failed, have to use a private colormap */
  182.       if (private)
  183.         Error("Couldn't allocate private colormap");
  184.       private = 1;
  185.       if (!Quiet_Flag)
  186.         fprintf(stderr, "Using private colormap (%d colors were available).n",
  187.           i-16);
  188.       /* Free colors. */
  189.       while (--i >= 16)
  190.       {
  191.         tmp_pixel = Pixel[i]; /* because XFreeColors expects unsigned long */
  192.         XFreeColors(Display_Ptr, cmap, &tmp_pixel, 1, 0);
  193.       }
  194.       /* i is now 15, this restarts the outer loop */
  195.       /* create private colormap */
  196.       XGetWindowAttributes(Display_Ptr, Window_Instance, &xwa);
  197.       cmap = XCreateColormap(Display_Ptr, Window_Instance, xwa.visual, AllocNone);
  198.       XSetWindowColormap(Display_Ptr, Window_Instance, cmap);
  199.     }
  200.   }
  201. #ifdef SH_MEM
  202.   if (XShmQueryExtension(Display_Ptr))
  203.     Shmem_Flag = 1;
  204.   else
  205.   {
  206.     Shmem_Flag = 0;
  207.     if (!Quiet_Flag)
  208.       fprintf(stderr, "Shared memory not supportednReverting to normal Xlibn");
  209.   }
  210.   if (Shmem_Flag)
  211.     CompletionType = XShmGetEventBase(Display_Ptr) + ShmCompletion;
  212.   InstallXErrorHandler();
  213.   if (Shmem_Flag)
  214.   {
  215.     Ximage_Ptr = XShmCreateImage(Display_Ptr, None, 8, ZPixmap, NULL,
  216.                              &Shminfo1,
  217.                              Coded_Picture_Width, Coded_Picture_Height);
  218.     if (!progressive_sequence)
  219.       Ximage_Ptr2 = XShmCreateImage(Display_Ptr, None, 8, ZPixmap, NULL,
  220.                                 &Shminfo2,
  221.                                 Coded_Picture_Width, Coded_Picture_Height);
  222.     /* If no go, then revert to normal Xlib calls. */
  223.     if (Ximage_Ptr==NULL || (!progressive_sequence && Ximage_Ptr2==NULL))
  224.     {
  225.       if (Ximage_Ptr!=NULL)
  226.         XDestroyImage(Ximage_Ptr);
  227.       if (!progressive_sequence && Ximage_Ptr2!=NULL)
  228.         XDestroyImage(Ximage_Ptr2);
  229.       if (!Quiet_Flag)
  230.         fprintf(stderr, "Shared memory error, disabling (Ximage error)n");
  231.       goto shmemerror;
  232.     }
  233.     /* Success here, continue. */
  234.     Shminfo1.shmid = shmget(IPC_PRIVATE, 
  235.                             Ximage_Ptr->bytes_per_line * Ximage_Ptr->height,
  236.                             IPC_CREAT | 0777);
  237.     if (!progressive_sequence)
  238.       Shminfo2.shmid = shmget(IPC_PRIVATE, 
  239.                               Ximage_Ptr2->bytes_per_line * Ximage_Ptr2->height,
  240.                               IPC_CREAT | 0777);
  241.     if (Shminfo1.shmid<0 || (!progressive_sequence && Shminfo2.shmid<0))
  242.     {
  243.       XDestroyImage(Ximage_Ptr);
  244.       if (!progressive_sequence)
  245.         XDestroyImage(Ximage_Ptr2);
  246.       if (!Quiet_Flag)
  247.         fprintf(stderr, "Shared memory error, disabling (seg id error)n");
  248.       goto shmemerror;
  249.     }
  250.     Shminfo1.shmaddr = (char *) shmat(Shminfo1.shmid, 0, 0);
  251.     Shminfo2.shmaddr = (char *) shmat(Shminfo2.shmid, 0, 0);
  252.     if (Shminfo1.shmaddr==((char *) -1) ||
  253.         (!progressive_sequence && Shminfo2.shmaddr==((char *) -1)))
  254.     {
  255.       XDestroyImage(Ximage_Ptr);
  256.       if (Shminfo1.shmaddr!=((char *) -1))
  257.         shmdt(Shminfo1.shmaddr);
  258.       if (!progressive_sequence)
  259.       {
  260.         XDestroyImage(Ximage_Ptr2);
  261.         if (Shminfo2.shmaddr!=((char *) -1))
  262.           shmdt(Shminfo2.shmaddr);
  263.       }
  264.       if (!Quiet_Flag)
  265.       {
  266.         fprintf(stderr, "Shared memory error, disabling (address error)n");
  267.       }
  268.       goto shmemerror;
  269.     }
  270.     Ximage_Ptr->data = Shminfo1.shmaddr;
  271.     Dithered_Image = (unsigned char *)Ximage_Ptr->data;
  272.     Shminfo1.readOnly = False;
  273.     XShmAttach(Display_Ptr, &Shminfo1);
  274.     if (!progressive_sequence)
  275.     {
  276.       Ximage_Ptr2->data = Shminfo2.shmaddr;
  277.       Dithered_Image2 = (unsigned char *)Ximage_Ptr2->data;
  278.       Shminfo2.readOnly = False;
  279.       XShmAttach(Display_Ptr, &Shminfo2);
  280.     }
  281.     XSync(Display_Ptr, False);
  282.     if (gXErrorFlag)
  283.     {
  284.       /* Ultimate failure here. */
  285.       XDestroyImage(Ximage_Ptr);
  286.       shmdt(Shminfo1.shmaddr);
  287.       if (!progressive_sequence)
  288.       {
  289.         XDestroyImage(Ximage_Ptr2);
  290.         shmdt(Shminfo2.shmaddr);
  291.       }
  292.       if (!Quiet_Flag)
  293.         fprintf(stderr, "Shared memory error, disabling.n");
  294.       gXErrorFlag = 0;
  295.       goto shmemerror;
  296.     }
  297.     else
  298.     {
  299.       shmctl(Shminfo1.shmid, IPC_RMID, 0);
  300.       if (!progressive_sequence)
  301.         shmctl(Shminfo2.shmid, IPC_RMID, 0);
  302.     }
  303.     if (!Quiet_Flag)
  304.     {
  305.       fprintf(stderr, "Sharing memory.n");
  306.     }
  307.   }
  308.   else
  309.   {
  310. shmemerror:
  311.     Shmem_Flag = 0;
  312. #endif
  313.     Ximage_Ptr = XCreateImage(Display_Ptr,None,8,ZPixmap,0,&dummy,
  314.                           Coded_Picture_Width,Coded_Picture_Height,8,0);
  315.     if (!(Dithered_Image = (unsigned char *)malloc(Coded_Picture_Width*
  316.                                                    Coded_Picture_Height)))
  317.       Error("malloc failed");
  318.     if (!progressive_sequence)
  319.     {
  320.       Ximage_Ptr2 = XCreateImage(Display_Ptr,None,8,ZPixmap,0,&dummy,
  321.                              Coded_Picture_Width,Coded_Picture_Height,8,0);
  322.       if (!(Dithered_Image2 = (unsigned char *)malloc(Coded_Picture_Width*
  323.                                                       Coded_Picture_Height)))
  324.         Error("malloc failed");
  325.     }
  326. #ifdef SH_MEM
  327.   }
  328.   DeInstallXErrorHandler();
  329. #endif
  330. }
  331. void Terminate_Display_Process()
  332. {
  333. #ifdef SH_MEM
  334.   if (Shmem_Flag)
  335.   {
  336.     XShmDetach(Display_Ptr, &Shminfo1);
  337.     XDestroyImage(Ximage_Ptr);
  338.     shmdt(Shminfo1.shmaddr);
  339.     if (!progressive_sequence)
  340.     {
  341.       XShmDetach(Display_Ptr, &Shminfo2);
  342.       XDestroyImage(Ximage_Ptr2);
  343.       shmdt(Shminfo2.shmaddr);
  344.     }
  345.   }
  346. #endif
  347. }
  348. static void Display_Image(Ximage_Ptr,Dithered_Image)
  349. XImage *Ximage_Ptr;
  350. unsigned char *Dithered_Image;
  351. {
  352.   /* display dithered image */
  353. #ifdef SH_MEM
  354.   if (Shmem_Flag)
  355.   {
  356.     XShmPutImage(Display_Ptr, Window_Instance, GC_Instance, Ximage_Ptr, 
  357.                  0, 0, 0, 0, Ximage_Ptr->width, Ximage_Ptr->height, True);
  358.     XFlush(Display_Ptr);
  359.       
  360.     while (1)
  361.     {
  362.       XEvent xev;
  363.       XNextEvent(Display_Ptr, &xev);
  364.       if (xev.type == CompletionType)
  365.         break;
  366.     }
  367.   }
  368.   else 
  369. #endif
  370.   {
  371.     Ximage_Ptr->data = (char *) Dithered_Image; 
  372.     XPutImage(Display_Ptr, Window_Instance, GC_Instance, Ximage_Ptr, 0, 0, 0, 0, Ximage_Ptr->width, Ximage_Ptr->height);
  373.   }
  374. }
  375. void Display_Second_Field()
  376. {
  377.   Display_Image(Ximage_Ptr2,Dithered_Image2);
  378. }
  379. /* 4x4 ordered dither
  380.  *
  381.  * threshold pattern:
  382.  *   0  8  2 10
  383.  *  12  4 14  6
  384.  *   3 11  1  9
  385.  *  15  7 13  5
  386.  */
  387. void Initialize_Dither_Matrix()
  388. {
  389.   int i, v;
  390.   for (i=-8; i<256+8; i++)
  391.   {
  392.     v = i>>4;
  393.     if (v<1)
  394.       v = 1;
  395.     else if (v>14)
  396.       v = 14;
  397.     Y_Table[i+8] = v<<4;
  398.   }
  399.   for (i=0; i<128+16; i++)
  400.   {
  401.     v = (i-40)>>4;
  402.     if (v<0)
  403.       v = 0;
  404.     else if (v>3)
  405.       v = 3;
  406.     Cb_Table[i] = v<<2;
  407.     Cr_Table[i] = v;
  408.   }
  409. }
  410. void dither(src)
  411. unsigned char *src[];
  412. {
  413.   /* should this test only the display flag, not progressive_sequence ? --CF */
  414.   /* CHANGE 95/05/13: progressive_sequence -> progressive_frame */
  415.   if( progressive_frame || Display_Progressive_Flag)
  416.     Dither_Frame(src);
  417.   else
  418.   {
  419.     if ((picture_structure==FRAME_PICTURE && top_field_first) || picture_structure==BOTTOM_FIELD)
  420.     {
  421.       /* top field first */
  422.       if (chroma_format==CHROMA420 && hiQdither)
  423.       {
  424.         Dither_Top_Field420(src,Dithered_Image);
  425.         Dither_Bottom_Field420(src,Dithered_Image2);
  426.       }
  427.       else
  428.       {
  429.         Dither_Top_Field(src,Dithered_Image);
  430.         Dither_Bottom_Field(src,Dithered_Image2);
  431.       }
  432.     }
  433.     else
  434.     {
  435.       /* bottom field first */
  436.       if (chroma_format==CHROMA420 && hiQdither)
  437.       {
  438.         Dither_Bottom_Field420(src,Dithered_Image);
  439.         Dither_Top_Field420(src,Dithered_Image2);
  440.       }
  441.       else
  442.       {
  443.         Dither_Bottom_Field(src,Dithered_Image);
  444.         Dither_Top_Field(src,Dithered_Image2);
  445.       }
  446.     }
  447.   }
  448.   Display_Image(Ximage_Ptr,Dithered_Image);
  449. }
  450. static void Dither_Frame(src)
  451. unsigned char *src[];
  452. {
  453.   int i,j;
  454.   int y,u,v;
  455.   unsigned char *py,*pu,*pv,*dst;
  456.   py = src[0];
  457.   pu = src[1];
  458.   pv = src[2];
  459.   dst = Dithered_Image;
  460.   for (j=0; j<Coded_Picture_Height; j+=4)
  461.   {
  462.     /* line j + 0 */
  463.     for (i=0; i<Coded_Picture_Width; i+=4)
  464.     {
  465.       y = *py++;
  466.       u = *pu++ >> 1;
  467.       v = *pv++ >> 1;
  468.       *dst++ = Pixel[Y_Table[y]|Cb_Table[u]|Cr_Table[v]];
  469.       y = *py++;
  470.       if (chroma_format==CHROMA444)
  471.       {
  472.         u = *pu++ >> 1;
  473.         v = *pv++ >> 1;
  474.       }
  475.       *dst++ = Pixel[Y_Table[y+8]|Cb_Table[u+8]|Cr_Table[v+8]];
  476.       y = *py++;
  477.       u = *pu++ >> 1;
  478.       v = *pv++ >> 1;
  479.       *dst++ = Pixel[Y_Table[y+2]|Cb_Table[u+2]|Cr_Table[v+2]];
  480.       y = *py++;
  481.       if (chroma_format==CHROMA444)
  482.       {
  483.         u = *pu++ >> 1;
  484.         v = *pv++ >> 1;
  485.       }
  486.       *dst++ = Pixel[Y_Table[y+10]|Cb_Table[u+10]|Cr_Table[v+10]];
  487.     }
  488.     if (chroma_format==CHROMA420)
  489.     {
  490.       pu -= Chroma_Width;
  491.       pv -= Chroma_Width;
  492.     }
  493.     /* line j + 1 */
  494.     for (i=0; i<Coded_Picture_Width; i+=4)
  495.     {
  496.       y = *py++;
  497.       u = *pu++ >> 1;
  498.       v = *pv++ >> 1;
  499.       *dst++ = Pixel[Y_Table[y+12]|Cb_Table[u+12]|Cr_Table[v+12]];
  500.       y = *py++;
  501.       if (chroma_format==CHROMA444)
  502.       {
  503.         u = *pu++ >> 1;
  504.         v = *pv++ >> 1;
  505.       }
  506.       *dst++ = Pixel[Y_Table[y+4]|Cb_Table[u+4]|Cr_Table[v+4]];
  507.       y = *py++;
  508.       u = *pu++ >> 1;
  509.       v = *pv++ >> 1;
  510.       *dst++ = Pixel[Y_Table[y+14]|Cb_Table[u+14]|Cr_Table[v+14]];
  511.       y = *py++;
  512.       if (chroma_format==CHROMA444)
  513.       {
  514.         u = *pu++ >> 1;
  515.         v = *pv++ >> 1;
  516.       }
  517.       *dst++ = Pixel[Y_Table[y+6]|Cb_Table[u+6]|Cr_Table[v+6]];
  518.     }
  519.     /* line j + 2 */
  520.     for (i=0; i<Coded_Picture_Width; i+=4)
  521.     {
  522.       y = *py++;
  523.       u = *pu++ >> 1;
  524.       v = *pv++ >> 1;
  525.       *dst++ = Pixel[Y_Table[y+3]|Cb_Table[u+3]|Cr_Table[v+3]];
  526.       y = *py++;
  527.       if (chroma_format==CHROMA444)
  528.       {
  529.         u = *pu++ >> 1;
  530.         v = *pv++ >> 1;
  531.       }
  532.       *dst++ = Pixel[Y_Table[y+11]|Cb_Table[u+11]|Cr_Table[v+11]];
  533.       y = *py++;
  534.       u = *pu++ >> 1;
  535.       v = *pv++ >> 1;
  536.       *dst++ = Pixel[Y_Table[y+1]|Cb_Table[u+1]|Cr_Table[v+1]];
  537.       y = *py++;
  538.       if (chroma_format==CHROMA444)
  539.       {
  540.         u = *pu++ >> 1;
  541.         v = *pv++ >> 1;
  542.       }
  543.       *dst++ = Pixel[Y_Table[y+9]|Cb_Table[u+9]|Cr_Table[v+9]];
  544.     }
  545.     if (chroma_format==CHROMA420)
  546.     {
  547.       pu -= Chroma_Width;
  548.       pv -= Chroma_Width;
  549.     }
  550.     /* line j + 3 */
  551.     for (i=0; i<Coded_Picture_Width; i+=4)
  552.     {
  553.       y = *py++;
  554.       u = *pu++ >> 1;
  555.       v = *pv++ >> 1;
  556.       *dst++ = Pixel[Y_Table[y+15]|Cb_Table[u+15]|Cr_Table[v+15]];
  557.       y = *py++;
  558.       if (chroma_format==CHROMA444)
  559.       {
  560.         u = *pu++ >> 1;
  561.         v = *pv++ >> 1;
  562.       }
  563.       *dst++ = Pixel[Y_Table[y+7]|Cb_Table[u+7]|Cr_Table[v+7]];
  564.       y = *py++;
  565.       u = *pu++ >> 1;
  566.       v = *pv++ >> 1;
  567.       *dst++ = Pixel[Y_Table[y+13]|Cb_Table[u+13]|Cr_Table[v+13]];
  568.       y = *py++;
  569.       if (chroma_format==CHROMA444)
  570.       {
  571.         u = *pu++ >> 1;
  572.         v = *pv++ >> 1;
  573.       }
  574.       *dst++ = Pixel[Y_Table[y+5]|Cb_Table[u+5]|Cr_Table[v+5]];
  575.     }
  576.   }
  577. }
  578. static void Dither_Top_Field(src,dst)
  579. unsigned char *src[];
  580. unsigned char *dst;
  581. {
  582.   int i,j;
  583.   int y,Y2,u,v;
  584.   unsigned char *py,*Y2_ptr,*pu,*pv,*dst2;
  585.   py = src[0];
  586.   Y2_ptr = src[0] + (Coded_Picture_Width<<1);
  587.   pu = src[1];
  588.   pv = src[2];
  589.   dst2 = dst + Coded_Picture_Width;
  590.   for (j=0; j<Coded_Picture_Height; j+=4)
  591.   {
  592.     /* line j + 0, j + 1 */
  593.     for (i=0; i<Coded_Picture_Width; i+=4)
  594.     {
  595.       y = *py++;
  596.       Y2 = *Y2_ptr++;
  597.       u = *pu++ >> 1;
  598.       v = *pv++ >> 1;
  599.       *dst++  = Pixel[Y_Table[y]|Cb_Table[u]|Cr_Table[v]];
  600.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+12]|Cb_Table[u+12]|Cr_Table[v+12]];
  601.       y = *py++;
  602.       Y2 = *Y2_ptr++;
  603.       if (chroma_format==CHROMA444)
  604.       {
  605.         u = *pu++ >> 1;
  606.         v = *pv++ >> 1;
  607.       }
  608.       *dst++  = Pixel[Y_Table[y+8]|Cb_Table[u+8]|Cr_Table[v+8]];
  609.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+4]|Cb_Table[u+4]|Cr_Table[v+4]];
  610.       y = *py++;
  611.       Y2 = *Y2_ptr++;
  612.       u = *pu++ >> 1;
  613.       v = *pv++ >> 1;
  614.       *dst++  = Pixel[Y_Table[y+2]|Cb_Table[u+2]|Cr_Table[v+2]];
  615.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+14]|Cb_Table[u+14]|Cr_Table[v+14]];
  616.       y = *py++;
  617.       Y2 = *Y2_ptr++;
  618.       if (chroma_format==CHROMA444)
  619.       {
  620.         u = *pu++ >> 1;
  621.         v = *pv++ >> 1;
  622.       }
  623.       *dst++  = Pixel[Y_Table[y+10]|Cb_Table[u+10]|Cr_Table[v+10]];
  624.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+6]|Cb_Table[u+6]|Cr_Table[v+6]];
  625.     }
  626.     py += Coded_Picture_Width;
  627.     if (j!=(Coded_Picture_Height-4))
  628.       Y2_ptr += Coded_Picture_Width;
  629.     else
  630.       Y2_ptr -= Coded_Picture_Width;
  631.     dst += Coded_Picture_Width;
  632.     dst2 += Coded_Picture_Width;
  633.     if (chroma_format==CHROMA420)
  634.     {
  635.       pu -= Chroma_Width;
  636.       pv -= Chroma_Width;
  637.     }
  638.     else
  639.     {
  640.       pu += Chroma_Width;
  641.       pv += Chroma_Width;
  642.     }
  643.     /* line j + 2, j + 3 */
  644.     for (i=0; i<Coded_Picture_Width; i+=4)
  645.     {
  646.       y = *py++;
  647.       Y2 = *Y2_ptr++;
  648.       u = *pu++ >> 1;
  649.       v = *pv++ >> 1;
  650.       *dst++  = Pixel[Y_Table[y+3]|Cb_Table[u+3]|Cr_Table[v+3]];
  651.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+15]|Cb_Table[u+15]|Cr_Table[v+15]];
  652.       y = *py++;
  653.       Y2 = *Y2_ptr++;
  654.       if (chroma_format==CHROMA444)
  655.       {
  656.         u = *pu++ >> 1;
  657.         v = *pv++ >> 1;
  658.       }
  659.       *dst++  = Pixel[Y_Table[y+11]|Cb_Table[u+11]|Cr_Table[v+11]];
  660.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+7]|Cb_Table[u+7]|Cr_Table[v+7]];
  661.       y = *py++;
  662.       Y2 = *Y2_ptr++;
  663.       u = *pu++ >> 1;
  664.       v = *pv++ >> 1;
  665.       *dst++  = Pixel[Y_Table[y+1]|Cb_Table[u+1]|Cr_Table[v+1]];
  666.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+13]|Cb_Table[u+13]|Cr_Table[v+13]];
  667.       y = *py++;
  668.       Y2 = *Y2_ptr++;
  669.       if (chroma_format==CHROMA444)
  670.       {
  671.         u = *pu++ >> 1;
  672.         v = *pv++ >> 1;
  673.       }
  674.       *dst++  = Pixel[Y_Table[y+9]|Cb_Table[u+9]|Cr_Table[v+9]];
  675.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+5]|Cb_Table[u+5]|Cr_Table[v+5]];
  676.     }
  677.     py += Coded_Picture_Width;
  678.     Y2_ptr += Coded_Picture_Width;
  679.     dst += Coded_Picture_Width;
  680.     dst2 += Coded_Picture_Width;
  681.     pu += Chroma_Width;
  682.     pv += Chroma_Width;
  683.   }
  684. }
  685. static void Dither_Bottom_Field(src,dst)
  686. unsigned char *src[];
  687. unsigned char *dst;
  688. {
  689.   int i,j;
  690.   int y,Y2,u,v;
  691.   unsigned char *py,*Y2_ptr,*pu,*pv,*dst2;
  692.   py = src[0] + Coded_Picture_Width;
  693.   Y2_ptr = py;
  694.   pu = src[1] + Chroma_Width;
  695.   pv = src[2] + Chroma_Width;
  696.   dst2 = dst + Coded_Picture_Width;
  697.   for (j=0; j<Coded_Picture_Height; j+=4)
  698.   {
  699.     /* line j + 0, j + 1 */
  700.     for (i=0; i<Coded_Picture_Width; i+=4)
  701.     {
  702.       y = *py++;
  703.       Y2 = *Y2_ptr++;
  704.       u = *pu++ >> 1;
  705.       v = *pv++ >> 1;
  706.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)]|Cb_Table[u]|Cr_Table[v]];
  707.       *dst2++ = Pixel[Y_Table[Y2+12]|Cb_Table[u+12]|Cr_Table[v+12]];
  708.       y = *py++;
  709.       Y2 = *Y2_ptr++;
  710.       if (chroma_format==CHROMA444)
  711.       {
  712.         u = *pu++ >> 1;
  713.         v = *pv++ >> 1;
  714.       }
  715.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+8]|Cb_Table[u+8]|Cr_Table[v+8]];
  716.       *dst2++ = Pixel[Y_Table[Y2+4]|Cb_Table[u+4]|Cr_Table[v+4]];
  717.       y = *py++;
  718.       Y2 = *Y2_ptr++;
  719.       u = *pu++ >> 1;
  720.       v = *pv++ >> 1;
  721.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+2]|Cb_Table[u+2]|Cr_Table[v+2]];
  722.       *dst2++ = Pixel[Y_Table[Y2+14]|Cb_Table[u+14]|Cr_Table[v+14]];
  723.       y = *py++;
  724.       Y2 = *Y2_ptr++;
  725.       if (chroma_format==CHROMA444)
  726.       {
  727.         u = *pu++ >> 1;
  728.         v = *pv++ >> 1;
  729.       }
  730.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+10]|Cb_Table[u+10]|Cr_Table[v+10]];
  731.       *dst2++ = Pixel[Y_Table[Y2+6]|Cb_Table[u+6]|Cr_Table[v+6]];
  732.     }
  733.     if (j==0)
  734.       py -= Coded_Picture_Width;
  735.     else
  736.       py += Coded_Picture_Width;
  737.     Y2_ptr += Coded_Picture_Width;
  738.     dst += Coded_Picture_Width;
  739.     dst2 += Coded_Picture_Width;
  740.     if (chroma_format==CHROMA420)
  741.     {
  742.       pu -= Chroma_Width;
  743.       pv -= Chroma_Width;
  744.     }
  745.     else
  746.     {
  747.       pu += Chroma_Width;
  748.       pv += Chroma_Width;
  749.     }
  750.     /* line j + 2. j + 3 */
  751.     for (i=0; i<Coded_Picture_Width; i+=4)
  752.     {
  753.       y = *py++;
  754.       Y2 = *Y2_ptr++;
  755.       u = *pu++ >> 1;
  756.       v = *pv++ >> 1;
  757.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+3]|Cb_Table[u+3]|Cr_Table[v+3]];
  758.       *dst2++ = Pixel[Y_Table[Y2+15]|Cb_Table[u+15]|Cr_Table[v+15]];
  759.       y = *py++;
  760.       Y2 = *Y2_ptr++;
  761.       if (chroma_format==CHROMA444)
  762.       {
  763.         u = *pu++ >> 1;
  764.         v = *pv++ >> 1;
  765.       }
  766.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+11]|Cb_Table[u+11]|Cr_Table[v+11]];
  767.       *dst2++ = Pixel[Y_Table[Y2+7]|Cb_Table[u+7]|Cr_Table[v+7]];
  768.       y = *py++;
  769.       Y2 = *Y2_ptr++;
  770.       u = *pu++ >> 1;
  771.       v = *pv++ >> 1;
  772.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+1]|Cb_Table[u+1]|Cr_Table[v+1]];
  773.       *dst2++ = Pixel[Y_Table[Y2+13]|Cb_Table[u+13]|Cr_Table[v+13]];
  774.       y = *py++;
  775.       Y2 = *Y2_ptr++;
  776.       if (chroma_format==CHROMA444)
  777.       {
  778.         u = *pu++ >> 1;
  779.         v = *pv++ >> 1;
  780.       }
  781.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+9]|Cb_Table[u+9]|Cr_Table[v+9]];
  782.       *dst2++ = Pixel[Y_Table[Y2+5]|Cb_Table[u+5]|Cr_Table[v+5]];
  783.     }
  784.     py += Coded_Picture_Width;
  785.     Y2_ptr += Coded_Picture_Width;
  786.     dst += Coded_Picture_Width;
  787.     dst2 += Coded_Picture_Width;
  788.     pu += Chroma_Width;
  789.     pv += Chroma_Width;
  790.   }
  791. }
  792. static void Dither_Top_Field420(src,dst)
  793. unsigned char *src[];
  794. unsigned char *dst;
  795. {
  796.   int i,j;
  797.   int Y1,Cb1,Cr1,Y2,Cb2,Cr2;
  798.   unsigned char *Y1_ptr,*Cb1_ptr,*Cr1_ptr,*Y2_ptr,*Cb2_ptr,*Cr2_ptr,*dst2;
  799.   Y1_ptr = src[0];
  800.   Cb1_ptr = src[1];
  801.   Cr1_ptr = src[2];
  802.   Y2_ptr = Y1_ptr + (Coded_Picture_Width<<1);
  803.   Cb2_ptr = Cb1_ptr + (Chroma_Width<<1);
  804.   Cr2_ptr = Cr1_ptr + (Chroma_Width<<1);
  805.   dst2 = dst + Coded_Picture_Width;
  806.   for (j=0; j<Coded_Picture_Height; j+=4)
  807.   {
  808.     /* line j + 0, j + 1 */
  809.     for (i=0; i<Coded_Picture_Width; i+=4)
  810.     {
  811.       Y1 = *Y1_ptr++;
  812.       Y2 = *Y2_ptr++;
  813.       Cb1 = *Cb1_ptr++ >> 1;
  814.       Cr1 = *Cr1_ptr++ >> 1;
  815.       Cb2 = *Cb2_ptr++ >> 1;
  816.       Cr2 = *Cr2_ptr++ >> 1;
  817.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)]|Cb_Table[Cb1]|Cr_Table[Cr1]];
  818.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+12]|Cb_Table[((3*Cb1+Cb2)>>2)+12]
  819.                                              |Cr_Table[((3*Cr1+Cr2)>>2)+12]];
  820.       Y1 = *Y1_ptr++;
  821.       Y2 = *Y2_ptr++;
  822.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+8]|Cb_Table[Cb1+8]|Cr_Table[Cr1+8]];
  823.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+4]|Cb_Table[((3*Cb1+Cb2)>>2)+4]
  824.                                             |Cr_Table[((3*Cr1+Cr2)>>2)+4]];
  825.       Y1 = *Y1_ptr++;
  826.       Y2 = *Y2_ptr++;
  827.       Cb1 = *Cb1_ptr++ >> 1;
  828.       Cr1 = *Cr1_ptr++ >> 1;
  829.       Cb2 = *Cb2_ptr++ >> 1;
  830.       Cr2 = *Cr2_ptr++ >> 1;
  831.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+2]|Cb_Table[Cb1+2]|Cr_Table[Cr1+2]];
  832.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+14]|Cb_Table[((3*Cb1+Cb2)>>2)+14]
  833.                                              |Cr_Table[((3*Cr1+Cr2)>>2)+14]];
  834.       Y1 = *Y1_ptr++;
  835.       Y2 = *Y2_ptr++;
  836.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+10]|Cb_Table[Cb1+10]|Cr_Table[Cr1+10]];
  837.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+6]|Cb_Table[((3*Cb1+Cb2)>>2)+6]
  838.                                             |Cr_Table[((3*Cr1+Cr2)>>2)+6]];
  839.     }
  840.     Y1_ptr += Coded_Picture_Width;
  841.     if (j!=(Coded_Picture_Height-4))
  842.       Y2_ptr += Coded_Picture_Width;
  843.     else
  844.       Y2_ptr -= Coded_Picture_Width;
  845.     Cb1_ptr -= Chroma_Width;
  846.     Cr1_ptr -= Chroma_Width;
  847.     Cb2_ptr -= Chroma_Width;
  848.     Cr2_ptr -= Chroma_Width;
  849.     dst  += Coded_Picture_Width;
  850.     dst2 += Coded_Picture_Width;
  851.     /* line j + 2, j + 3 */
  852.     for (i=0; i<Coded_Picture_Width; i+=4)
  853.     {
  854.       Y1 = *Y1_ptr++;
  855.       Y2 = *Y2_ptr++;
  856.       Cb1 = *Cb1_ptr++ >> 1;
  857.       Cr1 = *Cr1_ptr++ >> 1;
  858.       Cb2 = *Cb2_ptr++ >> 1;
  859.       Cr2 = *Cr2_ptr++ >> 1;
  860.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+3]|Cb_Table[((Cb1+Cb2)>>1)+3]
  861.                                             |Cr_Table[((Cr1+Cr2)>>1)+3]];
  862.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+15]|Cb_Table[((Cb1+3*Cb2)>>2)+15]
  863.                                              |Cr_Table[((Cr1+3*Cr2)>>2)+15]];
  864.       Y1 = *Y1_ptr++;
  865.       Y2 = *Y2_ptr++;
  866.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+11]|Cb_Table[((Cb1+Cb2)>>1)+11]
  867.                                              |Cr_Table[((Cr1+Cr2)>>1)+11]];
  868.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+7]|Cb_Table[((Cb1+3*Cb2)>>2)+7]
  869.                                             |Cr_Table[((Cr1+3*Cr2)>>2)+7]];
  870.       Y1 = *Y1_ptr++;
  871.       Y2 = *Y2_ptr++;
  872.       Cb1 = *Cb1_ptr++ >> 1;
  873.       Cr1 = *Cr1_ptr++ >> 1;
  874.       Cb2 = *Cb2_ptr++ >> 1;
  875.       Cr2 = *Cr2_ptr++ >> 1;
  876.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+1]|Cb_Table[((Cb1+Cb2)>>1)+1]
  877.                                             |Cr_Table[((Cr1+Cr2)>>1)+1]];
  878.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+13]|Cb_Table[((Cb1+3*Cb2)>>2)+13]
  879.                                              |Cr_Table[((Cr1+3*Cr2)>>2)+13]];
  880.       Y1 = *Y1_ptr++;
  881.       Y2 = *Y2_ptr++;
  882.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+9]|Cb_Table[((Cb1+Cb2)>>1)+9]
  883.                                             |Cr_Table[((Cr1+Cr2)>>1)+9]];
  884.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+5]|Cb_Table[((Cb1+3*Cb2)>>2)+5]
  885.                                             |Cr_Table[((Cr1+3*Cr2)>>2)+5]];
  886.     }
  887.     Y1_ptr += Coded_Picture_Width;
  888.     Y2_ptr += Coded_Picture_Width;
  889.     Cb1_ptr += Chroma_Width;
  890.     Cr1_ptr += Chroma_Width;
  891.     if (j!=(Coded_Picture_Height-8))
  892.     {
  893.       Cb2_ptr += Chroma_Width;
  894.       Cr2_ptr += Chroma_Width;
  895.     }
  896.     else
  897.     {
  898.       Cb2_ptr -= Chroma_Width;
  899.       Cr2_ptr -= Chroma_Width;
  900.     }
  901.     dst += Coded_Picture_Width;
  902.     dst2+= Coded_Picture_Width;
  903.   }
  904. }
  905. static void Dither_Bottom_Field420(src,dst)
  906. unsigned char *src[];
  907. unsigned char *dst;
  908. {
  909.   int i,j;
  910.   int Y1,Cb1,Cr1,Y2,Cb2,Cr2;
  911.   unsigned char *Y1_ptr,*Cb1_ptr,*Cr1_ptr,*Y2_ptr,*Cb2_ptr,*Cr2_ptr,*dst2;
  912.   Y2_ptr = Y1_ptr = src[0] + Coded_Picture_Width;
  913.   Cb2_ptr = Cb1_ptr = src[1] + Chroma_Width;
  914.   Cr2_ptr = Cr1_ptr = src[2] + Chroma_Width;
  915.   dst2 = dst;
  916.   for (j=0; j<Coded_Picture_Height; j+=4)
  917.   {
  918.     /* line j + 0, j + 1 */
  919.     for (i=0; i<Coded_Picture_Width; i+=4)
  920.     {
  921.       Y1 = *Y1_ptr++;
  922.       Y2 = *Y2_ptr++;
  923.       Cb1 = *Cb1_ptr++ >> 1;
  924.       Cr1 = *Cr1_ptr++ >> 1;
  925.       Cb2 = *Cb2_ptr++ >> 1;
  926.       Cr2 = *Cr2_ptr++ >> 1;
  927.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+15]|Cb_Table[((3*Cb1+Cb2)>>2)+15]
  928.                                              |Cr_Table[((3*Cr1+Cr2)>>2)+15]];
  929.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)]|Cb_Table[((Cb1+Cb2)>>1)]
  930.                                           |Cr_Table[((Cr1+Cr2)>>1)]];
  931.       Y1 = *Y1_ptr++;
  932.       Y2 = *Y2_ptr++;
  933.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+7]|Cb_Table[((3*Cb1+Cb2)>>2)+7]
  934.                                             |Cr_Table[((3*Cr1+Cr2)>>2)+7]];
  935.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+8]|Cb_Table[((Cb1+Cb2)>>1)+8]
  936.                                             |Cr_Table[((Cr1+Cr2)>>1)+8]];
  937.       Y1 = *Y1_ptr++;
  938.       Y2 = *Y2_ptr++;
  939.       Cb1 = *Cb1_ptr++ >> 1;
  940.       Cr1 = *Cr1_ptr++ >> 1;
  941.       Cb2 = *Cb2_ptr++ >> 1;
  942.       Cr2 = *Cr2_ptr++ >> 1;
  943.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+13]|Cb_Table[((3*Cb1+Cb2)>>2)+13]
  944.                                              |Cr_Table[((3*Cr1+Cr2)>>2)+13]];
  945.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+2]|Cb_Table[((Cb1+Cb2)>>1)+2]
  946.                                             |Cr_Table[((Cr1+Cr2)>>1)+2]];
  947.       Y1 = *Y1_ptr++;
  948.       Y2 = *Y2_ptr++;
  949.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+5]|Cb_Table[((3*Cb1+Cb2)>>2)+5]
  950.                                             |Cr_Table[((3*Cr1+Cr2)>>2)+5]];
  951.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+10]|Cb_Table[((Cb1+Cb2)>>1)+10]
  952.                                              |Cr_Table[((Cr1+Cr2)>>1)+10]];
  953.     }
  954.     if (j!=0)
  955.       Y1_ptr += Coded_Picture_Width;
  956.     else
  957.       Y1_ptr -= Coded_Picture_Width;
  958.     Y2_ptr += Coded_Picture_Width;
  959.     Cb1_ptr -= Chroma_Width;
  960.     Cr1_ptr -= Chroma_Width;
  961.     Cb2_ptr -= Chroma_Width;
  962.     Cr2_ptr -= Chroma_Width;
  963.     if (j!=0)
  964.       dst  += Coded_Picture_Width;
  965.     dst2 += Coded_Picture_Width;
  966.     /* line j + 2, j + 3 */
  967.     for (i=0; i<Coded_Picture_Width; i+=4)
  968.     {
  969.       Y1 = *Y1_ptr++;
  970.       Y2 = *Y2_ptr++;
  971.       Cb1 = *Cb1_ptr++ >> 1;
  972.       Cr1 = *Cr1_ptr++ >> 1;
  973.       Cb2 = *Cb2_ptr++ >> 1;
  974.       Cr2 = *Cr2_ptr++ >> 1;
  975.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+12]|Cb_Table[((Cb1+3*Cb2)>>2)+12]
  976.                                              |Cr_Table[((Cr1+3*Cr2)>>2)+12]];
  977.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+3]|Cb_Table[Cb2+3]
  978.                                             |Cr_Table[Cr2+3]];
  979.       Y1 = *Y1_ptr++;
  980.       Y2 = *Y2_ptr++;
  981.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+4]|Cb_Table[((Cb1+3*Cb2)>>2)+4]
  982.                                             |Cr_Table[((Cr1+3*Cr2)>>2)+4]];
  983.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+11]|Cb_Table[Cb2+11]
  984.                                              |Cr_Table[Cr2+11]];
  985.       Y1 = *Y1_ptr++;
  986.       Y2 = *Y2_ptr++;
  987.       Cb1 = *Cb1_ptr++ >> 1;
  988.       Cr1 = *Cr1_ptr++ >> 1;
  989.       Cb2 = *Cb2_ptr++ >> 1;
  990.       Cr2 = *Cr2_ptr++ >> 1;
  991.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+14]|Cb_Table[((Cb1+3*Cb2)>>2)+14]
  992.                                              |Cr_Table[((Cr1+3*Cr2)>>2)+14]];
  993.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+1]|Cb_Table[Cb2+1]
  994.                                             |Cr_Table[Cr2+1]];
  995.       Y1 = *Y1_ptr++;
  996.       Y2 = *Y2_ptr++;
  997.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+6]|Cb_Table[((Cb1+3*Cb2)>>2)+6]
  998.                                             |Cr_Table[((Cr1+3*Cr2)>>2)+6]];
  999.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+9]|Cb_Table[Cb2+9]
  1000.                                             |Cr_Table[Cr2+9]];
  1001.     }
  1002.     Y1_ptr += Coded_Picture_Width;
  1003.     Y2_ptr += Coded_Picture_Width;
  1004.     if (j!=0)
  1005.     {
  1006.       Cb1_ptr += Chroma_Width;
  1007.       Cr1_ptr += Chroma_Width;
  1008.     }
  1009.     else
  1010.     {
  1011.       Cb1_ptr -= Chroma_Width;
  1012.       Cr1_ptr -= Chroma_Width;
  1013.     }
  1014.     Cb2_ptr += Chroma_Width;
  1015.     Cr2_ptr += Chroma_Width;
  1016.     dst += Coded_Picture_Width;
  1017.     dst2+= Coded_Picture_Width;
  1018.   }
  1019.   Y2_ptr -= (Coded_Picture_Width<<1);
  1020.   Cb2_ptr -= (Chroma_Width<<1);
  1021.   Cr2_ptr -= (Chroma_Width<<1);
  1022.   /* dither last line */
  1023.   for (i=0; i<Coded_Picture_Width; i+=4)
  1024.   {
  1025.     Y1 = *Y1_ptr++;
  1026.     Y2 = *Y2_ptr++;
  1027.     Cb1 = *Cb1_ptr++ >> 1;
  1028.     Cr1 = *Cr1_ptr++ >> 1;
  1029.     Cb2 = *Cb2_ptr++ >> 1;
  1030.     Cr2 = *Cr2_ptr++ >> 1;
  1031.     *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+15]|Cb_Table[((3*Cb1+Cb2)>>2)+15]
  1032.                                            |Cr_Table[((3*Cr1+Cr2)>>2)+15]];
  1033.     Y1 = *Y1_ptr++;
  1034.     Y2 = *Y2_ptr++;
  1035.     *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+7]|Cb_Table[((3*Cb1+Cb2)>>2)+7]
  1036.                                           |Cr_Table[((3*Cr1+Cr2)>>2)+7]];
  1037.     Y1 = *Y1_ptr++;
  1038.     Y2 = *Y2_ptr++;
  1039.     Cb1 = *Cb1_ptr++ >> 1;
  1040.     Cr1 = *Cr1_ptr++ >> 1;
  1041.     Cb2 = *Cb2_ptr++ >> 1;
  1042.     Cr2 = *Cr2_ptr++ >> 1;
  1043.     *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+13]|Cb_Table[((3*Cb1+Cb2)>>2)+13]
  1044.                                            |Cr_Table[((3*Cr1+Cr2)>>2)+13]];
  1045.     Y1 = *Y1_ptr++;
  1046.     Y2 = *Y2_ptr++;
  1047.     *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+5]|Cb_Table[((3*Cb1+Cb2)>>2)+5]
  1048.                                           |Cr_Table[((3*Cr1+Cr2)>>2)+5]];
  1049.     }
  1050. }
  1051. #endif