← Back to branch summary

~misterc/libva/Trunk

« back to all changes in this revision

Viewing changes to va/x11/va_x11.c

  • Committer: Sean V Kelley
  • Date: 2017-02-18 23:19:05 UTC
  • Revision ID: git-v1:7b8cc07dc7a9b954b9a8c9bde5091fb2e8d443dc
PROJECT HAS MOVED

See https://github.com/01org/libva

Signed-off-by: Sean V Kelley <seanvk@posteo.de>

Show diffs side-by-side

added added

removed removed

Lines of Context:
va/x11/va_x11.c
1
 
/*
2
 
 * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
3
 
 *
4
 
 * Permission is hereby granted, free of charge, to any person obtaining a
5
 
 * copy of this software and associated documentation files (the
6
 
 * "Software"), to deal in the Software without restriction, including
7
 
 * without limitation the rights to use, copy, modify, merge, publish,
8
 
 * distribute, sub license, and/or sell copies of the Software, and to
9
 
 * permit persons to whom the Software is furnished to do so, subject to
10
 
 * the following conditions:
11
 
 * 
12
 
 * The above copyright notice and this permission notice (including the
13
 
 * next paragraph) shall be included in all copies or substantial portions
14
 
 * of the Software.
15
 
 * 
16
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17
 
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18
 
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
19
 
 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
20
 
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21
 
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22
 
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23
 
 */
24
 
 
25
 
#define _GNU_SOURCE 1
26
 
#include "sysdeps.h"
27
 
#include "va.h"
28
 
#include "va_backend.h"
29
 
#include "va_trace.h"
30
 
#include "va_fool.h"
31
 
#include "va_x11.h"
32
 
#include "va_dri2.h"
33
 
#include "va_dricommon.h"
34
 
#include "va_nvctrl.h"
35
 
#include "va_fglrx.h"
36
 
#include <stdio.h>
37
 
#include <stdlib.h>
38
 
#include <stdarg.h>
39
 
#include <string.h>
40
 
#include <unistd.h>
41
 
#include <sys/types.h>
42
 
#include <sys/stat.h>
43
 
#include <fcntl.h>
44
 
#include <errno.h>
45
 
 
46
 
static int va_DisplayContextIsValid (
47
 
    VADisplayContextP pDisplayContext
48
 
)
49
 
{
50
 
    return (pDisplayContext != NULL && 
51
 
            pDisplayContext->pDriverContext != NULL);
52
 
}
53
 
 
54
 
static void va_DisplayContextDestroy (
55
 
    VADisplayContextP pDisplayContext
56
 
)
57
 
{
58
 
    VADriverContextP ctx;
59
 
    struct dri_state *dri_state;
60
 
 
61
 
    if (pDisplayContext == NULL)
62
 
        return;
63
 
 
64
 
    ctx = pDisplayContext->pDriverContext;
65
 
    dri_state = ctx->drm_state;
66
 
 
67
 
    if (dri_state && dri_state->close)
68
 
        dri_state->close(ctx);
69
 
 
70
 
    free(pDisplayContext->pDriverContext->drm_state);
71
 
    free(pDisplayContext->pDriverContext);
72
 
    free(pDisplayContext);
73
 
}
74
 
 
75
 
 
76
 
static VAStatus va_DRI2GetDriverName (
77
 
    VADisplayContextP pDisplayContext,
78
 
    char **driver_name
79
 
)
80
 
{
81
 
    VADriverContextP ctx = pDisplayContext->pDriverContext;
82
 
 
83
 
    if (!isDRI2Connected(ctx, driver_name))
84
 
        return VA_STATUS_ERROR_UNKNOWN;
85
 
 
86
 
    return VA_STATUS_SUCCESS;
87
 
}
88
 
 
89
 
static VAStatus va_NVCTRL_GetDriverName (
90
 
    VADisplayContextP pDisplayContext,
91
 
    char **driver_name
92
 
)
93
 
{
94
 
    VADriverContextP ctx = pDisplayContext->pDriverContext;
95
 
    int direct_capable, driver_major, driver_minor, driver_patch;
96
 
    Bool result;
97
 
 
98
 
    result = VA_NVCTRLQueryDirectRenderingCapable(ctx->native_dpy, ctx->x11_screen,
99
 
                                                  &direct_capable);
100
 
    if (!result || !direct_capable)
101
 
        return VA_STATUS_ERROR_UNKNOWN;
102
 
 
103
 
    result = VA_NVCTRLGetClientDriverName(ctx->native_dpy, ctx->x11_screen,
104
 
                                          &driver_major, &driver_minor,
105
 
                                          &driver_patch, driver_name);
106
 
    if (!result)
107
 
        return VA_STATUS_ERROR_UNKNOWN;
108
 
 
109
 
    return VA_STATUS_SUCCESS;
110
 
}
111
 
 
112
 
static VAStatus va_FGLRX_GetDriverName (
113
 
    VADisplayContextP pDisplayContext,
114
 
    char **driver_name
115
 
)
116
 
{
117
 
    VADriverContextP ctx = pDisplayContext->pDriverContext;
118
 
    int driver_major, driver_minor, driver_patch;
119
 
    Bool result;
120
 
 
121
 
    result = VA_FGLRXGetClientDriverName(ctx->native_dpy, ctx->x11_screen,
122
 
                                         &driver_major, &driver_minor,
123
 
                                         &driver_patch, driver_name);
124
 
    if (!result)
125
 
        return VA_STATUS_ERROR_UNKNOWN;
126
 
 
127
 
    return VA_STATUS_SUCCESS;
128
 
}
129
 
 
130
 
static VAStatus va_DisplayContextGetDriverName (
131
 
    VADisplayContextP pDisplayContext,
132
 
    char **driver_name
133
 
)
134
 
{
135
 
    VAStatus vaStatus;
136
 
 
137
 
    if (driver_name)
138
 
        *driver_name = NULL;
139
 
    else
140
 
        return VA_STATUS_ERROR_UNKNOWN;
141
 
    
142
 
    vaStatus = va_DRI2GetDriverName(pDisplayContext, driver_name);
143
 
    if (vaStatus != VA_STATUS_SUCCESS)
144
 
        vaStatus = va_NVCTRL_GetDriverName(pDisplayContext, driver_name);
145
 
    if (vaStatus != VA_STATUS_SUCCESS)
146
 
        vaStatus = va_FGLRX_GetDriverName(pDisplayContext, driver_name);
147
 
    return vaStatus;
148
 
}
149
 
 
150
 
 
151
 
VADisplay vaGetDisplay (
152
 
    Display *native_dpy /* implementation specific */
153
 
)
154
 
{
155
 
  VADisplay dpy = NULL;
156
 
  VADisplayContextP pDisplayContext;
157
 
 
158
 
  if (!native_dpy)
159
 
      return NULL;
160
 
 
161
 
  if (!dpy)
162
 
  {
163
 
      /* create new entry */
164
 
      VADriverContextP pDriverContext;
165
 
      struct dri_state *dri_state;
166
 
      pDisplayContext = calloc(1, sizeof(*pDisplayContext));
167
 
      pDriverContext  = calloc(1, sizeof(*pDriverContext));
168
 
      dri_state       = calloc(1, sizeof(*dri_state));
169
 
      if (pDisplayContext && pDriverContext && dri_state)
170
 
      {
171
 
          pDisplayContext->vadpy_magic = VA_DISPLAY_MAGIC;          
172
 
 
173
 
          pDriverContext->native_dpy       = (void *)native_dpy;
174
 
          pDriverContext->x11_screen       = XDefaultScreen(native_dpy);
175
 
          pDriverContext->display_type     = VA_DISPLAY_X11;
176
 
          pDisplayContext->pDriverContext  = pDriverContext;
177
 
          pDisplayContext->vaIsValid       = va_DisplayContextIsValid;
178
 
          pDisplayContext->vaDestroy       = va_DisplayContextDestroy;
179
 
          pDisplayContext->vaGetDriverName = va_DisplayContextGetDriverName;
180
 
          pDisplayContext->opaque          = NULL;
181
 
          pDriverContext->drm_state        = dri_state;
182
 
          dpy                              = (VADisplay)pDisplayContext;
183
 
      }
184
 
      else
185
 
      {
186
 
          if (pDisplayContext)
187
 
              free(pDisplayContext);
188
 
          if (pDriverContext)
189
 
              free(pDriverContext);
190
 
          if (dri_state)
191
 
              free(dri_state);
192
 
      }
193
 
  }
194
 
  
195
 
  return dpy;
196
 
}
197
 
 
198
 
#define CTX(dpy) (((VADisplayContextP)dpy)->pDriverContext)
199
 
#define CHECK_DISPLAY(dpy) if( !vaDisplayIsValid(dpy) ) { return VA_STATUS_ERROR_INVALID_DISPLAY; }
200
 
 
201
 
void va_TracePutSurface (
202
 
    VADisplay dpy,
203
 
    VASurfaceID surface,
204
 
    void *draw, /* the target Drawable */
205
 
    short srcx,
206
 
    short srcy,
207
 
    unsigned short srcw,
208
 
    unsigned short srch,
209
 
    short destx,
210
 
    short desty,
211
 
    unsigned short destw,
212
 
    unsigned short desth,
213
 
    VARectangle *cliprects, /* client supplied clip list */
214
 
    unsigned int number_cliprects, /* number of clip rects in the clip list */
215
 
    unsigned int flags /* de-interlacing flags */
216
 
);
217
 
 
218
 
 
219
 
VAStatus vaPutSurface (
220
 
    VADisplay dpy,
221
 
    VASurfaceID surface,
222
 
    Drawable draw, /* X Drawable */
223
 
    short srcx,
224
 
    short srcy,
225
 
    unsigned short srcw,
226
 
    unsigned short srch,
227
 
    short destx,
228
 
    short desty,
229
 
    unsigned short destw,
230
 
    unsigned short desth,
231
 
    VARectangle *cliprects, /* client supplied clip list */
232
 
    unsigned int number_cliprects, /* number of clip rects in the clip list */
233
 
    unsigned int flags /* de-interlacing flags */
234
 
)
235
 
{
236
 
  VADriverContextP ctx;
237
 
 
238
 
  if (fool_postp)
239
 
      return VA_STATUS_SUCCESS;
240
 
 
241
 
  CHECK_DISPLAY(dpy);
242
 
  ctx = CTX(dpy);
243
 
  
244
 
  VA_TRACE_LOG(va_TracePutSurface, dpy, surface, (void *)draw, srcx, srcy, srcw, srch,
245
 
               destx, desty, destw, desth,
246
 
               cliprects, number_cliprects, flags );
247
 
  
248
 
  return ctx->vtable->vaPutSurface( ctx, surface, (void *)draw, srcx, srcy, srcw, srch,
249
 
                                   destx, desty, destw, desth,
250
 
                                   cliprects, number_cliprects, flags );
251
 
}