#include "xorg_tracker.h" #include #include #include #include "xorg_exa.h" #include "xorg_renderer.h" #include "xorg_exa_tgsi.h" #include "cso_cache/cso_context.h" #include "util/u_sampler.h" #include "pipe/p_screen.h" /*XXX get these from pipe's texture limits */ #define IMAGE_MAX_WIDTH 2048 #define IMAGE_MAX_HEIGHT 2048 #define RES_720P_X 1280 #define RES_720P_Y 720 /* The ITU-R BT.601 conversion matrix for SDTV. */ /* original, matrix, but we transpose it to * make the shader easier static const float bt_601[] = { 1.0, 0.0, 1.4075, , 1.0, -0.3455, -0.7169, 0, 1.0, 1.7790, 0., 0, };*/ static const float bt_601[] = { 1.0, 1.0, 1.0, 0.5, 0.0, -0.3455, 1.7790, 0, 1.4075, -0.7169, 0., 0, }; /* The ITU-R BT.709 conversion matrix for HDTV. */ /* original, but we transpose to make the conversion * in the shader easier static const float bt_709[] = { 1.0, 0.0, 1.581, 0, 1.0, -0.1881, -0.47, 0, 1.0, 1.8629, 0., 0, };*/ static const float bt_709[] = { 1.0, 1.0, 1.0, 0.5, 0.0, -0.1881, 1.8629, 0, 1.581,-0.47 , 0.0, 0, }; #define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE) static Atom xvBrightness, xvContrast; #define NUM_TEXTURED_ATTRIBUTES 2 static XF86AttributeRec TexturedAttributes[NUM_TEXTURED_ATTRIBUTES] = { {XvSettable | XvGettable, -128, 127, "XV_BRIGHTNESS"}, {XvSettable | XvGettable, 0, 255, "XV_CONTRAST"} }; #define NUM_FORMATS 3 static XF86VideoFormatRec Formats[NUM_FORMATS] = { {15, TrueColor}, {16, TrueColor}, {24, TrueColor} }; static XF86VideoEncodingRec DummyEncoding[1] = { { 0, "XV_IMAGE", IMAGE_MAX_WIDTH, IMAGE_MAX_HEIGHT, {1, 1} } }; #define NUM_IMAGES 3 static XF86ImageRec Images[NUM_IMAGES] = { XVIMAGE_UYVY, XVIMAGE_YUY2, XVIMAGE_YV12, }; struct xorg_xv_port_priv { struct xorg_renderer *r; RegionRec clip; int brightness; int contrast; int current_set; /* juggle two sets of seperate Y, U and V * textures */ struct pipe_resource *yuv[2][3]; struct pipe_sampler_view *yuv_views[2][3]; }; static void stop_video(ScrnInfoPtr pScrn, pointer data, Bool shutdown) { struct xorg_xv_port_priv *priv = (struct xorg_xv_port_priv *)data; REGION_EMPTY(pScrn->pScreen, &priv->clip); } static int set_port_attribute(ScrnInfoPtr pScrn, Atom attribute, INT32 value, pointer data) { struct xorg_xv_port_priv *priv = (struct xorg_xv_port_priv *)data; if (attribute == xvBrightness) { if ((value < -128) || (value > 127)) return BadValue; priv->brightness = value; } else if (attribute == xvContrast) { if ((value < 0) || (value > 255)) return BadValue; priv->contrast = value; } else return BadMatch; return Success; } static int get_port_attribute(ScrnInfoPtr pScrn, Atom attribute, INT32 * value, pointer data) { struct xorg_xv_port_priv *priv = (struct xorg_xv_port_priv *)data; if (attribute == xvBrightness) *value = priv->brightness; else if (attribute == xvContrast) *value = priv->contrast; else return BadMatch; return Success; } static void query_best_size(ScrnInfoPtr pScrn, Bool motion, short vid_w, short vid_h, short drw_w, short drw_h, unsigned int *p_w, unsigned int *p_h, pointer data) { if (vid_w > (drw_w << 1)) drw_w = vid_w >> 1; if (vid_h > (drw_h << 1)) drw_h = vid_h >> 1; *p_w = drw_w; *p_h = drw_h; } static INLINE struct pipe_resource * create_component_texture(struct pipe_context *pipe, int width, int height) { struct pipe_screen *screen = pipe->screen; struct pipe_resource *tex = 0; struct pipe_resource templ; memset(&templ, 0, sizeof(templ)); templ.target = PIPE_TEXTURE_2D; templ.format = PIPE_FORMAT_L8_UNORM; templ.last_level = 0; templ.width0 = width; templ.height0 = height; templ.depth0 = 1; templ.array_size = 1; templ.bind = PIPE_BIND_SAMPLER_VIEW; tex = screen->resource_create(screen, &templ); return tex; } static int check_yuv_textures(struct xorg_xv_port_priv *priv, int width, int height) { struct pipe_resource **dst = priv->yuv[priv->current_set]; struct pipe_sampler_view **dst_view = priv->yuv_views[priv->current_set]; struct pipe_sampler_view view_templ; struct pipe_context *pipe = priv->r->pipe; if (!dst[0] || dst[0]->width0 != width || dst[0]->height0 != height) { pipe_resource_reference(&dst[0], NULL); pipe_sampler_view_reference(&dst_view[0], NULL); } if (!dst[1] || dst[1]->width0 != width || dst[1]->height0 != height) { pipe_resource_reference(&dst[1], NULL); pipe_sampler_view_reference(&dst_view[1], NULL); } if (!dst[2] || dst[2]->width0 != width || dst[2]->height0 != height) { pipe_resource_reference(&dst[2], NULL); pipe_sampler_view_reference(&dst_view[2], NULL); } if (!dst[0]) { dst[0] = create_component_texture(priv->r->pipe, width, height); if (dst[0]) { u_sampler_view_default_template(&view_templ, dst[0], dst[0]->format); dst_view[0] = pipe->create_sampler_view(pipe, dst[0], &view_templ); } } if (!dst[1]) { dst[1] = create_component_texture(priv->r->pipe, width, height); if (dst[1]) { u_sampler_view_default_template(&view_templ, dst[1], dst[1]->format); dst_view[1] = pipe->create_sampler_view(pipe, dst[1], &view_templ); } } if (!dst[2]) { dst[2] = create_component_texture(priv->r->pipe, width, height); if (dst[2]) { u_sampler_view_default_template(&view_templ, dst[2], dst[2]->format); dst_view[2] = pipe->create_sampler_view(pipe, dst[2], &view_templ); } } if (!dst[0] || !dst[1] || !dst[2] || !dst_view[0] || !dst_view[1] || !dst_view[2] ) return BadAlloc; return Success; } static int query_image_attributes(ScrnInfoPtr pScrn, int id, unsigned short *w, unsigned short *h, int *pitches, int *offsets) { int size, tmp; if (*w > IMAGE_MAX_WIDTH) *w = IMAGE_MAX_WIDTH; if (*h > IMAGE_MAX_HEIGHT) *h = IMAGE_MAX_HEIGHT; *w = (*w + 1) & ~1; if (offsets) offsets[0] = 0; switch (id) { case FOURCC_YV12: *h = (*h + 1) & ~1; size = (*w + 3) & ~3; if (pitches) { pitches[0] = size; } size *= *h; if (offsets) { offsets[1] = size; } tmp = ((*w >> 1) + 3) & ~3; if (pitches) { pitches[1] = pitches[2] = tmp; } tmp *= (*h >> 1); size += tmp; if (offsets) { offsets[2] = size; } size += tmp; break; case FOURCC_UYVY: case FOURCC_YUY2: default: size = *w << 1; if (pitches) pitches[0] = size; size *= *h; break; } return size; } static void copy_packed_data(ScrnInfoPtr pScrn, struct xorg_xv_port_priv *port, int id, unsigned char *buf, int left, int top, unsigned short w, unsigned short h) { int i, j; struct pipe_resource **dst = port->yuv[port->current_set]; struct pipe_transfer *ytrans, *utrans, *vtrans; struct pipe_context *pipe = port->r->pipe; char *ymap, *vmap, *umap; unsigned char y1, y2, u, v; int yidx, uidx, vidx; int y_array_size = w * h; ymap = pipe_transfer_map(pipe, dst[0], 0, 0, PIPE_TRANSFER_WRITE, left, top, w, h, &ytrans); umap = pipe_transfer_map(pipe, dst[1], 0, 0, PIPE_TRANSFER_WRITE, left, top, w, h, &utrans); vmap = pipe_transfer_map(pipe, dst[2], 0, 0, PIPE_TRANSFER_WRITE, left, top, w, h, &vtrans); yidx = uidx = vidx = 0; switch (id) { case FOURCC_YV12: { int pitches[3], offsets[3]; unsigned char *y, *u, *v; query_image_attributes(pScrn, FOURCC_YV12, &w, &h, pitches, offsets); y = buf + offsets[0]; v = buf + offsets[1]; u = buf + offsets[2]; for (i = 0; i < h; ++i) { for (j = 0; j < w; ++j) { int yoffset = (w*i+j); int ii = (i|1), jj = (j|1); int vuoffset = (w/2)*(ii/2) + (jj/2); ymap[yidx++] = y[yoffset]; umap[uidx++] = u[vuoffset]; vmap[vidx++] = v[vuoffset]; } } } break; case FOURCC_UYVY: for (i = 0; i < y_array_size; i +=2 ) { /* extracting two pixels */ u = buf[0]; y1 = buf[1]; v = buf[2]; y2 = buf[3]; buf += 4; ymap[yidx++] = y1; ymap[yidx++] = y2; umap[uidx++] = u; umap[uidx++] = u; vmap[vidx++] = v; vmap[vidx++] = v; } break; case FOURCC_YUY2: for (i = 0; i < y_array_size; i +=2 ) { /* extracting two pixels */ y1 = buf[0]; u = buf[1]; y2 = buf[2]; v = buf[3]; buf += 4; ymap[yidx++] = y1; ymap[yidx++] = y2; umap[uidx++] = u; umap[uidx++] = u; vmap[vidx++] = v; vmap[vidx++] = v; } break; default: debug_assert(!"Unsupported yuv format!"); break; } pipe->transfer_unmap(pipe, ytrans); pipe->transfer_unmap(pipe, utrans); pipe->transfer_unmap(pipe, vtrans); } static void setup_fs_video_constants(struct xorg_renderer *r, boolean hdtv) { const int param_bytes = 12 * sizeof(float); const float *video_constants = (hdtv) ? bt_709 : bt_601; renderer_set_constants(r, PIPE_SHADER_FRAGMENT, video_constants, param_bytes); } static void draw_yuv(struct xorg_xv_port_priv *port, float src_x, float src_y, float src_w, float src_h, int dst_x, int dst_y, int dst_w, int dst_h) { struct pipe_resource **textures = port->yuv[port->current_set]; /*debug_printf(" draw_yuv([%d, %d, %d ,%d], [%d, %d, %d, %d])\n", src_x, src_y, src_w, src_h, dst_x, dst_y, dst_w, dst_h);*/ renderer_draw_yuv(port->r, src_x, src_y, src_w, src_h, dst_x, dst_y, dst_w, dst_h, textures); } static void bind_blend_state(struct xorg_xv_port_priv *port) { struct pipe_blend_state blend; memset(&blend, 0, sizeof(struct pipe_blend_state)); blend.rt[0].blend_enable = 0; blend.rt[0].colormask = PIPE_MASK_RGBA; /* porter&duff src */ blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE; blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE; blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO; blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO; cso_set_blend(port->r->cso, &blend); } static void bind_shaders(struct xorg_xv_port_priv *port) { unsigned vs_traits = 0, fs_traits = 0; struct xorg_shader shader; vs_traits |= VS_YUV; fs_traits |= FS_YUV; shader = xorg_shaders_get(port->r->shaders, vs_traits, fs_traits); cso_set_vertex_shader_handle(port->r->cso, shader.vs); cso_set_fragment_shader_handle(port->r->cso, shader.fs); } static void bind_samplers(struct xorg_xv_port_priv *port) { struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS]; struct pipe_sampler_state sampler; struct pipe_sampler_view **dst_views = port->yuv_views[port->current_set]; memset(&sampler, 0, sizeof(struct pipe_sampler_state)); sampler.wrap_s = PIPE_TEX_WRAP_CLAMP; sampler.wrap_t = PIPE_TEX_WRAP_CLAMP; sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR; sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR; sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST; sampler.normalized_coords = 1; samplers[0] = &sampler; samplers[1] = &sampler; samplers[2] = &sampler; cso_set_samplers(port->r->cso, PIPE_SHADER_FRAGMENT, 3, (const struct pipe_sampler_state **)samplers); cso_set_sampler_views(port->r->cso, PIPE_SHADER_FRAGMENT, 3, dst_views); } static int display_video(ScrnInfoPtr pScrn, struct xorg_xv_port_priv *pPriv, int id, RegionPtr dstRegion, int src_x, int src_y, int src_w, int src_h, int dstX, int dstY, int dst_w, int dst_h, PixmapPtr pPixmap) { modesettingPtr ms = modesettingPTR(pScrn); BoxPtr pbox; int nbox; int dxo, dyo; Bool hdtv; int x, y, w, h; struct exa_pixmap_priv *dst; struct pipe_surface *dst_surf = NULL; exaMoveInPixmap(pPixmap); dst = exaGetPixmapDriverPrivate(pPixmap); /*debug_printf("display_video([%d, %d, %d, %d], [%d, %d, %d, %d])\n", src_x, src_y, src_w, src_h, dstX, dstY, dst_w, dst_h);*/ if (dst && !dst->tex) { xorg_exa_set_shared_usage(pPixmap); pScrn->pScreen->ModifyPixmapHeader(pPixmap, 0, 0, 0, 0, 0, NULL); } if (!dst || !dst->tex) XORG_FALLBACK("Xv destination %s", !dst ? "!dst" : "!dst->tex"); dst_surf = xorg_gpu_surface(pPriv->r->pipe, dst); hdtv = ((src_w >= RES_720P_X) && (src_h >= RES_720P_Y)); #ifdef COMPOSITE REGION_TRANSLATE(pScrn->pScreen, dstRegion, -pPixmap->screen_x, -pPixmap->screen_y); #endif dxo = dstRegion->extents.x1; dyo = dstRegion->extents.y1; pbox = REGION_RECTS(dstRegion); nbox = REGION_NUM_RECTS(dstRegion); renderer_bind_destination(pPriv->r, dst_surf, dst_surf->width, dst_surf->height); bind_blend_state(pPriv); bind_shaders(pPriv); bind_samplers(pPriv); setup_fs_video_constants(pPriv->r, hdtv); DamageDamageRegion(&pPixmap->drawable, dstRegion); while (nbox--) { int box_x1 = pbox->x1; int box_y1 = pbox->y1; int box_x2 = pbox->x2; int box_y2 = pbox->y2; float diff_x = (float)src_w / (float)dst_w; float diff_y = (float)src_h / (float)dst_h; float offset_x = box_x1 - dstX; float offset_y = box_y1 - dstY; float offset_w; float offset_h; #ifdef COMPOSITE offset_x += pPixmap->screen_x; offset_y += pPixmap->screen_y; #endif x = box_x1; y = box_y1; w = box_x2 - box_x1; h = box_y2 - box_y1; offset_w = dst_w - w; offset_h = dst_h - h; draw_yuv(pPriv, (float) src_x + offset_x*diff_x, (float) src_y + offset_y*diff_y, (float) src_w - offset_w*diff_x, (float) src_h - offset_h*diff_y, x, y, w, h); pbox++; } DamageRegionProcessPending(&pPixmap->drawable); pipe_surface_reference(&dst_surf, NULL); return TRUE; } static int put_image(ScrnInfoPtr pScrn, short src_x, short src_y, short drw_x, short drw_y, short src_w, short src_h, short drw_w, short drw_h, int id, unsigned char *buf, short width, short height, Bool sync, RegionPtr clipBoxes, pointer data, DrawablePtr pDraw) { struct xorg_xv_port_priv *pPriv = (struct xorg_xv_port_priv *) data; ScreenPtr pScreen = xf86ScrnToScreen(pScrn); PixmapPtr pPixmap; INT32 x1, x2, y1, y2; BoxRec dstBox; int ret; /* Clip */ x1 = src_x; x2 = src_x + src_w; y1 = src_y; y2 = src_y + src_h; dstBox.x1 = drw_x; dstBox.x2 = drw_x + drw_w; dstBox.y1 = drw_y; dstBox.y2 = drw_y + drw_h; if (!xf86XVClipVideoHelper(&dstBox, &x1, &x2, &y1, &y2, clipBoxes, width, height)) return Success; ret = check_yuv_textures(pPriv, width, height); if (ret) return ret; copy_packed_data(pScrn, pPriv, id, buf, src_x, src_y, width, height); if (pDraw->type == DRAWABLE_WINDOW) { pPixmap = (*pScreen->GetWindowPixmap)((WindowPtr)pDraw); } else { pPixmap = (PixmapPtr)pDraw; } display_video(pScrn, pPriv, id, clipBoxes, src_x, src_y, src_w, src_h, drw_x, drw_y, drw_w, drw_h, pPixmap); pPriv->current_set = (pPriv->current_set + 1) & 1; return Success; } static struct xorg_xv_port_priv * port_priv_create(struct xorg_renderer *r) { struct xorg_xv_port_priv *priv = NULL; priv = calloc(1, sizeof(struct xorg_xv_port_priv)); if (!priv) return NULL; priv->r = r; REGION_NULL(pScreen, &priv->clip); debug_assert(priv && priv->r); return priv; } static XF86VideoAdaptorPtr xorg_setup_textured_adapter(ScreenPtr pScreen) { ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); modesettingPtr ms = modesettingPTR(pScrn); XF86VideoAdaptorPtr adapt; XF86AttributePtr attrs; DevUnion *dev_unions; int nports = 16, i; int nattributes; nattributes = NUM_TEXTURED_ATTRIBUTES; debug_assert(ms->exa); debug_assert(ms->exa->renderer); adapt = calloc(1, sizeof(XF86VideoAdaptorRec)); dev_unions = calloc(nports, sizeof(DevUnion)); attrs = calloc(nattributes, sizeof(XF86AttributeRec)); if (adapt == NULL || dev_unions == NULL || attrs == NULL) { free(adapt); free(dev_unions); free(attrs); return NULL; } adapt->type = XvWindowMask | XvInputMask | XvImageMask; adapt->flags = 0; adapt->name = "Gallium3D Textured Video"; adapt->nEncodings = 1; adapt->pEncodings = DummyEncoding; adapt->nFormats = NUM_FORMATS; adapt->pFormats = Formats; adapt->nPorts = 0; adapt->pPortPrivates = dev_unions; adapt->nAttributes = nattributes; adapt->pAttributes = attrs; memcpy(attrs, TexturedAttributes, nattributes * sizeof(XF86AttributeRec)); adapt->nImages = NUM_IMAGES; adapt->pImages = Images; adapt->PutVideo = NULL; adapt->PutStill = NULL; adapt->GetVideo = NULL; adapt->GetStill = NULL; adapt->StopVideo = stop_video; adapt->SetPortAttribute = set_port_attribute; adapt->GetPortAttribute = get_port_attribute; adapt->QueryBestSize = query_best_size; adapt->PutImage = put_image; adapt->QueryImageAttributes = query_image_attributes; for (i = 0; i < nports; i++) { struct xorg_xv_port_priv *priv = port_priv_create(ms->exa->renderer); adapt->pPortPrivates[i].ptr = (pointer) (priv); adapt->nPorts++; } return adapt; } void xorg_xv_init(ScreenPtr pScreen) { ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); /*modesettingPtr ms = modesettingPTR(pScrn);*/ XF86VideoAdaptorPtr *adaptors, *new_adaptors = NULL; XF86VideoAdaptorPtr textured_adapter; int num_adaptors; num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors); new_adaptors = malloc((num_adaptors + 1) * sizeof(XF86VideoAdaptorPtr *)); if (new_adaptors == NULL) return; memcpy(new_adaptors, adaptors, num_adaptors * sizeof(XF86VideoAdaptorPtr)); adaptors = new_adaptors; /* Add the adaptors supported by our hardware. First, set up the atoms * that will be used by both output adaptors. */ xvBrightness = MAKE_ATOM("XV_BRIGHTNESS"); xvContrast = MAKE_ATOM("XV_CONTRAST"); textured_adapter = xorg_setup_textured_adapter(pScreen); debug_assert(textured_adapter); if (textured_adapter) { adaptors[num_adaptors++] = textured_adapter; } if (num_adaptors) { xf86XVScreenInit(pScreen, adaptors, num_adaptors); if (textured_adapter) xorg_xvmc_init(pScreen, textured_adapter->name); } else { xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "Disabling Xv because no adaptors could be initialized.\n"); } free(adaptors); }