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

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

DVD

开发平台：

Unix_Linux

display_x11.c：源码内容
  1. /* 
  2.  * display_x11.c, X11 interface                                               
  3.  *
  4.  *
  5.  * Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. 
  6.  *
  7.  * Hacked into mpeg2dec by
  8.  * 
  9.  * Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
  10.  *
  11.  * 15 & 16 bpp support added by Franck Sicard <Franck.Sicard@solsoft.fr>
  12.  */
  14. #include <stdio.h>
  15. #include <stdlib.h>
  17. #include <X11/Xlib.h>
  18. #include <X11/Xutil.h>
  19. #include <X11/extensions/XShm.h>
  20. #include <string.h>
  21. #include <errno.h>
  23. #include "mpeg2.h"
  24. #include "mpeg2_internal.h"
  26. int Inverse_Table_6_9[8][4] =
  27. {
  28.   {117504, 138453, 13954, 34903}, /* no sequence_display_extension */
  29.   {117504, 138453, 13954, 34903}, /* ITU-R Rec. 709 (1990) */
  30.   {104597, 132201, 25675, 53279}, /* unspecified */
  31.   {104597, 132201, 25675, 53279}, /* reserved */
  32.   {104448, 132798, 24759, 53109}, /* FCC */
  33.   {104597, 132201, 25675, 53279}, /* ITU-R Rec. 624-4 System B, G */
  34.   {104597, 132201, 25675, 53279}, /* SMPTE 170M */
  35.   {117579, 136230, 16907, 35559}  /* SMPTE 240M (1987) */
  36. };
  39. /* private prototypes */
  40. static void Display_Image (XImage * myximage, unsigned char *ImageData);
  42. /* local data */
  43. static unsigned char *ImageData;
  45. /* X11 related variables */
  46. static Display *mydisplay;
  47. static Window mywindow;
  48. static GC mygc;
  49. static XImage *myximage;
  50. static int bpp;
  51. static XWindowAttributes attribs;
  52. static int X_already_started = 0;
  55. #define SH_MEM
  57. #ifdef SH_MEM
  59. #include <sys/ipc.h>
  60. #include <sys/shm.h>
  61. #include <X11/extensions/XShm.h>
  63. //static int HandleXError _ANSI_ARGS_((Display * dpy, XErrorEvent * event));
  64. static void InstallXErrorHandler (void);
  65. static void DeInstallXErrorHandler (void);
  67. static int Shmem_Flag;
  68. static int Quiet_Flag;
  69. static XShmSegmentInfo Shminfo1;
  70. static int gXErrorFlag;
  71. static int CompletionType = -1;
  73. /*
  74. static int HandleXfprintf(stderr,Dpy, Event)
  75. Display *Dpy;
  76. XErrorEvent *Event;
  77. {
  78.     gXErrorFlag = 1;
  80.     return 0;
  81. }
  82. */
  84. static void InstallXErrorHandler()
  85. {
  86.     //XSetErrorHandler(HandleXError);
  87.     XFlush(mydisplay);
  88. }
  90. static void DeInstallXErrorHandler()
  91. {
  92.     XSetErrorHandler(NULL);
  93.     XFlush(mydisplay);
  94. }
  96. #endif
  98. // Clamp to [0,255]
  99. static uint_8 clip_tbl[1024]; /* clipping table */
  100. static uint_8 *clip;
  102. uint_32 image_width;
  103. uint_32 image_height;
  104. uint_32 progressive_sequence = 0;
  105. uint_32 matrix_coefficients = 1;
  107. /* connect to server, create and map window,
  108.  * allocate colors and (shared) memory
  109.  */
  110. void display_init(uint_32 width, uint_32 height)
  111. {
  112.    int screen;
  113.    unsigned int fg, bg;
  114.    sint_32 i;
  115.    char *hello = "I hate X11";
  116.    char *name = ":0.0";
  117.    XSizeHints hint;
  118.    XVisualInfo vinfo;
  119.    XEvent xev;
  121.    XGCValues xgcv;
  122.    Colormap theCmap;
  123.    XSetWindowAttributes xswa;
  124.    unsigned long xswamask;
  126.    clip = clip_tbl + 384;
  128.    for (i= -384; i< 640; i++)
  129.       clip[i] = (i < 0) ? 0 : ((i > 255) ? 255 : i);
  130.                 
  131.    image_height = height;
  132.    image_width = width;
  134.    if (X_already_started)
  135.       return;
  137.    if(getenv("DISPLAY"))
  138.       name = getenv("DISPLAY");
  139.    mydisplay = XOpenDisplay(name);
  141.    if (mydisplay == NULL)
  142.       fprintf(stderr,"Can not open displayn");
  144.    screen = DefaultScreen(mydisplay);
  146.    hint.x = 0;
  147.    hint.y = 10;
  148.    hint.width = image_width;
  149.    hint.height = image_height;
  150.    hint.flags = PPosition | PSize;
  152.    /* Get some colors */
  154.    bg = WhitePixel(mydisplay, screen);
  155.    fg = BlackPixel(mydisplay, screen);
  157.    /* Make the window */
  159.    XGetWindowAttributes(mydisplay, DefaultRootWindow(mydisplay), &attribs);
  160.    bpp = attribs.depth;
  161.    if (bpp != 15 && bpp != 16 && bpp != 24 && bpp != 32) {
  162.       fprintf(stderr,"Only 15,16,24, and 32bpp supported. Trying 24bpp!n");
  163.       bpp = 24;
  164.    }
  165.    //BEGIN HACK
  166.    //mywindow = XCreateSimpleWindow(mydisplay, DefaultRootWindow(mydisplay),
  167.    //hint.x, hint.y, hint.width, hint.height, 4, fg, bg);
  168.    //
  169.    XMatchVisualInfo(mydisplay,screen,bpp,TrueColor,&vinfo);
  170.    printf("visual id is  %lxn",vinfo.visualid);
  172.    theCmap   = XCreateColormap(mydisplay, RootWindow(mydisplay,screen), 
  173.                                vinfo.visual, AllocNone);
  175.    xswa.background_pixel = 0;
  176.    xswa.border_pixel     = 1;
  177.    xswa.colormap         = theCmap;
  178.    xswamask = CWBackPixel | CWBorderPixel |CWColormap;
  181.    mywindow = XCreateWindow(mydisplay, RootWindow(mydisplay,screen),
  182.                             hint.x, hint.y, hint.width, hint.height, 4, bpp,CopyFromParent,vinfo.visual,xswamask,&xswa);
  184.    XSelectInput(mydisplay, mywindow, StructureNotifyMask);
  186.    /* Tell other applications about this window */
  188.    XSetStandardProperties(mydisplay, mywindow, hello, hello, None, NULL, 0, &hint);
  190.    /* Map window. */
  192.    XMapWindow(mydisplay, mywindow);
  194.    /* Wait for map. */
  195.    do {
  196.       XNextEvent(mydisplay, &xev);
  197.    }
  198.    while (xev.type != MapNotify || xev.xmap.event != mywindow);
  200.    XSelectInput(mydisplay, mywindow, NoEventMask);
  202.    XFlush(mydisplay);
  203.    XSync(mydisplay, False);
  204.     
  205.    mygc = XCreateGC(mydisplay, mywindow, 0L, &xgcv);
  206.     
  209. #ifdef SH_MEM
  210.    if (XShmQueryExtension(mydisplay))
  211.       Shmem_Flag = 1;
  212.    else 
  213.    {
  214.       Shmem_Flag = 0;
  215.       if (!Quiet_Flag)
  216.          fprintf(stderr, "Shared memory not supportednReverting to normal Xlibn");
  217.    }
  219.    if (Shmem_Flag)
  220.       CompletionType = XShmGetEventBase(mydisplay) + ShmCompletion;
  222.    InstallXErrorHandler();
  224.    if (Shmem_Flag) {
  225.       myximage = XShmCreateImage(mydisplay, vinfo.visual, bpp, 
  226.                                  ZPixmap, NULL, &Shminfo1, width, 
  227.                                  image_height);
  229.       /* If no go, then revert to normal Xlib calls. */
  231.       if (myximage == NULL ) 
  232.       {
  233.          if (myximage != NULL)
  234.             XDestroyImage(myximage);
  235.          if (!Quiet_Flag)
  236.             fprintf(stderr, "Shared memory error, disabling (Ximage error)n");
  237.          goto shmemerror;
  238.       }
  239.       /* Success here, continue. */
  241.       Shminfo1.shmid = shmget(IPC_PRIVATE, 
  242.                               myximage->bytes_per_line * myximage->height ,
  243.                               IPC_CREAT | 0777);
  244.       if (Shminfo1.shmid < 0 ) {
  245.          XDestroyImage(myximage);
  246.          if (!Quiet_Flag)
  247.          {
  248.             printf("%sn",strerror(errno));
  249.             perror(strerror(errno));
  250.             fprintf(stderr, "Shared memory error, disabling (seg id error)n");
  251.          }
  252.          goto shmemerror;
  253.       }
  254.       Shminfo1.shmaddr = (char *) shmat(Shminfo1.shmid, 0, 0);
  255.       
  256.       if (Shminfo1.shmaddr == ((char *) -1)) {
  257.          XDestroyImage(myximage);
  258.          if (Shminfo1.shmaddr != ((char *) -1))
  259.             shmdt(Shminfo1.shmaddr);
  260.          if (!Quiet_Flag) {
  261.             fprintf(stderr, "Shared memory error, disabling (address error)n");
  262.          }
  263.          goto shmemerror;
  264.       }
  265.       myximage->data = Shminfo1.shmaddr;
  266.       ImageData = (unsigned char *) myximage->data;
  267.       Shminfo1.readOnly = False;
  268.       XShmAttach(mydisplay, &Shminfo1);
  269.       
  270.       XSync(mydisplay, False);
  272.       if (gXErrorFlag) {
  273.          /* Ultimate failure here. */
  274.          XDestroyImage(myximage);
  275.          shmdt(Shminfo1.shmaddr);
  276.          if (!Quiet_Flag)
  277.             fprintf(stderr, "Shared memory error, disabling.n");
  278.          gXErrorFlag = 0;
  279.          goto shmemerror;
  280.       } else {
  281.          shmctl(Shminfo1.shmid, IPC_RMID, 0);
  282.       }
  284.       if (!Quiet_Flag) {
  285.          fprintf(stderr, "Sharing memory.n");
  286.       }
  287.    } else {
  288.  shmemerror:
  289.       Shmem_Flag = 0;
  290. #endif
  291.       myximage = XGetImage(mydisplay, mywindow, 0, 0,
  292.                            width, image_height, AllPlanes, ZPixmap);
  293.       ImageData = myximage->data;
  295. #ifdef SH_MEM
  296.    }
  298.    DeInstallXErrorHandler();
  299. #endif
  300.    X_already_started++;
  301.  bpp = myximage->bits_per_pixel;
  302. }
  304. void Terminate_Display_Process() {
  305.    getchar(); /* wait for enter to remove window */
  306. #ifdef SH_MEM
  307.     if (Shmem_Flag) {
  308. XShmDetach(mydisplay, &Shminfo1);
  309. XDestroyImage(myximage);
  310. shmdt(Shminfo1.shmaddr);
  311.     }
  312. #endif
  313.     XDestroyWindow(mydisplay, mywindow);
  314.     XCloseDisplay(mydisplay);
  315.     X_already_started = 0;
  316. }
  318. static void Display_Image(myximage, ImageData)
  319. XImage *myximage;
  320. unsigned char *ImageData;
  321. {
  322. #ifdef SH_MEM
  323.     if (Shmem_Flag) {
  324. XShmPutImage(mydisplay, mywindow, mygc, myximage,
  325. 0, 0, 0, 0, myximage->width, myximage->height, True);
  326. XFlush(mydisplay);
  328. #if 0
  329. //I don't know why this code is here, but it craashes
  330. //when I don't compile with -pg. Very odd.
  331. while (1) {
  332.     XEvent xev;
  334.     XNextEvent(mydisplay, &xev);
  335.     if (xev.type == CompletionType)
  336. break;
  337. }
  338. #endif
  339.     } else
  341. #endif
  342. XPutImage(mydisplay, mywindow, mygc, myximage, 0, 0,
  343. 0, 0, myximage->width, myximage->height);
  344. }
  346. void Display_First_Field(void) { /* nothing */ }
  347. void Display_Second_Field(void) { /* nothing */ }
  349. unsigned char *dst, *py, *pu, *pv;
  351. static void display_frame_32bpp_420(const uint_8 * py, const uint_8 * pv,
  352.                                     const uint_8 * pu, uint_8 * image,
  353.                                     int h_size, int v_size, int bpp);
  354. static void display_frame_24bpp_420(const uint_8 * py, const uint_8 * pv,
  355.                                     const uint_8 * pu, uint_8 * image,
  356.                                     int h_size, int v_size, int bpp);
  357. static void display_frame_16bpp_420(const uint_8 * py, const uint_8 * pv,
  358.                                     const uint_8 * pu, uint_8 * image,
  359.                                     int h_size, int v_size, int bpp);
  360. void display_frame(uint_8 *src[])
  361. {
  362.    if (bpp==32) 
  363.  {
  364.       display_frame_32bpp_420(src[0],src[1],src[2],ImageData, 
  365. image_width, image_height, bpp);
  366.    } 
  367.  else if (bpp==24) 
  368.  {
  369.       display_frame_24bpp_420(src[0],src[1],src[2],ImageData, 
  370. image_width, image_height, bpp);
  371.    } 
  372.  else if (bpp == 15 || bpp == 16) 
  373.  {
  374.       display_frame_16bpp_420(src[0],src[1],src[2],ImageData, 
  375. image_width, image_height, bpp);
  376.    }
  377.    Display_Image(myximage, ImageData);
  378. }
  380. /* do 32 bpp output */
  381. static void display_frame_32bpp_420(const uint_8 * py, const uint_8 * pv, 
  382. const uint_8 * pu, uint_8 * image, int h_size, int v_size, int bpp)
  383. {
  384. sint_32 Y,U,V;
  385. sint_32 g_common,b_common,r_common;
  386. uint_32 x,y;
  388. uint_8 *dst_line_1;
  389. uint_8 *dst_line_2;
  390. const uint_8* py_line_1;
  391. const uint_8* py_line_2;
  392. volatile char prefetch;
  394. int byte_per_line=h_size*(bpp/8);
  396. int crv,cbu,cgu,cgv;
  398. /* matrix coefficients */
  399. crv = Inverse_Table_6_9[matrix_coefficients][0];
  400. cbu = Inverse_Table_6_9[matrix_coefficients][1];
  401. cgu = Inverse_Table_6_9[matrix_coefficients][2];
  402. cgv = Inverse_Table_6_9[matrix_coefficients][3];
  405. dst_line_1 = dst_line_2 =  image;
  406. dst_line_2 = dst_line_1 + byte_per_line;
  408. py_line_1 = py;
  409. py_line_2 = py + h_size;
  411. for (y = 0; y < v_size / 2; y++) 
  412. {
  413. for (x = 0; x < h_size / 2; x++) 
  414. {
  416. //Common to all four pixels
  417. prefetch = pu[32];
  418. U = (*pu++) - 128;
  419. prefetch = pv[32];
  420. V = (*pv++) - 128;
  422. g_common = cgu * U + cgv * V - 32768;
  423. b_common = cbu * U + 32768;
  424. r_common = crv * V;
  426. //Pixel I
  427. prefetch = py_line_1[32];
  428. Y = 76309 * ((*py_line_1++) - 16);
  429. *dst_line_1++ = clip[(Y+r_common)>>16];
  430. *dst_line_1++ = clip[(Y-g_common)>>16];
  431. *dst_line_1++ = clip[(Y+b_common)>>16];
  432. dst_line_1++;
  434. //Pixel II
  435. Y = 76309 * ((*py_line_1++) - 16);
  437. *dst_line_1++ = clip[(Y+r_common)>>16];
  438. *dst_line_1++ = clip[(Y-g_common)>>16];
  439. *dst_line_1++ = clip[(Y+b_common)>>16];
  440. dst_line_1++;
  442. //Pixel III
  443. prefetch = py_line_2[32];
  444. Y = 76309 * ((*py_line_2++) - 16);
  446. *dst_line_2++ = clip[(Y+r_common)>>16];
  447. *dst_line_2++ = clip[(Y-g_common)>>16];
  448. *dst_line_2++ = clip[(Y+b_common)>>16];
  449. dst_line_2++;
  451. //Pixel IV
  452. Y = 76309 * ((*py_line_2++) - 16);
  454. *dst_line_2++ = clip[(Y+r_common)>>16];
  455. *dst_line_2++ = clip[(Y-g_common)>>16];
  456. *dst_line_2++ = clip[(Y+b_common)>>16];
  457. dst_line_2++;
  458. }
  460. py_line_1 += h_size;
  461. py_line_2 += h_size;
  462. dst_line_1 += byte_per_line;
  463. dst_line_2 += byte_per_line;
  464. }
  465. }
  467. /* do 24 bpp output */
  468. static void display_frame_24bpp_420(const uint_8 * py, const uint_8 * pv, 
  469. const uint_8 * pu, uint_8 * image, int h_size, int v_size, int bpp)
  470. {
  471. sint_32 Y,U,V;
  472. sint_32 g_common,b_common,r_common;
  473. uint_32 x,y;
  475. uint_8 *dst_line_1;
  476. uint_8 *dst_line_2;
  477. const uint_8* py_line_1;
  478. const uint_8* py_line_2;
  479. volatile char prefetch;
  481. int byte_per_line=h_size*(bpp/8);
  483. int crv,cbu,cgu,cgv;
  485. /* matrix coefficients */
  486. crv = Inverse_Table_6_9[matrix_coefficients][0];
  487. cbu = Inverse_Table_6_9[matrix_coefficients][1];
  488. cgu = Inverse_Table_6_9[matrix_coefficients][2];
  489. cgv = Inverse_Table_6_9[matrix_coefficients][3];
  492. dst_line_1 = dst_line_2 =  image;
  493. dst_line_2 = dst_line_1 + byte_per_line;
  495. py_line_1 = py;
  496. py_line_2 = py + h_size;
  498. for (y = 0; y < v_size / 2; y++) 
  499. {
  500. for (x = 0; x < h_size / 2; x++) 
  501. {
  503. //Common to all four pixels
  504. prefetch = pu[32];
  505. U = (*pu++) - 128;
  506. prefetch = pv[32];
  507. V = (*pv++) - 128;
  509. g_common = cgu * U + cgv * V - 32768;
  510. b_common = cbu * U + 32768;
  511. r_common = crv * V;
  513. //Pixel I
  514. prefetch = py_line_1[32];
  515. Y = 76309 * ((*py_line_1++) - 16);
  516. *dst_line_1++ = clip[(Y+r_common)>>16];
  517. *dst_line_1++ = clip[(Y-g_common)>>16];
  518. *dst_line_1++ = clip[(Y+b_common)>>16];
  519. if (bpp==32)
  520. {
  521. dst_line_1++;
  522. }
  524. //Pixel II
  525. Y = 76309 * ((*py_line_1++) - 16);
  527. *dst_line_1++ = clip[(Y+r_common)>>16];
  528. *dst_line_1++ = clip[(Y-g_common)>>16];
  529. *dst_line_1++ = clip[(Y+b_common)>>16];
  530. if (bpp==32)
  531. {
  532. dst_line_1++;
  533. }
  535. //Pixel III
  536. prefetch = py_line_2[32];
  537. Y = 76309 * ((*py_line_2++) - 16);
  539. *dst_line_2++ = clip[(Y+r_common)>>16];
  540. *dst_line_2++ = clip[(Y-g_common)>>16];
  541. *dst_line_2++ = clip[(Y+b_common)>>16];
  542. if (bpp==32)
  543. {
  544. dst_line_1++;
  545. }
  547. //Pixel IV
  548. Y = 76309 * ((*py_line_2++) - 16);
  550. *dst_line_2++ = clip[(Y+r_common)>>16];
  551. *dst_line_2++ = clip[(Y-g_common)>>16];
  552. *dst_line_2++ = clip[(Y+b_common)>>16];
  553. if (bpp==32)
  554. {
  555. dst_line_1++;
  556. }
  557. }
  559. py_line_1 += h_size;
  560. py_line_2 += h_size;
  561. dst_line_1 += byte_per_line;
  562. dst_line_2 += byte_per_line;
  563. }
  564. }
  566. /* do 16 and 15 bpp output */
  567. static void display_frame_16bpp_420(const uint_8 * py, const uint_8 * pv, 
  568. const uint_8 * pu, uint_8 * image, int h_size, int v_size, int bpp)
  569. {
  570. uint_32 U,V;
  571. uint_32 pixel_idx;
  572. uint_32 x,y;
  574. uint_16 *dst_line_1;
  575. uint_16 *dst_line_2;
  576. const uint_8* py_line_1;
  577. const uint_8* py_line_2;
  578. uint_8  r,v,b;
  580. static uint_16 * lookUpTable=NULL;
  582. int i,j,k;
  584. //not sure if this is a win using the LUT. Can someone try
  585. //the direct calculation (like in the 32bpp) and compare?
  586. if (lookUpTable==NULL) 
  587. {
  588. lookUpTable=malloc((1<<18)*sizeof(uint_16));
  590. for (i=0;i<(1<<6);++i) 
  591. { /* Y */
  592. int Y=i<<2;
  594. for(j=0;j<(1<<6);++j) 
  595. { /* Cr */
  596. int Cb=j<<2;
  598. for(k=0;k<(1<<6);k++) 
  599. { /* Cb */
  600. int Cr=k<<2;
  602. /*
  603. R = clp[(int)(*Y + 1.371*(*Cr-128))];  
  604. V = clp[(int)(*Y - 0.698*(*Cr-128) - 0.336*(*Cr-128))]; 
  605. B = clp[(int)(*Y++ + 1.732*(*Cb-128))];
  606. */
  607. r=clip[(Y*1000 + 1371*(Cr-128))/1000] >>3;
  608. v=clip[(Y*1000 - 698*(Cr-128) - 336*(Cr-128))/1000] >> (bpp==16?2:3);
  609. b=clip[(Y*1000 + 1732*(Cb-128))/1000] >> 3;
  610. lookUpTable[i|(j<<6)|(k<<12)] = r | (v << 5) | (b <<  (bpp==16?11:10));
  611. }
  612. }
  613. }
  614. }
  616. dst_line_1 = dst_line_2 =  (uint_16*) image;
  617. dst_line_2 = dst_line_1 + h_size;
  619. py_line_1 = py;
  620. py_line_2 = py + h_size;
  622. for (y = 0; y < v_size / 2; y++) 
  623. {
  624. for (x = 0; x < h_size / 2; x++) 
  625. {
  626. //Common to all four pixels
  627. U = (*pu++)>>2;
  628. V = (*pv++)>>2;
  629. pixel_idx=U<<6|V<<12;
  631. //Pixel I
  632. *dst_line_1++=lookUpTable[(*py_line_1++)>>2|pixel_idx];
  634. //Pixel II
  635. *dst_line_1++=lookUpTable[(*py_line_1++)>>2|pixel_idx];
  637. //Pixel III
  638. *dst_line_2++=lookUpTable[(*py_line_2++)>>2|pixel_idx];
  640. //Pixel IV
  641. *dst_line_2++=lookUpTable[(*py_line_2++)>>2|pixel_idx];
  642. }
  643. py_line_1 += h_size;
  644. py_line_2 += h_size;
  645. dst_line_1 += h_size;
  646. dst_line_2 += h_size;
  647. }
  648. }