开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
display.cc
资源名称：dvd-munitions.tar.gz　[点击查看]
上传用户：aoeyumen
上传日期：2007-01-06
资源大小：3329k
文件大小：38k
源码类别：

DVD

开发平台：

Unix_Linux

display.cc：源码内容
  1. /*
  2.    File: display.cc
  4.    By: Alex de Jong (original by MSSG)
  5.    Created: March 1996
  6.    
  7.    Description:
  8.    Multi-Threaded display class. Displays class is able to 
  9.    synchronize frames with a synchronoization object, which
  10.    in turn is updates by a decoder timer.
  11. */
  13. #ifdef __GNUG__
  14. #pragma implementation
  15. #endif
  17. #include "athread.hh"
  19. #include <stdio.h>
  20. #include <fstream.h>
  21. #include <sys/time.h>
  23. #include "error.hh"
  24. #include "debug.hh"
  25. #include "util.hh"
  27. #include "videoconst.hh"
  28. #include "sync.hh"
  29. #include "display.hh"
  31. #include "ditherer_lk16.hh"
  32. #include "ditherer_lkbw.hh"
  33. #include "ditherer_mmx16.hh"
  35. extern int quiet;
  36. //extern int coded_picture_width; use horizontal_size attribute
  37. //extern int coded_picture_height;  use horizontal_size attribute
  38. extern int prog_seq;
  39. extern int chroma_format;
  40. extern int chrom_width;
  41. extern int pict_struct, topfirst;
  42. extern int convmat[8][4];
  43. extern int matrix_coefficients;
  44. extern int playedlastframe;
  46. // #define USE_DGA 1               /* enable this to use DGA extention */
  49. #ifdef SH_MEM
  50. // Dummies to get rid of warnings
  51. extern "C" {
  52. int XShmQueryExtension(Display*);
  53. int XShmGetEventBase(Display*);
  54. }
  55. #ifdef USE_DGA
  56. #include <X11/extensions/xf86dga.h>
  57. #include <X11/extensions/xf86vmode.h>
  58. #endif
  59. #endif
  62. #ifdef SOLARIS_SDK_XIL
  64. Xil_boolean error_handler(XilError error){
  65.   xil_call_next_error_handler(error);
  66.   error("XIL received an error: exiting!");
  67.   exit(1);
  68.   return True;
  69. }
  70. #endif // SOLARIS_SDK_XIL
  73. DisplayX11::DisplayX11(const char* title, Synchronization* s){
  74.   TRACER("DisplayX11::DisplayX11(const char* title, Synchronization* s)");
  75.   int crv, cbu, cgu, cgv;
  76.   int y, u, v, r, g, b;
  77.   int i, j;
  78.   Colormap cmap;
  79.   XColor xcolor;
  80.   unsigned int fg, bg;
  81.   XSizeHints hint;
  82.   unsigned long tmp_pixel;
  83.   XWindowAttributes xwa;
  84.   int screen;
  85.   
  86.   // init to avoid invalid destroy in destructor
  87.   ximage=0;
  88.   ximage2=0;
  89.   // Synchronization with decoder clock
  90.   sync=s;
  92.   // Init display lock/condition to prevent threads to pass eachother
  93.   source=0;
  95. #ifdef SOLARIS_SDK_XIL
  96.   resized=0;  // window has not been resized
  97.   horizontal_size=100;
  98.   vertical_size=100;
  99.   horizontal_factor=1.0;
  100.   vertical_factor=1.0;
  101. #else
  102. #ifdef SH_MEM
  103.   CompletionType = -1;
  104. #endif
  105. #endif
  107.   // create clipping table
  108.   clp=new unsigned char[1024];  // clip table
  109.   clp += 384;
  110.   for (i=-384; i<640; i++) 
  111.     clp[i] = (i<0) ? 0 : ((i>255) ? 255 : i);
  113.   if (!(display=XOpenDisplay(0))){
  114.     error("Can not open displayn");
  115.     athr_exit(0);
  116.   }
  118. #ifdef TRACE
  119.   XSynchronize(display, 1);
  120. #endif
  121.     
  122.   screen = DefaultScreen(display);
  124.   // find best display
  125.   if (XMatchVisualInfo(display, screen, 24, TrueColor, &vinfo)){
  126.   } else
  127.   if (XMatchVisualInfo(display, screen, 16, TrueColor, &vinfo)){
  128.   } else
  129.   if (XMatchVisualInfo(display, screen, 15, TrueColor, &vinfo)){
  130.   } else
  131.   if (XMatchVisualInfo(display, screen, 8, PseudoColor, &vinfo)){
  132.   }
  133.   else if (XMatchVisualInfo(display, screen, 8, GrayScale, &vinfo)){
  134.   }
  135.   else if (XMatchVisualInfo(display, screen, 8, StaticGray, &vinfo)){
  136.   }
  137.   else if (XMatchVisualInfo(display, screen, 1, StaticGray, &vinfo)) {
  138.   }
  139. #ifdef LINUX
  140.   else error("requires 16 bit displayn");
  141. #else
  142.   else error("requires 8 bit or 24 bit displayn");
  143. #endif
  145.   // Make the window
  146.   hint.x = 1;
  147.   hint.y = 1;
  148.   hint.width = 400 ;//horizontal_size;
  149.   hint.height= 300;//vertical_size;
  150.   hint.flags = PPosition | PSize;
  151.   bpp = vinfo.depth;
  152.   if (vinfo.red_mask == 0x7c00)
  153.     rgb_mode = 1; // RGB555    for more modes see yuv12-rgb.s
  154.   else
  155.     rgb_mode = 0; // RGB565
  156.   if (vinfo.c_class==TrueColor && bpp == 24 ){
  157. #ifdef SOLARIS_SDK_XIL
  158.     bands=3;
  159. #endif
  160.     cmap=XCreateColormap(display, DefaultRootWindow(display), vinfo.visual, AllocNone);
  161.     
  162.     XSetWindowAttributes xswa;
  163.     xswa.colormap = cmap;
  164.     xswa.event_mask = StructureNotifyMask;
  165.     xswa.border_pixel = BlackPixel(display, screen);
  166.     
  167.     window=XCreateWindow(display, DefaultRootWindow(display),
  168.                            hint.x, hint.y, hint.width, hint.height,
  169.                            0,
  170.                            vinfo.depth, InputOutput, vinfo.visual,
  171.                            CWBorderPixel | CWColormap | CWEventMask, &xswa);
  172.   }
  173.   else {
  174. #ifdef SOLARIS_SDK_XIL
  175.      bands=1;
  176. #endif
  177.     // Get some colors
  178.     bg = WhitePixel(display, screen);
  179.     fg = BlackPixel(display, screen);
  181.     window=XCreateSimpleWindow(display, DefaultRootWindow (display),
  182.                                hint.x, hint.y, hint.width, hint.height, 4, fg, bg);
  183.   }
  185.   // Tell other applications about this window
  186.   XSetStandardProperties(display, window, title, title, None, NULL, 0, &hint);
  188.   XSelectInput(display, window, StructureNotifyMask);
  190.   // Map window
  191.   XMapWindow(display, window);
  193.   // Wait for map.
  194.   do {
  195.     XNextEvent(display, &event);
  196.   }
  197.   while (event.type != MapNotify || event.xmap.event != window);
  199.   XSelectInput(display, window, NoEventMask);
  201.   if (vinfo.c_class==PseudoColor){     // Do dithering before display
  202.     int privte=0;
  203.     
  204.     // allocate colors
  205.     gc = DefaultGC(display, screen);
  206.     cmap = DefaultColormap(display, screen);
  208.     // matrix coefficients
  209.     crv = convmat[matrix_coefficients][0];
  210.     cbu = convmat[matrix_coefficients][1];
  211.     cgu = convmat[matrix_coefficients][2];
  212.     cgv = convmat[matrix_coefficients][3];
  213.     
  214.     /* color allocation:
  215.      * i is the (internal) 8 bit color number, it consists of separate
  216.      * bit fields for Y, U and V: i = (yyyyuuvv), we don't use yyyy=0000
  217.      * yyyy=0001 and yyyy=1111, this leaves 48 colors for other applications
  218.      *
  219.      * the allocated colors correspond to the following Y, U and V values:
  220.      * Y:   40, 56, 72, 88, 104, 120, 136, 152, 168, 184, 200, 216, 232
  221.      * U,V: -48, -16, 16, 48
  222.      *
  223.      * U and V values span only about half the color space; this gives
  224.      * usually much better quality, although highly saturated colors can
  225.      * not be displayed properly
  226.      *
  227.      * translation to R,G,B is implicitly done by the color look-up table
  228.      */
  229.     // THIS IS REALLY SLOW on a 24 Bit display. Please drop me a line if
  230.     // you know how to do this faster (alex.dejong@nist.gov)
  232.     // DON'T ALLOCATE 240 COLORS!! Just 215 will do and stops Solaris
  233.     // from colors blinking when moving the cursor
  234. #if (defined(SOLARIS))
  235.     int number_of_colors=215;
  236. #endif
  237. #if (defined(IRIX)|| defined(LINUX))
  238.     int number_of_colors=240;
  239. #endif
  241.     for (i=32; i<number_of_colors; i++){
  242.       /* color space conversion */
  243.       y = 16*((i>>4)&15) + 8;
  244.       u = 32*((i>>2)&3)  - 48;
  245.       v = 32*(i&3)       - 48;
  246.       
  247.       y = 76309 * (y - 16); /* (255/219)*65536 */
  248.       
  249.       r = clp[(y + crv*v + 32768)>>16];
  250.       g = clp[(y - cgu*u -cgv*v + 32768)>>16];
  251.       b = clp[(y + cbu*u + 32786)>>16];
  252.       
  253.       /* X11 colors are 16 bit */
  254.       xcolor.red   = r << 8;
  255.       xcolor.green = g << 8;
  256.       xcolor.blue  = b << 8;
  257.       
  258.       if (XAllocColor(display, cmap, &xcolor) != 0) pixel[i] = xcolor.pixel;
  259.       else {
  260.         /* allocation failed, have to use a private colormap */
  261.         
  262.         if (privte) error("Couldn't allocate private colormap");
  263.         
  264.         privte = 1;
  265.         
  266.         if (!quiet)
  267.           fprintf(stderr, "Using private colormap (%d colors were available)n",
  268.                   i-32);
  269.         
  270.         /* Free colors. */
  271.         while (--i >= 32){
  272.           tmp_pixel = pixel[i]; /* because XFreeColors expects unsigned long */
  273.           XFreeColors(display, cmap, &tmp_pixel, 1, 0);
  274.         }
  275.          /* i is now 31, this restarts the outer loop */
  276.         
  277.         /* create private colormap */
  278.         
  279.         XGetWindowAttributes(display, window, &xwa);
  280.         cmap = XCreateColormap(display, window, xwa.visual, AllocNone);
  281.         XSetWindowColormap(display, window, cmap);
  282.       }
  283.     }
  284.   }
  285.   else
  286.     gc = DefaultGC(display, screen);
  288. /*
  289.    Init dither
  290.    4x4 ordered dither
  291.    threshold pattern:
  292.     0  8  2 10
  293.    12  4 14  6
  294.     3 11  1  9
  295.    15  7 13  5
  296. */
  298.   unsigned char ctab[256+32];
  299.   
  300.   for (i=0; i<256+16; i++){
  301.     v = (i-8)>>4;
  302.     if (v<2) v=2;
  303.     else if (v>14) v=14;
  304.     for (j=0; j<16; j++) 
  305.       ytab[16*i+j] = pixel[(v<<4)+j];
  306.   }
  308.   for (i=0; i<256+32; i++){
  309.     v = (i+48-128)>>5;
  310.     if (v<0) v=0;
  311.     else if (v>3) v=3;
  312.     ctab[i]=v;
  313.   }
  315.   for (i=0; i<255+15; i++)
  316.     for (j=0; j<255+15; j++)
  317.       uvtab[256*i+j]=(ctab[i+16]<<6)|(ctab[j+16]<<4)|(ctab[i]<<2)|ctab[j];
  318. }
  321. DisplayX11::~DisplayX11(){ 
  322.   TRACER("DisplayX11::~DisplayX11()");
  323.   display_lock.lock();
  324.   if (!terminated) athr_join(thread_id);
  325.   exit_display();
  326.   delete clp; // delete clipping table
  327.   display_lock.unlock();
  328. }
  331. void* DisplayX11::dither_thread(DisplayX11* d){
  332.   d->display_lock.lock();
  333.   d->terminated=0;
  334.   d->dither_image(d->source);
  335.   d->display_image(d->ximage, d->dithered_image); 
  336.   d->source=0;
  337.   d->display_cond.signal();
  338.   d->terminated=1;
  339.   d->display_lock.unlock(); 
  340. #if !defined(IRIX) && !defined(SOLARIS_SDK_XIL) && !defined(LINUX)
  341.   athr_exit(0);
  342. #endif
  343.   return 0;
  344. }
  347. void* DisplayX11::display_thread(DisplayX11* d){
  348. #ifndef LINUX
  349.   d->display_lock.lock();
  350.   d->terminated=0;
  351.   d->display_image(d->ximage2, d->dithered_image2); 
  352.   d->terminated=1;
  353.   d->display_lock.unlock();
  354. #if !defined(IRIX) && !defined(SOLARIS_SDK_XIL) && !defined(LINUX)
  355.   athr_exit(0);
  356. #endif
  357. #endif
  358.   return 0;
  359. }
  362. int DisplayX11::init(int h_size, int v_size,int sx_div_h=1,int sx_div_l=1,
  363.                      int sy_div_h=1,int sy_div_l=1,
  364.                      int clip_y_l=0, int clip_y_h=0) {
  365.   
  366.   screenx_div_h=sx_div_h;
  367.   screenx_div_l=sx_div_l;
  368.   screeny_div_h=sy_div_h;
  369.   screeny_div_l=sy_div_l;
  371.   TRACER("void DisplayX11::init(int h_size, int v_size)");
  373.   display_lock.lock();  // lock the display from others access for now
  375.   // resize window
  377.   if (clip_y_l != 0 && clip_y_h != 0) {
  378.      clipping_y_l=clip_y_l;
  379.      clipping_y_h=clip_y_h;
  380.   } else {
  381.      clipping_y_l=0;
  382.      clipping_y_h=v_size;
  383.   }
  384.   
  385.   horizontal_size=h_size*screenx_div_h/screenx_div_l;
  386.   vertical_size=/*v_size*/(clipping_y_h-clipping_y_l)*screeny_div_h/screeny_div_l;
  387.   original_horizontal_size=h_size;
  388.   original_vertical_size=(clipping_y_h-clipping_y_l);
  390.   XResizeWindow(display, window, horizontal_size, vertical_size);
  392. #ifdef SOLARIS_SDK_XIL
  393.   if ((State = xil_open()) == NULL)
  394.     exit(1);   // XIL sends an error message to stderr if xil_open fails 
  396.   // Install error handler
  397.   if (xil_install_error_handler(State, error_handler) == XIL_FAILURE)
  398.     error("unable to install error handler for XIL");
  400.   if (!(displayimage=xil_create_from_window(State, display, window)))
  401.     exit(1); // XIL sends error message to stderr if xil_create_from_window fails
  403.   ximage=xil_create(State, horizontal_size, vertical_size, bands, XIL_BYTE);
  404.   ximage2=xil_create(State, horizontal_size, vertical_size, bands, XIL_BYTE);
  405.   resized_image=xil_create(State, horizontal_size, vertical_size, bands, XIL_BYTE);
  407. /*
  408.   // Only when using XIL colorspace conversion; this seems rather slow
  409.   if (bands==3){
  410.     XilColorspace cspace=xil_colorspace_get_by_name(State, "ycc601");
  411.     xil_set_colorspace(ximage, cspace);
  412.     cspace=xil_colorspace_get_by_name(State, "ycc601");
  413.     xil_set_colorspace(resized_image, cspace);
  414.     cspace=xil_colorspace_get_by_name(State, "rgb709");
  415.     xil_set_colorspace(displayimage, cspace);
  416.   }
  417. */
  419.   XSelectInput(display, window, StructureNotifyMask);
  420. #else
  422. #ifdef SH_MEM
  423.   char dummy;
  424.   shmem_flag = 0;
  425. #ifdef USE_DGA             /* enable this if you want to have DGA support */
  426.   int EventBase, ErrorBase, flags,vp_width,vp_height,bank,ram;
  427.   if (XF86DGAQueryExtension (display, &EventBase, &ErrorBase)) {
  428.       XF86DGAQueryDirectVideo (display, XDefaultScreen (display), &flags);
  429.       if ((flags & XF86DGADirectPresent) == 0) {
  430.           if (!quiet) message ("dga: no direct present");
  431.       }
  432.       else {
  433.           shmem_flag = 2;
  434.           if (!quiet) message ("using DGA ");
  435.       }
  437.       XF86DGAGetVideo (display, XDefaultScreen (display), (char **) &dithered_image,
  438.                         &xwidth, &bank, &ram);
  439.       dithered_image2 = dithered_image;
  440.       XF86DGAGetViewPortSize (display, XDefaultScreen (display),
  441.                         &vp_width, &vp_height);
  442.       if (vp_height < v_size || vp_width < h_size) {
  443.         if (!quiet) message("View Port too small for DGA");
  444.         shmem_flag = 0;
  445.       }
  446.       else {
  447.         XF86DGASetViewPort (display, XDefaultScreen (display), 0, 0);
  448.         XF86DGADirectVideo (display, XDefaultScreen (display),XF86DGADirectGraphics );
  449.       }
  450.   }
  451. #endif
  452.   if (!shmem_flag) 
  453.     if (XShmQueryExtension(display)) shmem_flag = 1;
  454.     else {
  455.       shmem_flag = 0;
  456.       if (!quiet){
  457.         message("Shared memory not supported");
  458.         message("Reverting to normal Xlib");
  459.       }
  460.     }
  462.   if (shmem_flag==1) CompletionType = XShmGetEventBase(display) + ShmCompletion;
  464.   InstallXErrorHandler();
  466.   if (shmem_flag==1){
  467.     ximage = XShmCreateImage(display, None, bpp, ZPixmap, NULL,
  468.                              &shminfo1,
  469.                              horizontal_size, vertical_size);
  471.     if (!prog_seq)
  472.       ximage2 = XShmCreateImage(display, None, bpp, ZPixmap, NULL,
  473.                                 &shminfo2,
  474.                                 horizontal_size, vertical_size);
  476.     /* If no go, then revert to normal Xlib calls. */
  478.     if (ximage==NULL || (!prog_seq && ximage2==NULL)){
  479.       if (ximage!=NULL) XDestroyImage(ximage);
  480.       if (!prog_seq && ximage2!=NULL) XDestroyImage(ximage2);
  481.       if (!quiet)
  482.         fprintf(stderr, "Shared memory error, disabling (Ximage error)n");
  483.       goto shmemerror;
  484.     }
  486.     /* Success here, continue. */
  488.     shminfo1.shmid = shmget(IPC_PRIVATE, 
  489.                             ximage->bytes_per_line * ximage->height,
  490.                             IPC_CREAT | 0777);
  491.     if (!prog_seq)
  492.       shminfo2.shmid = shmget(IPC_PRIVATE, 
  493.                               ximage2->bytes_per_line * ximage2->height,
  494.                               IPC_CREAT | 0777);
  496.     if (shminfo1.shmid<0 || (!prog_seq && shminfo2.shmid<0)){
  497.       XDestroyImage(ximage);
  498.       if (!prog_seq) XDestroyImage(ximage2);
  499.       if (!quiet)
  500.         fprintf(stderr, "Shared memory error, disabling (seg id error)n");
  501.       goto shmemerror;
  502.     }
  504.     shminfo1.shmaddr = (char *) shmat(shminfo1.shmid, 0, 0);
  505.     shminfo2.shmaddr = (char *) shmat(shminfo2.shmid, 0, 0);
  507.     if (shminfo1.shmaddr==((char *) -1) ||
  508.         (!prog_seq && shminfo2.shmaddr==((char *) -1))){
  509.       XDestroyImage(ximage);
  510.       if (shminfo1.shmaddr!=((char *) -1)) shmdt(shminfo1.shmaddr);
  511.       if (!prog_seq){
  512.         XDestroyImage(ximage2);
  513.         if (shminfo2.shmaddr!=((char *) -1))
  514.           shmdt(shminfo2.shmaddr);
  515.       }
  516.       if (!quiet)
  517.       {
  518.         fprintf(stderr, "Shared memory error, disabling (address error)n");
  519.       }
  520.       goto shmemerror;
  521.     }
  523.     ximage->data = shminfo1.shmaddr;
  524.     dithered_image = (unsigned char *)ximage->data;
  525.     shminfo1.readOnly = False;
  526.     XShmAttach(display, &shminfo1);
  527.     if (!prog_seq){
  528.       ximage2->data = shminfo2.shmaddr;
  529.       dithered_image2 = (unsigned char *)ximage2->data;
  530.       shminfo2.readOnly = False;
  531.       XShmAttach(display, &shminfo2);
  532.     }
  534.     XSync(display, False);
  536.     if (gXErrorFlag){
  537.       /* Ultimate failure here. */
  538.       XDestroyImage(ximage);
  539.       shmdt(shminfo1.shmaddr);
  540.       if (!prog_seq){
  541.         XDestroyImage(ximage2);
  542.         shmdt(shminfo2.shmaddr);
  543.       }
  544.       if (!quiet)
  545.         fprintf(stderr, "Shared memory error, disabling.n");
  546.       gXErrorFlag = 0;
  547.       goto shmemerror;
  548.     }
  549.     else {
  550.       shmctl(shminfo1.shmid, IPC_RMID, 0);
  551.       if (!prog_seq)
  552.         shmctl(shminfo2.shmid, IPC_RMID, 0);
  553.     }
  555.     if (!quiet){
  556.       fprintf(stderr, "Sharing memory.n");
  557.     }
  558.   }
  559.   else if (shmem_flag != 2) {
  561. shmemerror:
  562.     shmem_flag = 0;
  563. #endif
  565.     ximage = XCreateImage(display,None,bpp,ZPixmap,0,&dummy,
  566.                           horizontal_size,vertical_size,8,0);
  568.     if (!(dithered_image = new unsigned char[horizontal_size*
  569.                                                    vertical_size]))
  570.       error("new failed");
  572.     if (!prog_seq){
  573.       ximage2 = XCreateImage(display,None,bpp,ZPixmap,0,&dummy,
  574.                              horizontal_size,vertical_size,8,0);
  576.       if (!(dithered_image2 = new unsigned char[horizontal_size*
  577.                                                       vertical_size]))
  578.         error("new failed");
  579.     }
  581. #ifdef SH_MEM
  582.   }
  584.   DeInstallXErrorHandler();
  585. #endif
  587. #endif // SOLARIS_SDK_XIL
  589.   display_lock.unlock();
  590.   return 1;
  591. }
  595. void DisplayX11::exit_display(){
  596. #ifdef SOLARIS_SDK_XIL
  597.   xil_destroy(displayimage);
  598.   xil_destroy(resized_image);
  599.   if (ximage) xil_destroy(ximage);
  600.   if (ximage2) xil_destroy(ximage2);
  601.   xil_close(State);
  602.   XCloseDisplay(display);
  603. #else
  604. #ifdef SH_MEM
  605. #ifdef USE_DGA
  606.   if (shmem_flag==2)
  607.     XF86DGADirectVideo (display, XDefaultScreen (display), 0);
  608. #endif
  609.   if (shmem_flag==1){
  610.     XShmDetach(display, &shminfo1);
  611.     shmdt(shminfo1.shmaddr);
  612.     if (!prog_seq){
  613.       XShmDetach(display, &shminfo2);
  614.       XDestroyImage(ximage2);
  615.       shmdt(shminfo2.shmaddr);
  616.     }
  617.   }
  618. #else
  619.   XDestroyImage(ximage);
  620. #endif
  621. #endif
  622. }
  625. #ifdef SOLARIS_SDK_XIL
  626. void DisplayX11::display_image(XilImage ximg, unsigned char *dithered_img){
  627. #else
  628. void DisplayX11::display_image(XImage *ximg, unsigned char *dithered_img){
  629. #endif
  630.   DEBUGGER("void DisplayX11::display_image(ximage, unsigned char *dithered_image)");
  631.   playedlastframe=1;  // indicate that frame is displayed
  632.   if (sync)  {
  633.     sync->wait(1);    // wait for presentation time stamp (PTS), id=1
  634.   }
  635. #ifdef SH_MEM                            // display dithered image
  636.   if (shmem_flag==2)
  637.     return;
  638. #endif
  641. #ifdef SOLARIS_SDK_XIL
  642.   xil_import(ximg, TRUE);
  643.   if (resized){
  644.     // , general and linear are Ok (These is no good for this: bilinear, bicubic)
  645.     xil_scale(ximage, resized_image, "general", horizontal_factor, vertical_factor);
  646.     // if (bands==1)   // Use XIL for color conversion
  647.     xil_copy(resized_image, displayimage);
  648.     // else 
  649.     //   xil_color_convert(resized_image, displayimage);
  650.   }
  651.   else {
  652.     // if (bands==1)   // Use XIL for color conversion
  653.     xil_copy(ximg, displayimage);
  654.     // else 
  655.     //   xil_color_convert(ximg, displayimage);
  656.   }
  658.   // check for geometry changes
  659.   if (XCheckWindowEvent(display, window, StructureNotifyMask, &event))  resize();
  660. #else
  661. #ifdef SH_MEM                            // display dithered image
  662.   if (shmem_flag==1){
  663.     XShmPutImage(display, window, gc, ximg, 0,0,0,0,ximg->width,ximg->height,True);
  664.     XFlush(display);
  665.   }
  666.   else 
  667. #endif // SH_MEM
  668.   {
  669.     ximg->data=(char*) dithered_img;
  670.     XPutImage(display, window, gc, ximg, 0, 0, 0, 0, ximg->width, ximg->height);
  671.   }
  672. #endif // SOLARIS_SDK_XIL
  673. }
  676. #ifdef SOLARIS_SDK_XIL
  678. int DisplayX11::dither_image_rgb24(unsigned char* src[], unsigned char* dithered_img){
  679.   register int h=0, w=-1;
  680.   register unsigned char *Y, *Cb, *Cr;  
  681.   Y=src[0];
  682.   Cb=src[1];
  683.   Cr=src[2];
  684.   register Xil_unsigned8* data;
  685.   data=dithered_img;
  686.   
  687.   //  map data in XIL image  
  688.   for (h=0; h<vertical_size; h++){
  689.     for (w=0; w<horizontal_size; w++){
  690.       *data++ = clp[(int)(*Y + 1.371*(*Cr-128))];  
  691.       *data++ = clp[(int)(*Y - 0.698*(*Cr-128) - 0.336*(*Cr-128))]; 
  692.       *data++ = clp[(int)(*Y++ + 1.732*(*Cb-128))];
  693.       if ((w % 4)==0){
  694.         Cr++;
  695.         Cb++;
  696.       }
  697.     }
  698.   }
  699.   return 0;
  700. };
  702. #endif
  704. #if defined(LINUX)
  705. //extern "C" void yuv_2_rgb(void *,void *,void *,int,int,int,int,int,void *,int,int,int,int);
  707. /* Need to have access to the memory after
  708. */
  710. int DisplayX11::dither_image_rgb16(unsigned char* src[], unsigned char* dithered_img){
  711.   int height,width,display_width;
  713. #ifdef HAVE_MMX
  714.   static Ditherer * dither_module=Ditherer::allocModule("mmx16b");
  715. #else
  716.   static Ditherer * dither_module=Ditherer::allocModule("lk16");
  717. #endif
  718.   
  719.   height=vertical_size;
  720.   width=horizontal_size;
  721.   
  722.   if (shmem_flag == 2)
  723.     display_width = xwidth;
  724.   else
  725.     display_width=horizontal_size;
  726.   
  727.   dither_module->setBpp(bpp);
  728.   dither_module->dither(src[0],src[1],src[2],dithered_img,
  729.                         original_horizontal_size, original_vertical_size,
  730.                         horizontal_size,vertical_size,
  731.                         display_width);
  732.   
  733.   return 0;
  734. }
  735.  
  736. #if 0
  737. int DisplayX11::dither_image_rgb24(unsigned char* src[], unsigned char* dithered_img){
  738.   int height,width,display_width;
  739.   height=vertical_size;
  740.   if (shmem_flag == 2)
  741.     display_width = xwidth;
  742.   else
  743.     display_width=horizontal_size;
  744.   width=horizontal_size;
  745.   if (rgb_mode == 0)
  746.     Color16DitherImageMod(src[0], src[2], src[1], dithered_img, height, width,display_width -width);
  747.   else
  748.     yuv_2_rgb(src[0],src[1],src[2],width,height,width,width/2,0,dithered_img,0,0,display_width*2,rgb_mode);
  749.   return 0;
  750. }
  751. #endif
  753. #endif
  756. void DisplayX11::dither_image(unsigned char *src[]){
  757. #ifdef SOLARIS_SDK_XIL
  758.   dithered_image=getImage1Data();
  759. #endif
  760.   if (prog_seq){
  761.     if (chroma_format!=CHROMA444){
  762. #if defined(LINUX)
  763.       if (vinfo.c_class==TrueColor && vinfo.depth==24){
  764.          //dither_image_rgb24(src, dithered_image);
  765.          cerr<<" 24 bpp display not supported (only 16bpp)"<<endl;
  766.          exit(1);
  767.          return;
  768.       }
  769.       dither_image_rgb16(src, dithered_image);
  770.       return;
  771. #endif
  772.       ditherframe(src);
  773.     }
  774.     else
  775.       ditherframe444(src);
  776.   }
  777.   else {
  778. #ifdef SOLARIS_SDK_XIL
  779.     dithered_image2=getImage2Data();
  780. #endif
  781. #if defined(LINUX) 
  782.     dither_image_rgb16(src, dithered_image);
  783.         return;
  784. #endif
  785.     if ((pict_struct==FRAME_PICTURE && topfirst) || pict_struct==BOTTOM_FIELD){
  786.       /* top field first */
  787.       if (chroma_format!=CHROMA444){
  788.         dithertop(src,dithered_image);
  789.         ditherbot(src,dithered_image2);
  790.       }
  791.       else {
  792.         dithertop444(src,dithered_image);
  793.         ditherbot444(src,dithered_image2);
  794.       }
  795.     }
  796.     else {
  797.       /* bottom field first */
  798.       if (chroma_format!=CHROMA444){
  799.         ditherbot(src,dithered_image);
  800.         dithertop(src,dithered_image2);
  801.       }
  802.       else {
  803.         ditherbot444(src,dithered_image);
  804.         dithertop444(src,dithered_image2);
  805.       }
  806.     }
  807.   }
  808. }
  811. /* only for 4:2:0 and 4:2:2! */
  813. void DisplayX11::ditherframe(unsigned char *src[]){
  814.   int i;
  815.   register unsigned int uv;
  816.   register unsigned char *py,*pu,*pv,*dst;
  817.   py = src[0];
  818.   pu = src[1];
  819.   pv = src[2];
  820.   dst = dithered_image;
  822.   for (int j=0; j<vertical_size; j+=4){
  823.     /* line j + 0 */
  824.     for (i=0; i<horizontal_size; i+=8){
  825.       uv = uvtab[(*pu++<<8)|*pv++];
  826.       *dst++ = ytab[((*py++)<<4)|(uv&15)];
  827.       *dst++ = ytab[((*py++ +8)<<4)|(uv>>4)];
  828.       uv = uvtab[((*pu++<<8)|*pv++)+1028];
  829.       *dst++ = ytab[((*py++ +2)<<4)|(uv&15)];
  830.       *dst++ = ytab[((*py++ +10)<<4)|(uv>>4)];
  831.       uv = uvtab[(*pu++<<8)|*pv++];
  832.       *dst++ = ytab[((*py++)<<4)|(uv&15)];
  833.       *dst++ = ytab[((*py++ +8)<<4)|(uv>>4)];
  834.       uv = uvtab[((*pu++<<8)|*pv++)+1028];
  835.       *dst++ = ytab[((*py++ +2)<<4)|(uv&15)];
  836.       *dst++ = ytab[((*py++ +10)<<4)|(uv>>4)];
  837.     }
  839.     if (chroma_format==CHROMA420){
  840.       pu -= chrom_width;
  841.       pv -= chrom_width;
  842.     }
  844.     /* line j + 1 */
  845.     for (i=0; i<horizontal_size; i+=8){
  846.       uv = uvtab[((*pu++<<8)|*pv++)+2056];
  847.       *dst++ = ytab[((*py++ +12)<<4)|(uv>>4)];
  848.       *dst++ = ytab[((*py++ +4)<<4)|(uv&15)];
  849.       uv = uvtab[((*pu++<<8)|*pv++)+3084];
  850.       *dst++ = ytab[((*py++ +14)<<4)|(uv>>4)];
  851.       *dst++ = ytab[((*py++ +6)<<4)|(uv&15)];
  852.       uv = uvtab[((*pu++<<8)|*pv++)+2056];
  853.       *dst++ = ytab[((*py++ +12)<<4)|(uv>>4)];
  854.       *dst++ = ytab[((*py++ +4)<<4)|(uv&15)];
  855.       uv = uvtab[((*pu++<<8)|*pv++)+3084];
  856.       *dst++ = ytab[((*py++ +14)<<4)|(uv>>4)];
  857.       *dst++ = ytab[((*py++ +6)<<4)|(uv&15)];
  858.     }
  860.     /* line j + 2 */
  861.     for (i=0; i<horizontal_size; i+=8){
  862.       uv = uvtab[((*pu++<<8)|*pv++)+1542];
  863.       *dst++ = ytab[((*py++ +3)<<4)|(uv&15)];
  864.       *dst++ = ytab[((*py++ +11)<<4)|(uv>>4)];
  865.       uv = uvtab[((*pu++<<8)|*pv++)+514];
  866.       *dst++ = ytab[((*py++ +1)<<4)|(uv&15)];
  867.       *dst++ = ytab[((*py++ +9)<<4)|(uv>>4)];
  868.       uv = uvtab[((*pu++<<8)|*pv++)+1542];
  869.       *dst++ = ytab[((*py++ +3)<<4)|(uv&15)];
  870.       *dst++ = ytab[((*py++ +11)<<4)|(uv>>4)];
  871.       uv = uvtab[((*pu++<<8)|*pv++)+514];
  872.       *dst++ = ytab[((*py++ +1)<<4)|(uv&15)];
  873.       *dst++ = ytab[((*py++ +9)<<4)|(uv>>4)];
  874.     }
  876.     if (chroma_format==CHROMA420){
  877.       pu -= chrom_width;
  878.       pv -= chrom_width;
  879.     }
  881.     /* line j + 3 */
  882.     for (i=0; i<horizontal_size; i+=8){
  883.       uv = uvtab[((*pu++<<8)|*pv++)+3598];
  884.       *dst++ = ytab[((*py++ +15)<<4)|(uv>>4)];
  885.       *dst++ = ytab[((*py++ +7)<<4)|(uv&15)];
  886.       uv = uvtab[((*pu++<<8)|*pv++)+2570];
  887.       *dst++ = ytab[((*py++ +13)<<4)|(uv>>4)];
  888.       *dst++ = ytab[((*py++ +5)<<4)|(uv&15)];
  889.       uv = uvtab[((*pu++<<8)|*pv++)+3598];
  890.       *dst++ = ytab[((*py++ +15)<<4)|(uv>>4)];
  891.       *dst++ = ytab[((*py++ +7)<<4)|(uv&15)];
  892.       uv = uvtab[((*pu++<<8)|*pv++)+2570];
  893.       *dst++ = ytab[((*py++ +13)<<4)|(uv>>4)];
  894.       *dst++ = ytab[((*py++ +5)<<4)|(uv&15)];
  895.     }
  896.   }
  897. }
  900. void DisplayX11::dithertop(unsigned char *src[], unsigned char *dst){
  901.   int i;
  902.   unsigned int y,uv1,uv2;
  903.   unsigned char *py,*py2,*pu,*pv,*dst2;
  905.   py = src[0];
  906.   py2 = src[0] + (horizontal_size<<1);
  907.   pu = src[1];
  908.   pv = src[2];
  909.   dst2 = dst + horizontal_size;
  911.   for (int j=0; j<vertical_size; j+=4){
  912.     /* line j + 0, j + 1 */
  913.     for (i=0; i<horizontal_size; i+=4){
  914.       y = *py++;
  915.       uv2 = (*pu++<<8)|*pv++;
  916.       uv1 = uvtab[uv2];
  917.       uv2 = uvtab[uv2+2056];
  918.       *dst++  = ytab[((y)<<4)|(uv1&15)];
  919.       *dst2++ = ytab[((((y + *py2++)>>1)+12)<<4)|(uv2>>4)];
  921.       y = *py++;
  922.       *dst++  = ytab[((y+8)<<4)|(uv1>>4)];
  923.       *dst2++ = ytab[((((y + *py2++)>>1)+4)<<4)|(uv2&15)];
  925.       y = *py++;
  926.       uv2 = (*pu++<<8)|*pv++;
  927.       uv1 = uvtab[uv2+1028];
  928.       uv2 = uvtab[uv2+3072];
  929.       *dst++  = ytab[((y+2)<<4)|(uv1&15)];
  930.       *dst2++ = ytab[((((y + *py2++)>>1)+14)<<4)|(uv2>>4)];
  932.       y = *py++;
  933.       *dst++  = ytab[((y+10)<<4)|(uv1>>4)];
  934.       *dst2++ = ytab[((((y + *py2++)>>1)+6)<<4)|(uv2&15)];
  935.     }
  937.     py += horizontal_size;
  939.     if (j!=(vertical_size-4)) py2 += horizontal_size;
  940.     else                             py2 -= horizontal_size;
  942.     dst += horizontal_size;
  943.     dst2 += horizontal_size;
  945.     if (chroma_format==CHROMA420){
  946.       pu -= chrom_width;
  947.       pv -= chrom_width;
  948.     }
  949.     else {
  950.       pu += chrom_width;
  951.       pv += chrom_width;
  952.     }
  954.     /* line j + 2, j + 3 */
  955.     for (i=0; i<horizontal_size; i+=4){
  956.       y = *py++;
  957.       uv2 = (*pu++<<8)|*pv++;
  958.       uv1 = uvtab[uv2+1542];
  959.       uv2 = uvtab[uv2+3598];
  960.       *dst++  = ytab[((y+3)<<4)|(uv1&15)];
  961.       *dst2++ = ytab[((((y + *py2++)>>1)+15)<<4)|(uv2>>4)];
  963.       y = *py++;
  964.       *dst++  = ytab[((y+11)<<4)|(uv1>>4)];
  965.       *dst2++ = ytab[((((y + *py2++)>>1)+7)<<4)|(uv2&15)];
  967.       y = *py++;
  968.       uv2 = (*pu++<<8)|*pv++;
  969.       uv1 = uvtab[uv2+514];
  970.       uv2 = uvtab[uv2+2570];
  971.       *dst++  = ytab[((y+1)<<4)|(uv1&15)];
  972.       *dst2++ = ytab[((((y + *py2++)>>1)+13)<<4)|(uv2>>4)];
  974.       y = *py++;
  975.       *dst++  = ytab[((y+9)<<4)|(uv1>>4)];
  976.       *dst2++ = ytab[((((y + *py2++)>>1)+5)<<4)|(uv2&15)];
  977.     }
  979.     py += horizontal_size;
  980.     py2 += horizontal_size;
  981.     dst += horizontal_size;
  982.     dst2 += horizontal_size;
  983.     pu += chrom_width;
  984.     pv += chrom_width;
  985.   }
  986. }
  989. void DisplayX11::ditherbot(unsigned char *src[], unsigned char *dst){
  990.   int i;
  991.   unsigned int y2,uv1,uv2;
  992.   unsigned char *py,*py2,*pu,*pv,*dst2;
  994.   py = src[0] + horizontal_size;
  995.   py2 = py;
  996.   pu = src[1] + chrom_width;
  997.   pv = src[2] + chrom_width;
  998.   dst2 = dst + horizontal_size;
  1000.   for (int j=0; j<vertical_size; j+=4){
  1001.     /* line j + 0, j + 1 */
  1002.     for (i=0; i<horizontal_size; i+=4){
  1003.       y2 = *py2++;
  1004.       uv2 = (*pu++<<8)|*pv++;
  1005.       uv1 = uvtab[uv2];
  1006.       uv2 = uvtab[uv2+2056];
  1007.       *dst++  = ytab[((((*py++ + y2)>>1))<<4)|(uv1&15)];
  1008.       *dst2++ = ytab[((y2+12)<<4)|(uv2>>4)];
  1010.       y2 = *py2++;
  1011.       *dst++  = ytab[((((*py++ + y2)>>1)+8)<<4)|(uv1>>4)];
  1012.       *dst2++ = ytab[((y2+4)<<4)|(uv2&15)];
  1014.       y2 = *py2++;
  1015.       uv2 = (*pu++<<8)|*pv++;
  1016.       uv1 = uvtab[uv2+1028];
  1017.       uv2 = uvtab[uv2+3072];
  1018.       *dst++  = ytab[((((*py++ + y2)>>1)+2)<<4)|(uv1&15)];
  1019.       *dst2++ = ytab[((y2+14)<<4)|(uv2>>4)];
  1021.       y2 = *py2++;
  1022.       *dst++  = ytab[((((*py++ + y2)>>1)+10)<<4)|(uv1>>4)];
  1023.       *dst2++ = ytab[((y2+6)<<4)|(uv2&15)];
  1024.     }
  1026.     if (j==0) py -= horizontal_size;
  1027.     else      py += horizontal_size;
  1029.     py2 += horizontal_size;
  1030.     dst += horizontal_size;
  1031.     dst2 += horizontal_size;
  1033.     if (chroma_format==CHROMA420){
  1034.       pu -= chrom_width;
  1035.       pv -= chrom_width;
  1036.     }
  1037.     else {
  1038.       pu += chrom_width;
  1039.       pv += chrom_width;
  1040.     }
  1042.     /* line j + 2, j + 3 */
  1043.     for (i=0; i<horizontal_size; i+=4){
  1044.       y2 = *py2++;
  1045.       uv2 = (*pu++<<8)|*pv++;
  1046.       uv1 = uvtab[uv2+1542];
  1047.       uv2 = uvtab[uv2+3598];
  1048.       *dst++  = ytab[((((*py++ + y2)>>1)+3)<<4)|(uv1&15)];
  1049.       *dst2++ = ytab[((y2+15)<<4)|(uv2>>4)];
  1051.       y2 = *py2++;
  1052.       *dst++  = ytab[((((*py++ + y2)>>1)+11)<<4)|(uv1>>4)];
  1053.       *dst2++ = ytab[((y2+7)<<4)|(uv2&15)];
  1055.       y2 = *py2++;
  1056.       uv2 = (*pu++<<8)|*pv++;
  1057.       uv1 = uvtab[uv2+514];
  1058.       uv2 = uvtab[uv2+2570];
  1059.       *dst++  = ytab[((((*py++ + y2)>>1)+1)<<4)|(uv1&15)];
  1060.       *dst2++ = ytab[((y2+13)<<4)|(uv2>>4)];
  1062.       y2 = *py2++;
  1063.       *dst++  = ytab[((((*py++ + y2)>>1)+9)<<4)|(uv1>>4)];
  1064.       *dst2++ = ytab[((y2+5)<<4)|(uv2&15)];
  1065.     }
  1067.     py += horizontal_size;
  1068.     py2 += horizontal_size;
  1069.     dst += horizontal_size;
  1070.     dst2 += horizontal_size;
  1071.     pu += chrom_width;
  1072.     pv += chrom_width;
  1073.   }
  1074. }
  1076. /* only for 4:4:4 */
  1078. void DisplayX11::ditherframe444(unsigned char *src[]){
  1079.   int i;
  1080.   unsigned char *py=src[0], *pu=src[1], *pv=src[2], *dst=dithered_image;
  1082.   for (int j=0; j<vertical_size; j+=4){
  1083.     /* line j + 0 */
  1084.     for (i=0; i<horizontal_size; i+=8){
  1085.       *dst++ = ytab[((*py++)<<4)|(uvtab[(*pu++<<8)|*pv++]&15)];
  1086.       *dst++ = ytab[((*py++ +8)<<4)|(uvtab[(*pu++<<8)|*pv++]>>4)];
  1087.       *dst++ = ytab[((*py++ +2)<<4)|(uvtab[((*pu++<<8)|*pv++)+1028]&15)];
  1088.       *dst++ = ytab[((*py++ +10)<<4)|(uvtab[((*pu++<<8)|*pv++)+1028]>>4)];
  1089.       *dst++ = ytab[((*py++)<<4)|(uvtab[(*pu++<<8)|*pv++]&15)];
  1090.       *dst++ = ytab[((*py++ +8)<<4)|(uvtab[(*pu++<<8)|*pv++]>>4)];
  1091.       *dst++ = ytab[((*py++ +2)<<4)|(uvtab[((*pu++<<8)|*pv++)+1028]&15)];
  1092.       *dst++ = ytab[((*py++ +10)<<4)|(uvtab[((*pu++<<8)|*pv++)+1028]>>4)];
  1093.     }
  1095.     /* line j + 1 */
  1096.     for (i=0; i<horizontal_size; i+=8){
  1097.       *dst++ = ytab[((*py++ +12)<<4)|(uvtab[((*pu++<<8)|*pv++)+2056]>>4)];
  1098.       *dst++ = ytab[((*py++ +4)<<4)|(uvtab[((*pu++<<8)|*pv++)+2056]&15)];
  1099.       *dst++ = ytab[((*py++ +14)<<4)|(uvtab[((*pu++<<8)|*pv++)+3084]>>4)];
  1100.       *dst++ = ytab[((*py++ +6)<<4)|(uvtab[((*pu++<<8)|*pv++)+3084]&15)];
  1101.       *dst++ = ytab[((*py++ +12)<<4)|(uvtab[((*pu++<<8)|*pv++)+2056]>>4)];
  1102.       *dst++ = ytab[((*py++ +4)<<4)|(uvtab[((*pu++<<8)|*pv++)+2056]&15)];
  1103.       *dst++ = ytab[((*py++ +14)<<4)|(uvtab[((*pu++<<8)|*pv++)+3084]>>4)];
  1104.       *dst++ = ytab[((*py++ +6)<<4)|(uvtab[((*pu++<<8)|*pv++)+3084]&15)];
  1105.     }
  1107.     /* line j + 2 */
  1108.     for (i=0; i<horizontal_size; i+=8){
  1109.       *dst++ = ytab[((*py++ +3)<<4)|(uvtab[((*pu++<<8)|*pv++)+1542]&15)];
  1110.       *dst++ = ytab[((*py++ +11)<<4)|(uvtab[((*pu++<<8)|*pv++)+1542]>>4)];
  1111.       *dst++ = ytab[((*py++ +1)<<4)|(uvtab[((*pu++<<8)|*pv++)+514]&15)];
  1112.       *dst++ = ytab[((*py++ +9)<<4)|(uvtab[((*pu++<<8)|*pv++)+514]>>4)];
  1113.       *dst++ = ytab[((*py++ +3)<<4)|(uvtab[((*pu++<<8)|*pv++)+1542]&15)];
  1114.       *dst++ = ytab[((*py++ +11)<<4)|(uvtab[((*pu++<<8)|*pv++)+1542]>>4)];
  1115.       *dst++ = ytab[((*py++ +1)<<4)|(uvtab[((*pu++<<8)|*pv++)+514]&15)];
  1116.       *dst++ = ytab[((*py++ +9)<<4)|(uvtab[((*pu++<<8)|*pv++)+514]>>4)];
  1117.     }
  1119.     /* line j + 3 */
  1120.     for (i=0; i<horizontal_size; i+=8){
  1121.       *dst++ = ytab[((*py++ +15)<<4)|(uvtab[((*pu++<<8)|*pv++)+3598]>>4)];
  1122.       *dst++ = ytab[((*py++ +7)<<4)|(uvtab[((*pu++<<8)|*pv++)+3598]&15)];
  1123.       *dst++ = ytab[((*py++ +13)<<4)|(uvtab[((*pu++<<8)|*pv++)+2570]>>4)];
  1124.       *dst++ = ytab[((*py++ +5)<<4)|(uvtab[((*pu++<<8)|*pv++)+2570]&15)];
  1125.       *dst++ = ytab[((*py++ +15)<<4)|(uvtab[((*pu++<<8)|*pv++)+3598]>>4)];
  1126.       *dst++ = ytab[((*py++ +7)<<4)|(uvtab[((*pu++<<8)|*pv++)+3598]&15)];
  1127.       *dst++ = ytab[((*py++ +13)<<4)|(uvtab[((*pu++<<8)|*pv++)+2570]>>4)];
  1128.       *dst++ = ytab[((*py++ +5)<<4)|(uvtab[((*pu++<<8)|*pv++)+2570]&15)];
  1129.     }
  1130.   }
  1131. }
  1134. void DisplayX11::dithertop444(unsigned char *src[], unsigned char *dst){
  1135.   int i;
  1136.   unsigned int y,uv;
  1137.   unsigned char *py,*py2,*pu,*pv,*dst2;
  1139.   py = src[0];
  1140.   py2 = src[0] + (horizontal_size<<1);
  1141.   pu = src[1];
  1142.   pv = src[2];
  1143.   dst2 = dst + horizontal_size;
  1145.   for (int j=0; j<vertical_size; j+=4){
  1146.     /* line j + 0, j + 1 */
  1147.     for (i=0; i<horizontal_size; i+=4){
  1148.       y = *py++;
  1149.       uv = (*pu++<<8)|*pv++;
  1150.       *dst++  = ytab[((y)<<4)|(uvtab[uv]&15)];
  1151.       *dst2++ = ytab[((((y + *py2++)>>1)+12)<<4)|(uvtab[uv+2056]>>4)];
  1153.       y = *py++;
  1154.       uv = (*pu++<<8)|*pv++;
  1155.       *dst++  = ytab[((y+8)<<4)|(uvtab[uv]>>4)];
  1156.       *dst2++ = ytab[((((y + *py2++)>>1)+4)<<4)|(uvtab[uv+2056]&15)];
  1158.       y = *py++;
  1159.       uv = (*pu++<<8)|*pv++;
  1160.       *dst++  = ytab[((y+2)<<4)|(uvtab[uv+1028]&15)];
  1161.       *dst2++ = ytab[((((y + *py2++)>>1)+14)<<4)|(uvtab[uv+3072]>>4)];
  1163.       y = *py++;
  1164.       uv = (*pu++<<8)|*pv++;
  1165.       *dst++  = ytab[((y+10)<<4)|(uvtab[uv+1028]>>4)];
  1166.       *dst2++ = ytab[((((y + *py2++)>>1)+6)<<4)|(uvtab[uv+3072]&15)];
  1167.     }
  1169.     py += horizontal_size;
  1171.     if (j!=(vertical_size-4))
  1172.       py2 += horizontal_size;
  1173.     else
  1174.       py2 -= horizontal_size;
  1176.     dst += horizontal_size;
  1177.     dst2 += horizontal_size;
  1179.     pu += chrom_width;
  1180.     pv += chrom_width;
  1182.     /* line j + 2, j + 3 */
  1183.     for (i=0; i<horizontal_size; i+=4){
  1184.       y = *py++;
  1185.       uv = (*pu++<<8)|*pv++;
  1186.       *dst++  = ytab[((y+3)<<4)|(uvtab[uv+1542]&15)];
  1187.       *dst2++ = ytab[((((y + *py2++)>>1)+15)<<4)|(uvtab[uv+3598]>>4)];
  1189.       y = *py++;
  1190.       uv = (*pu++<<8)|*pv++;
  1191.       *dst++  = ytab[((y+11)<<4)|(uvtab[uv+1542]>>4)];
  1192.       *dst2++ = ytab[((((y + *py2++)>>1)+7)<<4)|(uvtab[uv+3598]&15)];
  1194.       y = *py++;
  1195.       uv = (*pu++<<8)|*pv++;
  1196.       *dst++  = ytab[((y+1)<<4)|(uvtab[uv+514]&15)];
  1197.       *dst2++ = ytab[((((y + *py2++)>>1)+13)<<4)|(uvtab[uv+2570]>>4)];
  1199.       y = *py++;
  1200.       uv = (*pu++<<8)|*pv++;
  1201.       *dst++  = ytab[((y+9)<<4)|(uvtab[uv+514]>>4)];
  1202.       *dst2++ = ytab[((((y + *py2++)>>1)+5)<<4)|(uvtab[uv+2570]&15)];
  1203.     }
  1205.     py += horizontal_size;
  1206.     py2 += horizontal_size;
  1207.     dst += horizontal_size;
  1208.     dst2 += horizontal_size;
  1209.     pu += chrom_width;
  1210.     pv += chrom_width;
  1211.   }
  1212. }
  1215. void DisplayX11::ditherbot444(unsigned char *src[], unsigned char *dst){
  1216.   int i;
  1217.   unsigned int y2,uv;
  1218.   unsigned char *py,*py2,*pu,*pv,*dst2;
  1220.   py = src[0] + horizontal_size;
  1221.   py2 = py;
  1222.   pu = src[1] + chrom_width;
  1223.   pv = src[2] + chrom_width;
  1224.   dst2 = dst + horizontal_size;
  1226.   for (int j=0; j<vertical_size; j+=4){
  1227.     /* line j + 0, j + 1 */
  1228.     for (i=0; i<horizontal_size; i+=4){
  1229.       y2 = *py2++;
  1230.       uv = (*pu++<<8)|*pv++;
  1231.       *dst++  = ytab[((((*py++ + y2)>>1))<<4)|(uvtab[uv]&15)];
  1232.       *dst2++ = ytab[((y2+12)<<4)|(uvtab[uv+2056]>>4)];
  1234.       y2 = *py2++;
  1235.       uv = (*pu++<<8)|*pv++;
  1236.       *dst++  = ytab[((((*py++ + y2)>>1)+8)<<4)|(uvtab[uv]>>4)];
  1237.       *dst2++ = ytab[((y2+4)<<4)|(uvtab[uv+2056]&15)];
  1239.       y2 = *py2++;
  1240.       uv = (*pu++<<8)|*pv++;
  1241.       *dst++  = ytab[((((*py++ + y2)>>1)+2)<<4)|(uvtab[uv+1028]&15)];
  1242.       *dst2++ = ytab[((y2+14)<<4)|(uvtab[uv+3072]>>4)];
  1244.       y2 = *py2++;
  1245.       uv = (*pu++<<8)|*pv++;
  1246.       *dst++  = ytab[((((*py++ + y2)>>1)+10)<<4)|(uvtab[uv+1028]>>4)];
  1247.       *dst2++ = ytab[((y2+6)<<4)|(uvtab[uv+3072]&15)];
  1248.     }
  1250.     if (j==0)
  1251.       py -= horizontal_size;
  1252.     else
  1253.       py += horizontal_size;
  1255.     py2 += horizontal_size;
  1256.     dst += horizontal_size;
  1257.     dst2 += horizontal_size;
  1259.     pu += chrom_width;
  1260.     pv += chrom_width;
  1262.     /* line j + 2, j + 3 */
  1263.     for (i=0; i<horizontal_size; i+=4){
  1264.       y2 = *py2++;
  1265.       uv = (*pu++<<8)|*pv++;
  1266.       *dst++  = ytab[((((*py++ + y2)>>1)+3)<<4)|(uvtab[uv+1542]&15)];
  1267.       *dst2++ = ytab[((y2+15)<<4)|(uvtab[uv+3598]>>4)];
  1269.       y2 = *py2++;
  1270.       uv = (*pu++<<8)|*pv++;
  1271.       *dst++  = ytab[((((*py++ + y2)>>1)+11)<<4)|(uvtab[uv+1542]>>4)];
  1272.       *dst2++ = ytab[((y2+7)<<4)|(uvtab[uv+3598]&15)];
  1274.       y2 = *py2++;
  1275.       uv = (*pu++<<8)|*pv++;
  1276.       *dst++  = ytab[((((*py++ + y2)>>1)+1)<<4)|(uvtab[uv+514]&15)];
  1277.       *dst2++ = ytab[((y2+13)<<4)|(uvtab[uv+2570]>>4)];
  1279.       y2 = *py2++;
  1280.       uv = (*pu++<<8)|*pv++;
  1281.       *dst++  = ytab[((((*py++ + y2)>>1)+9)<<4)|(uvtab[uv+514]>>4)];
  1282.       *dst2++ = ytab[((y2+5)<<4)|(uvtab[uv+2570]&15)];
  1283.     }
  1285.     py += horizontal_size;
  1286.     py2 += horizontal_size;
  1287.     dst += horizontal_size;
  1288.     dst2 += horizontal_size;
  1289.     pu += chrom_width;
  1290.     pv += chrom_width;
  1291.   }
  1292. }
  1294. #ifdef SOLARIS_SDK_XIL
  1296. int DisplayX11::resize(){
  1297.   TRACER("int DisplayX11::resize()");
  1298.   Window root;
  1299.   int x, y;
  1300.   unsigned int w, h, b, d;
  1301.   XGetGeometry(display, window, &root, &x, &y, &w, &h, &b, &d);
  1303.   // indicate resize
  1304.   resized=1;
  1305.   horizontal_factor=((float) w)/horizontal_size;
  1306.   vertical_factor=((float) h)/vertical_size;
  1308.   // to avoid new events for the time being
  1309.   XSelectInput(display, window, NoEventMask);
  1310.   
  1311.   // Create new image with new geometry
  1312.   xil_destroy(displayimage);
  1313.   displayimage=xil_create_from_window(State, display, window);
  1314.   xil_destroy(resized_image);
  1315.   resized_image=xil_create(State, w, h, bands, XIL_BYTE);
  1316. /*
  1317.   if (bands==3){
  1318.     XilColorspace cspace=xil_colorspace_get_by_name(State, "ycc601");
  1319.     xil_set_colorspace(resized_image, cspace);
  1320.     cspace=xil_colorspace_get_by_name(State, "rgb709");
  1321.     xil_set_colorspace(displayimage, cspace);
  1322.   }
  1323. */
  1325.   XSelectInput(display, window, StructureNotifyMask);
  1326.   return 1;
  1327. }
  1329. #endif // SOLARIS_SDK_XIL
  1331. void  DisplayX11::dither_bw_rgb16(unsigned char * src,
  1332.                                   unsigned short * dithered_img,
  1333.                                   int height,
  1334.                                   int width,
  1335.                                   int display_width,
  1336.                                   int step) {
  1337.    int i,j,k,l=0;
  1338.    static unsigned short * look_up_table=NULL;
  1340.    if (look_up_table==NULL) {
  1341.       look_up_table=new unsigned short[256];
  1342.       for (i=0;i<256;++i) {
  1343.          look_up_table[i]=(i>>3)|((i>>2)<<5)|((i>>3)<<11);
  1344.          //fprintf(stdout,"%d=%02x ",i, look_up_table[i]);
  1345.       }
  1346.    }
  1347.    for (j=0;j<height;j+=step) {
  1348.       k=display_width*l++;
  1349.       for (i=0;i<width;i+=step) {
  1350.          dithered_img[k++]= look_up_table[src[j*width+i]];
  1351.       }
  1352.    }
  1353. }