| /* |
| * Copyright (c) 2011 Intel Corporation. All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the |
| * "Software"), to deal in the Software without restriction, including |
| * without limitation the rights to use, copy, modify, merge, publish, |
| * distribute, sub license, and/or sell copies of the Software, and to |
| * permit persons to whom the Software is furnished to do so, subject to |
| * the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the |
| * next paragraph) shall be included in all copies or substantial portions |
| * of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. |
| * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR |
| * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| * |
| * Authors: |
| * Jason Hu <jason.hu@intel.com> |
| * Zhaohan Ren <zhaohan.ren@intel.com> |
| * Shengquan Yuan <shengquan.yuan@intel.com> |
| * |
| */ |
| |
| #include <X11/Xutil.h> |
| #include <X11/extensions/Xrandr.h> |
| #include <va/va_backend.h> |
| #include "psb_output.h" |
| #include "psb_surface.h" |
| #include "psb_buffer.h" |
| #include "psb_x11.h" |
| #include "psb_drv_debug.h" |
| |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdarg.h> |
| #include "psb_surface_ext.h" |
| #include <wsbm/wsbm_manager.h> |
| #include "psb_drv_video.h" |
| #include "psb_xrandr.h" |
| #include <sys/types.h> |
| |
| #define INIT_DRIVER_DATA psb_driver_data_p driver_data = (psb_driver_data_p) ctx->pDriverData |
| #define INIT_OUTPUT_PRIV psb_x11_output_p output = (psb_x11_output_p)(((psb_driver_data_p)ctx->pDriverData)->ws_priv) |
| #define SURFACE(id) ((object_surface_p) object_heap_lookup( &driver_data->surface_heap, id )) |
| |
| static int |
| psb_x11_getWindowCoordinate(Display * display, |
| Window x11_window_id, |
| psb_x11_win_t * psX11Window, |
| int * pbIsVisible) |
| { |
| Window DummyWindow; |
| Status status; |
| XWindowAttributes sXWinAttrib; |
| |
| if ((status = XGetWindowAttributes(display, |
| x11_window_id, |
| &sXWinAttrib)) == 0) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Failed to get X11 window coordinates - error %lu\n", __func__, (unsigned long)status); |
| return -1; |
| } |
| |
| psX11Window->i32Left = sXWinAttrib.x; |
| psX11Window->i32Top = sXWinAttrib.y; |
| psX11Window->ui32Width = sXWinAttrib.width; |
| psX11Window->ui32Height = sXWinAttrib.height; |
| *pbIsVisible = (sXWinAttrib.map_state == IsViewable); |
| |
| if (!*pbIsVisible) |
| return 0; |
| |
| if (XTranslateCoordinates(display, |
| x11_window_id, |
| DefaultRootWindow(display), |
| 0, |
| 0, |
| &psX11Window->i32Left, |
| &psX11Window->i32Top, |
| &DummyWindow) == 0) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Failed to tranlate X coordinates - error %lu\n", __func__, (unsigned long)status); |
| return -1; |
| } |
| |
| psX11Window->i32Right = psX11Window->i32Left + psX11Window->ui32Width - 1; |
| psX11Window->i32Bottom = psX11Window->i32Top + psX11Window->ui32Height - 1; |
| |
| return 0; |
| } |
| static psb_x11_clip_list_t * |
| psb_x11_createClipBoxNode(psb_x11_win_t * pRect, |
| psb_x11_clip_list_t * pClipNext) |
| { |
| psb_x11_clip_list_t * pCurrent = NULL; |
| |
| pCurrent = (psb_x11_clip_list_t *)calloc(1, sizeof(psb_x11_clip_list_t)); |
| if (pCurrent) { |
| pCurrent->rect = *pRect; |
| pCurrent->next = pClipNext; |
| |
| return pCurrent; |
| } else |
| return pClipNext; |
| } |
| |
| void |
| psb_x11_freeWindowClipBoxList(psb_x11_clip_list_t * pHead) |
| { |
| psb_x11_clip_list_t * pNext = NULL; |
| |
| while (pHead) { |
| pNext = pHead->next; |
| free(pHead); |
| pHead = pNext; |
| } |
| } |
| |
| #define IS_BETWEEN_RANGE(a,b,c) ((a<=b)&&(b<=c)) |
| |
| static psb_x11_clip_list_t * |
| psb_x11_substractRects(Display * display, |
| psb_x11_clip_list_t * psRegion, |
| psb_x11_win_t * psRect) |
| { |
| psb_x11_clip_list_t * psCur, * psPrev, * psFirst, * psNext; |
| psb_x11_win_t sCreateRect; |
| int display_width = (int)(DisplayWidth(display, DefaultScreen(display))) - 1; |
| int display_height = (int)(DisplayHeight(display, DefaultScreen(display))) - 1; |
| |
| psFirst = psb_x11_createClipBoxNode(psRect, NULL); |
| |
| if (psFirst->rect.i32Left < 0) |
| psFirst->rect.i32Left = 0; |
| else if (psFirst->rect.i32Left > display_width) |
| psFirst->rect.i32Left = display_width; |
| |
| if (psFirst->rect.i32Right < 0) |
| psFirst->rect.i32Right = 0; |
| else if (psFirst->rect.i32Right > display_width) |
| psFirst->rect.i32Right = display_width; |
| |
| if (psFirst->rect.i32Top < 0) |
| psFirst->rect.i32Top = 0; |
| else if (psFirst->rect.i32Top > display_height) |
| psFirst->rect.i32Top = display_height; |
| |
| if (psFirst->rect.i32Bottom < 0) |
| psFirst->rect.i32Bottom = 0; |
| else if (psFirst->rect.i32Bottom > display_height) |
| psFirst->rect.i32Bottom = display_height; |
| |
| while (psRegion) { |
| psCur = psFirst; |
| psPrev = NULL; |
| |
| while (psCur) { |
| psNext = psCur->next; |
| |
| if ((psRegion->rect.i32Left > psCur->rect.i32Left) && |
| (psRegion->rect.i32Left <= psCur->rect.i32Right)) { |
| sCreateRect.i32Right = psRegion->rect.i32Left - 1; |
| |
| sCreateRect.i32Left = psCur->rect.i32Left; |
| sCreateRect.i32Top = psCur->rect.i32Top; |
| sCreateRect.i32Bottom = psCur->rect.i32Bottom; |
| |
| psFirst = psb_x11_createClipBoxNode(&sCreateRect, psFirst); |
| |
| if (!psPrev) |
| psPrev = psFirst; |
| |
| psCur->rect.i32Left = psRegion->rect.i32Left; |
| } |
| |
| if ((psRegion->rect.i32Right >= psCur->rect.i32Left) && |
| (psRegion->rect.i32Right < psCur->rect.i32Right)) |
| |
| { |
| sCreateRect.i32Left = psRegion->rect.i32Right + 1; |
| |
| sCreateRect.i32Right = psCur->rect.i32Right; |
| sCreateRect.i32Top = psCur->rect.i32Top; |
| sCreateRect.i32Bottom = psCur->rect.i32Bottom; |
| |
| psFirst = psb_x11_createClipBoxNode(&sCreateRect, psFirst); |
| |
| if (!psPrev) |
| psPrev = psFirst; |
| |
| psCur->rect.i32Right = psRegion->rect.i32Right; |
| } |
| |
| if ((psRegion->rect.i32Top > psCur->rect.i32Top) && |
| (psRegion->rect.i32Top <= psCur->rect.i32Bottom)) { |
| sCreateRect.i32Bottom = psRegion->rect.i32Top - 1; |
| |
| sCreateRect.i32Left = psCur->rect.i32Left; |
| sCreateRect.i32Right = psCur->rect.i32Right; |
| sCreateRect.i32Top = psCur->rect.i32Top; |
| |
| psFirst = psb_x11_createClipBoxNode(&sCreateRect, psFirst); |
| |
| if (!psPrev) |
| psPrev = psFirst; |
| |
| psCur->rect.i32Top = psRegion->rect.i32Top; |
| } |
| |
| if ((psRegion->rect.i32Bottom >= psCur->rect.i32Top) && |
| (psRegion->rect.i32Bottom < psCur->rect.i32Bottom)) { |
| sCreateRect.i32Top = psRegion->rect.i32Bottom + 1; |
| sCreateRect.i32Left = psCur->rect.i32Left; |
| sCreateRect.i32Right = psCur->rect.i32Right; |
| sCreateRect.i32Bottom = psCur->rect.i32Bottom; |
| |
| psFirst = psb_x11_createClipBoxNode(&sCreateRect, psFirst); |
| |
| if (!psPrev) |
| psPrev = psFirst; |
| |
| psCur->rect.i32Bottom = psRegion->rect.i32Bottom; |
| } |
| |
| if ((IS_BETWEEN_RANGE(psRegion->rect.i32Left, psCur->rect.i32Left, psRegion->rect.i32Right)) && |
| (IS_BETWEEN_RANGE(psRegion->rect.i32Left, psCur->rect.i32Right, psRegion->rect.i32Right)) && |
| (IS_BETWEEN_RANGE(psRegion->rect.i32Top, psCur->rect.i32Top, psRegion->rect.i32Bottom)) && |
| (IS_BETWEEN_RANGE(psRegion->rect.i32Top, psCur->rect.i32Bottom, psRegion->rect.i32Bottom))) { |
| if (psPrev) { |
| psPrev->next = psCur->next; |
| free(psCur); |
| psCur = psPrev; |
| } else { |
| free(psCur); |
| psCur = NULL; |
| psFirst = psNext; |
| } |
| } |
| psPrev = psCur; |
| psCur = psNext; |
| }//while(psCur) |
| psRegion = psRegion->next; |
| }//while(psRegion) |
| |
| return psFirst; |
| } |
| |
| static int |
| psb_x11_createWindowClipBoxList(Display * display, |
| Window x11_window_id, |
| psb_x11_clip_list_t ** ppWindowClipBoxList, |
| unsigned int * pui32NumClipBoxList) |
| { |
| Window CurrentWindow = x11_window_id; |
| Window RootWindow, ParentWindow, ChildWindow; |
| Window * pChildWindow; |
| Status XResult; |
| unsigned int i32NumChildren, i; |
| int bIsVisible; |
| unsigned int ui32NumRects = 0; |
| psb_x11_clip_list_t *psRegions = NULL; |
| psb_x11_win_t sRect; |
| |
| if (!display || (!ppWindowClipBoxList) || (!pui32NumClipBoxList)) |
| return -1; |
| |
| XResult = XQueryTree(display, |
| CurrentWindow, |
| &RootWindow, |
| &ParentWindow, |
| &pChildWindow, |
| &i32NumChildren); |
| if (XResult == 0) |
| return -2; |
| |
| if (i32NumChildren) { |
| for (i = 0; i < i32NumChildren; i++) { |
| |
| psb_x11_getWindowCoordinate(display, x11_window_id, &sRect, &bIsVisible); |
| if (bIsVisible) { |
| psRegions = psb_x11_createClipBoxNode(&sRect, psRegions); |
| ui32NumRects++; |
| } |
| } |
| XFree(pChildWindow); |
| i32NumChildren = 0; |
| } |
| |
| while (CurrentWindow != RootWindow) { |
| ChildWindow = CurrentWindow; |
| CurrentWindow = ParentWindow; |
| |
| XResult = XQueryTree(display, |
| CurrentWindow, |
| &RootWindow, |
| &ParentWindow, |
| &pChildWindow, |
| &i32NumChildren); |
| if (XResult == 0) { |
| if (i32NumChildren) |
| XFree(pChildWindow); |
| |
| psb_x11_freeWindowClipBoxList(psRegions); |
| return -3; |
| } |
| |
| if (i32NumChildren) { |
| unsigned int iStartWindow = 0; |
| |
| for (i = 0; i < i32NumChildren; i++) { |
| if (pChildWindow[i] == ChildWindow) { |
| iStartWindow = i; |
| break; |
| } |
| } |
| |
| if (i == i32NumChildren) { |
| XFree(pChildWindow); |
| psb_x11_freeWindowClipBoxList(psRegions); |
| return -4; |
| } |
| |
| for (i = iStartWindow + 1; i < i32NumChildren; i++) { |
| psb_x11_getWindowCoordinate(display, pChildWindow[i], &sRect, &bIsVisible); |
| if (bIsVisible) { |
| psRegions = psb_x11_createClipBoxNode(&sRect, psRegions); |
| ui32NumRects++; |
| } |
| } |
| |
| XFree(pChildWindow); |
| } |
| } |
| |
| ui32NumRects = 0; |
| |
| if (psRegions) { |
| psb_x11_getWindowCoordinate(display, x11_window_id, &sRect, &bIsVisible); |
| *ppWindowClipBoxList = psb_x11_substractRects(display, psRegions, &sRect); |
| psb_x11_freeWindowClipBoxList(psRegions); |
| |
| psRegions = *ppWindowClipBoxList; |
| |
| while (psRegions) { |
| ui32NumRects++; |
| psRegions = psRegions->next; |
| } |
| } else { |
| *ppWindowClipBoxList = psb_x11_substractRects(display, NULL, &sRect); |
| ui32NumRects = 1; |
| } |
| |
| *pui32NumClipBoxList = ui32NumRects; |
| |
| return 0; |
| } |
| |
| static int psb_cleardrawable_stopoverlay( |
| VADriverContextP ctx, |
| Drawable draw, /* X Drawable */ |
| short destx, |
| short desty, |
| unsigned short destw, |
| unsigned short desth |
| ) |
| { |
| INIT_DRIVER_DATA; |
| INIT_OUTPUT_PRIV; |
| |
| XFillRectangle((Display *)ctx->native_dpy, draw, output->gc, destx, desty, destw, desth); |
| XSync((Display *)ctx->native_dpy, False); |
| |
| driver_data->cur_displaying_surface = VA_INVALID_SURFACE; |
| driver_data->last_displaying_surface = VA_INVALID_SURFACE; |
| |
| return 0; |
| } |
| |
| static VAStatus psb_DisplayRGBASubpicture( |
| PsbVASurfaceRec *subpicture, |
| VADriverContextP ctx, |
| int win_width, |
| int win_height, |
| int surface_x, |
| int surface_y, |
| int surface_w, |
| int surface_h, |
| psb_extvideo_subtitle subtitle |
| ) |
| { |
| INIT_DRIVER_DATA; |
| INIT_OUTPUT_PRIV; |
| XImage *ximg = NULL; |
| Visual *visual; |
| PsbPortPrivRec *pPriv = (PsbPortPrivPtr)(&driver_data->coverlay_priv); |
| struct _WsbmBufferObject *bo = subpicture->bo; |
| int image_width, image_height, width, height, size; |
| int srcx, srcy, srcw, srch; |
| int destx, desty, destw, desth; |
| int depth, i; |
| |
| if (subpicture->fourcc != VA_FOURCC_RGBA) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Invalid image format, ONLY support RGBA subpicture now.\n", __func__); |
| return VA_STATUS_ERROR_INVALID_IMAGE_FORMAT; |
| } |
| |
| for (i = 0; subpicture != NULL; subpicture = subpicture->next, i++) { |
| srcx = subpicture->subpic_srcx; |
| srcy = subpicture->subpic_srcy; |
| srcw = subpicture->subpic_srcw; |
| srch = subpicture->subpic_srch; |
| |
| destx = subpicture->subpic_dstx + surface_x; |
| desty = subpicture->subpic_dsty + surface_y; |
| destw = subpicture->subpic_dstw; |
| desth = subpicture->subpic_dsth; |
| |
| image_width = subpicture->width; |
| image_height = subpicture->height; |
| size = subpicture->size; |
| |
| //clip in image region |
| if (srcx < 0) { |
| srcw += srcx; |
| srcx = 0; |
| } |
| |
| if (srcy < 0) { |
| srch += srcy; |
| srcy = 0; |
| } |
| |
| if ((srcx + srcw) > image_width) |
| srcw = image_width - srcx; |
| if ((srcy + srch) > image_height) |
| srch = image_height - srcy; |
| |
| //clip in drawable region |
| if (destx < 0) { |
| destw += destx; |
| destx = 0; |
| } |
| |
| if (desty < 0) { |
| desth += desty; |
| desty = 0; |
| } |
| |
| if ((destx + destw) > surface_w) |
| destw = surface_w - destx; |
| if ((desty + desth) > surface_h) |
| desth = surface_h - desty; |
| |
| if (srcw <= destw) |
| width = srcw; |
| else |
| width = destw; |
| |
| if (srch <= desth) |
| height = srch; |
| else |
| height = desth; |
| |
| visual = DefaultVisual(ctx->native_dpy, 0); |
| depth = DefaultDepth(ctx->native_dpy, 0); |
| |
| ximg = XCreateImage(ctx->native_dpy, visual, depth, ZPixmap, 0, NULL, image_width, image_height, 32, 0); |
| |
| if (NULL == ximg) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: XCreateImage failed! at L%d\n", __func__, __LINE__); |
| return VA_STATUS_ERROR_UNKNOWN; |
| } |
| |
| ximg->data = wsbmBOMap(bo, WSBM_ACCESS_READ); |
| if (NULL == ximg->data) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Failed to map to ximg->data.\n", __func__); |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| |
| pPriv->clear_key[i].subpic_dstx = destx; |
| pPriv->clear_key[i].subpic_dsty = desty; |
| pPriv->clear_key[i].subpic_dstw = destw; |
| pPriv->clear_key[i].subpic_dsth = desth; |
| if (psb_xrandr_extvideo_mode()) { |
| /*It is a HACK: Adjust subtitle to proper position.*/ |
| float xScale, yScale; |
| |
| xScale = win_width * 1.0 / surface_w; |
| yScale = win_height * 1.0 / surface_h; |
| destx = subpicture->subpic_dstx * xScale; |
| desty = subpicture->subpic_dsty * yScale; |
| } |
| XPutImage(ctx->native_dpy, output->output_drawable, output->gc, ximg, srcx, srcy, destx, desty, width, height); |
| XSync((Display *)ctx->native_dpy, False); |
| |
| if (psb_xrandr_extvideo_mode() && |
| (subtitle == ONLY_HDMI || subtitle == BOTH)) { |
| float xScale, yScale; |
| |
| xScale = pPriv->extend_display_width * 1.0 / surface_w; |
| yScale = pPriv->extend_display_height * 1.0 / surface_h; |
| |
| destx = subpicture->subpic_dstx * xScale; |
| desty = subpicture->subpic_dsty * yScale; |
| |
| XPutImage(ctx->native_dpy, output->extend_drawable, output->extend_gc, ximg, |
| srcx, srcy, destx, desty, destw, desth); |
| XSync((Display *)ctx->native_dpy, False); |
| } |
| |
| pPriv->subpic_clear_flag = 0; |
| ximg->data = NULL; |
| wsbmBOUnmap(bo); |
| if (NULL != ximg) |
| XDestroyImage(ximg); |
| } |
| return VA_STATUS_SUCCESS; |
| } |
| |
| static VAStatus psb_repaint_colorkey( |
| VADriverContextP ctx, |
| Drawable draw, /* X Drawable */ |
| VASurfaceID surface, |
| int x11_window_width, |
| int x11_window_height |
| ) |
| { |
| INIT_DRIVER_DATA; |
| INIT_OUTPUT_PRIV; |
| int i, ret; |
| psb_x11_clip_list_t *pClipNext = NULL; |
| VARectangle *pVaWindowClipRects = NULL; |
| object_surface_p obj_surface = SURFACE(surface); |
| PsbPortPrivRec *pPriv = (PsbPortPrivPtr)(&driver_data->coverlay_priv); |
| |
| if (output->frame_count % 500 == 0 || driver_data->xrandr_update) { |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "Repaint color key.\n"); |
| if (output->pClipBoxList) |
| psb_x11_freeWindowClipBoxList(output->pClipBoxList); |
| /* get window clipbox */ |
| ret = psb_x11_createWindowClipBoxList(ctx->native_dpy, draw, &output->pClipBoxList, &output->ui32NumClipBoxList); |
| if (ret != 0) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: get window clip boxes error # %d\n", __func__, ret); |
| return VA_STATUS_ERROR_UNKNOWN; |
| } |
| if (output->frame_count == 500) |
| output->frame_count = 0; |
| |
| driver_data->xrandr_update = 0; |
| } |
| |
| pVaWindowClipRects = (VARectangle *)calloc(1, sizeof(VARectangle) * output->ui32NumClipBoxList); |
| if (!pVaWindowClipRects) { |
| psb_x11_freeWindowClipBoxList(output->pClipBoxList); |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| |
| memset(pVaWindowClipRects, 0, sizeof(VARectangle)*output->ui32NumClipBoxList); |
| pClipNext = output->pClipBoxList; |
| #ifdef CLIP_DEBUG |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Total %d clip boxes\n", __func__, output->ui32NumClipBoxList); |
| #endif |
| for (i = 0; i < output->ui32NumClipBoxList; i++) { |
| pVaWindowClipRects[i].x = pClipNext->rect.i32Left; |
| pVaWindowClipRects[i].y = pClipNext->rect.i32Top; |
| pVaWindowClipRects[i].width = pClipNext->rect.i32Right - pClipNext->rect.i32Left; |
| pVaWindowClipRects[i].height = pClipNext->rect.i32Bottom - pClipNext->rect.i32Top; |
| #ifdef CLIP_DEBUG |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: clip boxes Left Top (%d, %d) Right Bottom (%d, %d) width %d height %d\n", __func__, |
| pClipNext->rect.i32Left, pClipNext->rect.i32Top, |
| pClipNext->rect.i32Right, pClipNext->rect.i32Bottom, |
| pVaWindowClipRects[i].width, pVaWindowClipRects[i].height); |
| #endif |
| pClipNext = pClipNext->next; |
| } |
| |
| /* repaint the color key when window size changed*/ |
| if (!obj_surface->subpictures && |
| ((pPriv->x11_window_width != x11_window_width) || |
| (pPriv->x11_window_height != x11_window_height))) { |
| pPriv->x11_window_width = x11_window_width; |
| pPriv->x11_window_height = x11_window_height; |
| XSetForeground((Display *)ctx->native_dpy, output->gc, pPriv->colorKey); |
| XFillRectangle((Display *)ctx->native_dpy, draw, output->gc, 0, 0, x11_window_width, x11_window_height); |
| XSync((Display *)ctx->native_dpy, False); |
| } |
| |
| |
| if ((!obj_surface->subpictures) && |
| ((output->ui32NumClipBoxList != pPriv->last_num_clipbox) || |
| (memcmp(&pVaWindowClipRects[0], &(pPriv->last_clipbox[0]), (output->ui32NumClipBoxList > 16 ? 16 : output->ui32NumClipBoxList)*sizeof(VARectangle)) != 0))) { |
| pPriv->last_num_clipbox = output->ui32NumClipBoxList; |
| memcpy(&pPriv->last_clipbox[0], &pVaWindowClipRects[0], (output->ui32NumClipBoxList > 16 ? 16 : output->ui32NumClipBoxList)*sizeof(VARectangle)); |
| XFillRectangle((Display *)ctx->native_dpy, draw, output->gc, 0, 0, x11_window_width, x11_window_height); |
| XSync((Display *)ctx->native_dpy, False); |
| } |
| |
| free(pVaWindowClipRects); |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| static VAStatus psb_extendMode_getCoordinate( |
| PsbPortPrivPtr pPriv, |
| psb_xrandr_location extend_location, |
| short destx, |
| short desty, |
| short srcx, |
| short srcy, |
| float xScaleFactor, |
| float yScaleFactor, |
| int *x11_window_width, |
| int *x11_window_height, |
| psb_overlay_rect_p local_rect, |
| psb_overlay_rect_p extend_rect, |
| enum overlay_id_t *extend_overlay |
| ) |
| { |
| switch (extend_location) { |
| case LEFT_OF: |
| if ((destx + *x11_window_width) > (pPriv->display_width + pPriv->extend_display_width)) { |
| *x11_window_width = pPriv->display_width + pPriv->extend_display_width - destx; |
| } |
| if (((desty + *x11_window_height) < pPriv->display_height) && |
| ((desty + *x11_window_height) < pPriv->extend_display_height)) |
| local_rect->dHeight = extend_rect->dHeight = *x11_window_height; |
| else if (pPriv->display_height < pPriv->extend_display_height) { |
| local_rect->dHeight = pPriv->display_height - desty; |
| if ((desty + *x11_window_height) > pPriv->extend_display_height) |
| extend_rect->dHeight = *x11_window_height = pPriv->extend_display_height - desty; |
| else |
| extend_rect->dHeight = *x11_window_height; |
| } else { |
| extend_rect->dHeight = pPriv->extend_display_height - desty; |
| if ((desty + *x11_window_height) > pPriv->display_height) |
| local_rect->dHeight = *x11_window_height = pPriv->display_height - desty; |
| else |
| local_rect->dHeight = *x11_window_height; |
| } |
| |
| if ((destx < pPriv->extend_display_width) && ((destx + *x11_window_width) < pPriv->extend_display_width)) { |
| local_rect->dWidth = 0; |
| extend_rect->dWidth = *x11_window_width; |
| *extend_overlay = OVERLAY_A; |
| local_rect->destx = 0; |
| } else if ((destx < pPriv->extend_display_width) && ((destx + *x11_window_width) >= pPriv->extend_display_width)) { |
| extend_rect->dWidth = pPriv->extend_display_width - destx; |
| local_rect->dWidth = *x11_window_width - extend_rect->dWidth; |
| local_rect->destx = 0; |
| } else { |
| local_rect->dWidth = *x11_window_width; |
| extend_rect->dWidth = 0; |
| local_rect->destx = destx - pPriv->extend_display_width; |
| } |
| local_rect->sWidth = (unsigned short)(local_rect->dWidth * xScaleFactor); |
| local_rect->sHeight = (unsigned short)(local_rect->dHeight * yScaleFactor); |
| extend_rect->sWidth = (unsigned short)(extend_rect->dWidth * xScaleFactor); |
| extend_rect->sHeight = (unsigned short)(extend_rect->dHeight * yScaleFactor); |
| |
| local_rect->srcx = srcx + extend_rect->sWidth; |
| extend_rect->srcx = srcx; |
| local_rect->srcy = extend_rect->srcy = srcy; |
| |
| extend_rect->destx = destx; |
| local_rect->desty = extend_rect->desty = desty; |
| break; |
| case RIGHT_OF: |
| if ((destx + *x11_window_width) > (pPriv->display_width + pPriv->extend_display_width)) { |
| *x11_window_width = pPriv->display_width + pPriv->extend_display_width - destx; |
| } |
| if (((desty + *x11_window_height) < pPriv->display_height) && |
| ((desty + *x11_window_height) < pPriv->extend_display_height)) |
| local_rect->dHeight = extend_rect->dHeight = *x11_window_height; |
| else if (pPriv->display_height < pPriv->extend_display_height) { |
| local_rect->dHeight = pPriv->display_height - desty; |
| if ((desty + *x11_window_height) > pPriv->extend_display_height) |
| extend_rect->dHeight = *x11_window_height = pPriv->extend_display_height - desty; |
| else |
| extend_rect->dHeight = *x11_window_height; |
| } else { |
| extend_rect->dHeight = pPriv->extend_display_height - desty; |
| if ((desty + *x11_window_height) > pPriv->display_height) |
| local_rect->dHeight = *x11_window_height = pPriv->display_height - desty; |
| else |
| local_rect->dHeight = *x11_window_height; |
| } |
| |
| if ((destx < pPriv->display_width) && ((destx + *x11_window_width) < pPriv->display_width)) { |
| local_rect->dWidth = *x11_window_width; |
| extend_rect->dWidth = 0; |
| extend_rect->destx = 0; |
| } else if ((destx < pPriv->display_width) && ((destx + *x11_window_width) >= pPriv->display_width)) { |
| local_rect->dWidth = pPriv->display_width - destx; |
| extend_rect->dWidth = *x11_window_width - local_rect->dWidth; |
| extend_rect->destx = 0; |
| } else { |
| local_rect->dWidth = 0; |
| extend_rect->dWidth = *x11_window_width; |
| *extend_overlay = OVERLAY_A; |
| extend_rect->destx = destx - pPriv->display_width; |
| } |
| local_rect->sWidth = (unsigned short)(local_rect->dWidth * xScaleFactor); |
| local_rect->sHeight = (unsigned short)(local_rect->dHeight * yScaleFactor); |
| extend_rect->sWidth = (unsigned short)(extend_rect->dWidth * xScaleFactor); |
| extend_rect->sHeight = (unsigned short)(extend_rect->dHeight * yScaleFactor); |
| |
| local_rect->srcx = srcx; |
| extend_rect->srcx = srcx + local_rect->sWidth; |
| local_rect->srcy = extend_rect->srcy = srcy; |
| |
| local_rect->destx = destx; |
| local_rect->desty = extend_rect->desty = desty; |
| break; |
| case ABOVE: |
| if (((destx + *x11_window_width) < pPriv->display_width) && |
| ((destx + *x11_window_width) < pPriv->extend_display_width)) |
| local_rect->dWidth = extend_rect->dWidth = *x11_window_width; |
| else if (pPriv->display_width < pPriv->extend_display_width) { |
| local_rect->dWidth = pPriv->display_width - destx; |
| if ((destx + *x11_window_width) > pPriv->extend_display_width) |
| extend_rect->dWidth = *x11_window_width = pPriv->extend_display_width - destx; |
| else |
| extend_rect->dWidth = *x11_window_width; |
| } else { |
| extend_rect->dWidth = pPriv->extend_display_width - destx; |
| if ((destx + *x11_window_width) > pPriv->display_width) |
| local_rect->dWidth = *x11_window_width = pPriv->display_width - destx; |
| else |
| local_rect->dWidth = *x11_window_width; |
| } |
| |
| if ((desty + *x11_window_height) > (pPriv->display_height + pPriv->extend_display_height)) { |
| *x11_window_height = pPriv->display_height + pPriv->extend_display_height - desty; |
| } |
| |
| if ((desty < pPriv->extend_display_height) && ((desty + *x11_window_height) < pPriv->extend_display_height)) { |
| local_rect->dHeight = 0; |
| extend_rect->dHeight = *x11_window_height; |
| *extend_overlay = OVERLAY_A; |
| local_rect->desty = 0; |
| } else if ((desty < pPriv->extend_display_height) && ((desty + *x11_window_height) >= pPriv->extend_display_height)) { |
| extend_rect->dHeight = pPriv->extend_display_height - desty; |
| local_rect->dHeight = *x11_window_height - extend_rect->dHeight; |
| local_rect->desty = 0; |
| } else { |
| local_rect->dHeight = *x11_window_height; |
| extend_rect->dHeight = 0; |
| local_rect->desty = desty - pPriv->extend_display_height; |
| } |
| local_rect->sWidth = (unsigned short)(local_rect->dWidth * xScaleFactor); |
| local_rect->sHeight = (unsigned short)(local_rect->dHeight * yScaleFactor); |
| extend_rect->sWidth = (unsigned short)(extend_rect->dWidth * xScaleFactor); |
| extend_rect->sHeight = (unsigned short)(extend_rect->dHeight * yScaleFactor); |
| |
| local_rect->srcy = srcy + extend_rect->sHeight; |
| extend_rect->srcy = srcy; |
| local_rect->srcx = extend_rect->srcx = srcx; |
| |
| extend_rect->desty = desty; |
| local_rect->destx = extend_rect->destx = destx; |
| break; |
| case BELOW: |
| if (((destx + *x11_window_width) < pPriv->display_width) && |
| ((destx + *x11_window_width) < pPriv->extend_display_width)) |
| local_rect->dWidth = extend_rect->dWidth = *x11_window_width; |
| else if (pPriv->display_width < pPriv->extend_display_width) { |
| local_rect->dWidth = pPriv->display_width - destx; |
| if ((destx + *x11_window_width) > pPriv->extend_display_width) |
| extend_rect->dWidth = *x11_window_width = pPriv->extend_display_width - destx; |
| else |
| extend_rect->dWidth = *x11_window_width; |
| } else { |
| extend_rect->dWidth = pPriv->extend_display_width - destx; |
| if ((destx + *x11_window_width) > pPriv->display_width) |
| local_rect->dWidth = *x11_window_width = pPriv->display_width - destx; |
| else |
| local_rect->dWidth = *x11_window_width; |
| } |
| |
| if ((desty + *x11_window_height) > (pPriv->display_height + pPriv->extend_display_height)) { |
| *x11_window_height = pPriv->display_height + pPriv->extend_display_height - desty; |
| } |
| |
| if ((desty < pPriv->display_height) && ((desty + *x11_window_height) < pPriv->display_height)) { |
| local_rect->dHeight = *x11_window_height; |
| extend_rect->dHeight = 0; |
| extend_rect->desty = 0; |
| } else if ((desty < pPriv->display_height) && ((desty + *x11_window_height) >= pPriv->display_height)) { |
| local_rect->dHeight = pPriv->display_height - desty; |
| extend_rect->dHeight = *x11_window_height - local_rect->dHeight; |
| extend_rect->desty = 0; |
| } else { |
| local_rect->dHeight = 0; |
| extend_rect->dHeight = *x11_window_height; |
| *extend_overlay = OVERLAY_A; |
| extend_rect->desty = desty - pPriv->display_height; |
| } |
| local_rect->sWidth = (unsigned short)(local_rect->dWidth * xScaleFactor); |
| local_rect->sHeight = (unsigned short)(local_rect->dHeight * yScaleFactor); |
| extend_rect->sWidth = (unsigned short)(extend_rect->dWidth * xScaleFactor); |
| extend_rect->sHeight = (unsigned short)(extend_rect->dHeight * yScaleFactor); |
| |
| local_rect->srcy = srcy; |
| extend_rect->srcy = srcy + local_rect->sHeight; |
| local_rect->srcx = extend_rect->srcx = srcx; |
| |
| local_rect->desty = desty; |
| local_rect->destx = extend_rect->destx = destx; |
| break; |
| case NORMAL: |
| default: |
| break; |
| } |
| return VA_STATUS_SUCCESS; |
| } |
| |
| static void psb_init_subpicture(VADriverContextP ctx, PsbPortPrivPtr pPriv) |
| { |
| INIT_DRIVER_DATA; |
| struct drm_psb_register_rw_arg regs; |
| unsigned int subpicture_enable_mask = REGRWBITS_DSPACNTR; |
| |
| if (!pPriv->subpicture_enabled) { |
| if (psb_xrandr_hdmi_enabled()) |
| subpicture_enable_mask |= REGRWBITS_DSPBCNTR; |
| if (psb_xrandr_mipi1_enabled()) |
| subpicture_enable_mask |= REGRWBITS_DSPCCNTR; |
| |
| memset(®s, 0, sizeof(regs)); |
| regs.subpicture_enable_mask = subpicture_enable_mask; |
| pPriv->subpicture_enable_mask = subpicture_enable_mask; |
| pPriv->subpicture_enabled = 1; |
| drmCommandWriteRead(driver_data->drm_fd, DRM_PSB_REGISTER_RW, ®s, sizeof(regs)); |
| } |
| } |
| |
| static void psb_clear_subpictures( |
| VADriverContextP ctx, |
| PsbPortPrivPtr pPriv, |
| int win_width, |
| int win_height, |
| object_surface_p obj_surface |
| ) |
| { |
| INIT_OUTPUT_PRIV; |
| PsbVASurfaceRec *subpicture = (PsbVASurfaceRec *)obj_surface->subpictures; |
| int i; |
| |
| if (subpicture == NULL) { |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "Surface has no subpicture to render.\n"); |
| return; |
| } |
| |
| for (i = 0; subpicture != NULL; subpicture = subpicture->next, i++) { |
| if ((subpicture->subpic_dstx != pPriv->clear_key[i].subpic_dstx) || |
| (subpicture->subpic_dsty != pPriv->clear_key[i].subpic_dsty) || |
| (subpicture->subpic_dstw != pPriv->clear_key[i].subpic_dstw) || |
| (subpicture->subpic_dsth != pPriv->clear_key[i].subpic_dsth)) { |
| XSetForeground((Display *)ctx->native_dpy, output->gc, 0); |
| XFillRectangle((Display *)ctx->native_dpy, output->output_drawable, output->gc, 0, 0, win_width, win_height); |
| XSync((Display *)ctx->native_dpy, False); |
| if (psb_xrandr_extvideo_mode()) { |
| XSetForeground((Display *)ctx->native_dpy, output->extend_gc, 0); |
| XFillRectangle((Display *)ctx->native_dpy, output->extend_drawable, output->extend_gc, |
| 0, 0, pPriv->extend_display_width, pPriv->extend_display_height); |
| XSync((Display *)ctx->native_dpy, False); |
| } |
| pPriv->subpic_clear_flag = 1; |
| } |
| } |
| return; |
| } |
| |
| VAStatus psb_putsurface_coverlay( |
| VADriverContextP ctx, |
| VASurfaceID surface, |
| Drawable draw, /* X Drawable */ |
| short srcx, |
| short srcy, |
| unsigned short srcw, |
| unsigned short srch, |
| short destx, |
| short desty, |
| unsigned short destw, |
| unsigned short desth, |
| VARectangle *cliprects, /* client supplied clip list */ |
| unsigned int number_cliprects, /* number of clip rects in the clip list */ |
| unsigned int flags /* de-interlacing flags */ |
| ) |
| { |
| INIT_DRIVER_DATA; |
| INIT_OUTPUT_PRIV; |
| int ret; |
| int x11_window_width = destw, x11_window_height = desth; |
| psb_xrandr_location extend_location; |
| object_surface_p obj_surface = SURFACE(surface); |
| PsbPortPrivRec *pPriv = (PsbPortPrivPtr)(&driver_data->coverlay_priv); |
| int primary_crtc_x, primary_crtc_y, extend_crtc_x, extend_crtc_y; |
| enum pipe_id_t local_pipe = PIPEA, extend_pipe = PIPEB; |
| int surfacex = destx, surfacey = desty; |
| float xScaleFactor, yScaleFactor; |
| Rotation rotation = RR_Rotate_0; |
| psb_output_device local_device, extend_device; |
| psb_extvideo_subtitle subtitle; |
| |
| if (flags & VA_CLEAR_DRAWABLE) { |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "Clean draw with color 0x%08x\n", driver_data->clear_color); |
| psb_cleardrawable_stopoverlay(ctx, draw, destx, desty, destw, desth); |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| if (output->frame_count % 500 == 0 || driver_data->xrandr_update) { |
| /* get window screen coordination */ |
| ret = psb_x11_getWindowCoordinate(ctx->native_dpy, draw, &output->winRect, &output->bIsVisible); |
| if (ret != 0) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Failed to get X11 window coordinates error # %d\n", __func__, ret); |
| return VA_STATUS_ERROR_UNKNOWN; |
| } |
| } |
| |
| if (!output->bIsVisible) { |
| return VA_STATUS_SUCCESS; |
| } |
| |
| if (NULL == obj_surface) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Invalid surface id 0x%08x.\n", __func__, surface); |
| return VA_STATUS_ERROR_INVALID_SURFACE; |
| } |
| |
| if (output->output_drawable != draw) { |
| output->output_drawable = draw; |
| } |
| |
| if (!output->gc) { |
| output->gc = XCreateGC((Display *)ctx->native_dpy, draw, 0, NULL); |
| /* paint the color key */ |
| if (!obj_surface->subpictures && !driver_data->overlay_auto_paint_color_key) { |
| XSetForeground((Display *)ctx->native_dpy, output->gc, pPriv->colorKey); |
| XFillRectangle((Display *)ctx->native_dpy, draw, output->gc, 0, 0, x11_window_width, x11_window_height); |
| XSync((Display *)ctx->native_dpy, False); |
| } |
| } |
| |
| if (driver_data->use_xrandr_thread && !driver_data->xrandr_thread_id) { |
| ret = psb_xrandr_thread_create(ctx); |
| if (ret != 0) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Failed to create psb xrandr thread error # %d\n", __func__, ret); |
| return VA_STATUS_ERROR_UNKNOWN; |
| } |
| } |
| |
| ret = psb_xrandr_local_crtc_coordinate(&local_device, &primary_crtc_x, &primary_crtc_y, &pPriv->display_width, &pPriv->display_height, &rotation); |
| if (ret != VA_STATUS_SUCCESS) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Failed to get primary crtc coordinates error # %d\n", __func__, ret); |
| return VA_STATUS_ERROR_UNKNOWN; |
| } |
| switch (local_device) { |
| case LVDS0: |
| case MIPI0: |
| local_pipe = PIPEA; |
| break; |
| /* single HDMI */ |
| case HDMI: |
| local_pipe = PIPEB; |
| break; |
| case MIPI1: |
| local_pipe = PIPEC; |
| break; |
| } |
| |
| if (!psb_xrandr_single_mode()) { |
| |
| ret = psb_xrandr_extend_crtc_coordinate(&extend_device, &extend_crtc_x, &extend_crtc_y, |
| &pPriv->extend_display_width, &pPriv->extend_display_height, &extend_location, &rotation); |
| if (ret != VA_STATUS_SUCCESS) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Failed to get extend crtc coordinates error # %d\n", __func__, ret); |
| return VA_STATUS_ERROR_UNKNOWN; |
| } |
| |
| switch (extend_device) { |
| case HDMI: |
| extend_pipe = PIPEB; |
| break; |
| case MIPI1: |
| extend_pipe = PIPEC; |
| break; |
| default: |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Failed to get extend pipe\n", __func__); |
| break; |
| } |
| } |
| |
| /*clip in the window area*/ |
| if (destx < 0) { |
| x11_window_width += destx; |
| destx = 0; |
| } |
| |
| if (desty < 0) { |
| x11_window_height += desty; |
| desty = 0; |
| } |
| |
| if (srcx < 0) { |
| srcw += srcx; |
| srcx = 0; |
| } |
| |
| if (srcy < 0) { |
| srch += srcy; |
| srcy = 0; |
| } |
| |
| if ((destx + x11_window_width) > output->winRect.ui32Width) |
| x11_window_width = output->winRect.ui32Width - destx; |
| |
| if ((desty + x11_window_height) > output->winRect.ui32Height) |
| x11_window_height = output->winRect.ui32Height - desty; |
| |
| /*translate destx, desty into screen coordinate*/ |
| destx += output->winRect.i32Left; |
| desty += output->winRect.i32Top; |
| |
| /*clip in the screen area*/ |
| xScaleFactor = srcw * 1.0 / x11_window_width; |
| yScaleFactor = srch * 1.0 / x11_window_height; |
| |
| if (destx < 0) { |
| x11_window_width += destx; |
| srcx = (short)((-destx) * xScaleFactor); |
| destx = 0; |
| } |
| |
| if (desty < 0) { |
| x11_window_height += desty; |
| srcy = (short)((-desty) * yScaleFactor); |
| desty = 0; |
| } |
| |
| /* display by overlay */ |
| if (psb_xrandr_single_mode() || IS_MRST(driver_data)) { |
| if ((destx + x11_window_width) > pPriv->display_width) { |
| x11_window_width = pPriv->display_width - destx; |
| srcw = (unsigned short)(x11_window_width * xScaleFactor); |
| } |
| |
| if ((desty + x11_window_height) > pPriv->display_height) { |
| x11_window_height = pPriv->display_height - desty; |
| srch = (unsigned short)(x11_window_height * yScaleFactor); |
| } |
| |
| if (!driver_data->overlay_auto_paint_color_key) { |
| ret = psb_repaint_colorkey(ctx, draw, surface, x11_window_width, x11_window_height); |
| if (ret != 0) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Failed to repaint color key error # %d\n", __func__, ret); |
| return VA_STATUS_ERROR_UNKNOWN; |
| } |
| } |
| |
| psb_putsurface_overlay( |
| ctx, surface, srcx, srcy, srcw, srch, |
| /* screen coordinate */ |
| destx, desty, x11_window_width, x11_window_height, |
| flags, OVERLAY_A, local_pipe); |
| } else if (psb_xrandr_clone_mode()) { |
| psb_overlay_rect_t local_rect, extend_rect; |
| |
| if (output->extend_drawable) { |
| XDestroyWindow(ctx->native_dpy, output->extend_drawable); |
| output->extend_drawable = 0; |
| XFreeGC((Display *)ctx->native_dpy, output->extend_gc); |
| output->extend_gc = 0; |
| } |
| |
| if (((destx + x11_window_width) < pPriv->display_width) && |
| ((destx + x11_window_width) < pPriv->extend_display_width)) |
| local_rect.dWidth = extend_rect.dWidth = x11_window_width; |
| else if (pPriv->display_width < pPriv->extend_display_width) { |
| local_rect.dWidth = pPriv->display_width - destx; |
| if ((destx + x11_window_width) > pPriv->extend_display_width) |
| extend_rect.dWidth = x11_window_width = pPriv->extend_display_width - destx; |
| else |
| extend_rect.dWidth = x11_window_width; |
| } else { |
| extend_rect.dWidth = pPriv->extend_display_width - destx; |
| if ((destx + x11_window_width) > pPriv->display_width) |
| local_rect.dWidth = x11_window_width = pPriv->display_width - destx; |
| else |
| local_rect.dWidth = x11_window_width; |
| } |
| |
| if (((desty + x11_window_height) < pPriv->display_height) && |
| ((desty + x11_window_height) < pPriv->extend_display_height)) |
| local_rect.dHeight = extend_rect.dHeight = x11_window_height; |
| else if (pPriv->display_height < pPriv->extend_display_height) { |
| local_rect.dHeight = pPriv->display_height - desty; |
| if ((desty + x11_window_height) > pPriv->extend_display_height) |
| extend_rect.dHeight = x11_window_height = pPriv->extend_display_height - desty; |
| else |
| extend_rect.dHeight = x11_window_height; |
| } else { |
| extend_rect.dHeight = pPriv->extend_display_height - desty; |
| if ((desty + x11_window_height) > pPriv->display_height) |
| local_rect.dHeight = x11_window_height = pPriv->display_height - desty; |
| else |
| local_rect.dHeight = x11_window_height; |
| } |
| if ((driver_data->mipi0_rotation != VA_ROTATION_NONE) || |
| (driver_data->hdmi_rotation != VA_ROTATION_NONE)) { |
| local_rect.sWidth = srcw; |
| local_rect.sHeight = srch; |
| extend_rect.sWidth = srcw; |
| extend_rect.sHeight = srch; |
| } else { |
| local_rect.sWidth = (unsigned short)(local_rect.dWidth * xScaleFactor); |
| local_rect.sHeight = (unsigned short)(local_rect.dHeight * yScaleFactor); |
| extend_rect.sWidth = (unsigned short)(extend_rect.dWidth * xScaleFactor); |
| extend_rect.sHeight = (unsigned short)(extend_rect.dHeight * yScaleFactor); |
| } |
| ret = psb_repaint_colorkey(ctx, draw, surface, x11_window_width, x11_window_height); |
| if (ret != 0) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Failed to repaint color key error # %d\n", __func__, ret); |
| return VA_STATUS_ERROR_UNKNOWN; |
| } |
| psb_putsurface_overlay( |
| ctx, surface, srcx, srcy, extend_rect.sWidth, extend_rect.sHeight, |
| /* screen coordinate */ |
| destx, desty, extend_rect.dWidth, extend_rect.dHeight, |
| flags, OVERLAY_C, extend_pipe); |
| psb_putsurface_overlay( |
| ctx, surface, srcx, srcy, local_rect.sWidth, local_rect.sHeight, |
| /* screen coordinate */ |
| destx, desty, local_rect.dWidth, local_rect.dHeight, |
| flags, OVERLAY_A, local_pipe); |
| } else if (psb_xrandr_extend_mode()) { |
| if (driver_data->extend_fullscreen) { |
| switch (extend_location) { |
| case RIGHT_OF: |
| XMoveResizeWindow(ctx->native_dpy, output->output_drawable, pPriv->display_width, 0, pPriv->extend_display_width, pPriv->extend_display_height); |
| break; |
| case BELOW: |
| XMoveResizeWindow(ctx->native_dpy, output->output_drawable, 0, pPriv->display_height, pPriv->extend_display_width, pPriv->extend_display_height); |
| break; |
| case LEFT_OF: |
| case ABOVE: |
| XMoveResizeWindow(ctx->native_dpy, output->output_drawable, 0, 0, pPriv->extend_display_width, pPriv->extend_display_height); |
| break; |
| default: |
| break; |
| |
| } |
| XSetForeground((Display *)ctx->native_dpy, output->gc, pPriv->colorKey); |
| XFillRectangle((Display *)ctx->native_dpy, draw, output->gc, 0, 0, pPriv->extend_display_width, pPriv->extend_display_height); |
| XFlush(ctx->native_dpy); |
| |
| psb_putsurface_overlay( |
| ctx, surface, srcx, srcy, srcw, srch, |
| /* screen coordinate */ |
| 0, 0, pPriv->extend_display_width, pPriv->extend_display_height, |
| flags, OVERLAY_A, PIPEB); |
| } else { |
| psb_overlay_rect_t local_rect, extend_rect; |
| enum overlay_id_t extend_overlay = OVERLAY_C; |
| |
| if (output->extend_drawable) { |
| XDestroyWindow(ctx->native_dpy, output->extend_drawable); |
| output->extend_drawable = 0; |
| XFreeGC((Display *)ctx->native_dpy, output->extend_gc); |
| output->extend_gc = 0; |
| } |
| memset(&local_rect, 0, sizeof(psb_overlay_rect_t)); |
| memset(&extend_rect, 0, sizeof(psb_overlay_rect_t)); |
| psb_extendMode_getCoordinate(pPriv, extend_location, destx, desty, srcx, srcy, |
| xScaleFactor, yScaleFactor, &x11_window_width, &x11_window_height, |
| &local_rect, &extend_rect, &extend_overlay); |
| |
| ret = psb_repaint_colorkey(ctx, draw, surface, x11_window_width, x11_window_height); |
| if (ret != 0) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Failed to repaint color key error # %d\n", __func__, ret); |
| return VA_STATUS_ERROR_UNKNOWN; |
| } |
| |
| if ((extend_rect.dWidth > 0) && (extend_rect.dHeight > 0)) { |
| psb_putsurface_overlay( |
| ctx, surface, |
| extend_rect.srcx, extend_rect.srcy, extend_rect.sWidth, extend_rect.sHeight, |
| extend_rect.destx, extend_rect.desty, extend_rect.dWidth, extend_rect.dHeight, |
| flags, extend_overlay, extend_pipe); |
| } |
| if ((local_rect.dWidth > 0) && (local_rect.dHeight > 0)) { |
| psb_putsurface_overlay( |
| ctx, surface, |
| local_rect.srcx, local_rect.srcy, local_rect.sWidth, local_rect.sHeight, |
| local_rect.destx, local_rect.desty, local_rect.dWidth, local_rect.dHeight, |
| flags, OVERLAY_A, local_pipe); |
| } |
| } |
| } else if (psb_xrandr_extvideo_mode()) { |
| unsigned int xres, yres, xoffset, yoffset, overscanmode, pannelfitting, x, y; |
| psb_extvideo_center center; |
| |
| psb_xrandr_extvideo_prop(&xres, &yres, &xoffset, &yoffset, ¢er, &subtitle, &overscanmode, &pannelfitting); |
| x = xoffset; |
| y = yoffset; |
| |
| switch (extend_location) { |
| case RIGHT_OF: |
| x += pPriv->display_width; |
| break; |
| case BELOW: |
| y += pPriv->display_height; |
| break; |
| case NORMAL: |
| break; |
| case LEFT_OF: |
| if (driver_data->xrandr_dirty & PSB_NEW_EXTVIDEO) { |
| destx += pPriv->extend_display_width; |
| XMoveResizeWindow(ctx->native_dpy, output->output_drawable, destx, desty, x11_window_width, x11_window_height); |
| XFillRectangle((Display *)ctx->native_dpy, draw, output->gc, 0, 0, x11_window_width, x11_window_height); |
| XFlush(ctx->native_dpy); |
| } |
| destx = destx - pPriv->extend_display_width; |
| break; |
| case ABOVE: |
| if (driver_data->xrandr_dirty & PSB_NEW_EXTVIDEO) { |
| desty += pPriv->extend_display_height; |
| XMoveResizeWindow(ctx->native_dpy, output->output_drawable, destx, desty, x11_window_width, x11_window_height); |
| XFillRectangle((Display *)ctx->native_dpy, draw, output->gc, 0, 0, x11_window_width, x11_window_height); |
| XFlush(ctx->native_dpy); |
| } |
| desty = desty - pPriv->extend_display_height; |
| break; |
| } |
| if ((destx + x11_window_width) > pPriv->display_width) |
| x11_window_width = pPriv->display_width - destx; |
| if ((desty + x11_window_height) > pPriv->display_height) |
| x11_window_height = pPriv->display_height - desty; |
| |
| if (driver_data->xrandr_dirty & PSB_NEW_EXTVIDEO) { |
| Window extend_win; |
| extend_win = psb_xrandr_create_full_screen_window(x, y, xres, yres); |
| if (output->extend_drawable != extend_win) { |
| output->extend_drawable = extend_win; |
| if (output->extend_gc) |
| XFreeGC((Display *)ctx->native_dpy, output->extend_gc); |
| output->extend_gc = XCreateGC((Display *)ctx->native_dpy, extend_win, 0, NULL); |
| |
| /* paint the color key */ |
| if (!obj_surface->subpictures) { |
| XSetForeground((Display *)ctx->native_dpy, output->extend_gc, pPriv->colorKey); |
| XFillRectangle((Display *)ctx->native_dpy, extend_win, output->extend_gc, 0, 0, xres, yres); |
| XSync((Display *)ctx->native_dpy, False); |
| } |
| } |
| driver_data->xrandr_dirty &= ~PSB_NEW_EXTVIDEO; |
| } |
| |
| ret = psb_repaint_colorkey(ctx, draw, surface, x11_window_width, x11_window_height); |
| if (ret != 0) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Failed to repaint color key error # %d\n", __func__, ret); |
| return VA_STATUS_ERROR_UNKNOWN; |
| } |
| |
| psb_putsurface_overlay( |
| ctx, surface, srcx, srcy, srcw, srch, |
| /* screen coordinate */ |
| xoffset, yoffset, xres, yres, |
| flags, OVERLAY_C, PIPEB); |
| psb_putsurface_overlay( |
| ctx, surface, srcx, srcy, srcw, srch, |
| /* screen coordinate */ |
| destx, desty, |
| x11_window_width, x11_window_height, |
| flags, OVERLAY_A, local_pipe); |
| } |
| |
| /*Init Overlay subpicuture blending and make proper clear.*/ |
| if (pPriv->is_mfld && obj_surface->subpictures) { |
| PsbVASurfaceRec *subpicture = (PsbVASurfaceRec *)obj_surface->subpictures; |
| |
| psb_init_subpicture(ctx, pPriv); |
| /*clear changed subpicture zones in drawable.*/ |
| psb_clear_subpictures(ctx, pPriv, x11_window_width, x11_window_height, obj_surface); |
| if (pPriv->subpic_clear_flag) { |
| psb_DisplayRGBASubpicture(subpicture, ctx, x11_window_width, x11_window_height, |
| surfacex, surfacey, obj_surface->width, obj_surface->height, subtitle); |
| } |
| } |
| |
| output->frame_count++; |
| |
| return VA_STATUS_SUCCESS; |
| } |
