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

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

DVD

开发平台：

Unix_Linux

display.cc.openptc：源码内容
  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. #define USE_PTC 1
  15. #ifdef __GNUG__
  16. #pragma implementation
  17. #endif
  19. #include "athread.hh"
  21. #include <stdio.h>
  22. #include <fstream.h>
  23. #include <sys/time.h>
  24. #ifdef USE_PTC
  25. #include <ptc/ptc.h>
  26. #endif
  29. #include "error.hh"
  30. #include "debug.hh"
  31. #include "util.hh"
  33. #include "videoconst.hh"
  34. #include "sync.hh"
  35. #include "display.hh"
  37. extern int quiet;
  38. extern int coded_picture_width;
  39. extern int coded_picture_height;
  40. extern int prog_seq;
  41. extern int chroma_format;
  42. extern int chrom_width;
  43. extern int pict_struct, topfirst;
  44. extern int convmat[8][4];
  45. extern int matrix_coefficients;
  46. extern int playedlastframe;
  48. // #define USE_DGA 1               /* enable this to use DGA extention */
  51. #ifdef SH_MEM
  52. // Dummies to get rid of warnings
  53. extern "C" {
  54. int XShmQueryExtension(Display*);
  55. int XShmGetEventBase(Display*);
  56. }
  57. #ifdef USE_DGA
  58. #include <X11/extensions/xf86dga.h>
  59. #include <X11/extensions/xf86vmode.h>
  60. #endif
  61. #endif
  65. DisplayX11::DisplayX11(const char* title, Synchronization* s){
  66.   TRACER("DisplayX11::DisplayX11(const char* title, Synchronization* s)");
  67.   int crv, cbu, cgu, cgv;
  68.   int y, u, v, r, g, b;
  69.   int i, j;
  70.   Colormap cmap;
  71.   XColor xcolor;
  72.   unsigned int fg, bg;
  73.   XSizeHints hint;
  74.   unsigned long tmp_pixel;
  75.   XWindowAttributes xwa;
  76.   int screen;
  77.   static Console console;
  78.   con = &console;
  79.   
  80.   // init to avoid invalid destroy in destructor
  81.   ximage=0;
  82.   ximage2=0;
  83.   // Synchronization with decoder clock
  84.   sync=s;
  86.   // Init display lock/condition to prevent threads to pass eachother
  87.   source=0;
  89. #ifdef SH_MEM
  90.   CompletionType = -1;
  91. #endif
  93.   // create clipping table
  94.   clp=new unsigned char[1024];  // clip table
  95.   clp += 384;
  96.   for (i=-384; i<640; i++) 
  97.     clp[i] = (i<0) ? 0 : ((i>255) ? 255 : i);
  99.   if (!(display=XOpenDisplay(0))){
  100.     error("Can not open displayn");
  101.     athr_exit(0);
  102.   }
  104. #ifdef TRACE
  105.   XSynchronize(display, 1);
  106. #endif
  107.     
  108.   screen = DefaultScreen(display);
  110.   // find  display
  111.   if (XMatchVisualInfo(display, screen, 16, TrueColor, &vinfo)){
  112.   } else
  113.    error("requires 16 bit displayn");
  115.   // Make the window
  116.   hint.x = 200;
  117.   hint.y = 200;
  118.   hint.width = 100;
  119.   hint.height= 100;
  120.   hint.flags = PPosition | PSize;
  121.   bpp = vinfo.depth;
  122.   if (vinfo.red_mask == 0x7c00)
  123.     rgb_mode = 1; // RGB555    for more modes see yuv12-rgb.s
  124.   else
  125.     rgb_mode = 0; // RGB565
  127. //  if (rgb_mode == 0) 
  128. //    Format format(16,0xf800,0x7e0,0x1f);
  129. //  else
  130. //    Format format(16,0x7c00,0x3e0,0x1f);
  131. //  form = &format;
  133. #if 0
  134.   // Get some colors
  135.   bg = WhitePixel(display, screen);
  136.   fg = BlackPixel(display, screen);
  138.   window=XCreateSimpleWindow(display, DefaultRootWindow (display),
  139.                                hint.x, hint.y, hint.width, hint.height, 4, fg, bg);
  141.   // Tell other applications about this window
  142.   XSetStandardProperties(display, window, title, title, None, NULL, 0, &hint);
  144.   XSelectInput(display, window, StructureNotifyMask);
  146.   // Map window
  147.   XMapWindow(display, window);
  149.   // Wait for map.
  150.   do {
  151.     XNextEvent(display, &event);
  152.   }
  153.   while (event.type != MapNotify || event.xmap.event != window);
  155.   XSelectInput(display, window, NoEventMask);
  157.   gc = DefaultGC(display, screen);
  159. /*
  160.    Init dither
  161.    4x4 ordered dither
  162.    threshold pattern:
  163.     0  8  2 10
  164.    12  4 14  6
  165.     3 11  1  9
  166.    15  7 13  5
  167. */
  169.   unsigned char ctab[256+32];
  170.   
  171.   for (i=0; i<256+16; i++){
  172.     v = (i-8)>>4;
  173.     if (v<2) v=2;
  174.     else if (v>14) v=14;
  175.     for (j=0; j<16; j++) 
  176.       ytab[16*i+j] = pixel[(v<<4)+j];
  177.   }
  179.   for (i=0; i<256+32; i++){
  180.     v = (i+48-128)>>5;
  181.     if (v<0) v=0;
  182.     else if (v>3) v=3;
  183.     ctab[i]=v;
  184.   }
  186.   for (i=0; i<255+15; i++)
  187.     for (j=0; j<255+15; j++)
  188.       uvtab[256*i+j]=(ctab[i+16]<<6)|(ctab[j+16]<<4)|(ctab[i]<<2)|ctab[j];
  189. #endif
  191. }
  194. DisplayX11::~DisplayX11(){ 
  195.   TRACER("DisplayX11::~DisplayX11()");
  196.   display_lock.lock();
  197.   if (!terminated) athr_join(thread_id);
  198.   exit_display();
  199.   delete clp; // delete clipping table
  200.   display_lock.unlock();
  201. }
  204. void* DisplayX11::dither_thread(DisplayX11* d){
  205.   d->display_lock.lock();
  206.   d->terminated=0;
  207.   d->dither_image(d->source);
  208.   d->display_image(d->ximage, d->dithered_image); 
  209.   d->source=0;
  210.   d->display_cond.signal();
  211.   d->terminated=1;
  212.   d->display_lock.unlock(); 
  213. #if !defined(IRIX) && !defined(SOLARIS_SDK_XIL) && !defined(LINUX)
  214.   athr_exit(0);
  215. #endif
  216.   return 0;
  217. }
  220. void* DisplayX11::display_thread(DisplayX11* d){
  221. #ifndef LINUX
  222.   d->display_lock.lock();
  223.   d->terminated=0;
  224.   d->display_image(d->ximage2, d->dithered_image2); 
  225.   d->terminated=1;
  226.   d->display_lock.unlock();
  227. #if !defined(IRIX) && !defined(SOLARIS_SDK_XIL) && !defined(LINUX)
  228.   athr_exit(0);
  229. #endif
  230. #endif
  231.   return 0;
  232. }
  235. int DisplayX11::init(int h_size, int v_size){
  236.   TRACER("void DisplayX11::init(int h_size, int v_size)");
  238.   display_lock.lock();  // lock the display from others access for now
  240.   // resize window
  241.   horizontal_size=h_size;
  242.   vertical_size=v_size;
  243.   Format format(16,0x7c00,0x3e0,0x1f);
  244.   con->option("dga pedantic init");
  245.   con->open("MPEG2 Player",h_size,v_size,format,0);
  246.   if (con->format() != format) message("Unable to get  format");
  249. #if 0
  251.   XResizeWindow(display, window, horizontal_size, vertical_size);
  254. #ifdef SH_MEM
  255.   char dummy;
  256.   shmem_flag = 0;
  257. #ifdef USE_DGA             /* enable this if you want to have DGA support */
  258.   int EventBase, ErrorBase, flags,vp_width,vp_height,bank,ram;
  259.   if (XF86DGAQueryExtension (display, &EventBase, &ErrorBase)) {
  260.       XF86DGAQueryDirectVideo (display, XDefaultScreen (display), &flags);
  261.       if ((flags & XF86DGADirectPresent) == 0) {
  262.           if (!quiet) message ("dga: no direct present");
  263.       }
  264.       else {
  265.           shmem_flag = 2;
  266.           if (!quiet) message ("using DGA ");
  267.       }
  269.       XF86DGAGetVideo (display, XDefaultScreen (display), (char **) &dithered_image,
  270.                         &xwidth, &bank, &ram);
  271.       dithered_image2 = dithered_image;
  272.       XF86DGAGetViewPortSize (display, XDefaultScreen (display),
  273.                         &vp_width, &vp_height);
  274.       if (vp_height < v_size || vp_width < h_size) {
  275.         if (!quiet) message("View Port too small for DGA");
  276.         shmem_flag = 0;
  277.       }
  278.       else {
  279.         XF86DGASetViewPort (display, XDefaultScreen (display), 0, 0);
  280.         XF86DGADirectVideo (display, XDefaultScreen (display),XF86DGADirectGraphics );
  281.       }
  282.   }
  283. #endif
  284.   if (!shmem_flag) 
  285.     if (XShmQueryExtension(display)) shmem_flag = 1;
  286.     else {
  287.       shmem_flag = 0;
  288.       if (!quiet){
  289.         message("Shared memory not supported");
  290.         message("Reverting to normal Xlib");
  291.       }
  292.     }
  294.   if (shmem_flag==1) CompletionType = XShmGetEventBase(display) + ShmCompletion;
  296.   InstallXErrorHandler();
  298.   if (shmem_flag==1){
  299.     ximage = XShmCreateImage(display, None, bpp, ZPixmap, NULL,
  300.                              &shminfo1,
  301.                              coded_picture_width, coded_picture_height);
  303.     if (!prog_seq)
  304.       ximage2 = XShmCreateImage(display, None, bpp, ZPixmap, NULL,
  305.                                 &shminfo2,
  306.                                 coded_picture_width, coded_picture_height);
  308.     /* If no go, then revert to normal Xlib calls. */
  310.     if (ximage==NULL || (!prog_seq && ximage2==NULL)){
  311.       if (ximage!=NULL) XDestroyImage(ximage);
  312.       if (!prog_seq && ximage2!=NULL) XDestroyImage(ximage2);
  313.       if (!quiet)
  314.         fprintf(stderr, "Shared memory error, disabling (Ximage error)n");
  315.       goto shmemerror;
  316.     }
  318.     /* Success here, continue. */
  320.     shminfo1.shmid = shmget(IPC_PRIVATE, 
  321.                             ximage->bytes_per_line * ximage->height,
  322.                             IPC_CREAT | 0777);
  323.     if (!prog_seq)
  324.       shminfo2.shmid = shmget(IPC_PRIVATE, 
  325.                               ximage2->bytes_per_line * ximage2->height,
  326.                               IPC_CREAT | 0777);
  328.     if (shminfo1.shmid<0 || (!prog_seq && shminfo2.shmid<0)){
  329.       XDestroyImage(ximage);
  330.       if (!prog_seq) XDestroyImage(ximage2);
  331.       if (!quiet)
  332.         fprintf(stderr, "Shared memory error, disabling (seg id error)n");
  333.       goto shmemerror;
  334.     }
  336.     shminfo1.shmaddr = (char *) shmat(shminfo1.shmid, 0, 0);
  337.     shminfo2.shmaddr = (char *) shmat(shminfo2.shmid, 0, 0);
  339.     if (shminfo1.shmaddr==((char *) -1) ||
  340.         (!prog_seq && shminfo2.shmaddr==((char *) -1))){
  341.       XDestroyImage(ximage);
  342.       if (shminfo1.shmaddr!=((char *) -1)) shmdt(shminfo1.shmaddr);
  343.       if (!prog_seq){
  344.         XDestroyImage(ximage2);
  345.         if (shminfo2.shmaddr!=((char *) -1))
  346.           shmdt(shminfo2.shmaddr);
  347.       }
  348.       if (!quiet)
  349.       {
  350.         fprintf(stderr, "Shared memory error, disabling (address error)n");
  351.       }
  352.       goto shmemerror;
  353.     }
  355.     ximage->data = shminfo1.shmaddr;
  356.     dithered_image = (unsigned char *)ximage->data;
  357.     shminfo1.readOnly = False;
  358.     XShmAttach(display, &shminfo1);
  359.     if (!prog_seq){
  360.       ximage2->data = shminfo2.shmaddr;
  361.       dithered_image2 = (unsigned char *)ximage2->data;
  362.       shminfo2.readOnly = False;
  363.       XShmAttach(display, &shminfo2);
  364.     }
  366.     XSync(display, False);
  368.     if (gXErrorFlag){
  369.       /* Ultimate failure here. */
  370.       XDestroyImage(ximage);
  371.       shmdt(shminfo1.shmaddr);
  372.       if (!prog_seq){
  373.         XDestroyImage(ximage2);
  374.         shmdt(shminfo2.shmaddr);
  375.       }
  376.       if (!quiet)
  377.         fprintf(stderr, "Shared memory error, disabling.n");
  378.       gXErrorFlag = 0;
  379.       goto shmemerror;
  380.     }
  381.     else {
  382.       shmctl(shminfo1.shmid, IPC_RMID, 0);
  383.       if (!prog_seq)
  384.         shmctl(shminfo2.shmid, IPC_RMID, 0);
  385.     }
  387.     if (!quiet){
  388.       fprintf(stderr, "Sharing memory.n");
  389.     }
  390.   }
  391.   else if (shmem_flag != 2) {
  393. shmemerror:
  394.     shmem_flag = 0;
  395. #endif
  397.     ximage = XCreateImage(display,None,bpp,ZPixmap,0,&dummy,
  398.                           coded_picture_width,coded_picture_height,8,0);
  400.     if (!(dithered_image = new unsigned char[coded_picture_width*
  401.                                                    coded_picture_height]))
  402.       error("new failed");
  404.     if (!prog_seq){
  405.       ximage2 = XCreateImage(display,None,bpp,ZPixmap,0,&dummy,
  406.                              coded_picture_width,coded_picture_height,8,0);
  408.       if (!(dithered_image2 = new unsigned char[coded_picture_width*
  409.                                                       coded_picture_height]))
  410.         error("new failed");
  411.     }
  413. #ifdef SH_MEM
  414.   }
  416.   DeInstallXErrorHandler();
  417. #endif
  419. #endif
  420.   display_lock.unlock();
  421.   return 1;
  422. }
  426. void DisplayX11::exit_display(){
  427. #ifdef SH_MEM
  428. #ifdef USE_DGA
  429.   if (shmem_flag==2)
  430.     XF86DGADirectVideo (display, XDefaultScreen (display), 0);
  431. #endif
  432.   if (shmem_flag==1){
  433.     XShmDetach(display, &shminfo1);
  434.     shmdt(shminfo1.shmaddr);
  435.     if (!prog_seq){
  436.       XShmDetach(display, &shminfo2);
  437.       XDestroyImage(ximage2);
  438.       shmdt(shminfo2.shmaddr);
  439.     }
  440.   }
  441. #else
  442.   XDestroyImage(ximage);
  443. #endif
  444. }
  447. #ifdef SOLARIS_SDK_XIL
  448. void DisplayX11::display_image(XilImage ximg, unsigned char *dithered_img){
  449. #else
  450. void DisplayX11::display_image(XImage *ximg, unsigned char *dithered_img){
  451. #endif
  452.   DEBUGGER("void DisplayX11::display_image(ximage, unsigned char *dithered_image)");
  453.   playedlastframe=1;  // indicate that frame is displayed
  454.   if (sync) 
  455.     sync->wait(1);    // wait for presentation time stamp (PTS), id=1
  457. #ifdef SH_MEM                            // display dithered image
  458.   if (shmem_flag==2)
  459.     return;
  460. #endif
  461.  return;
  463. #ifdef SOLARIS_SDK_XIL
  464.   xil_import(ximg, TRUE);
  465.   if (resized){
  466.     // , general and linear are Ok (These is no good for this: bilinear, bicubic)
  467.     xil_scale(ximage, resized_image, "general", horizontal_factor, vertical_factor);
  468.     // if (bands==1)   // Use XIL for color conversion
  469.     xil_copy(resized_image, displayimage);
  470.     // else 
  471.     //   xil_color_convert(resized_image, displayimage);
  472.   }
  473.   else {
  474.     // if (bands==1)   // Use XIL for color conversion
  475.     xil_copy(ximg, displayimage);
  476.     // else 
  477.     //   xil_color_convert(ximg, displayimage);
  478.   }
  480.   // check for geometry changes
  481.   if (XCheckWindowEvent(display, window, StructureNotifyMask, &event))  resize();
  482. #else
  483. #ifdef SH_MEM                            // display dithered image
  484.   if (shmem_flag==1){
  485.     XShmPutImage(display, window, gc, ximg, 0,0,0,0,ximg->width,ximg->height,True);
  486.     XFlush(display);
  487.   }
  488.   else 
  489. #endif // SH_MEM
  490.   {
  491.     ximg->data=(char*) dithered_img;
  492.     XPutImage(display, window, gc, ximg, 0, 0, 0, 0, ximg->width, ximg->height);
  493.   }
  494. #endif // SOLARIS_SDK_XIL
  495. }
  498. #ifdef SOLARIS_SDK_XIL
  500. int DisplayX11::dither_image_rgb24(unsigned char* src[], unsigned char* dithered_img){
  501.   register int h=0, w=-1;
  502.   register unsigned char *Y, *Cb, *Cr;  
  503.   Y=src[0];
  504.   Cb=src[1];
  505.   Cr=src[2];
  506.   register Xil_unsigned8* data;
  507.   data=dithered_img;
  508.   
  509.   //  map data in XIL image  
  510.   for (h=0; h<coded_picture_height; h++){
  511.     for (w=0; w<coded_picture_width; w++){
  512.       *data++ = clp[(int)(*Y + 1.371*(*Cr-128))];  
  513.       *data++ = clp[(int)(*Y - 0.698*(*Cr-128) - 0.336*(*Cr-128))]; 
  514.       *data++ = clp[(int)(*Y++ + 1.732*(*Cb-128))];
  515.       if ((w % 4)==0){
  516.         Cr++;
  517.         Cb++;
  518.       }
  519.     }
  520.   }
  521.   return 0;
  522. };
  524. #endif
  526. #ifdef LINUX
  527. extern "C" void yuv_2_rgb(void *,void *,void *,int,int,int,int,int,void *,int,int,int,int);
  530. int DisplayX11::dither_image_rgb16(unsigned char* src[], unsigned char* dithered_img){
  531.   int height,width,display_width;
  532.   height=coded_picture_height;
  533.   dithered_img = (unsigned char *)con->lock();
  534.   if (shmem_flag == 2)
  535.     display_width = xwidth;
  536.   else
  537.     display_width=coded_picture_width;
  538.   width=coded_picture_width;
  539.   display_width = con->pitch() ;
  540.   yuv_2_rgb(src[0],src[1],src[2],width,height,width,width/2,0,dithered_img,0,0,display_width,rgb_mode);
  541.   con->unlock();
  542.   con->update();
  543.   return 0;
  544. }
  545. #endif
  548. void DisplayX11::dither_image(unsigned char *src[]){
  549. #ifdef SOLARIS_SDK_XIL
  550.   dithered_image=getImage1Data();
  551. #endif
  552.   if (prog_seq){
  553.     if (chroma_format!=CHROMA444){
  554. #ifdef SOLARIS_SDK_XIL
  555.       if (vinfo.c_class==TrueColor && vinfo.depth==24){
  556.         dither_image_rgb24(src, dithered_image);
  557.         return;
  558.       }
  559. #endif
  560. #ifdef LINUX 
  561.       if (bpp == 16 ) {
  562.         dither_image_rgb16(src, dithered_image);
  563.         return;
  564.       }
  565. #endif
  566.       ditherframe(src);
  567.     }
  568.     else
  569.       ditherframe444(src);
  570.   }
  571.   else {
  572. #ifdef SOLARIS_SDK_XIL
  573.     dithered_image2=getImage2Data();
  574. #endif
  575. #ifdef LINUX 
  576.       if (bpp == 16 ){
  577.         dither_image_rgb16(src, dithered_image);
  578.         return;
  579.       }
  580. #endif
  581.     if ((pict_struct==FRAME_PICTURE && topfirst) || pict_struct==BOTTOM_FIELD){
  582.       /* top field first */
  583.       if (chroma_format!=CHROMA444){
  584.         dithertop(src,dithered_image);
  585.         ditherbot(src,dithered_image2);
  586.       }
  587.       else {
  588.         dithertop444(src,dithered_image);
  589.         ditherbot444(src,dithered_image2);
  590.       }
  591.     }
  592.     else {
  593.       /* bottom field first */
  594.       if (chroma_format!=CHROMA444){
  595.         ditherbot(src,dithered_image);
  596.         dithertop(src,dithered_image2);
  597.       }
  598.       else {
  599.         ditherbot444(src,dithered_image);
  600.         dithertop444(src,dithered_image2);
  601.       }
  602.     }
  603.   }
  604. }
  607. /* only for 4:2:0 and 4:2:2! */
  609. void DisplayX11::ditherframe(unsigned char *src[]){
  610.   int i;
  611.   register unsigned int uv;
  612.   register unsigned char *py,*pu,*pv,*dst;
  613.   py = src[0];
  614.   pu = src[1];
  615.   pv = src[2];
  616.   dst = dithered_image;
  618.   for (int j=0; j<coded_picture_height; j+=4){
  619.     /* line j + 0 */
  620.     for (i=0; i<coded_picture_width; i+=8){
  621.       uv = uvtab[(*pu++<<8)|*pv++];
  622.       *dst++ = ytab[((*py++)<<4)|(uv&15)];
  623.       *dst++ = ytab[((*py++ +8)<<4)|(uv>>4)];
  624.       uv = uvtab[((*pu++<<8)|*pv++)+1028];
  625.       *dst++ = ytab[((*py++ +2)<<4)|(uv&15)];
  626.       *dst++ = ytab[((*py++ +10)<<4)|(uv>>4)];
  627.       uv = uvtab[(*pu++<<8)|*pv++];
  628.       *dst++ = ytab[((*py++)<<4)|(uv&15)];
  629.       *dst++ = ytab[((*py++ +8)<<4)|(uv>>4)];
  630.       uv = uvtab[((*pu++<<8)|*pv++)+1028];
  631.       *dst++ = ytab[((*py++ +2)<<4)|(uv&15)];
  632.       *dst++ = ytab[((*py++ +10)<<4)|(uv>>4)];
  633.     }
  635.     if (chroma_format==CHROMA420){
  636.       pu -= chrom_width;
  637.       pv -= chrom_width;
  638.     }
  640.     /* line j + 1 */
  641.     for (i=0; i<coded_picture_width; i+=8){
  642.       uv = uvtab[((*pu++<<8)|*pv++)+2056];
  643.       *dst++ = ytab[((*py++ +12)<<4)|(uv>>4)];
  644.       *dst++ = ytab[((*py++ +4)<<4)|(uv&15)];
  645.       uv = uvtab[((*pu++<<8)|*pv++)+3084];
  646.       *dst++ = ytab[((*py++ +14)<<4)|(uv>>4)];
  647.       *dst++ = ytab[((*py++ +6)<<4)|(uv&15)];
  648.       uv = uvtab[((*pu++<<8)|*pv++)+2056];
  649.       *dst++ = ytab[((*py++ +12)<<4)|(uv>>4)];
  650.       *dst++ = ytab[((*py++ +4)<<4)|(uv&15)];
  651.       uv = uvtab[((*pu++<<8)|*pv++)+3084];
  652.       *dst++ = ytab[((*py++ +14)<<4)|(uv>>4)];
  653.       *dst++ = ytab[((*py++ +6)<<4)|(uv&15)];
  654.     }
  656.     /* line j + 2 */
  657.     for (i=0; i<coded_picture_width; i+=8){
  658.       uv = uvtab[((*pu++<<8)|*pv++)+1542];
  659.       *dst++ = ytab[((*py++ +3)<<4)|(uv&15)];
  660.       *dst++ = ytab[((*py++ +11)<<4)|(uv>>4)];
  661.       uv = uvtab[((*pu++<<8)|*pv++)+514];
  662.       *dst++ = ytab[((*py++ +1)<<4)|(uv&15)];
  663.       *dst++ = ytab[((*py++ +9)<<4)|(uv>>4)];
  664.       uv = uvtab[((*pu++<<8)|*pv++)+1542];
  665.       *dst++ = ytab[((*py++ +3)<<4)|(uv&15)];
  666.       *dst++ = ytab[((*py++ +11)<<4)|(uv>>4)];
  667.       uv = uvtab[((*pu++<<8)|*pv++)+514];
  668.       *dst++ = ytab[((*py++ +1)<<4)|(uv&15)];
  669.       *dst++ = ytab[((*py++ +9)<<4)|(uv>>4)];
  670.     }
  672.     if (chroma_format==CHROMA420){
  673.       pu -= chrom_width;
  674.       pv -= chrom_width;
  675.     }
  677.     /* line j + 3 */
  678.     for (i=0; i<coded_picture_width; i+=8){
  679.       uv = uvtab[((*pu++<<8)|*pv++)+3598];
  680.       *dst++ = ytab[((*py++ +15)<<4)|(uv>>4)];
  681.       *dst++ = ytab[((*py++ +7)<<4)|(uv&15)];
  682.       uv = uvtab[((*pu++<<8)|*pv++)+2570];
  683.       *dst++ = ytab[((*py++ +13)<<4)|(uv>>4)];
  684.       *dst++ = ytab[((*py++ +5)<<4)|(uv&15)];
  685.       uv = uvtab[((*pu++<<8)|*pv++)+3598];
  686.       *dst++ = ytab[((*py++ +15)<<4)|(uv>>4)];
  687.       *dst++ = ytab[((*py++ +7)<<4)|(uv&15)];
  688.       uv = uvtab[((*pu++<<8)|*pv++)+2570];
  689.       *dst++ = ytab[((*py++ +13)<<4)|(uv>>4)];
  690.       *dst++ = ytab[((*py++ +5)<<4)|(uv&15)];
  691.     }
  692.   }
  693. }
  696. void DisplayX11::dithertop(unsigned char *src[], unsigned char *dst){
  697.   int i;
  698.   unsigned int y,uv1,uv2;
  699.   unsigned char *py,*py2,*pu,*pv,*dst2;
  701.   py = src[0];
  702.   py2 = src[0] + (coded_picture_width<<1);
  703.   pu = src[1];
  704.   pv = src[2];
  705.   dst2 = dst + coded_picture_width;
  707.   for (int j=0; j<coded_picture_height; j+=4){
  708.     /* line j + 0, j + 1 */
  709.     for (i=0; i<coded_picture_width; i+=4){
  710.       y = *py++;
  711.       uv2 = (*pu++<<8)|*pv++;
  712.       uv1 = uvtab[uv2];
  713.       uv2 = uvtab[uv2+2056];
  714.       *dst++  = ytab[((y)<<4)|(uv1&15)];
  715.       *dst2++ = ytab[((((y + *py2++)>>1)+12)<<4)|(uv2>>4)];
  717.       y = *py++;
  718.       *dst++  = ytab[((y+8)<<4)|(uv1>>4)];
  719.       *dst2++ = ytab[((((y + *py2++)>>1)+4)<<4)|(uv2&15)];
  721.       y = *py++;
  722.       uv2 = (*pu++<<8)|*pv++;
  723.       uv1 = uvtab[uv2+1028];
  724.       uv2 = uvtab[uv2+3072];
  725.       *dst++  = ytab[((y+2)<<4)|(uv1&15)];
  726.       *dst2++ = ytab[((((y + *py2++)>>1)+14)<<4)|(uv2>>4)];
  728.       y = *py++;
  729.       *dst++  = ytab[((y+10)<<4)|(uv1>>4)];
  730.       *dst2++ = ytab[((((y + *py2++)>>1)+6)<<4)|(uv2&15)];
  731.     }
  733.     py += coded_picture_width;
  735.     if (j!=(coded_picture_height-4)) py2 += coded_picture_width;
  736.     else                             py2 -= coded_picture_width;
  738.     dst += coded_picture_width;
  739.     dst2 += coded_picture_width;
  741.     if (chroma_format==CHROMA420){
  742.       pu -= chrom_width;
  743.       pv -= chrom_width;
  744.     }
  745.     else {
  746.       pu += chrom_width;
  747.       pv += chrom_width;
  748.     }
  750.     /* line j + 2, j + 3 */
  751.     for (i=0; i<coded_picture_width; i+=4){
  752.       y = *py++;
  753.       uv2 = (*pu++<<8)|*pv++;
  754.       uv1 = uvtab[uv2+1542];
  755.       uv2 = uvtab[uv2+3598];
  756.       *dst++  = ytab[((y+3)<<4)|(uv1&15)];
  757.       *dst2++ = ytab[((((y + *py2++)>>1)+15)<<4)|(uv2>>4)];
  759.       y = *py++;
  760.       *dst++  = ytab[((y+11)<<4)|(uv1>>4)];
  761.       *dst2++ = ytab[((((y + *py2++)>>1)+7)<<4)|(uv2&15)];
  763.       y = *py++;
  764.       uv2 = (*pu++<<8)|*pv++;
  765.       uv1 = uvtab[uv2+514];
  766.       uv2 = uvtab[uv2+2570];
  767.       *dst++  = ytab[((y+1)<<4)|(uv1&15)];
  768.       *dst2++ = ytab[((((y + *py2++)>>1)+13)<<4)|(uv2>>4)];
  770.       y = *py++;
  771.       *dst++  = ytab[((y+9)<<4)|(uv1>>4)];
  772.       *dst2++ = ytab[((((y + *py2++)>>1)+5)<<4)|(uv2&15)];
  773.     }
  775.     py += coded_picture_width;
  776.     py2 += coded_picture_width;
  777.     dst += coded_picture_width;
  778.     dst2 += coded_picture_width;
  779.     pu += chrom_width;
  780.     pv += chrom_width;
  781.   }
  782. }
  785. void DisplayX11::ditherbot(unsigned char *src[], unsigned char *dst){
  786.   int i;
  787.   unsigned int y2,uv1,uv2;
  788.   unsigned char *py,*py2,*pu,*pv,*dst2;
  790.   py = src[0] + coded_picture_width;
  791.   py2 = py;
  792.   pu = src[1] + chrom_width;
  793.   pv = src[2] + chrom_width;
  794.   dst2 = dst + coded_picture_width;
  796.   for (int j=0; j<coded_picture_height; j+=4){
  797.     /* line j + 0, j + 1 */
  798.     for (i=0; i<coded_picture_width; i+=4){
  799.       y2 = *py2++;
  800.       uv2 = (*pu++<<8)|*pv++;
  801.       uv1 = uvtab[uv2];
  802.       uv2 = uvtab[uv2+2056];
  803.       *dst++  = ytab[((((*py++ + y2)>>1))<<4)|(uv1&15)];
  804.       *dst2++ = ytab[((y2+12)<<4)|(uv2>>4)];
  806.       y2 = *py2++;
  807.       *dst++  = ytab[((((*py++ + y2)>>1)+8)<<4)|(uv1>>4)];
  808.       *dst2++ = ytab[((y2+4)<<4)|(uv2&15)];
  810.       y2 = *py2++;
  811.       uv2 = (*pu++<<8)|*pv++;
  812.       uv1 = uvtab[uv2+1028];
  813.       uv2 = uvtab[uv2+3072];
  814.       *dst++  = ytab[((((*py++ + y2)>>1)+2)<<4)|(uv1&15)];
  815.       *dst2++ = ytab[((y2+14)<<4)|(uv2>>4)];
  817.       y2 = *py2++;
  818.       *dst++  = ytab[((((*py++ + y2)>>1)+10)<<4)|(uv1>>4)];
  819.       *dst2++ = ytab[((y2+6)<<4)|(uv2&15)];
  820.     }
  822.     if (j==0) py -= coded_picture_width;
  823.     else      py += coded_picture_width;
  825.     py2 += coded_picture_width;
  826.     dst += coded_picture_width;
  827.     dst2 += coded_picture_width;
  829.     if (chroma_format==CHROMA420){
  830.       pu -= chrom_width;
  831.       pv -= chrom_width;
  832.     }
  833.     else {
  834.       pu += chrom_width;
  835.       pv += chrom_width;
  836.     }
  838.     /* line j + 2, j + 3 */
  839.     for (i=0; i<coded_picture_width; i+=4){
  840.       y2 = *py2++;
  841.       uv2 = (*pu++<<8)|*pv++;
  842.       uv1 = uvtab[uv2+1542];
  843.       uv2 = uvtab[uv2+3598];
  844.       *dst++  = ytab[((((*py++ + y2)>>1)+3)<<4)|(uv1&15)];
  845.       *dst2++ = ytab[((y2+15)<<4)|(uv2>>4)];
  847.       y2 = *py2++;
  848.       *dst++  = ytab[((((*py++ + y2)>>1)+11)<<4)|(uv1>>4)];
  849.       *dst2++ = ytab[((y2+7)<<4)|(uv2&15)];
  851.       y2 = *py2++;
  852.       uv2 = (*pu++<<8)|*pv++;
  853.       uv1 = uvtab[uv2+514];
  854.       uv2 = uvtab[uv2+2570];
  855.       *dst++  = ytab[((((*py++ + y2)>>1)+1)<<4)|(uv1&15)];
  856.       *dst2++ = ytab[((y2+13)<<4)|(uv2>>4)];
  858.       y2 = *py2++;
  859.       *dst++  = ytab[((((*py++ + y2)>>1)+9)<<4)|(uv1>>4)];
  860.       *dst2++ = ytab[((y2+5)<<4)|(uv2&15)];
  861.     }
  863.     py += coded_picture_width;
  864.     py2 += coded_picture_width;
  865.     dst += coded_picture_width;
  866.     dst2 += coded_picture_width;
  867.     pu += chrom_width;
  868.     pv += chrom_width;
  869.   }
  870. }
  872. /* only for 4:4:4 */
  874. void DisplayX11::ditherframe444(unsigned char *src[]){
  875.   int i;
  876.   unsigned char *py=src[0], *pu=src[1], *pv=src[2], *dst=dithered_image;
  878.   for (int j=0; j<coded_picture_height; j+=4){
  879.     /* line j + 0 */
  880.     for (i=0; i<coded_picture_width; i+=8){
  881.       *dst++ = ytab[((*py++)<<4)|(uvtab[(*pu++<<8)|*pv++]&15)];
  882.       *dst++ = ytab[((*py++ +8)<<4)|(uvtab[(*pu++<<8)|*pv++]>>4)];
  883.       *dst++ = ytab[((*py++ +2)<<4)|(uvtab[((*pu++<<8)|*pv++)+1028]&15)];
  884.       *dst++ = ytab[((*py++ +10)<<4)|(uvtab[((*pu++<<8)|*pv++)+1028]>>4)];
  885.       *dst++ = ytab[((*py++)<<4)|(uvtab[(*pu++<<8)|*pv++]&15)];
  886.       *dst++ = ytab[((*py++ +8)<<4)|(uvtab[(*pu++<<8)|*pv++]>>4)];
  887.       *dst++ = ytab[((*py++ +2)<<4)|(uvtab[((*pu++<<8)|*pv++)+1028]&15)];
  888.       *dst++ = ytab[((*py++ +10)<<4)|(uvtab[((*pu++<<8)|*pv++)+1028]>>4)];
  889.     }
  891.     /* line j + 1 */
  892.     for (i=0; i<coded_picture_width; i+=8){
  893.       *dst++ = ytab[((*py++ +12)<<4)|(uvtab[((*pu++<<8)|*pv++)+2056]>>4)];
  894.       *dst++ = ytab[((*py++ +4)<<4)|(uvtab[((*pu++<<8)|*pv++)+2056]&15)];
  895.       *dst++ = ytab[((*py++ +14)<<4)|(uvtab[((*pu++<<8)|*pv++)+3084]>>4)];
  896.       *dst++ = ytab[((*py++ +6)<<4)|(uvtab[((*pu++<<8)|*pv++)+3084]&15)];
  897.       *dst++ = ytab[((*py++ +12)<<4)|(uvtab[((*pu++<<8)|*pv++)+2056]>>4)];
  898.       *dst++ = ytab[((*py++ +4)<<4)|(uvtab[((*pu++<<8)|*pv++)+2056]&15)];
  899.       *dst++ = ytab[((*py++ +14)<<4)|(uvtab[((*pu++<<8)|*pv++)+3084]>>4)];
  900.       *dst++ = ytab[((*py++ +6)<<4)|(uvtab[((*pu++<<8)|*pv++)+3084]&15)];
  901.     }
  903.     /* line j + 2 */
  904.     for (i=0; i<coded_picture_width; i+=8){
  905.       *dst++ = ytab[((*py++ +3)<<4)|(uvtab[((*pu++<<8)|*pv++)+1542]&15)];
  906.       *dst++ = ytab[((*py++ +11)<<4)|(uvtab[((*pu++<<8)|*pv++)+1542]>>4)];
  907.       *dst++ = ytab[((*py++ +1)<<4)|(uvtab[((*pu++<<8)|*pv++)+514]&15)];
  908.       *dst++ = ytab[((*py++ +9)<<4)|(uvtab[((*pu++<<8)|*pv++)+514]>>4)];
  909.       *dst++ = ytab[((*py++ +3)<<4)|(uvtab[((*pu++<<8)|*pv++)+1542]&15)];
  910.       *dst++ = ytab[((*py++ +11)<<4)|(uvtab[((*pu++<<8)|*pv++)+1542]>>4)];
  911.       *dst++ = ytab[((*py++ +1)<<4)|(uvtab[((*pu++<<8)|*pv++)+514]&15)];
  912.       *dst++ = ytab[((*py++ +9)<<4)|(uvtab[((*pu++<<8)|*pv++)+514]>>4)];
  913.     }
  915.     /* line j + 3 */
  916.     for (i=0; i<coded_picture_width; i+=8){
  917.       *dst++ = ytab[((*py++ +15)<<4)|(uvtab[((*pu++<<8)|*pv++)+3598]>>4)];
  918.       *dst++ = ytab[((*py++ +7)<<4)|(uvtab[((*pu++<<8)|*pv++)+3598]&15)];
  919.       *dst++ = ytab[((*py++ +13)<<4)|(uvtab[((*pu++<<8)|*pv++)+2570]>>4)];
  920.       *dst++ = ytab[((*py++ +5)<<4)|(uvtab[((*pu++<<8)|*pv++)+2570]&15)];
  921.       *dst++ = ytab[((*py++ +15)<<4)|(uvtab[((*pu++<<8)|*pv++)+3598]>>4)];
  922.       *dst++ = ytab[((*py++ +7)<<4)|(uvtab[((*pu++<<8)|*pv++)+3598]&15)];
  923.       *dst++ = ytab[((*py++ +13)<<4)|(uvtab[((*pu++<<8)|*pv++)+2570]>>4)];
  924.       *dst++ = ytab[((*py++ +5)<<4)|(uvtab[((*pu++<<8)|*pv++)+2570]&15)];
  925.     }
  926.   }
  927. }
  930. void DisplayX11::dithertop444(unsigned char *src[], unsigned char *dst){
  931.   int i;
  932.   unsigned int y,uv;
  933.   unsigned char *py,*py2,*pu,*pv,*dst2;
  935.   py = src[0];
  936.   py2 = src[0] + (coded_picture_width<<1);
  937.   pu = src[1];
  938.   pv = src[2];
  939.   dst2 = dst + coded_picture_width;
  941.   for (int j=0; j<coded_picture_height; j+=4){
  942.     /* line j + 0, j + 1 */
  943.     for (i=0; i<coded_picture_width; i+=4){
  944.       y = *py++;
  945.       uv = (*pu++<<8)|*pv++;
  946.       *dst++  = ytab[((y)<<4)|(uvtab[uv]&15)];
  947.       *dst2++ = ytab[((((y + *py2++)>>1)+12)<<4)|(uvtab[uv+2056]>>4)];
  949.       y = *py++;
  950.       uv = (*pu++<<8)|*pv++;
  951.       *dst++  = ytab[((y+8)<<4)|(uvtab[uv]>>4)];
  952.       *dst2++ = ytab[((((y + *py2++)>>1)+4)<<4)|(uvtab[uv+2056]&15)];
  954.       y = *py++;
  955.       uv = (*pu++<<8)|*pv++;
  956.       *dst++  = ytab[((y+2)<<4)|(uvtab[uv+1028]&15)];
  957.       *dst2++ = ytab[((((y + *py2++)>>1)+14)<<4)|(uvtab[uv+3072]>>4)];
  959.       y = *py++;
  960.       uv = (*pu++<<8)|*pv++;
  961.       *dst++  = ytab[((y+10)<<4)|(uvtab[uv+1028]>>4)];
  962.       *dst2++ = ytab[((((y + *py2++)>>1)+6)<<4)|(uvtab[uv+3072]&15)];
  963.     }
  965.     py += coded_picture_width;
  967.     if (j!=(coded_picture_height-4))
  968.       py2 += coded_picture_width;
  969.     else
  970.       py2 -= coded_picture_width;
  972.     dst += coded_picture_width;
  973.     dst2 += coded_picture_width;
  975.     pu += chrom_width;
  976.     pv += chrom_width;
  978.     /* line j + 2, j + 3 */
  979.     for (i=0; i<coded_picture_width; i+=4){
  980.       y = *py++;
  981.       uv = (*pu++<<8)|*pv++;
  982.       *dst++  = ytab[((y+3)<<4)|(uvtab[uv+1542]&15)];
  983.       *dst2++ = ytab[((((y + *py2++)>>1)+15)<<4)|(uvtab[uv+3598]>>4)];
  985.       y = *py++;
  986.       uv = (*pu++<<8)|*pv++;
  987.       *dst++  = ytab[((y+11)<<4)|(uvtab[uv+1542]>>4)];
  988.       *dst2++ = ytab[((((y + *py2++)>>1)+7)<<4)|(uvtab[uv+3598]&15)];
  990.       y = *py++;
  991.       uv = (*pu++<<8)|*pv++;
  992.       *dst++  = ytab[((y+1)<<4)|(uvtab[uv+514]&15)];
  993.       *dst2++ = ytab[((((y + *py2++)>>1)+13)<<4)|(uvtab[uv+2570]>>4)];
  995.       y = *py++;
  996.       uv = (*pu++<<8)|*pv++;
  997.       *dst++  = ytab[((y+9)<<4)|(uvtab[uv+514]>>4)];
  998.       *dst2++ = ytab[((((y + *py2++)>>1)+5)<<4)|(uvtab[uv+2570]&15)];
  999.     }
  1001.     py += coded_picture_width;
  1002.     py2 += coded_picture_width;
  1003.     dst += coded_picture_width;
  1004.     dst2 += coded_picture_width;
  1005.     pu += chrom_width;
  1006.     pv += chrom_width;
  1007.   }
  1008. }
  1011. void DisplayX11::ditherbot444(unsigned char *src[], unsigned char *dst){
  1012.   int i;
  1013.   unsigned int y2,uv;
  1014.   unsigned char *py,*py2,*pu,*pv,*dst2;
  1016.   py = src[0] + coded_picture_width;
  1017.   py2 = py;
  1018.   pu = src[1] + chrom_width;
  1019.   pv = src[2] + chrom_width;
  1020.   dst2 = dst + coded_picture_width;
  1022.   for (int j=0; j<coded_picture_height; j+=4){
  1023.     /* line j + 0, j + 1 */
  1024.     for (i=0; i<coded_picture_width; i+=4){
  1025.       y2 = *py2++;
  1026.       uv = (*pu++<<8)|*pv++;
  1027.       *dst++  = ytab[((((*py++ + y2)>>1))<<4)|(uvtab[uv]&15)];
  1028.       *dst2++ = ytab[((y2+12)<<4)|(uvtab[uv+2056]>>4)];
  1030.       y2 = *py2++;
  1031.       uv = (*pu++<<8)|*pv++;
  1032.       *dst++  = ytab[((((*py++ + y2)>>1)+8)<<4)|(uvtab[uv]>>4)];
  1033.       *dst2++ = ytab[((y2+4)<<4)|(uvtab[uv+2056]&15)];
  1035.       y2 = *py2++;
  1036.       uv = (*pu++<<8)|*pv++;
  1037.       *dst++  = ytab[((((*py++ + y2)>>1)+2)<<4)|(uvtab[uv+1028]&15)];
  1038.       *dst2++ = ytab[((y2+14)<<4)|(uvtab[uv+3072]>>4)];
  1040.       y2 = *py2++;
  1041.       uv = (*pu++<<8)|*pv++;
  1042.       *dst++  = ytab[((((*py++ + y2)>>1)+10)<<4)|(uvtab[uv+1028]>>4)];
  1043.       *dst2++ = ytab[((y2+6)<<4)|(uvtab[uv+3072]&15)];
  1044.     }
  1046.     if (j==0)
  1047.       py -= coded_picture_width;
  1048.     else
  1049.       py += coded_picture_width;
  1051.     py2 += coded_picture_width;
  1052.     dst += coded_picture_width;
  1053.     dst2 += coded_picture_width;
  1055.     pu += chrom_width;
  1056.     pv += chrom_width;
  1058.     /* line j + 2, j + 3 */
  1059.     for (i=0; i<coded_picture_width; i+=4){
  1060.       y2 = *py2++;
  1061.       uv = (*pu++<<8)|*pv++;
  1062.       *dst++  = ytab[((((*py++ + y2)>>1)+3)<<4)|(uvtab[uv+1542]&15)];
  1063.       *dst2++ = ytab[((y2+15)<<4)|(uvtab[uv+3598]>>4)];
  1065.       y2 = *py2++;
  1066.       uv = (*pu++<<8)|*pv++;
  1067.       *dst++  = ytab[((((*py++ + y2)>>1)+11)<<4)|(uvtab[uv+1542]>>4)];
  1068.       *dst2++ = ytab[((y2+7)<<4)|(uvtab[uv+3598]&15)];
  1070.       y2 = *py2++;
  1071.       uv = (*pu++<<8)|*pv++;
  1072.       *dst++  = ytab[((((*py++ + y2)>>1)+1)<<4)|(uvtab[uv+514]&15)];
  1073.       *dst2++ = ytab[((y2+13)<<4)|(uvtab[uv+2570]>>4)];
  1075.       y2 = *py2++;
  1076.       uv = (*pu++<<8)|*pv++;
  1077.       *dst++  = ytab[((((*py++ + y2)>>1)+9)<<4)|(uvtab[uv+514]>>4)];
  1078.       *dst2++ = ytab[((y2+5)<<4)|(uvtab[uv+2570]&15)];
  1079.     }
  1081.     py += coded_picture_width;
  1082.     py2 += coded_picture_width;
  1083.     dst += coded_picture_width;
  1084.     dst2 += coded_picture_width;
  1085.     pu += chrom_width;
  1086.     pv += chrom_width;
  1087.   }
  1088. }
  1090. #ifdef SOLARIS_SDK_XIL
  1092. int DisplayX11::resize(){
  1093.   TRACER("int DisplayX11::resize()");
  1094.   Window root;
  1095.   int x, y;
  1096.   unsigned int w, h, b, d;
  1097.   XGetGeometry(display, window, &root, &x, &y, &w, &h, &b, &d);
  1099.   // indicate resize
  1100.   resized=1;
  1101.   horizontal_factor=((float) w)/horizontal_size;
  1102.   vertical_factor=((float) h)/vertical_size;
  1104.   // to avoid new events for the time being
  1105.   XSelectInput(display, window, NoEventMask);
  1106.   
  1107.   // Create new image with new geometry
  1108.   xil_destroy(displayimage);
  1109.   displayimage=xil_create_from_window(State, display, window);
  1110.   xil_destroy(resized_image);
  1111.   resized_image=xil_create(State, w, h, bands, XIL_BYTE);
  1112. /*
  1113.   if (bands==3){
  1114.     XilColorspace cspace=xil_colorspace_get_by_name(State, "ycc601");
  1115.     xil_set_colorspace(resized_image, cspace);
  1116.     cspace=xil_colorspace_get_by_name(State, "rgb709");
  1117.     xil_set_colorspace(displayimage, cspace);
  1118.   }
  1119. */
  1121.   XSelectInput(display, window, StructureNotifyMask);
  1122.   return 1;
  1123. }
  1125. #endif // SOLARIS_SDK_XIL