Xext/xvmc.c

   1
   2 #include <dix-config.h>
   3
   4 #include <string.h>
   5 #include <X11/X.h>
   6 #include <X11/Xproto.h>
   7
   8 #include "Xext/xvdix_priv.h"
   9
  10 #include "misc.h"
  11 #include "os.h"
  12 #include "dixstruct.h"
  13 #include "resource.h"
  14 #include "scrnintstr.h"
  15 #include "extnsionst.h"
  16 #include "extinit_priv.h"
  17 #include "servermd.h"
  18 #include <X11/Xfuncproto.h>
  19 #include <X11/extensions/XvMC.h>
  20 #include <X11/extensions/Xvproto.h>
  21 #include <X11/extensions/XvMCproto.h>
  22 #include "xvmcext.h"
  23
  24 #ifdef HAS_XVMCSHM
  25 #include <sys/ipc.h>
  26 #include <sys/types.h>
  27 #include <sys/shm.h>
  28 #endif                          /* HAS_XVMCSHM */
  29
  30 #define SERVER_XVMC_MAJOR_VERSION               1
  31 #define SERVER_XVMC_MINOR_VERSION               1
  32
  33 #define DR_CLIENT_DRIVER_NAME_SIZE 48
  34 #define DR_BUSID_SIZE 48
  35
  36 static DevPrivateKeyRec XvMCScreenKeyRec;
  37
  38 #define XvMCScreenKey (&XvMCScreenKeyRec)
  39 static Bool XvMCInUse;
  40
  41 int XvMCReqCode;
  42 int XvMCEventBase;
  43
  44 static RESTYPE XvMCRTContext;
  45 static RESTYPE XvMCRTSurface;
  46 static RESTYPE XvMCRTSubpicture;
  47
  48 typedef struct {
  49     int num_adaptors;
  50     XvMCAdaptorPtr adaptors;
  51     CloseScreenProcPtr CloseScreen;
  52     char clientDriverName[DR_CLIENT_DRIVER_NAME_SIZE];
  53     char busID[DR_BUSID_SIZE];
  54     int major;
  55     int minor;
  56     int patchLevel;
  57 } XvMCScreenRec, *XvMCScreenPtr;
  58
  59 #define XVMC_GET_PRIVATE(pScreen) \
  60     (XvMCScreenPtr)(dixLookupPrivate(&(pScreen)->devPrivates, XvMCScreenKey))
  61
  62 static int
  63 XvMCDestroyContextRes(void *data, XID id)
  64 {
  65     XvMCContextPtr pContext = (XvMCContextPtr) data;
  66
  67     pContext->refcnt--;
  68
  69     if (!pContext->refcnt) {
  70         XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
  71
  72         (*pScreenPriv->adaptors[pContext->adapt_num].DestroyContext) (pContext);
  73         free(pContext);
  74     }
  75
  76     return Success;
  77 }
  78
  79 static int
  80 XvMCDestroySurfaceRes(void *data, XID id)
  81 {
  82     XvMCSurfacePtr pSurface = (XvMCSurfacePtr) data;
  83     XvMCContextPtr pContext = pSurface->context;
  84     XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
  85
  86     (*pScreenPriv->adaptors[pContext->adapt_num].DestroySurface) (pSurface);
  87     free(pSurface);
  88
  89     XvMCDestroyContextRes((void *) pContext, pContext->context_id);
  90
  91     return Success;
  92 }
  93
  94 static int
  95 XvMCDestroySubpictureRes(void *data, XID id)
  96 {
  97     XvMCSubpicturePtr pSubpict = (XvMCSubpicturePtr) data;
  98     XvMCContextPtr pContext = pSubpict->context;
  99     XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
 100
 101     (*pScreenPriv->adaptors[pContext->adapt_num].DestroySubpicture) (pSubpict);
 102     free(pSubpict);
 103
 104     XvMCDestroyContextRes((void *) pContext, pContext->context_id);
 105
 106     return Success;
 107 }
 108
 109 static int
 110 ProcXvMCQueryVersion(ClientPtr client)
 111 {
 112     xvmcQueryVersionReply rep = {
 113         .type = X_Reply,
 114         .sequenceNumber = client->sequence,
 115         .length = 0,
 116         .major = SERVER_XVMC_MAJOR_VERSION,
 117         .minor = SERVER_XVMC_MINOR_VERSION
 118     };
 119
 120     /* REQUEST(xvmcQueryVersionReq); */
 121     REQUEST_SIZE_MATCH(xvmcQueryVersionReq);
 122
 123     WriteToClient(client, sizeof(xvmcQueryVersionReply), &rep);
 124     return Success;
 125 }
 126
 127 static int
 128 ProcXvMCListSurfaceTypes(ClientPtr client)
 129 {
 130     XvPortPtr pPort;
 131     int i;
 132     XvMCScreenPtr pScreenPriv;
 133     xvmcListSurfaceTypesReply rep;
 134     xvmcSurfaceInfo info;
 135     XvMCAdaptorPtr adaptor = NULL;
 136     XvMCSurfaceInfoPtr surface;
 137     int num_surfaces;
 138
 139     REQUEST(xvmcListSurfaceTypesReq);
 140     REQUEST_SIZE_MATCH(xvmcListSurfaceTypesReq);
 141
 142     VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
 143
 144     if (XvMCInUse) {            /* any adaptors at all */
 145         ScreenPtr pScreen = pPort->pAdaptor->pScreen;
 146
 147         if ((pScreenPriv = XVMC_GET_PRIVATE(pScreen))) {        /* any this screen */
 148             for (i = 0; i < pScreenPriv->num_adaptors; i++) {
 149                 if (pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
 150                     adaptor = &(pScreenPriv->adaptors[i]);
 151                     break;
 152                 }
 153             }
 154         }
 155     }
 156
 157     num_surfaces = (adaptor) ? adaptor->num_surfaces : 0;
 158     rep = (xvmcListSurfaceTypesReply) {
 159         .type = X_Reply,
 160         .sequenceNumber = client->sequence,
 161         .num = num_surfaces,
 162         .length = bytes_to_int32(num_surfaces * sizeof(xvmcSurfaceInfo)),
 163     };
 164
 165     WriteToClient(client, sizeof(xvmcListSurfaceTypesReply), &rep);
 166
 167     for (i = 0; i < num_surfaces; i++) {
 168         surface = adaptor->surfaces[i];
 169         info.surface_type_id = surface->surface_type_id;
 170         info.chroma_format = surface->chroma_format;
 171         info.max_width = surface->max_width;
 172         info.max_height = surface->max_height;
 173         info.subpicture_max_width = surface->subpicture_max_width;
 174         info.subpicture_max_height = surface->subpicture_max_height;
 175         info.mc_type = surface->mc_type;
 176         info.flags = surface->flags;
 177         WriteToClient(client, sizeof(xvmcSurfaceInfo), &info);
 178     }
 179
 180     return Success;
 181 }
 182
 183 static int
 184 ProcXvMCCreateContext(ClientPtr client)
 185 {
 186     XvPortPtr pPort;
 187     CARD32 *data = NULL;
 188     int dwords = 0;
 189     int i, result, adapt_num = -1;
 190     ScreenPtr pScreen;
 191     XvMCContextPtr pContext;
 192     XvMCScreenPtr pScreenPriv;
 193     XvMCAdaptorPtr adaptor = NULL;
 194     XvMCSurfaceInfoPtr surface = NULL;
 195     xvmcCreateContextReply rep;
 196
 197     REQUEST(xvmcCreateContextReq);
 198     REQUEST_SIZE_MATCH(xvmcCreateContextReq);
 199
 200     VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
 201
 202     pScreen = pPort->pAdaptor->pScreen;
 203
 204     if (!XvMCInUse)             /* no XvMC adaptors */
 205         return BadMatch;
 206
 207     if (!(pScreenPriv = XVMC_GET_PRIVATE(pScreen)))     /* none this screen */
 208         return BadMatch;
 209
 210     for (i = 0; i < pScreenPriv->num_adaptors; i++) {
 211         if (pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
 212             adaptor = &(pScreenPriv->adaptors[i]);
 213             adapt_num = i;
 214             break;
 215         }
 216     }
 217
 218     if (adapt_num < 0)          /* none this port */
 219         return BadMatch;
 220
 221     for (i = 0; i < adaptor->num_surfaces; i++) {
 222         if (adaptor->surfaces[i]->surface_type_id == stuff->surface_type_id) {
 223             surface = adaptor->surfaces[i];
 224             break;
 225         }
 226     }
 227
 228     /* adaptor doesn't support this suface_type_id */
 229     if (!surface)
 230         return BadMatch;
 231
 232     if ((stuff->width > surface->max_width) ||
 233         (stuff->height > surface->max_height))
 234         return BadValue;
 235
 236     if (!(pContext = malloc(sizeof(XvMCContextRec)))) {
 237         return BadAlloc;
 238     }
 239
 240     pContext->pScreen = pScreen;
 241     pContext->adapt_num = adapt_num;
 242     pContext->context_id = stuff->context_id;
 243     pContext->surface_type_id = stuff->surface_type_id;
 244     pContext->width = stuff->width;
 245     pContext->height = stuff->height;
 246     pContext->flags = stuff->flags;
 247     pContext->refcnt = 1;
 248
 249     result = (*adaptor->CreateContext) (pPort, pContext, &dwords, &data);
 250
 251     if (result != Success) {
 252         free(pContext);
 253         return result;
 254     }
 255     if (!AddResource(pContext->context_id, XvMCRTContext, pContext)) {
 256         free(data);
 257         return BadAlloc;
 258     }
 259
 260     rep = (xvmcCreateContextReply) {
 261         .type = X_Reply,
 262         .sequenceNumber = client->sequence,
 263         .length = dwords,
 264         .width_actual = pContext->width,
 265         .height_actual = pContext->height,
 266         .flags_return = pContext->flags
 267     };
 268
 269     WriteToClient(client, sizeof(xvmcCreateContextReply), &rep);
 270     if (dwords)
 271         WriteToClient(client, dwords << 2, data);
 272
 273     free(data);
 274
 275     return Success;
 276 }
 277
 278 static int
 279 ProcXvMCDestroyContext(ClientPtr client)
 280 {
 281     void *val;
 282     int rc;
 283
 284     REQUEST(xvmcDestroyContextReq);
 285     REQUEST_SIZE_MATCH(xvmcDestroyContextReq);
 286
 287     rc = dixLookupResourceByType(&val, stuff->context_id, XvMCRTContext,
 288                                  client, DixDestroyAccess);
 289     if (rc != Success)
 290         return rc;
 291
 292     FreeResource(stuff->context_id, X11_RESTYPE_NONE);
 293
 294     return Success;
 295 }
 296
 297 static int
 298 ProcXvMCCreateSurface(ClientPtr client)
 299 {
 300     CARD32 *data = NULL;
 301     int dwords = 0;
 302     int result;
 303     XvMCContextPtr pContext;
 304     XvMCSurfacePtr pSurface;
 305     XvMCScreenPtr pScreenPriv;
 306     xvmcCreateSurfaceReply rep;
 307
 308     REQUEST(xvmcCreateSurfaceReq);
 309     REQUEST_SIZE_MATCH(xvmcCreateSurfaceReq);
 310
 311     result = dixLookupResourceByType((void **) &pContext, stuff->context_id,
 312                                      XvMCRTContext, client, DixUseAccess);
 313     if (result != Success)
 314         return result;
 315
 316     pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
 317
 318     if (!(pSurface = malloc(sizeof(XvMCSurfaceRec))))
 319         return BadAlloc;
 320
 321     pSurface->surface_id = stuff->surface_id;
 322     pSurface->surface_type_id = pContext->surface_type_id;
 323     pSurface->context = pContext;
 324
 325     result =
 326         (*pScreenPriv->adaptors[pContext->adapt_num].CreateSurface) (pSurface,
 327                                                                      &dwords,
 328                                                                      &data);
 329
 330     if (result != Success) {
 331         free(pSurface);
 332         return result;
 333     }
 334     if (!AddResource(pSurface->surface_id, XvMCRTSurface, pSurface)) {
 335         free(data);
 336         return BadAlloc;
 337     }
 338
 339     rep = (xvmcCreateSurfaceReply) {
 340         .type = X_Reply,
 341         .sequenceNumber = client->sequence,
 342         .length = dwords
 343     };
 344
 345     WriteToClient(client, sizeof(xvmcCreateSurfaceReply), &rep);
 346     if (dwords)
 347         WriteToClient(client, dwords << 2, data);
 348
 349     free(data);
 350
 351     pContext->refcnt++;
 352
 353     return Success;
 354 }
 355
 356 static int
 357 ProcXvMCDestroySurface(ClientPtr client)
 358 {
 359     void *val;
 360     int rc;
 361
 362     REQUEST(xvmcDestroySurfaceReq);
 363     REQUEST_SIZE_MATCH(xvmcDestroySurfaceReq);
 364
 365     rc = dixLookupResourceByType(&val, stuff->surface_id, XvMCRTSurface,
 366                                  client, DixDestroyAccess);
 367     if (rc != Success)
 368         return rc;
 369
 370     FreeResource(stuff->surface_id, X11_RESTYPE_NONE);
 371
 372     return Success;
 373 }
 374
 375 static int
 376 ProcXvMCCreateSubpicture(ClientPtr client)
 377 {
 378     Bool image_supported = FALSE;
 379     CARD32 *data = NULL;
 380     int i, result, dwords = 0;
 381     XvMCContextPtr pContext;
 382     XvMCSubpicturePtr pSubpicture;
 383     XvMCScreenPtr pScreenPriv;
 384     xvmcCreateSubpictureReply rep;
 385     XvMCAdaptorPtr adaptor;
 386     XvMCSurfaceInfoPtr surface = NULL;
 387
 388     REQUEST(xvmcCreateSubpictureReq);
 389     REQUEST_SIZE_MATCH(xvmcCreateSubpictureReq);
 390
 391     result = dixLookupResourceByType((void **) &pContext, stuff->context_id,
 392                                      XvMCRTContext, client, DixUseAccess);
 393     if (result != Success)
 394         return result;
 395
 396     pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
 397
 398     adaptor = &(pScreenPriv->adaptors[pContext->adapt_num]);
 399
 400     /* find which surface this context supports */
 401     for (i = 0; i < adaptor->num_surfaces; i++) {
 402         if (adaptor->surfaces[i]->surface_type_id == pContext->surface_type_id) {
 403             surface = adaptor->surfaces[i];
 404             break;
 405         }
 406     }
 407
 408     if (!surface)
 409         return BadMatch;
 410
 411     /* make sure this surface supports that xvimage format */
 412     if (!surface->compatible_subpictures)
 413         return BadMatch;
 414
 415     for (i = 0; i < surface->compatible_subpictures->num_xvimages; i++) {
 416         if (surface->compatible_subpictures->xvimage_ids[i] ==
 417             stuff->xvimage_id) {
 418             image_supported = TRUE;
 419             break;
 420         }
 421     }
 422
 423     if (!image_supported)
 424         return BadMatch;
 425
 426     /* make sure the size is OK */
 427     if ((stuff->width > surface->subpicture_max_width) ||
 428         (stuff->height > surface->subpicture_max_height))
 429         return BadValue;
 430
 431     if (!(pSubpicture = malloc(sizeof(XvMCSubpictureRec))))
 432         return BadAlloc;
 433
 434     pSubpicture->subpicture_id = stuff->subpicture_id;
 435     pSubpicture->xvimage_id = stuff->xvimage_id;
 436     pSubpicture->width = stuff->width;
 437     pSubpicture->height = stuff->height;
 438     pSubpicture->num_palette_entries = 0;       /* overwritten by DDX */
 439     pSubpicture->entry_bytes = 0;       /* overwritten by DDX */
 440     pSubpicture->component_order[0] = 0;        /* overwritten by DDX */
 441     pSubpicture->component_order[1] = 0;
 442     pSubpicture->component_order[2] = 0;
 443     pSubpicture->component_order[3] = 0;
 444     pSubpicture->context = pContext;
 445
 446     result =
 447         (*pScreenPriv->adaptors[pContext->adapt_num].
 448          CreateSubpicture) (pSubpicture, &dwords, &data);
 449
 450     if (result != Success) {
 451         free(pSubpicture);
 452         return result;
 453     }
 454     if (!AddResource(pSubpicture->subpicture_id, XvMCRTSubpicture, pSubpicture)) {
 455         free(data);
 456         return BadAlloc;
 457     }
 458
 459     rep = (xvmcCreateSubpictureReply) {
 460         .type = X_Reply,
 461         .sequenceNumber = client->sequence,
 462         .length = dwords,
 463         .width_actual = pSubpicture->width,
 464         .height_actual = pSubpicture->height,
 465         .num_palette_entries = pSubpicture->num_palette_entries,
 466         .entry_bytes = pSubpicture->entry_bytes,
 467         .component_order[0] = pSubpicture->component_order[0],
 468         .component_order[1] = pSubpicture->component_order[1],
 469         .component_order[2] = pSubpicture->component_order[2],
 470         .component_order[3] = pSubpicture->component_order[3]
 471     };
 472
 473     WriteToClient(client, sizeof(xvmcCreateSubpictureReply), &rep);
 474     if (dwords)
 475         WriteToClient(client, dwords << 2, data);
 476
 477     free(data);
 478
 479     pContext->refcnt++;
 480
 481     return Success;
 482 }
 483
 484 static int
 485 ProcXvMCDestroySubpicture(ClientPtr client)
 486 {
 487     void *val;
 488     int rc;
 489
 490     REQUEST(xvmcDestroySubpictureReq);
 491     REQUEST_SIZE_MATCH(xvmcDestroySubpictureReq);
 492
 493     rc = dixLookupResourceByType(&val, stuff->subpicture_id, XvMCRTSubpicture,
 494                                  client, DixDestroyAccess);
 495     if (rc != Success)
 496         return rc;
 497
 498     FreeResource(stuff->subpicture_id, X11_RESTYPE_NONE);
 499
 500     return Success;
 501 }
 502
 503 static int
 504 ProcXvMCListSubpictureTypes(ClientPtr client)
 505 {
 506     XvPortPtr pPort;
 507     xvmcListSubpictureTypesReply rep;
 508     XvMCScreenPtr pScreenPriv;
 509     ScreenPtr pScreen;
 510     XvMCAdaptorPtr adaptor = NULL;
 511     XvMCSurfaceInfoPtr surface = NULL;
 512     xvImageFormatInfo info;
 513     XvImagePtr pImage;
 514     int i, j;
 515
 516     REQUEST(xvmcListSubpictureTypesReq);
 517     REQUEST_SIZE_MATCH(xvmcListSubpictureTypesReq);
 518
 519     VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
 520
 521     pScreen = pPort->pAdaptor->pScreen;
 522
 523     if (!dixPrivateKeyRegistered(XvMCScreenKey))
 524         return BadMatch;        /* No XvMC adaptors */
 525
 526     if (!(pScreenPriv = XVMC_GET_PRIVATE(pScreen)))
 527         return BadMatch;        /* None this screen */
 528
 529     for (i = 0; i < pScreenPriv->num_adaptors; i++) {
 530         if (pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
 531             adaptor = &(pScreenPriv->adaptors[i]);
 532             break;
 533         }
 534     }
 535
 536     if (!adaptor)
 537         return BadMatch;
 538
 539     for (i = 0; i < adaptor->num_surfaces; i++) {
 540         if (adaptor->surfaces[i]->surface_type_id == stuff->surface_type_id) {
 541             surface = adaptor->surfaces[i];
 542             break;
 543         }
 544     }
 545
 546     if (!surface)
 547         return BadMatch;
 548
 549     rep = (xvmcListSubpictureTypesReply) {
 550         .type = X_Reply,
 551         .sequenceNumber = client->sequence,
 552         .num = 0
 553     };
 554     if (surface->compatible_subpictures)
 555         rep.num = surface->compatible_subpictures->num_xvimages;
 556
 557     rep.length = bytes_to_int32(rep.num * sizeof(xvImageFormatInfo));
 558
 559     WriteToClient(client, sizeof(xvmcListSubpictureTypesReply), &rep);
 560
 561     for (i = 0; i < rep.num; i++) {
 562         pImage = NULL;
 563         for (j = 0; j < adaptor->num_subpictures; j++) {
 564             if (surface->compatible_subpictures->xvimage_ids[i] ==
 565                 adaptor->subpictures[j]->id) {
 566                 pImage = adaptor->subpictures[j];
 567                 break;
 568             }
 569         }
 570         if (!pImage)
 571             return BadImplementation;
 572
 573         info.id = pImage->id;
 574         info.type = pImage->type;
 575         info.byte_order = pImage->byte_order;
 576         memcpy(&info.guid, pImage->guid, 16);
 577         info.bpp = pImage->bits_per_pixel;
 578         info.num_planes = pImage->num_planes;
 579         info.depth = pImage->depth;
 580         info.red_mask = pImage->red_mask;
 581         info.green_mask = pImage->green_mask;
 582         info.blue_mask = pImage->blue_mask;
 583         info.format = pImage->format;
 584         info.y_sample_bits = pImage->y_sample_bits;
 585         info.u_sample_bits = pImage->u_sample_bits;
 586         info.v_sample_bits = pImage->v_sample_bits;
 587         info.horz_y_period = pImage->horz_y_period;
 588         info.horz_u_period = pImage->horz_u_period;
 589         info.horz_v_period = pImage->horz_v_period;
 590         info.vert_y_period = pImage->vert_y_period;
 591         info.vert_u_period = pImage->vert_u_period;
 592         info.vert_v_period = pImage->vert_v_period;
 593         memcpy(&info.comp_order, pImage->component_order, 32);
 594         info.scanline_order = pImage->scanline_order;
 595         WriteToClient(client, sizeof(xvImageFormatInfo), &info);
 596     }
 597
 598     return Success;
 599 }
 600
 601 static int
 602 ProcXvMCGetDRInfo(ClientPtr client)
 603 {
 604     xvmcGetDRInfoReply rep;
 605     XvPortPtr pPort;
 606     ScreenPtr pScreen;
 607     XvMCScreenPtr pScreenPriv;
 608
 609 #ifdef HAS_XVMCSHM
 610     volatile CARD32 *patternP;
 611 #endif
 612
 613     REQUEST(xvmcGetDRInfoReq);
 614     REQUEST_SIZE_MATCH(xvmcGetDRInfoReq);
 615
 616     VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
 617
 618     pScreen = pPort->pAdaptor->pScreen;
 619     pScreenPriv = XVMC_GET_PRIVATE(pScreen);
 620
 621     rep = (xvmcGetDRInfoReply) {
 622         .type = X_Reply,
 623         .sequenceNumber = client->sequence,
 624         .major = pScreenPriv->major,
 625         .minor = pScreenPriv->minor,
 626         .patchLevel = pScreenPriv->patchLevel,
 627         .nameLen = bytes_to_int32(strlen(pScreenPriv->clientDriverName) + 1),
 628         .busIDLen = bytes_to_int32(strlen(pScreenPriv->busID) + 1),
 629         .isLocal = 1
 630     };
 631
 632     rep.length = rep.nameLen + rep.busIDLen;
 633     rep.nameLen <<= 2;
 634     rep.busIDLen <<= 2;
 635
 636     /*
 637      * Read back to the client what she has put in the shared memory
 638      * segment she prepared for us.
 639      */
 640
 641 #ifdef HAS_XVMCSHM
 642     patternP = (CARD32 *) shmat(stuff->shmKey, NULL, SHM_RDONLY);
 643     if (-1 != (long) patternP) {
 644         volatile CARD32 *patternC = patternP;
 645         int i;
 646         CARD32 magic = stuff->magic;
 647
 648         rep.isLocal = 1;
 649         i = 1024 / sizeof(CARD32);
 650
 651         while (i--) {
 652             if (*patternC++ != magic) {
 653                 rep.isLocal = 0;
 654                 break;
 655             }
 656             magic = ~magic;
 657         }
 658         shmdt((char *) patternP);
 659     }
 660 #endif                          /* HAS_XVMCSHM */
 661
 662     WriteToClient(client, sizeof(xvmcGetDRInfoReply), &rep);
 663     if (rep.length) {
 664         WriteToClient(client, rep.nameLen, pScreenPriv->clientDriverName);
 665         WriteToClient(client, rep.busIDLen, pScreenPriv->busID);
 666     }
 667     return Success;
 668 }
 669
 670 int (*ProcXvMCVector[xvmcNumRequest]) (ClientPtr) = {
 671 ProcXvMCQueryVersion,
 672         ProcXvMCListSurfaceTypes,
 673         ProcXvMCCreateContext,
 674         ProcXvMCDestroyContext,
 675         ProcXvMCCreateSurface,
 676         ProcXvMCDestroySurface,
 677         ProcXvMCCreateSubpicture,
 678         ProcXvMCDestroySubpicture,
 679         ProcXvMCListSubpictureTypes, ProcXvMCGetDRInfo};
 680
 681 static int
 682 ProcXvMCDispatch(ClientPtr client)
 683 {
 684     REQUEST(xReq);
 685
 686     if (stuff->data < xvmcNumRequest)
 687         return (*ProcXvMCVector[stuff->data]) (client);
 688     else
 689         return BadRequest;
 690 }
 691
 692 static int _X_COLD
 693 SProcXvMCDispatch(ClientPtr client)
 694 {
 695     /* We only support local */
 696     return BadImplementation;
 697 }
 698
 699 void
 700 XvMCExtensionInit(void)
 701 {
 702     ExtensionEntry *extEntry;
 703
 704     if (!dixPrivateKeyRegistered(XvMCScreenKey))
 705         return;
 706
 707     if (!(XvMCRTContext = CreateNewResourceType(XvMCDestroyContextRes,
 708                                                 "XvMCRTContext")))
 709         return;
 710
 711     if (!(XvMCRTSurface = CreateNewResourceType(XvMCDestroySurfaceRes,
 712                                                 "XvMCRTSurface")))
 713         return;
 714
 715     if (!(XvMCRTSubpicture = CreateNewResourceType(XvMCDestroySubpictureRes,
 716                                                    "XvMCRTSubpicture")))
 717         return;
 718
 719     extEntry = AddExtension(XvMCName, XvMCNumEvents, XvMCNumErrors,
 720                             ProcXvMCDispatch, SProcXvMCDispatch,
 721                             NULL, StandardMinorOpcode);
 722
 723     if (!extEntry)
 724         return;
 725
 726     XvMCReqCode = extEntry->base;
 727     XvMCEventBase = extEntry->eventBase;
 728     SetResourceTypeErrorValue(XvMCRTContext,
 729                               extEntry->errorBase + XvMCBadContext);
 730     SetResourceTypeErrorValue(XvMCRTSurface,
 731                               extEntry->errorBase + XvMCBadSurface);
 732     SetResourceTypeErrorValue(XvMCRTSubpicture,
 733                               extEntry->errorBase + XvMCBadSubpicture);
 734 }
 735
 736 static Bool
 737 XvMCCloseScreen(ScreenPtr pScreen)
 738 {
 739     XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pScreen);
 740
 741     pScreen->CloseScreen = pScreenPriv->CloseScreen;
 742
 743     free(pScreenPriv);
 744
 745     return (*pScreen->CloseScreen) (pScreen);
 746 }
 747
 748 int
 749 XvMCScreenInit(ScreenPtr pScreen, int num, XvMCAdaptorPtr pAdapt)
 750 {
 751     XvMCScreenPtr pScreenPriv;
 752
 753     if (!dixRegisterPrivateKey(&XvMCScreenKeyRec, PRIVATE_SCREEN, 0))
 754         return BadAlloc;
 755
 756     if (!(pScreenPriv = malloc(sizeof(XvMCScreenRec))))
 757         return BadAlloc;
 758
 759     dixSetPrivate(&pScreen->devPrivates, XvMCScreenKey, pScreenPriv);
 760
 761     pScreenPriv->CloseScreen = pScreen->CloseScreen;
 762     pScreen->CloseScreen = XvMCCloseScreen;
 763
 764     pScreenPriv->num_adaptors = num;
 765     pScreenPriv->adaptors = pAdapt;
 766     pScreenPriv->clientDriverName[0] = 0;
 767     pScreenPriv->busID[0] = 0;
 768     pScreenPriv->major = 0;
 769     pScreenPriv->minor = 0;
 770     pScreenPriv->patchLevel = 0;
 771
 772     XvMCInUse = TRUE;
 773
 774     return Success;
 775 }
 776
 777 XvImagePtr
 778 XvMCFindXvImage(XvPortPtr pPort, CARD32 id)
 779 {
 780     XvImagePtr pImage = NULL;
 781     ScreenPtr pScreen = pPort->pAdaptor->pScreen;
 782     XvMCScreenPtr pScreenPriv;
 783     XvMCAdaptorPtr adaptor = NULL;
 784     int i;
 785
 786     if (!dixPrivateKeyRegistered(XvMCScreenKey))
 787         return NULL;
 788
 789     if (!(pScreenPriv = XVMC_GET_PRIVATE(pScreen)))
 790         return NULL;
 791
 792     for (i = 0; i < pScreenPriv->num_adaptors; i++) {
 793         if (pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
 794             adaptor = &(pScreenPriv->adaptors[i]);
 795             break;
 796         }
 797     }
 798
 799     if (!adaptor)
 800         return NULL;
 801
 802     for (i = 0; i < adaptor->num_subpictures; i++) {
 803         if (adaptor->subpictures[i]->id == id) {
 804             pImage = adaptor->subpictures[i];
 805             break;
 806         }
 807     }
 808
 809     return pImage;
 810 }
 811
 812 int
 813 xf86XvMCRegisterDRInfo(ScreenPtr pScreen, const char *name,
 814                        const char *busID, int major, int minor, int patchLevel)
 815 {
 816     XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pScreen);
 817
 818     strlcpy(pScreenPriv->clientDriverName, name, DR_CLIENT_DRIVER_NAME_SIZE);
 819     strlcpy(pScreenPriv->busID, busID, DR_BUSID_SIZE);
 820     pScreenPriv->major = major;
 821     pScreenPriv->minor = minor;
 822     pScreenPriv->patchLevel = patchLevel;
 823     return Success;
 824 }