← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/gallium/frontends/xvmc/surface.c

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/frontends/xvmc/surface.c
1
 
/**************************************************************************
2
 
 *
3
 
 * Copyright 2009 Younes Manton.
4
 
 * All Rights Reserved.
5
 
 *
6
 
 * Permission is hereby granted, free of charge, to any person obtaining a
7
 
 * copy of this software and associated documentation files (the
8
 
 * "Software"), to deal in the Software without restriction, including
9
 
 * without limitation the rights to use, copy, modify, merge, publish,
10
 
 * distribute, sub license, and/or sell copies of the Software, and to
11
 
 * permit persons to whom the Software is furnished to do so, subject to
12
 
 * the following conditions:
13
 
 *
14
 
 * The above copyright notice and this permission notice (including the
15
 
 * next paragraph) shall be included in all copies or substantial portions
16
 
 * of the Software.
17
 
 *
18
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19
 
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20
 
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21
 
 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22
 
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23
 
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24
 
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25
 
 *
26
 
 **************************************************************************/
27
 
 
28
 
#include <assert.h>
29
 
#include <stdio.h>
30
 
 
31
 
#include <X11/Xlibint.h>
32
 
 
33
 
#include "pipe/p_video_codec.h"
34
 
#include "pipe/p_video_state.h"
35
 
#include "pipe/p_state.h"
36
 
 
37
 
#include "util/macros.h"
38
 
#include "util/u_inlines.h"
39
 
#include "util/u_memory.h"
40
 
#include "util/u_math.h"
41
 
#include "vl/vl_winsys.h"
42
 
 
43
 
#include "xvmc_private.h"
44
 
 
45
 
static void
46
 
MacroBlocksToPipe(XvMCContextPrivate *context,
47
 
                  XvMCSurfacePrivate *surface,
48
 
                  unsigned int xvmc_picture_structure,
49
 
                  const XvMCMacroBlock *xvmc_mb,
50
 
                  const XvMCBlockArray *xvmc_blocks,
51
 
                  struct pipe_mpeg12_macroblock *mb,
52
 
                  unsigned int num_macroblocks)
53
 
{
54
 
   unsigned int i, j, k;
55
 
 
56
 
   assert(xvmc_mb);
57
 
   assert(xvmc_blocks);
58
 
   assert(num_macroblocks);
59
 
 
60
 
   for (; num_macroblocks > 0; --num_macroblocks) {
61
 
      mb->base.codec = PIPE_VIDEO_FORMAT_MPEG12;
62
 
      mb->x = xvmc_mb->x;
63
 
      mb->y = xvmc_mb->y;
64
 
      mb->macroblock_type = xvmc_mb->macroblock_type;
65
 
 
66
 
      switch (xvmc_picture_structure) {
67
 
      case XVMC_FRAME_PICTURE:
68
 
         mb->macroblock_modes.bits.frame_motion_type = xvmc_mb->motion_type;
69
 
         mb->macroblock_modes.bits.field_motion_type = 0;
70
 
         break;
71
 
 
72
 
      case XVMC_TOP_FIELD:
73
 
      case XVMC_BOTTOM_FIELD:
74
 
         mb->macroblock_modes.bits.frame_motion_type = 0;
75
 
         mb->macroblock_modes.bits.field_motion_type = xvmc_mb->motion_type;
76
 
         break;
77
 
 
78
 
      default:
79
 
         assert(0);
80
 
      }
81
 
 
82
 
      mb->macroblock_modes.bits.dct_type = xvmc_mb->dct_type;
83
 
      mb->motion_vertical_field_select = xvmc_mb->motion_vertical_field_select;
84
 
 
85
 
      for (i = 0; i < 2; ++i)
86
 
         for (j = 0; j < 2; ++j)
87
 
            for (k = 0; k < 2; ++k)
88
 
               mb->PMV[i][j][k] = xvmc_mb->PMV[i][j][k];
89
 
 
90
 
      mb->coded_block_pattern = xvmc_mb->coded_block_pattern;
91
 
      mb->blocks = xvmc_blocks->blocks + xvmc_mb->index * BLOCK_SIZE_SAMPLES;
92
 
      mb->num_skipped_macroblocks = 0;
93
 
 
94
 
      ++xvmc_mb;
95
 
      ++mb;
96
 
   }
97
 
}
98
 
 
99
 
static void
100
 
GetPictureDescription(XvMCSurfacePrivate *surface, struct pipe_mpeg12_picture_desc *desc)
101
 
{
102
 
   unsigned i, num_refs = 0;
103
 
 
104
 
   assert(surface && desc);
105
 
 
106
 
   memset(desc, 0, sizeof(*desc));
107
 
   desc->base.profile = PIPE_VIDEO_PROFILE_MPEG1;
108
 
   desc->picture_structure = surface->picture_structure;
109
 
   for (i = 0; i < 2; ++i) {
110
 
      if (surface->ref[i]) {
111
 
         XvMCSurfacePrivate *ref = surface->ref[i]->privData;
112
 
 
113
 
         if (ref)
114
 
            desc->ref[num_refs++] = ref->video_buffer;
115
 
      }
116
 
   }
117
 
}
118
 
 
119
 
static void
120
 
RecursiveEndFrame(XvMCSurfacePrivate *surface)
121
 
{
122
 
   XvMCContextPrivate *context_priv;
123
 
   unsigned i;
124
 
 
125
 
   assert(surface);
126
 
 
127
 
   context_priv = surface->context->privData;
128
 
 
129
 
   for ( i = 0; i < 2; ++i ) {
130
 
      if (surface->ref[i]) {
131
 
         XvMCSurface *ref = surface->ref[i];
132
 
 
133
 
         assert(ref);
134
 
 
135
 
         surface->ref[i] = NULL;
136
 
         RecursiveEndFrame(ref->privData);
137
 
         surface->ref[i] = ref;
138
 
      }
139
 
   }
140
 
 
141
 
   if (surface->picture_structure) {
142
 
      struct pipe_mpeg12_picture_desc desc;
143
 
      GetPictureDescription(surface, &desc);
144
 
      surface->picture_structure = 0;
145
 
 
146
 
      for (i = 0; i < 2; ++i)
147
 
         surface->ref[i] = NULL;
148
 
 
149
 
      context_priv->decoder->end_frame(context_priv->decoder, surface->video_buffer, &desc.base);
150
 
   }
151
 
}
152
 
 
153
 
PUBLIC
154
 
Status XvMCCreateSurface(Display *dpy, XvMCContext *context, XvMCSurface *surface)
155
 
{
156
 
   XvMCContextPrivate *context_priv;
157
 
   struct pipe_context *pipe;
158
 
   XvMCSurfacePrivate *surface_priv;
159
 
   struct pipe_video_buffer tmpl;
160
 
 
161
 
   XVMC_MSG(XVMC_TRACE, "[XvMC] Creating surface %p.\n", surface);
162
 
 
163
 
   assert(dpy);
164
 
 
165
 
   if (!context)
166
 
      return XvMCBadContext;
167
 
   if (!surface)
168
 
      return XvMCBadSurface;
169
 
 
170
 
   context_priv = context->privData;
171
 
   pipe = context_priv->pipe;
172
 
 
173
 
   surface_priv = CALLOC(1, sizeof(XvMCSurfacePrivate));
174
 
   if (!surface_priv)
175
 
      return BadAlloc;
176
 
 
177
 
   memset(&tmpl, 0, sizeof(tmpl));
178
 
   tmpl.buffer_format = pipe->screen->get_video_param
179
 
   (
180
 
      pipe->screen,
181
 
      context_priv->decoder->profile,
182
 
      context_priv->decoder->entrypoint,
183
 
      PIPE_VIDEO_CAP_PREFERED_FORMAT
184
 
   );
185
 
   assert(pipe_format_to_chroma_format(tmpl.buffer_format) == context_priv->decoder->chroma_format);
186
 
   tmpl.width = context_priv->decoder->width;
187
 
   tmpl.height = context_priv->decoder->height;
188
 
   tmpl.interlaced = pipe->screen->get_video_param
189
 
   (
190
 
      pipe->screen,
191
 
      context_priv->decoder->profile,
192
 
      context_priv->decoder->entrypoint,
193
 
      PIPE_VIDEO_CAP_PREFERS_INTERLACED
194
 
   );
195
 
 
196
 
   surface_priv->video_buffer = pipe->create_video_buffer(pipe, &tmpl);
197
 
   if (!surface_priv->video_buffer) {
198
 
      FREE(surface_priv);
199
 
      return BadAlloc;
200
 
   }
201
 
   surface_priv->context = context;
202
 
 
203
 
   surface->surface_id = XAllocID(dpy);
204
 
   surface->context_id = context->context_id;
205
 
   surface->surface_type_id = context->surface_type_id;
206
 
   surface->width = context->width;
207
 
   surface->height = context->height;
208
 
   surface->privData = surface_priv;
209
 
 
210
 
   SyncHandle();
211
 
 
212
 
   XVMC_MSG(XVMC_TRACE, "[XvMC] Surface %p created.\n", surface);
213
 
 
214
 
   return Success;
215
 
}
216
 
 
217
 
PUBLIC
218
 
Status XvMCRenderSurface(Display *dpy, XvMCContext *context, unsigned int picture_structure,
219
 
                         XvMCSurface *target_surface, XvMCSurface *past_surface, XvMCSurface *future_surface,
220
 
                         unsigned int flags, unsigned int num_macroblocks, unsigned int first_macroblock,
221
 
                         XvMCMacroBlockArray *macroblocks, XvMCBlockArray *blocks
222
 
)
223
 
{
224
 
   struct pipe_mpeg12_macroblock mb[num_macroblocks];
225
 
   struct pipe_video_codec *decoder;
226
 
   struct pipe_mpeg12_picture_desc desc;
227
 
 
228
 
   XvMCContextPrivate *context_priv;
229
 
   XvMCSurfacePrivate *target_surface_priv;
230
 
   ASSERTED XvMCSurfacePrivate *past_surface_priv;
231
 
   ASSERTED XvMCSurfacePrivate *future_surface_priv;
232
 
   XvMCMacroBlock *xvmc_mb;
233
 
 
234
 
   XVMC_MSG(XVMC_TRACE, "[XvMC] Rendering to surface %p, with past %p and future %p\n",
235
 
            target_surface, past_surface, future_surface);
236
 
 
237
 
   assert(dpy);
238
 
 
239
 
   if (!context || !context->privData)
240
 
      return XvMCBadContext;
241
 
   if (!target_surface || !target_surface->privData)
242
 
      return XvMCBadSurface;
243
 
 
244
 
   if (picture_structure != XVMC_TOP_FIELD &&
245
 
       picture_structure != XVMC_BOTTOM_FIELD &&
246
 
       picture_structure != XVMC_FRAME_PICTURE)
247
 
      return BadValue;
248
 
   /* Bkwd pred equivalent to fwd (past && !future) */
249
 
   if (future_surface && !past_surface)
250
 
      return BadMatch;
251
 
 
252
 
   assert(context->context_id == target_surface->context_id);
253
 
   assert(!past_surface || context->context_id == past_surface->context_id);
254
 
   assert(!future_surface || context->context_id == future_surface->context_id);
255
 
 
256
 
   assert(macroblocks);
257
 
   assert(blocks);
258
 
 
259
 
   assert(macroblocks->context_id == context->context_id);
260
 
   assert(blocks->context_id == context->context_id);
261
 
 
262
 
   assert(flags == 0 || flags == XVMC_SECOND_FIELD);
263
 
 
264
 
   context_priv = context->privData;
265
 
   decoder = context_priv->decoder;
266
 
 
267
 
   target_surface_priv = target_surface->privData;
268
 
   past_surface_priv = past_surface ? past_surface->privData : NULL;
269
 
   future_surface_priv = future_surface ? future_surface->privData : NULL;
270
 
 
271
 
   assert(target_surface_priv->context == context);
272
 
   assert(!past_surface || past_surface_priv->context == context);
273
 
   assert(!future_surface || future_surface_priv->context == context);
274
 
 
275
 
   // call end frame on all referenced frames
276
 
   if (past_surface)
277
 
      RecursiveEndFrame(past_surface->privData);
278
 
 
279
 
   if (future_surface)
280
 
      RecursiveEndFrame(future_surface->privData);
281
 
 
282
 
   xvmc_mb = macroblocks->macro_blocks + first_macroblock;
283
 
 
284
 
   /* If the surface we're rendering hasn't changed the ref frames shouldn't change. */
285
 
   if (target_surface_priv->picture_structure > 0 && (
286
 
       target_surface_priv->picture_structure != picture_structure ||
287
 
       target_surface_priv->ref[0] != past_surface ||
288
 
       target_surface_priv->ref[1] != future_surface ||
289
 
       (xvmc_mb->x == 0 && xvmc_mb->y == 0))) {
290
 
 
291
 
      // If they change anyway we must assume that the current frame is ended
292
 
      RecursiveEndFrame(target_surface_priv);
293
 
   }
294
 
 
295
 
   target_surface_priv->ref[0] = past_surface;
296
 
   target_surface_priv->ref[1] = future_surface;
297
 
 
298
 
   if (target_surface_priv->picture_structure)
299
 
      GetPictureDescription(target_surface_priv, &desc);
300
 
   else {
301
 
      target_surface_priv->picture_structure = picture_structure;
302
 
      GetPictureDescription(target_surface_priv, &desc);
303
 
      decoder->begin_frame(decoder, target_surface_priv->video_buffer, &desc.base);
304
 
   }
305
 
 
306
 
   MacroBlocksToPipe(context_priv, target_surface_priv, picture_structure,
307
 
                     xvmc_mb, blocks, mb, num_macroblocks);
308
 
 
309
 
   context_priv->decoder->decode_macroblock(context_priv->decoder,
310
 
                                            target_surface_priv->video_buffer,
311
 
                                            &desc.base,
312
 
                                            &mb[0].base, num_macroblocks);
313
 
 
314
 
   XVMC_MSG(XVMC_TRACE, "[XvMC] Submitted surface %p for rendering.\n", target_surface);
315
 
 
316
 
   return Success;
317
 
}
318
 
 
319
 
PUBLIC
320
 
Status XvMCFlushSurface(Display *dpy, XvMCSurface *surface)
321
 
{
322
 
   assert(dpy);
323
 
 
324
 
   if (!surface)
325
 
      return XvMCBadSurface;
326
 
 
327
 
   // don't call flush here, because this is usually
328
 
   // called once for every slice instead of every frame
329
 
 
330
 
   XVMC_MSG(XVMC_TRACE, "[XvMC] Flushing surface %p\n", surface);
331
 
 
332
 
   return Success;
333
 
}
334
 
 
335
 
PUBLIC
336
 
Status XvMCSyncSurface(Display *dpy, XvMCSurface *surface)
337
 
{
338
 
   assert(dpy);
339
 
 
340
 
   if (!surface)
341
 
      return XvMCBadSurface;
342
 
 
343
 
   XVMC_MSG(XVMC_TRACE, "[XvMC] Syncing surface %p\n", surface);
344
 
 
345
 
   return Success;
346
 
}
347
 
 
348
 
PUBLIC
349
 
Status XvMCPutSurface(Display *dpy, XvMCSurface *surface, Drawable drawable,
350
 
                      short srcx, short srcy, unsigned short srcw, unsigned short srch,
351
 
                      short destx, short desty, unsigned short destw, unsigned short desth,
352
 
                      int flags)
353
 
{
354
 
   static int dump_window = -1;
355
 
 
356
 
   struct pipe_context *pipe;
357
 
   struct vl_compositor *compositor;
358
 
   struct vl_compositor_state *cstate;
359
 
   struct vl_screen *vscreen;
360
 
 
361
 
   XvMCSurfacePrivate *surface_priv;
362
 
   XvMCContextPrivate *context_priv;
363
 
   XvMCSubpicturePrivate *subpicture_priv;
364
 
   XvMCContext *context;
365
 
   struct u_rect src_rect = {srcx, srcx + srcw, srcy, srcy + srch};
366
 
   struct u_rect dst_rect = {destx, destx + destw, desty, desty + desth};
367
 
 
368
 
   struct pipe_resource *tex;
369
 
   struct pipe_surface surf_templ, *surf;
370
 
   struct u_rect *dirty_area;
371
 
 
372
 
   XVMC_MSG(XVMC_TRACE, "[XvMC] Displaying surface %p.\n", surface);
373
 
 
374
 
   assert(dpy);
375
 
 
376
 
   if (!surface || !surface->privData)
377
 
      return XvMCBadSurface;
378
 
 
379
 
   surface_priv = surface->privData;
380
 
   context = surface_priv->context;
381
 
   context_priv = context->privData;
382
 
 
383
 
   assert(flags == XVMC_TOP_FIELD || flags == XVMC_BOTTOM_FIELD || flags == XVMC_FRAME_PICTURE);
384
 
   assert(srcx + srcw - 1 < surface->width);
385
 
   assert(srcy + srch - 1 < surface->height);
386
 
 
387
 
   subpicture_priv = surface_priv->subpicture ? surface_priv->subpicture->privData : NULL;
388
 
   pipe = context_priv->pipe;
389
 
   compositor = &context_priv->compositor;
390
 
   cstate = &context_priv->cstate;
391
 
   vscreen = context_priv->vscreen;
392
 
 
393
 
   tex = vscreen->texture_from_drawable(vscreen, (void *)drawable);
394
 
   dirty_area = vscreen->get_dirty_area(vscreen);
395
 
 
396
 
   memset(&surf_templ, 0, sizeof(surf_templ));
397
 
   surf_templ.format = tex->format;
398
 
   surf = pipe->create_surface(pipe, tex, &surf_templ);
399
 
 
400
 
   if (!surf)
401
 
      return BadDrawable;
402
 
 
403
 
   /*
404
 
    * Some apps (mplayer) hit these asserts because they call
405
 
    * this function after the window has been resized by the WM
406
 
    * but before they've handled the corresponding XEvent and
407
 
    * know about the new dimensions. The output should be clipped
408
 
    * until the app updates destw and desth.
409
 
    */
410
 
   /*
411
 
   assert(destx + destw - 1 < drawable_surface->width);
412
 
   assert(desty + desth - 1 < drawable_surface->height);
413
 
    */
414
 
 
415
 
   RecursiveEndFrame(surface_priv);
416
 
 
417
 
   context_priv->decoder->flush(context_priv->decoder);
418
 
 
419
 
   vl_compositor_clear_layers(cstate);
420
 
   vl_compositor_set_buffer_layer(cstate, compositor, 0, surface_priv->video_buffer,
421
 
                                  &src_rect, NULL, VL_COMPOSITOR_WEAVE);
422
 
 
423
 
   if (subpicture_priv) {
424
 
      XVMC_MSG(XVMC_TRACE, "[XvMC] Surface %p has subpicture %p.\n", surface, surface_priv->subpicture);
425
 
 
426
 
      assert(subpicture_priv->surface == surface);
427
 
 
428
 
      if (subpicture_priv->palette)
429
 
         vl_compositor_set_palette_layer(cstate, compositor, 1, subpicture_priv->sampler, subpicture_priv->palette,
430
 
                                         &subpicture_priv->src_rect, &subpicture_priv->dst_rect, true);
431
 
      else
432
 
         vl_compositor_set_rgba_layer(cstate, compositor, 1, subpicture_priv->sampler,
433
 
                                      &subpicture_priv->src_rect, &subpicture_priv->dst_rect, NULL);
434
 
 
435
 
      surface_priv->subpicture = NULL;
436
 
      subpicture_priv->surface = NULL;
437
 
   }
438
 
 
439
 
   // Workaround for r600g, there seems to be a bug in the fence refcounting code
440
 
   pipe->screen->fence_reference(pipe->screen, &surface_priv->fence, NULL);
441
 
 
442
 
   vl_compositor_set_layer_dst_area(cstate, 0, &dst_rect);
443
 
   vl_compositor_set_layer_dst_area(cstate, 1, &dst_rect);
444
 
   vl_compositor_render(cstate, compositor, surf, dirty_area, true);
445
 
 
446
 
   pipe->flush(pipe, &surface_priv->fence, 0);
447
 
 
448
 
   XVMC_MSG(XVMC_TRACE, "[XvMC] Submitted surface %p for display. Pushing to front buffer.\n", surface);
449
 
 
450
 
   pipe->screen->flush_frontbuffer(pipe->screen, pipe, tex, 0, 0,
451
 
                                   vscreen->get_private(vscreen), NULL);
452
 
 
453
 
   if(dump_window == -1) {
454
 
      dump_window = debug_get_num_option("XVMC_DUMP", 0);
455
 
   }
456
 
 
457
 
   if(dump_window) {
458
 
      static unsigned int framenum = 0;
459
 
      char cmd[256];
460
 
 
461
 
      sprintf(cmd, "xwd -id %d -out xvmc_frame_%08d.xwd", (int)drawable, ++framenum);
462
 
      if (system(cmd) != 0)
463
 
         XVMC_MSG(XVMC_ERR, "[XvMC] Dumping surface %p failed.\n", surface);
464
 
   }
465
 
 
466
 
   XVMC_MSG(XVMC_TRACE, "[XvMC] Pushed surface %p to front buffer.\n", surface);
467
 
 
468
 
   return Success;
469
 
}
470
 
 
471
 
PUBLIC
472
 
Status XvMCGetSurfaceStatus(Display *dpy, XvMCSurface *surface, int *status)
473
 
{
474
 
   struct pipe_context *pipe;
475
 
   XvMCSurfacePrivate *surface_priv;
476
 
   XvMCContextPrivate *context_priv;
477
 
 
478
 
   assert(dpy);
479
 
 
480
 
   if (!surface)
481
 
      return XvMCBadSurface;
482
 
 
483
 
   assert(status);
484
 
 
485
 
   surface_priv = surface->privData;
486
 
   context_priv = surface_priv->context->privData;
487
 
   pipe = context_priv->pipe;
488
 
 
489
 
   *status = 0;
490
 
 
491
 
   if (surface_priv->fence)
492
 
      if (!pipe->screen->fence_finish(pipe->screen, NULL, surface_priv->fence, 0))
493
 
         *status |= XVMC_RENDERING;
494
 
 
495
 
   return Success;
496
 
}
497
 
 
498
 
PUBLIC
499
 
Status XvMCDestroySurface(Display *dpy, XvMCSurface *surface)
500
 
{
501
 
   XvMCSurfacePrivate *surface_priv;
502
 
   XvMCContextPrivate *context_priv;
503
 
 
504
 
   XVMC_MSG(XVMC_TRACE, "[XvMC] Destroying surface %p.\n", surface);
505
 
 
506
 
   assert(dpy);
507
 
 
508
 
   if (!surface || !surface->privData)
509
 
      return XvMCBadSurface;
510
 
 
511
 
   surface_priv = surface->privData;
512
 
   context_priv = surface_priv->context->privData;
513
 
 
514
 
   if (surface_priv->picture_structure) {
515
 
      struct pipe_mpeg12_picture_desc desc;
516
 
      GetPictureDescription(surface_priv, &desc);
517
 
      context_priv->decoder->end_frame(context_priv->decoder, surface_priv->video_buffer, &desc.base);
518
 
   }
519
 
   surface_priv->video_buffer->destroy(surface_priv->video_buffer);
520
 
   FREE(surface_priv);
521
 
   surface->privData = NULL;
522
 
 
523
 
   XVMC_MSG(XVMC_TRACE, "[XvMC] Surface %p destroyed.\n", surface);
524
 
 
525
 
   return Success;
526
 
}
527
 
 
528
 
PUBLIC
529
 
Status XvMCHideSurface(Display *dpy, XvMCSurface *surface)
530
 
{
531
 
   assert(dpy);
532
 
 
533
 
   if (!surface || !surface->privData)
534
 
      return XvMCBadSurface;
535
 
 
536
 
   /* No op, only for overlaid rendering */
537
 
 
538
 
   return Success;
539
 
}