int main(int argc, char *argv[]) { Display *dpy; unsigned int ver, rev, eventB, reqB, errorB; int i, j, k, n; unsigned int nencode, nadaptors; int nscreens, nattr, numImages; XvAdaptorInfo *ainfo; XvAttribute *attributes; XvEncodingInfo *encodings; XvFormat *format; XvImageFormatValues *formats; char *disname = NULL; char shortmode = 0; if ((argc > 4)) PrintUsage(); if (argc != 1) { for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-display")) { disname = argv[i + 1]; i++; } else if (!strcmp(argv[i], "-short")) shortmode = 1; else if (!strcmp(argv[i], "-version")) { printf("%s\n", PACKAGE_STRING); exit(0); } else { PrintUsage(); } } } if (!(dpy = XOpenDisplay(disname))) { fprintf(stderr, "xvinfo: Unable to open display %s\n", (disname != NULL) ? disname : XDisplayName(NULL)); exit(-1); } if ((Success != XvQueryExtension(dpy, &ver, &rev, &reqB, &eventB, &errorB))) { fprintf(stderr, "xvinfo: No X-Video Extension on %s\n", (disname != NULL) ? disname : XDisplayName(NULL)); exit(0); } else { fprintf(stdout, "X-Video Extension version %i.%i\n", ver, rev); } nscreens = ScreenCount(dpy); for (i = 0; i < nscreens; i++) { fprintf(stdout, "screen #%i\n", i); XvQueryAdaptors(dpy, RootWindow(dpy, i), &nadaptors, &ainfo); if (!nadaptors) { fprintf(stdout, " no adaptors present\n"); continue; } for (j = 0; j < nadaptors; j++) { fprintf(stdout, " Adaptor #%i: \"%s\"\n", j, ainfo[j].name); fprintf(stdout, " number of ports: %li\n", ainfo[j].num_ports); fprintf(stdout, " port base: %li\n", ainfo[j].base_id); fprintf(stdout, " operations supported: "); switch (ainfo[j].type & (XvInputMask | XvOutputMask)) { case XvInputMask: if (ainfo[j].type & XvVideoMask) fprintf(stdout, "PutVideo "); if (ainfo[j].type & XvStillMask) fprintf(stdout, "PutStill "); if (ainfo[j].type & XvImageMask) fprintf(stdout, "PutImage "); break; case XvOutputMask: if (ainfo[j].type & XvVideoMask) fprintf(stdout, "GetVideo "); if (ainfo[j].type & XvStillMask) fprintf(stdout, "GetStill "); break; default: fprintf(stdout, "none "); break; } fprintf(stdout, "\n"); format = ainfo[j].formats; if (!shortmode) { fprintf(stdout, " supported visuals:\n"); for (k = 0; k < ainfo[j].num_formats; k++, format++) { fprintf(stdout, " depth %i, visualID 0x%2lx\n", format->depth, format->visual_id); } } attributes = XvQueryPortAttributes(dpy, ainfo[j].base_id, &nattr); if (attributes && nattr) { fprintf(stdout, " number of attributes: %i\n", nattr); for (k = 0; k < nattr; k++) { fprintf(stdout, " \"%s\" (range %i to %i)\n", attributes[k].name, attributes[k].min_value, attributes[k].max_value); if (attributes[k].flags & XvSettable) { if (!shortmode) fprintf(stdout, " client settable attribute\n"); else fprintf(stdout, " settable"); } if (attributes[k].flags & XvGettable) { Atom the_atom; int value; if (!shortmode) fprintf(stdout, " client gettable attribute"); else fprintf(stdout, ", gettable"); the_atom = XInternAtom(dpy, attributes[k].name, True); if (the_atom != None) { if ((Success == XvGetPortAttribute(dpy, ainfo[j].base_id, the_atom, &value))) fprintf(stdout, " (current value is %i)", value); } fprintf(stdout, "\n"); } else if (shortmode) fprintf(stdout, "\n"); } XFree(attributes); } else { fprintf(stdout, " no port attributes defined\n"); } XvQueryEncodings(dpy, ainfo[j].base_id, &nencode, &encodings); if (encodings && nencode) { int ImageEncodings = 0; for (n = 0; n < nencode; n++) { if (!strcmp(encodings[n].name, "XV_IMAGE")) ImageEncodings++; } if (nencode - ImageEncodings) { fprintf(stdout, " number of encodings: %i\n", nencode - ImageEncodings); for (n = 0; n < nencode; n++) { if (strcmp(encodings[n].name, "XV_IMAGE")) { fprintf(stdout, " encoding ID #%li: \"%s\"\n", encodings[n].encoding_id, encodings[n].name); fprintf(stdout, " size: %li x %li\n", encodings[n].width, encodings[n].height); fprintf(stdout, " rate: %f\n", (float) encodings[n].rate.numerator / (float) encodings[n].rate.denominator); } } } if (ImageEncodings && (ainfo[j].type & XvImageMask)) { char imageName[5]; for (n = 0; n < nencode; n++) { if (!strcmp(encodings[n].name, "XV_IMAGE")) { fprintf(stdout, " maximum XvImage size: %li x %li\n", encodings[n].width, encodings[n].height); break; } } formats = XvListImageFormats(dpy, ainfo[j].base_id, &numImages); fprintf(stdout, " Number of image formats: %i\n", numImages); for (n = 0; n < numImages; n++) { sprintf(imageName, "%c%c%c%c", formats[n].id & 0xff, (formats[n].id >> 8) & 0xff, (formats[n].id >> 16) & 0xff, (formats[n].id >> 24) & 0xff); fprintf(stdout, " id: 0x%x", formats[n].id); if (isprint(imageName[0]) && isprint(imageName[1]) && isprint(imageName[2]) && isprint(imageName[3])) { fprintf(stdout, " (%s)\n", imageName); } else { fprintf(stdout, "\n"); } if (!shortmode) { fprintf(stdout, " guid: "); fprintf(stdout, "%02x", (unsigned char) formats[n].guid[0]); fprintf(stdout, "%02x", (unsigned char) formats[n].guid[1]); fprintf(stdout, "%02x", (unsigned char) formats[n].guid[2]); fprintf(stdout, "%02x-", (unsigned char) formats[n].guid[3]); fprintf(stdout, "%02x", (unsigned char) formats[n].guid[4]); fprintf(stdout, "%02x-", (unsigned char) formats[n].guid[5]); fprintf(stdout, "%02x", (unsigned char) formats[n].guid[6]); fprintf(stdout, "%02x-", (unsigned char) formats[n].guid[7]); fprintf(stdout, "%02x", (unsigned char) formats[n].guid[8]); fprintf(stdout, "%02x-", (unsigned char) formats[n].guid[9]); fprintf(stdout, "%02x", (unsigned char) formats[n].guid[10]); fprintf(stdout, "%02x", (unsigned char) formats[n].guid[11]); fprintf(stdout, "%02x", (unsigned char) formats[n].guid[12]); fprintf(stdout, "%02x", (unsigned char) formats[n].guid[13]); fprintf(stdout, "%02x", (unsigned char) formats[n].guid[14]); fprintf(stdout, "%02x\n", (unsigned char) formats[n].guid[15]); fprintf(stdout, " bits per pixel: %i\n", formats[n].bits_per_pixel); fprintf(stdout, " number of planes: %i\n", formats[n].num_planes); fprintf(stdout, " type: %s (%s)\n", (formats[n].type == XvRGB) ? "RGB" : "YUV", (formats[n].format == XvPacked) ? "packed" : "planar"); if (formats[n].type == XvRGB) { fprintf(stdout, " depth: %i\n", formats[n].depth); fprintf(stdout, " red, green, blue masks: " "0x%x, 0x%x, 0x%x\n", formats[n].red_mask, formats[n].green_mask, formats[n].blue_mask); } else { } } } if (formats) XFree(formats); } XvFreeEncodingInfo(encodings); } }
static void gst_v4l2_xoverlay_open (GstV4l2Object * v4l2object) { struct stat s; GstV4l2Xv *v4l2xv; const gchar *name = g_getenv ("DISPLAY"); unsigned int ver, rel, req, ev, err, anum; int i, id = 0, first_id = 0, min; XvAdaptorInfo *ai; Display *dpy; /* we need a display, obviously */ if (!name || !(dpy = XOpenDisplay (name))) { GST_WARNING_OBJECT (v4l2object->element, "No $DISPLAY set or failed to open - no overlay"); return; } /* First let's check that XVideo extension is available */ if (!XQueryExtension (dpy, "XVideo", &i, &i, &i)) { GST_WARNING_OBJECT (v4l2object->element, "Xv extension not available - no overlay"); XCloseDisplay (dpy); return; } /* find port that belongs to this device */ if (XvQueryExtension (dpy, &ver, &rel, &req, &ev, &err) != Success) { GST_WARNING_OBJECT (v4l2object->element, "Xv extension not supported - no overlay"); XCloseDisplay (dpy); return; } if (XvQueryAdaptors (dpy, DefaultRootWindow (dpy), &anum, &ai) != Success) { GST_WARNING_OBJECT (v4l2object->element, "Failed to query Xv adaptors"); XCloseDisplay (dpy); return; } if (fstat (v4l2object->video_fd, &s) < 0) { GST_ELEMENT_ERROR (v4l2object->element, RESOURCE, NOT_FOUND, (_("Cannot identify device '%s'."), v4l2object->videodev), GST_ERROR_SYSTEM); XCloseDisplay (dpy); return; } min = s.st_rdev & 0xff; for (i = 0; i < anum; i++) { if (!strcmp (ai[i].name, "video4linux2")) { if (first_id == 0) first_id = ai[i].base_id; /* hmm... */ if (first_id != 0 && ai[i].base_id == first_id + min) id = ai[i].base_id; } } XvFreeAdaptorInfo (ai); if (id == 0) { GST_WARNING_OBJECT (v4l2object->element, "Did not find XvPortID for device - no overlay"); XCloseDisplay (dpy); return; } v4l2xv = g_new0 (GstV4l2Xv, 1); v4l2xv->dpy = dpy; v4l2xv->port = id; v4l2xv->mutex = g_mutex_new (); v4l2xv->idle_id = 0; v4l2object->xv = v4l2xv; if (v4l2object->xwindow_id) { gst_v4l2_xoverlay_set_xwindow_id (v4l2object, v4l2object->xwindow_id); } }
int xf_video_init(xfInfo * xfi) { unsigned int version; unsigned int release; unsigned int request_base; unsigned int event_base; unsigned int error_base; unsigned int num_adaptors; unsigned int i; int ret; XvAdaptorInfo * ai; XvAttribute * attr; XvImageFormatValues * fo; xfi->xv_colorkey_atom = None; xfi->xv_image_size = 0; if (!XShmQueryExtension(xfi->display)) { printf("xf_video_init: no shmem available.\n"); return 1; } ret = XvQueryExtension(xfi->display, &version, &release, &request_base, &event_base, &error_base); if (ret != Success) { printf("xf_video_init: XvQueryExtension failed %d.\n", ret); return 1; } printf("xf_video_init:"); printf(" version %u", version); printf(" release %u", release); printf("\n"); ret = XvQueryAdaptors(xfi->display, DefaultRootWindow(xfi->display), &num_adaptors, &ai); if (ret != Success) { printf("xf_video_init: XvQueryAdaptors failed %d.\n", ret); return 1; } for (i = 0; i < num_adaptors; i++) { printf("xf_video_init: adapter port %ld-%ld (%s)\n", ai[i].base_id, ai[i].base_id + ai[i].num_ports - 1, ai[i].name); if (xfi->xv_port == -1 && i == num_adaptors - 1) xfi->xv_port = ai[i].base_id; } if (num_adaptors > 0) XvFreeAdaptorInfo(ai); if (xfi->xv_port == -1) { printf("xf_video_init: no adapter selected, video frames will not be processed.\n"); return 1; } printf("xf_video_init: selected %ld\n", xfi->xv_port); attr = XvQueryPortAttributes(xfi->display, xfi->xv_port, &ret); for (i = 0; i < (unsigned int)ret; i++) { if (strcmp(attr[i].name, "XV_COLORKEY") == 0) { xfi->xv_colorkey_atom = XInternAtom(xfi->display, "XV_COLORKEY", False); XvSetPortAttribute(xfi->display, xfi->xv_port, xfi->xv_colorkey_atom, attr[i].min_value + 1); break; } } XFree(attr); printf("xf_video_init: pixel format "); fo = XvListImageFormats(xfi->display, xfi->xv_port, &ret); if (ret > 0) { xfi->xv_pixfmts = (uint32 *) malloc((ret + 1) * sizeof(uint32)); for (i = 0; i < ret; i++) { xfi->xv_pixfmts[i] = fo[i].id; printf("%c%c%c%c ", ((char*)(xfi->xv_pixfmts + i))[0], ((char*)(xfi->xv_pixfmts + i))[1], ((char*)(xfi->xv_pixfmts + i))[2], ((char*)(xfi->xv_pixfmts + i))[3]); } xfi->xv_pixfmts[i] = 0; } printf("\n"); return 0; }
static void draw_osd(struct vo *vo, struct osd_state *osd) { struct xvctx *ctx = vo->priv; struct mp_image img = get_xv_buffer(vo, ctx->current_buf); struct mp_osd_res res = { .w = ctx->image_width, .h = ctx->image_height, .display_par = 1.0 / vo->aspdat.par, }; osd_draw_on_image(osd, res, osd->vo_pts, 0, &img); } static void wait_for_completion(struct vo *vo, int max_outstanding) { #if HAVE_SHM struct xvctx *ctx = vo->priv; struct vo_x11_state *x11 = vo->x11; if (ctx->Shmem_Flag) { while (x11->ShmCompletionWaitCount > max_outstanding) { if (!ctx->Shm_Warned_Slow) { MP_WARN(vo, "X11 can't keep up! Waiting" " for XShm completion events...\n"); ctx->Shm_Warned_Slow = 1; } mp_sleep_us(1000); vo_x11_check_events(vo); } } #endif } static void flip_page(struct vo *vo) { struct xvctx *ctx = vo->priv; put_xvimage(vo, ctx->xvimage[ctx->current_buf]); /* remember the currently visible buffer */ ctx->current_buf = (ctx->current_buf + 1) % ctx->num_buffers; if (!ctx->Shmem_Flag) XSync(vo->x11->display, False); } static mp_image_t *get_screenshot(struct vo *vo) { struct xvctx *ctx = vo->priv; if (!ctx->original_image) return NULL; return mp_image_new_ref(ctx->original_image); } // Note: redraw_frame() can call this with NULL. static void draw_image(struct vo *vo, mp_image_t *mpi) { struct xvctx *ctx = vo->priv; wait_for_completion(vo, ctx->num_buffers - 1); struct mp_image xv_buffer = get_xv_buffer(vo, ctx->current_buf); if (mpi) { mp_image_copy(&xv_buffer, mpi); } else { mp_image_clear(&xv_buffer, 0, 0, xv_buffer.w, xv_buffer.h); } mp_image_setrefp(&ctx->original_image, mpi); } static int redraw_frame(struct vo *vo) { struct xvctx *ctx = vo->priv; draw_image(vo, ctx->original_image); return true; } static int query_format(struct vo *vo, uint32_t format) { struct xvctx *ctx = vo->priv; uint32_t i; int flag = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW; int fourcc = find_xv_format(format); if (fourcc) { for (i = 0; i < ctx->formats; i++) { if (ctx->fo[i].id == fourcc) return flag; } } return 0; } static void uninit(struct vo *vo) { struct xvctx *ctx = vo->priv; int i; talloc_free(ctx->original_image); if (ctx->ai) XvFreeAdaptorInfo(ctx->ai); ctx->ai = NULL; if (ctx->fo) { XFree(ctx->fo); ctx->fo = NULL; } for (i = 0; i < ctx->num_buffers; i++) deallocate_xvimage(vo, i); // uninit() shouldn't get called unless initialization went past vo_init() vo_x11_uninit(vo); } static int preinit(struct vo *vo) { XvPortID xv_p; int busy_ports = 0; unsigned int i; struct xvctx *ctx = vo->priv; int xv_adaptor = ctx->cfg_xv_adaptor; if (!vo_x11_init(vo)) return -1; struct vo_x11_state *x11 = vo->x11; /* check for Xvideo extension */ unsigned int ver, rel, req, ev, err; if (Success != XvQueryExtension(x11->display, &ver, &rel, &req, &ev, &err)) { MP_ERR(vo, "Xv not supported by this X11 version/driver\n"); goto error; } /* check for Xvideo support */ if (Success != XvQueryAdaptors(x11->display, DefaultRootWindow(x11->display), &ctx->adaptors, &ctx->ai)) { MP_ERR(vo, "XvQueryAdaptors failed.\n"); goto error; } /* check adaptors */ if (ctx->xv_port) { int port_found; for (port_found = 0, i = 0; !port_found && i < ctx->adaptors; i++) { if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask)) { for (xv_p = ctx->ai[i].base_id; xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p) { if (xv_p == ctx->xv_port) { port_found = 1; break; } } } } if (port_found) { if (XvGrabPort(x11->display, ctx->xv_port, CurrentTime)) ctx->xv_port = 0; } else { MP_WARN(vo, "Invalid port parameter, overriding with port 0.\n"); ctx->xv_port = 0; } } for (i = 0; i < ctx->adaptors && ctx->xv_port == 0; i++) { /* check if adaptor number has been specified */ if (xv_adaptor != -1 && xv_adaptor != i) continue; if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask)) { for (xv_p = ctx->ai[i].base_id; xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p) if (!XvGrabPort(x11->display, xv_p, CurrentTime)) { ctx->xv_port = xv_p; MP_VERBOSE(vo, "Using Xv Adapter #%d (%s)\n", i, ctx->ai[i].name); break; } else { MP_WARN(vo, "Could not grab port %i.\n", (int) xv_p); ++busy_ports; } } } if (!ctx->xv_port) { if (busy_ports) MP_ERR(vo, "Could not find free Xvideo port - maybe another process is already\n"\ "using it. Close all video applications, and try again. If that does\n"\ "not help, see 'mpv -vo help' for other (non-xv) video out drivers.\n"); else MP_ERR(vo, "It seems there is no Xvideo support for your video card available.\n"\ "Run 'xvinfo' to verify its Xv support and read\n"\ "DOCS/HTML/en/video.html#xv!\n"\ "See 'mpv -vo help' for other (non-xv) video out drivers.\n"\ "Try -vo x11.\n"); goto error; } if (!xv_init_colorkey(vo)) { goto error; // bail out, colorkey setup failed } xv_enable_vsync(vo); xv_get_max_img_dim(vo, &ctx->max_width, &ctx->max_height); ctx->fo = XvListImageFormats(x11->display, ctx->xv_port, (int *) &ctx->formats); return 0; error: uninit(vo); // free resources return -1; }
static int XVideoGetPort( Display *p_display, int32_t i_chroma, int i_requested_adaptor) // -1 for autoscan { XvAdaptorInfo *p_adaptor; unsigned int i; unsigned int i_adaptor, i_num_adaptors; int i_selected_port; switch( XvQueryExtension( p_display, &i, &i, &i, &i, &i ) ) { case Success: break; case XvBadExtension: ml_log_error("XvBadExtension\n" ); return -1; case XvBadAlloc: ml_log_error("XvBadAlloc\n" ); return -1; default: ml_log_error("XvQueryExtension failed\n" ); return -1; } switch( XvQueryAdaptors( p_display, DefaultRootWindow( p_display ), &i_num_adaptors, &p_adaptor ) ) { case Success: break; case XvBadExtension: ml_log_error("XvBadExtension for XvQueryAdaptors\n" ); return -1; case XvBadAlloc: ml_log_error("XvBadAlloc for XvQueryAdaptors\n" ); return -1; default: ml_log_error("XvQueryAdaptors failed\n" ); return -1; } i_selected_port = -1; for( i_adaptor = 0; i_adaptor < i_num_adaptors; ++i_adaptor ) { XvImageFormatValues *p_formats; int i_format, i_num_formats; int i_port; /* If we requested an adaptor and it's not this one, we aren't * interested */ if( i_requested_adaptor != -1 && i_adaptor != (unsigned int)i_requested_adaptor ) { continue; } /* If the adaptor doesn't have the required properties, skip it */ if( !( p_adaptor[ i_adaptor ].type & XvInputMask ) || !( p_adaptor[ i_adaptor ].type & XvImageMask ) ) { continue; } /* Check that adaptor supports our requested format... */ p_formats = XvListImageFormats( p_display, p_adaptor[i_adaptor].base_id, &i_num_formats ); for( i_format = 0; i_format < i_num_formats && ( i_selected_port == -1 ); i_format++ ) { XvAttribute *p_attr; int i_attr, i_num_attributes; /* Matching chroma? */ if( p_formats[ i_format ].id != i_chroma ) { continue; } /* Look for the first available port supporting this format */ for( i_port = p_adaptor[i_adaptor].base_id; ( i_port < (int)(p_adaptor[i_adaptor].base_id + p_adaptor[i_adaptor].num_ports) ) && ( i_selected_port == -1 ); i_port++ ) { if( XvGrabPort( p_display, i_port, CurrentTime ) == Success ) { i_selected_port = i_port; } } /* If no free port was found, forget it */ if( i_selected_port == -1 ) { continue; } /* If we found a port, print information about it */ ml_log_info("X11 display adaptor %i, port %i, format 0x%x (%4.4s) %s\n", i_adaptor, i_selected_port, p_formats[ i_format ].id, (char *)&p_formats[ i_format ].id, ( p_formats[ i_format ].format == XvPacked ) ? "packed" : "planar" ); /* Make sure XV_AUTOPAINT_COLORKEY is set */ p_attr = XvQueryPortAttributes( p_display, i_selected_port, &i_num_attributes ); for( i_attr = 0; i_attr < i_num_attributes; i_attr++ ) { if( !strcmp( p_attr[i_attr].name, "XV_AUTOPAINT_COLORKEY" ) ) { const Atom autopaint = XInternAtom( p_display, "XV_AUTOPAINT_COLORKEY", False ); XvSetPortAttribute( p_display, i_selected_port, autopaint, 1 ); break; } } if( p_attr != NULL ) { XFree( p_attr ); } } if( p_formats != NULL ) { XFree( p_formats ); } } if( i_num_adaptors > 0 ) { XvFreeAdaptorInfo( p_adaptor ); } if( i_selected_port == -1 ) { int i_chroma_tmp = X112VLC_FOURCC( i_chroma ); if( i_requested_adaptor == -1 ) { ml_log_error("no free XVideo port found for format: " "0x%.8x (%4.4s)\n", i_chroma_tmp, (char*)&i_chroma_tmp ); } else { ml_log_error("XVideo adaptor %i does not have a free: " "XVideo port for format 0x%.8x (%4.4s)\n", i_requested_adaptor, i_chroma_tmp, (char*)&i_chroma_tmp ); } } return i_selected_port; }
/** The initialization function * This function opens the frame buffer device and allocates memory for display * also it finds the frame buffer supported display formats */ OMX_ERRORTYPE omx_xvideo_sink_component_Init(OMX_COMPONENTTYPE *openmaxStandComp) { omx_xvideo_sink_component_PrivateType* omx_xvideo_sink_component_Private = openmaxStandComp->pComponentPrivate; omx_xvideo_sink_component_PortType* pPort = (omx_xvideo_sink_component_PortType *) omx_xvideo_sink_component_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX]; int yuv_width = pPort->sPortParam.format.video.nFrameWidth; int yuv_height = pPort->sPortParam.format.video.nFrameHeight; unsigned int err,i; omx_xvideo_sink_component_Private->dpy = XOpenDisplay(NULL); omx_xvideo_sink_component_Private->screen = DefaultScreen(omx_xvideo_sink_component_Private->dpy); XGetWindowAttributes(omx_xvideo_sink_component_Private->dpy, DefaultRootWindow(omx_xvideo_sink_component_Private->dpy), &omx_xvideo_sink_component_Private->attribs); XMatchVisualInfo(omx_xvideo_sink_component_Private->dpy, omx_xvideo_sink_component_Private->screen, omx_xvideo_sink_component_Private->attribs.depth, TrueColor, & omx_xvideo_sink_component_Private->vinfo); omx_xvideo_sink_component_Private->wmDeleteWindow = XInternAtom(omx_xvideo_sink_component_Private->dpy, "WM_DELETE_WINDOW", False); omx_xvideo_sink_component_Private->hint.x = 1; omx_xvideo_sink_component_Private->hint.y = 1; omx_xvideo_sink_component_Private->hint.width = yuv_width; omx_xvideo_sink_component_Private->hint.height = yuv_height; omx_xvideo_sink_component_Private->hint.flags = PPosition | PSize; omx_xvideo_sink_component_Private->xswa.colormap = XCreateColormap(omx_xvideo_sink_component_Private->dpy, DefaultRootWindow(omx_xvideo_sink_component_Private->dpy), omx_xvideo_sink_component_Private->vinfo.visual, AllocNone); omx_xvideo_sink_component_Private->xswa.event_mask = StructureNotifyMask | ExposureMask; omx_xvideo_sink_component_Private->xswa.background_pixel = 0; omx_xvideo_sink_component_Private->xswa.border_pixel = 0; omx_xvideo_sink_component_Private->window = XCreateWindow(omx_xvideo_sink_component_Private->dpy, DefaultRootWindow(omx_xvideo_sink_component_Private->dpy), 0, 0, yuv_width, yuv_height, 0, omx_xvideo_sink_component_Private->vinfo.depth, InputOutput, omx_xvideo_sink_component_Private->vinfo.visual, CWBackPixel | CWBorderPixel | CWColormap | CWEventMask, &omx_xvideo_sink_component_Private->xswa); XSelectInput(omx_xvideo_sink_component_Private->dpy, omx_xvideo_sink_component_Private->window, StructureNotifyMask); XSetStandardProperties(omx_xvideo_sink_component_Private->dpy, omx_xvideo_sink_component_Private->window, "xvcam", "xvcam", None, NULL, 0, &omx_xvideo_sink_component_Private->hint); XSetWMProtocols(omx_xvideo_sink_component_Private->dpy, omx_xvideo_sink_component_Private->window, &omx_xvideo_sink_component_Private->wmDeleteWindow, 1); XMapWindow(omx_xvideo_sink_component_Private->dpy, omx_xvideo_sink_component_Private->window); if (XShmQueryExtension(omx_xvideo_sink_component_Private->dpy)) omx_xvideo_sink_component_Private->CompletionType = XShmGetEventBase(omx_xvideo_sink_component_Private->dpy) + ShmCompletion; else return OMX_ErrorUndefined; if (Success != XvQueryExtension(omx_xvideo_sink_component_Private->dpy, &omx_xvideo_sink_component_Private->ver, &omx_xvideo_sink_component_Private->rel, &omx_xvideo_sink_component_Private->req, &omx_xvideo_sink_component_Private->ev, &err)) fprintf(stderr, "Couldn't do Xv stuff\n"); if (Success != XvQueryAdaptors(omx_xvideo_sink_component_Private->dpy, DefaultRootWindow(omx_xvideo_sink_component_Private->dpy), &omx_xvideo_sink_component_Private->adapt, &omx_xvideo_sink_component_Private->ai)) fprintf(stderr, "Couldn't do Xv stuff\n"); for (i = 0; i < (int) omx_xvideo_sink_component_Private->adapt; i++) { omx_xvideo_sink_component_Private->xv_port = omx_xvideo_sink_component_Private->ai[i].base_id; } if (omx_xvideo_sink_component_Private->adapt > 0) XvFreeAdaptorInfo(omx_xvideo_sink_component_Private->ai); omx_xvideo_sink_component_Private->gc = XCreateGC(omx_xvideo_sink_component_Private->dpy, omx_xvideo_sink_component_Private->window, 0, 0); omx_xvideo_sink_component_Private->yuv_image = XvShmCreateImage(omx_xvideo_sink_component_Private->dpy, omx_xvideo_sink_component_Private->xv_port, GUID_I420_PLANAR, 0, yuv_width, yuv_height, &omx_xvideo_sink_component_Private->yuv_shminfo); omx_xvideo_sink_component_Private->yuv_shminfo.shmid = shmget(IPC_PRIVATE, omx_xvideo_sink_component_Private->yuv_image->data_size, IPC_CREAT | 0777); omx_xvideo_sink_component_Private->yuv_shminfo.shmaddr = (char *) shmat(omx_xvideo_sink_component_Private->yuv_shminfo.shmid, 0, 0); omx_xvideo_sink_component_Private->yuv_image->data = omx_xvideo_sink_component_Private->yuv_shminfo.shmaddr; omx_xvideo_sink_component_Private->yuv_shminfo.readOnly = False; if (!XShmAttach(omx_xvideo_sink_component_Private->dpy, &omx_xvideo_sink_component_Private->yuv_shminfo)) { printf("XShmAttach go boom boom!\n"); return OMX_ErrorUndefined; } omx_xvideo_sink_component_Private->old_time = 0; omx_xvideo_sink_component_Private->new_time = 0; omx_xvideo_sink_component_Private->bIsXVideoInit = OMX_TRUE; /*Signal XVideo Initialized*/ tsem_up(omx_xvideo_sink_component_Private->xvideoSyncSem); return OMX_ErrorNone; }
static int preinit(struct vo *vo) { XvPortID xv_p; int busy_ports = 0; unsigned int i; struct xvctx *ctx = vo->priv; int xv_adaptor = ctx->cfg_xv_adaptor; if (!vo_x11_init(vo)) return -1; if (!vo_x11_create_vo_window(vo, NULL, "xv")) goto error; struct vo_x11_state *x11 = vo->x11; /* check for Xvideo extension */ unsigned int ver, rel, req, ev, err; if (Success != XvQueryExtension(x11->display, &ver, &rel, &req, &ev, &err)) { MP_ERR(vo, "Xv not supported by this X11 version/driver\n"); goto error; } /* check for Xvideo support */ if (Success != XvQueryAdaptors(x11->display, DefaultRootWindow(x11->display), &ctx->adaptors, &ctx->ai)) { MP_ERR(vo, "XvQueryAdaptors failed.\n"); goto error; } /* check adaptors */ if (ctx->xv_port) { int port_found; for (port_found = 0, i = 0; !port_found && i < ctx->adaptors; i++) { if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask)) { for (xv_p = ctx->ai[i].base_id; xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p) { if (xv_p == ctx->xv_port) { port_found = 1; break; } } } } if (port_found) { if (XvGrabPort(x11->display, ctx->xv_port, CurrentTime)) ctx->xv_port = 0; } else { MP_WARN(vo, "Invalid port parameter, overriding with port 0.\n"); ctx->xv_port = 0; } } for (i = 0; i < ctx->adaptors && ctx->xv_port == 0; i++) { /* check if adaptor number has been specified */ if (xv_adaptor != -1 && xv_adaptor != i) continue; if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask)) { for (xv_p = ctx->ai[i].base_id; xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p) if (!XvGrabPort(x11->display, xv_p, CurrentTime)) { ctx->xv_port = xv_p; MP_VERBOSE(vo, "Using Xv Adapter #%d (%s)\n", i, ctx->ai[i].name); break; } else { MP_WARN(vo, "Could not grab port %i.\n", (int) xv_p); ++busy_ports; } } } if (!ctx->xv_port) { if (busy_ports) MP_ERR(vo, "Xvideo ports busy.\n"); else MP_ERR(vo, "No Xvideo support found.\n"); goto error; } if (!xv_init_colorkey(vo)) { goto error; // bail out, colorkey setup failed } xv_enable_vsync(vo); xv_get_max_img_dim(vo, &ctx->max_width, &ctx->max_height); ctx->fo = XvListImageFormats(x11->display, ctx->xv_port, (int *) &ctx->formats); MP_WARN(vo, "Warning: this legacy VO has bad quality and performance, " "and will in particular result in blurry OSD and subtitles. " "You should fix your graphic drivers, or not force the xv VO.\n"); return 0; error: uninit(vo); // free resources return -1; }
int XVWindow::Init (Display* dp, Window rootWindow, GC gc, int x, int y, int windowWidth, int windowHeight, int imageWidth, int imageHeight) { // local variables needed for creation of window // and initialization of XV extension unsigned int ver = 0; unsigned int rel = 0; unsigned int req = 0; unsigned int ev = 0; unsigned int err = 0; int ret = 0; unsigned int i = 0; _display = dp; _rootWindow = rootWindow; _imageWidth = imageWidth; _imageHeight = imageHeight; PTRACE(4, "XVideo\tInitializing XV window with " << windowWidth << "x" << windowHeight << " at " << x << "," << y); XLockDisplay (_display); // check if SHM XV window is possible ret = XvQueryExtension (_display, &ver, &rel, &req, &ev, &err); PTRACE(4, "XVideo\tXvQueryExtension: Version: " << ver << " Release: " << rel << " Request Base: " << req << " Event Base: " << ev << " Error Base: " << err ); if (Success != ret) { if (ret == XvBadExtension) PTRACE(1, "XVideo\tXvQueryExtension failed - XvBadExtension"); else if (ret == XvBadAlloc) PTRACE(1, "XVideo\tXvQueryExtension failed - XvBadAlloc"); else PTRACE(1, "XVideo\tXQueryExtension failed"); XUnlockDisplay (_display); return 0; } // Find XV port _XVPort = FindXVPort (); if (!_XVPort) { PTRACE(1, "XVideo\tFindXVPort failed"); XUnlockDisplay(_display); return 0; } PTRACE(4, "XVideo\tUsing XVideo port: " << _XVPort); if (!CreateAtomsAndWindow(gc, x, y, windowWidth, windowHeight)) { XUnlockDisplay(_display); return 0; } XV_SYNC_TO_VBLANK = GetXVAtom("XV_SYNC_TO_VBLANK"); XV_COLORKEY = GetXVAtom( "XV_COLORKEY" ); XV_AUTOPAINT_COLORKEY = GetXVAtom( "XV_AUTOPAINT_COLORKEY" ); if ( !InitColorkey() ) { PTRACE(1, "XVideo\tColorkey initialization failed"); XUnlockDisplay(_display); return 0; } if (XV_SYNC_TO_VBLANK != None) if (XvSetPortAttribute(_display, _XVPort, XV_SYNC_TO_VBLANK, 1) == Success) PTRACE(4, "XVideo\tVertical sync successfully activated" ); else PTRACE(4, "XVideo\tFailure when trying to activate vertical sync" ); else PTRACE(4, "XVideo\tVertical sync not supported"); if (!checkMaxSize (imageWidth, imageHeight)) { PTRACE(1, "XVideo\tCheck of image size failed"); XUnlockDisplay(_display); return 0; } #ifdef HAVE_SHM if (XShmQueryExtension (_display)) { _useShm = true; PTRACE(1, "XVideo\tXQueryShmExtension success"); } else { _useShm = false; PTRACE(1, "XVideo\tXQueryShmExtension failed"); } if (_useShm) ShmAttach(imageWidth, imageHeight); if (!_useShm) { #endif for (i = 0; i < NUM_BUFFERS; i++) { _XVImage[i] = (XvImage *) XvCreateImage( _display, _XVPort, GUID_YV12_PLANAR, 0, imageWidth, imageHeight); if (!_XVImage[i]) { PTRACE(1, "XVideo\tUnable to create XVideo Image"); XUnlockDisplay (_display); return 0; } _XVImage[i]->data = (char*) malloc(_XVImage[i]->data_size); } PTRACE(1, "XVideo\tNot using SHM extension"); #ifdef HAVE_SHM } else { PTRACE(1, "XVideo\tUsing SHM extension"); } #endif XSync(_display, False); _isInitialized = true; XUnlockDisplay (_display); // detect the window manager type _wmType = GetWMType (); CalculateSize (windowWidth, windowHeight, true); return 1; }
static int xv_check_extension( void ) { unsigned int version; unsigned int release; unsigned int dummy; unsigned int adaptors; unsigned int i; unsigned long j; int has_yuy2 = 0; XvAdaptorInfo *adaptorInfo; if( ( XvQueryExtension( display, &version, &release, &dummy, &dummy, &dummy) != Success ) || ( version < 2 ) || ( ( version == 2 ) && ( release < 2 ) ) ) { fprintf( stderr, "xvoutput: XVIDEO extension not found: X too old? didn't load extmod?\n" ); return 0; } XvQueryAdaptors( display, output_window, &adaptors, &adaptorInfo ); for( i = 0; i < adaptors; i++ ) { if( adaptorInfo[ i ].type & XvImageMask ) { for( j = 0; j < adaptorInfo[ i ].num_ports; j++ ) { if( xv_port_has_yuy2( adaptorInfo[ i ].base_id + j ) ) { if( XvGrabPort( display, adaptorInfo[ i ].base_id + j, 0 ) == Success ) { xv_port = adaptorInfo[ i ].base_id + j; if( xvoutput_verbose ) { fprintf( stderr, "xvoutput: Using XVIDEO adaptor %lu: %s.\n", adaptorInfo[ i ].base_id + j, adaptorInfo[ i ].name ); } XvFreeAdaptorInfo( adaptorInfo ); return 1; } has_yuy2 = 1; } } } } XvFreeAdaptorInfo( adaptorInfo ); if( has_yuy2 ) { fprintf( stderr, "xvoutput: No YUY2 XVIDEO port available.\n" ); fprintf( stderr, "\n*** tvtime requires a hardware YUY2 overlay. One is supported\n" "*** by your driver, but we could not grab it. It is likely\n" "*** being used by another application, either another tvtime\n" "*** instance or a media player. Please shut down this other\n" "*** application and try tvtime again.\n\n" ); } else { fprintf( stderr, "xvoutput: No XVIDEO port found which supports YUY2 images.\n" ); fprintf( stderr, "\n*** tvtime requires hardware YUY2 overlay support from your video card\n" "*** driver. If you are using an older NVIDIA card (TNT2), then\n" "*** this capability is only available with their binary drivers.\n" "*** For some ATI cards, this feature may be found in the experimental\n" "*** GATOS drivers: http://gatos.sourceforge.net/\n" "*** If unsure, please check with your distribution to see if your\n" "*** X driver supports hardware overlay surfaces.\n\n" ); } return 0; }
static int preinit(struct vo *vo, const char *arg) { XvPortID xv_p; int busy_ports = 0; unsigned int i; strarg_t ck_src_arg = { 0, NULL }; strarg_t ck_method_arg = { 0, NULL }; struct xvctx *ctx = talloc_zero(vo, struct xvctx); vo->priv = ctx; int xv_adaptor = -1; if (!vo_init(vo)) return -1; struct vo_x11_state *x11 = vo->x11; const opt_t subopts[] = { /* name arg type arg var test */ { "port", OPT_ARG_INT, &x11->xv_port, int_pos }, { "adaptor", OPT_ARG_INT, &xv_adaptor, int_non_neg }, { "ck", OPT_ARG_STR, &ck_src_arg, xv_test_ck }, { "ck-method", OPT_ARG_STR, &ck_method_arg, xv_test_ckm }, { NULL } }; x11->xv_port = 0; /* parse suboptions */ if (subopt_parse(arg, subopts) != 0) { return -1; } /* modify colorkey settings according to the given options */ xv_setup_colorkeyhandling(vo, ck_method_arg.str, ck_src_arg.str); /* check for Xvideo extension */ unsigned int ver, rel, req, ev, err; if (Success != XvQueryExtension(x11->display, &ver, &rel, &req, &ev, &err)) { mp_tmsg(MSGT_VO, MSGL_ERR, "[VO_XV] Sorry, Xv not supported by this X11 version/driver\n[VO_XV] ******** Try with -vo x11 *********\n"); goto error; } /* check for Xvideo support */ if (Success != XvQueryAdaptors(x11->display, DefaultRootWindow(x11->display), &ctx->adaptors, &ctx->ai)) { mp_tmsg(MSGT_VO, MSGL_ERR, "[VO_XV] XvQueryAdaptors failed.\n"); goto error; } /* check adaptors */ if (x11->xv_port) { int port_found; for (port_found = 0, i = 0; !port_found && i < ctx->adaptors; i++) { if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask)) { for (xv_p = ctx->ai[i].base_id; xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p) { if (xv_p == x11->xv_port) { port_found = 1; break; } } } } if (port_found) { if (XvGrabPort(x11->display, x11->xv_port, CurrentTime)) x11->xv_port = 0; } else { mp_tmsg(MSGT_VO, MSGL_WARN, "[VO_XV] Invalid port parameter, overriding with port 0.\n"); x11->xv_port = 0; } } for (i = 0; i < ctx->adaptors && x11->xv_port == 0; i++) { /* check if adaptor number has been specified */ if (xv_adaptor != -1 && xv_adaptor != i) continue; if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask)) { for (xv_p = ctx->ai[i].base_id; xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p) if (!XvGrabPort(x11->display, xv_p, CurrentTime)) { x11->xv_port = xv_p; mp_msg(MSGT_VO, MSGL_V, "[VO_XV] Using Xv Adapter #%d (%s)\n", i, ctx->ai[i].name); break; } else { mp_tmsg(MSGT_VO, MSGL_WARN, "[VO_XV] Could not grab port %i.\n", (int) xv_p); ++busy_ports; } } } if (!x11->xv_port) { if (busy_ports) mp_tmsg(MSGT_VO, MSGL_ERR, "[VO_XV] Could not find free Xvideo port - maybe another process is already\n"\ "[VO_XV] using it. Close all video applications, and try again. If that does\n"\ "[VO_XV] not help, see 'mpv -vo help' for other (non-xv) video out drivers.\n"); else mp_tmsg(MSGT_VO, MSGL_ERR, "[VO_XV] It seems there is no Xvideo support for your video card available.\n"\ "[VO_XV] Run 'xvinfo' to verify its Xv support and read\n"\ "[VO_XV] DOCS/HTML/en/video.html#xv!\n"\ "[VO_XV] See 'mpv -vo help' for other (non-xv) video out drivers.\n"\ "[VO_XV] Try -vo x11.\n"); goto error; } if (!vo_xv_init_colorkey(vo)) { goto error; // bail out, colorkey setup failed } vo_xv_enable_vsync(vo); vo_xv_get_max_img_dim(vo, &ctx->max_width, &ctx->max_height); ctx->fo = XvListImageFormats(x11->display, x11->xv_port, (int *) &ctx->formats); ctx->osd_backup = talloc_steal(ctx, mp_draw_sub_backup_new()); return 0; error: uninit(vo); // free resources return -1; }
static void gst_v4l_xoverlay_open (GstV4lElement * v4lelement) { struct stat s; GstV4lXv *v4lxv; const gchar *name = g_getenv ("DISPLAY"); unsigned int ver, rel, req, ev, err, anum; int i, id = 0, first_id = 0, min; XvAdaptorInfo *ai; Display *dpy; /* we need a display, obviously */ if (!name || !(dpy = XOpenDisplay (name))) { GST_WARNING ("No $DISPLAY set or failed to open - no overlay"); return; } /* First let's check that XVideo extension is available */ if (!XQueryExtension (dpy, "XVideo", &i, &i, &i)) { GST_WARNING ("Xv extension not available - no overlay"); XCloseDisplay (dpy); return; } /* find port that belongs to this device */ if (XvQueryExtension (dpy, &ver, &rel, &req, &ev, &err) != Success) { GST_WARNING ("Xv extension not supported - no overlay"); XCloseDisplay (dpy); return; } if (XvQueryAdaptors (dpy, DefaultRootWindow (dpy), &anum, &ai) != Success) { GST_WARNING ("Failed to query Xv adaptors"); XCloseDisplay (dpy); return; } if (fstat (v4lelement->video_fd, &s) < 0) { GST_ERROR ("Failed to stat() file descriptor: %s", g_strerror (errno)); XCloseDisplay (dpy); return; } min = s.st_rdev & 0xff; for (i = 0; i < anum; i++) { if (!strcmp (ai[i].name, "video4linux")) { if (first_id == 0) first_id = ai[i].base_id; /* hmm... */ if (first_id != 0 && ai[i].base_id == first_id + min) id = ai[i].base_id; } } XvFreeAdaptorInfo (ai); if (id == 0) { GST_WARNING ("Did not find XvPortID for device - no overlay"); XCloseDisplay (dpy); return; } v4lxv = g_new0 (GstV4lXv, 1); v4lxv->dpy = dpy; v4lxv->port = id; v4lxv->mutex = g_mutex_new (); v4lxv->idle_id = 0; v4lelement->xv = v4lxv; if (v4lelement->xwindow_id) { gst_v4l_xoverlay_set_window_handle (GST_X_OVERLAY (v4lelement), v4lelement->xwindow_id); } }
static int preinit(struct vo *vo) { XvPortID xv_p; int busy_ports = 0; unsigned int i; struct xvctx *ctx = vo->priv; int xv_adaptor = ctx->cfg_xv_adaptor; if (!vo_x11_init(vo)) return -1; struct vo_x11_state *x11 = vo->x11; /* check for Xvideo extension */ unsigned int ver, rel, req, ev, err; if (Success != XvQueryExtension(x11->display, &ver, &rel, &req, &ev, &err)) { MP_ERR(vo, "Xv not supported by this X11 version/driver\n"); goto error; } /* check for Xvideo support */ if (Success != XvQueryAdaptors(x11->display, DefaultRootWindow(x11->display), &ctx->adaptors, &ctx->ai)) { MP_ERR(vo, "XvQueryAdaptors failed.\n"); goto error; } /* check adaptors */ if (ctx->xv_port) { int port_found; for (port_found = 0, i = 0; !port_found && i < ctx->adaptors; i++) { if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask)) { for (xv_p = ctx->ai[i].base_id; xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p) { if (xv_p == ctx->xv_port) { port_found = 1; break; } } } } if (port_found) { if (XvGrabPort(x11->display, ctx->xv_port, CurrentTime)) ctx->xv_port = 0; } else { MP_WARN(vo, "Invalid port parameter, overriding with port 0.\n"); ctx->xv_port = 0; } } for (i = 0; i < ctx->adaptors && ctx->xv_port == 0; i++) { /* check if adaptor number has been specified */ if (xv_adaptor != -1 && xv_adaptor != i) continue; if ((ctx->ai[i].type & XvInputMask) && (ctx->ai[i].type & XvImageMask)) { for (xv_p = ctx->ai[i].base_id; xv_p < ctx->ai[i].base_id + ctx->ai[i].num_ports; ++xv_p) if (!XvGrabPort(x11->display, xv_p, CurrentTime)) { ctx->xv_port = xv_p; MP_VERBOSE(vo, "Using Xv Adapter #%d (%s)\n", i, ctx->ai[i].name); break; } else { MP_WARN(vo, "Could not grab port %i.\n", (int) xv_p); ++busy_ports; } } } if (!ctx->xv_port) { if (busy_ports) MP_ERR(vo, "Could not find free Xvideo port - maybe another process is already\n"\ "using it. Close all video applications, and try again. If that does\n"\ "not help, see 'mpv -vo help' for other (non-xv) video out drivers.\n"); else MP_ERR(vo, "It seems there is no Xvideo support for your video card available.\n"\ "Run 'xvinfo' to verify its Xv support and read\n"\ "DOCS/HTML/en/video.html#xv!\n"\ "See 'mpv -vo help' for other (non-xv) video out drivers.\n"\ "Try -vo x11.\n"); goto error; } if (!xv_init_colorkey(vo)) { goto error; // bail out, colorkey setup failed } xv_enable_vsync(vo); xv_get_max_img_dim(vo, &ctx->max_width, &ctx->max_height); ctx->fo = XvListImageFormats(x11->display, ctx->xv_port, (int *) &ctx->formats); return 0; error: uninit(vo); // free resources return -1; }
int xv_test_fourcc( Display *dpy, __u32 fourcc ) { unsigned int version, release; unsigned int request_base, event_base, error_base; int i; int num_adaptors; XvAdaptorInfo *p_adaptor_info; if( XvQueryExtension( dpy, &version, &release, &request_base, &event_base, &error_base ) != Success ) { #ifdef DEBUG fprintf( stderr, "XvQueryExtension failed\n" ); #endif return -1; } if( XvQueryAdaptors( dpy, DefaultRootWindow( dpy ), &num_adaptors, &p_adaptor_info ) != Success ) { #ifdef DEBUG fprintf( stderr, "XvQueryAdaptors failed\n" ); #endif return -1; } if( num_adaptors == 0 ) { return -2; } for( i = 0; i < num_adaptors; i++ ) { unsigned int num_encodings; XvEncodingInfo *p_encoding_info; int encoding; XvAttribute *at; unsigned int num_attributes; int attribute; XvImageFormatValues *xvimage_formats; unsigned int num_xvimage_formats; int format; #ifdef DEBUG if( XvQueryEncodings( dpy, p_adaptor_info[i].base_id, &num_encodings, &p_encoding_info ) != Success ) { fprintf( stderr, "XvQueryEncodings failed\n" ); } #endif xvimage_formats = XvListImageFormats( dpy, p_adaptor_info[i].base_id, &num_xvimage_formats ); for( format = 0; format < num_xvimage_formats; format++ ) { if( xvimage_formats[format].id == fourcc ) { return 1; } } return 0; } return 0; }
int xv_init( xv_handle_t handle, Display *dpy, __u32 fourcc, int width, int height, int bpp ) { unsigned int version, release; unsigned int request_base, event_base, error_base; int i; if( XvQueryExtension( dpy, &version, &release, &request_base, &event_base, &error_base ) != Success ) { #ifdef DEBUG fprintf( stderr, "XvQueryExtension failed\n" ); #endif return -1; } if( XvQueryAdaptors( dpy, DefaultRootWindow( dpy ), &handle->num_adaptors, &handle->p_adaptor_info ) != Success ) { #ifdef DEBUG fprintf( stderr, "XvQueryAdaptors failed\n" ); #endif return -1; } /* printf( "%d adaptors found\n", handle->num_adaptors ); */ if( handle->num_adaptors == 0 ) { return -2; } for( i = 0; i < handle->num_adaptors; i++ ) { /* int format; */ unsigned int num_encodings; XvEncodingInfo *p_encoding_info; int encoding; XvAttribute *at; unsigned int num_attributes; int attribute; XvImageFormatValues *xvimage_formats; unsigned int num_xvimage_formats; int format; #ifdef DEBUG printf( "Adaptor: %d\n", i ); printf( "Name: %s\n", handle->p_adaptor_info[i].name ); printf( "Ports: %lu\n", handle->p_adaptor_info[i].num_ports ); printf( "Formats: %lu\n", handle->p_adaptor_info[i].num_formats ); for( format = 0; format < handle->p_adaptor_info[i].num_formats; format++ ) { printf( "+Format: %d\n", format ); printf( " +Depth: %d\n", handle->p_adaptor_info[i].formats[format].depth ); printf( " +VisualID: %lu\n", handle->p_adaptor_info[i].formats[format].visual_id ); } if( XvQueryEncodings( dpy, handle->p_adaptor_info[i].base_id, &num_encodings, &p_encoding_info ) != Success ) { fprintf( stderr, "XvQueryEncodings failed\n" ); } printf( " +num_encodings: %d\n", num_encodings ); for( encoding = 0; encoding < num_encodings; encoding++ ) { printf( " +Encoding: %d\n", encoding ); printf( " +Name: %s\n", p_encoding_info[encoding].name ); printf( " +Resolution: %lu x %lu\n", p_encoding_info[encoding].width, p_encoding_info[encoding].height ); } #endif //DEBUG at = XvQueryPortAttributes( dpy, handle->p_adaptor_info[i].base_id, &num_attributes ); #ifdef DEBUG printf( "num_attributes: %d\n", num_attributes ); #endif for( attribute = 0; attribute < num_attributes; attribute++ ) { int val; Atom atom; if( !strcmp( at[attribute].name, "XV_COLORKEY" ) ) { #ifdef DEBUG printf( "attribute: %d\n", attribute ); printf( "name: %s\n", at[attribute].name ); #endif atom = (Atom)XInternAtom( dpy, at[attribute].name, 0 ); #ifdef DEBUG printf( "atom: %p\n", atom ); #endif XvGetPortAttribute( dpy, handle->p_adaptor_info[i].base_id, atom, &val ); #ifdef DEBUG printf( "Attribute: %d\n", attribute ); printf( "Name: %s\n", at[attribute].name ); printf( "min: %x\n", at[attribute].min_value ); printf( "max: %x\n", at[attribute].max_value ); printf( "value: %x\n", val ); #endif handle->atom_colorkey = XInternAtom( dpy, at[attribute].name, 0 ); } if( !strcmp( at[attribute].name, "XV_BRIGHTNESS" ) ) { handle->atom_brightness = XInternAtom( dpy, at[attribute].name, 0 ); handle->brightness_min = at[attribute].min_value; handle->brightness_max = at[attribute].max_value; } if( !strcmp( at[attribute].name, "XV_HUE" ) ) { handle->atom_hue = XInternAtom( dpy, at[attribute].name, 0 ); handle->hue_min = at[attribute].min_value; handle->hue_max = at[attribute].max_value; } if( !strcmp( at[attribute].name, "XV_CONTRAST" ) ) { handle->atom_contrast = XInternAtom( dpy, at[attribute].name, 0 ); handle->contrast_min = at[attribute].min_value; handle->contrast_max = at[attribute].max_value; } if( !strcmp( at[attribute].name, "XV_DOUBLE_BUFFER" ) ) { Atom _atom; _atom = XInternAtom( dpy, at[attribute].name, 0 ); XvSetPortAttribute( dpy, handle->p_adaptor_info[i].base_id, _atom, 1 ); #ifdef DEBUG printf( "Xv: DOUBLE_BUFFER available\n" ); #endif } } xvimage_formats = XvListImageFormats( dpy, handle->p_adaptor_info[i].base_id, &num_xvimage_formats ); /* printf( "num_xvimage_formats: %d\n", num_xvimage_formats ); */ for( format = 0; format < num_xvimage_formats; format++ ) { char imageName[5] = {0, 0, 0, 0, 0}; memcpy(imageName, &(xvimage_formats[format].id), 4); #ifdef DEBUG fprintf(stdout, " id: 0x%x", xvimage_formats[format].id); #endif if( isprint( imageName[0]) && isprint(imageName[1]) && isprint( imageName[2]) && isprint(imageName[3])) { #ifdef DEBUG fprintf(stdout, " (%s)\n", imageName); #endif if( xvimage_formats[format].id == fourcc ) { handle->xv_mode_id = fourcc; break; } } else { #ifdef DEBUG fprintf(stdout, "\n"); #endif } } if( handle->xv_mode_id != fourcc ) { return -3; } if( XvGrabPort( dpy, handle->p_adaptor_info[i].base_id, CurrentTime ) != Success ) { /* fprintf( stderr, "Failed to grab port!\n" ); */ return -1; } } handle->use_shm = 1; if( handle->use_shm ) { memset( &handle->shminfo, 0, sizeof( XShmSegmentInfo ) ); handle->image = XvShmCreateImage( dpy, handle->p_adaptor_info[0].base_id, handle->xv_mode_id, (char*)NULL, width, height, &handle->shminfo ); if( handle->image ) { handle->shminfo.shmid = shmget( IPC_PRIVATE, handle->image->data_size, IPC_CREAT | 0777 ); if( handle->shminfo.shmid == -1 ) { /* fprintf( stderr, "shmget failed\n" ); */ return -1; } handle->shminfo.shmaddr = handle->image->data = shmat( handle->shminfo.shmid, 0, 0 ); shmctl(handle->shminfo.shmid, IPC_RMID, 0); /* destroy when we terminate, now if shmat failed */ if( handle->shminfo.shmaddr == ( void * ) -1 ) { /* fprintf( stderr, "shmat failed\n" ); */ return -1; } handle->shminfo.readOnly = False; if( !XShmAttach( dpy, &handle->shminfo ) ) { /* fprintf( stderr, "XShmAttach failed\n" ); */ shmdt( handle->shminfo.shmaddr ); XFree( handle->image ); return -1; } } else { /* fprintf( stderr, "XvShmCreateImage failed\n" ); */ return -1; } } else { char * data = (char*) malloc( width*height*(bpp/8)); handle->image = XvCreateImage( dpy, handle->p_adaptor_info[0].base_id, handle->xv_mode_id, data, width, height ); } handle->display = dpy; return 0; }
//------------------------------------ // //------------------------------------ uint8_t GUI_XvInit(GUI_WindowInfo * window, uint32_t w, uint32_t h) { unsigned int ver, rel, req, ev, err; unsigned int port, adaptors; static XvAdaptorInfo *ai; static XvAdaptorInfo *curai; #if 0 win = gtk_widget_get_parent_window(window); xv_display = GDK_WINDOW_XDISPLAY(win); // xv_win= RootWindow(xv_display,0); xv_win = GDK_WINDOW_XWINDOW(GTK_WIDGET(window)->window); #endif xv_display=(Display *)window->display; xv_win=window->window; #define WDN xv_display xv_port = 0; if (Success != XvQueryExtension(WDN, &ver, &rel, &req, &ev, &err)) { printf("\n Query Extension failed\n"); goto failed; } /* check for Xvideo support */ if (Success != XvQueryAdaptors(WDN, DefaultRootWindow(WDN), &adaptors, &ai)) { printf("\n Query Adaptor failed\n"); goto failed; } curai = ai; XvFormat *formats; // Dump infos port = 0; for (uint16_t i = 0; (!port) && (i < adaptors); i++) { /* XvPortID base_id; unsigned long num_ports; char type; char *name; unsigned long num_formats; XvFormat *formats; unsigned long num_adaptors; */ #ifdef VERBOSE_XV printf("\n_______________________________\n"); printf("\n Adaptor : %d", i); printf("\n Base ID : %ld", curai->base_id); printf("\n Nb Port : %lu", curai->num_ports); printf("\n Type : %d,", curai->type); #define CHECK(x) if(curai->type & x) printf("|"#x); CHECK(XvInputMask); CHECK(XvOutputMask); CHECK(XvVideoMask); CHECK(XvStillMask); CHECK(XvImageMask); printf("\n Name : %s", curai->name); printf("\n Num Adap : %lu", curai->num_adaptors); printf("\n Num fmt : %lu", curai->num_formats); #endif formats = curai->formats; // uint16_t k; for (k = 0; (k < curai->num_ports) && !port; k++) { if (GUI_XvList(WDN, k + curai->base_id, &xv_format)) port = k + curai->base_id; } curai++; } // if (!port) { printf("\n no port found"); goto failed; } #ifdef COLORSPACE_YV12 printf("\n Xv YV12 found at port :%d, format : %ld", port, xv_format); #else printf("\n Xv YUY2 found at port :%d, format : %ld", port, xv_format); #endif if (Success != XvGrabPort(WDN, port, 0)) goto failed; { xv_port = port; /* Display *display, XvPortID port, int id, char* data, int width, int height, XShmSegmentInfo *shminfo */ XSetWindowAttributes xswa; XWindowAttributes attribs; static Atom xv_atom; unsigned long xswamask; int erCode; /* check if colorkeying is needed */ xv_atom = getAtom( "XV_AUTOPAINT_COLORKEY" ); if(xv_atom!=None) { XvSetPortAttribute( xv_display, xv_port, xv_atom, 1 ); } else printf("No autopaint \n"); /* if we have to deal with colorkeying ... */ xvimage = XvShmCreateImage(WDN, xv_port, xv_format, 0, w, h, &Shminfo); Shminfo.shmid = shmget(IPC_PRIVATE, xvimage->data_size, IPC_CREAT | 0777); if(Shminfo.shmid<=0) { printf("shmget failed\n"); } Shminfo.shmaddr = (char *) shmat(Shminfo.shmid, 0, 0); Shminfo.readOnly = False; if(Shminfo.shmaddr==(char *)-1) { printf("Shmat failed\n"); } xvimage->data = Shminfo.shmaddr; XShmAttach(WDN, &Shminfo); XSync(WDN, False); erCode=shmctl(Shminfo.shmid, IPC_RMID, 0); if(erCode) { printf("Shmctl failed :%d\n",erCode); } memset(xvimage->data, 0, xvimage->data_size); xv_xgc.graphics_exposures = False; xv_gc = XCreateGC(xv_display, xv_win, 0L, &xv_xgc); //ADM_assert(BadWindow!=XSelectInput(xv_display, xv_win, ExposureMask | VisibilityChangeMask)); } printf("\n Xv init succeedeed\n"); return 1; failed: printf("\n Xv init failed..\n"); return 0; }
void xf_tsmf_init(xfInfo* xfi, long xv_port) { int ret; unsigned int i; unsigned int version; unsigned int release; unsigned int event_base; unsigned int error_base; unsigned int request_base; unsigned int num_adaptors; xfXvContext* xv; XvAdaptorInfo* ai; XvAttribute* attr; XvImageFormatValues* fo; xv = (xfXvContext*) malloc(sizeof(xfXvContext)); ZeroMemory(xv, sizeof(xfXvContext)); xfi->xv_context = xv; xv->xv_colorkey_atom = None; xv->xv_image_size = 0; xv->xv_port = xv_port; if (!XShmQueryExtension(xfi->display)) { DEBUG_XV("no shmem available."); return; } ret = XvQueryExtension(xfi->display, &version, &release, &request_base, &event_base, &error_base); if (ret != Success) { DEBUG_XV("XvQueryExtension failed %d.", ret); return; } DEBUG_XV("version %u release %u", version, release); ret = XvQueryAdaptors(xfi->display, DefaultRootWindow(xfi->display), &num_adaptors, &ai); if (ret != Success) { DEBUG_XV("XvQueryAdaptors failed %d.", ret); return; } for (i = 0; i < num_adaptors; i++) { DEBUG_XV("adapter port %ld-%ld (%s)", ai[i].base_id, ai[i].base_id + ai[i].num_ports - 1, ai[i].name); if (xv->xv_port == 0 && i == num_adaptors - 1) xv->xv_port = ai[i].base_id; } if (num_adaptors > 0) XvFreeAdaptorInfo(ai); if (xv->xv_port == 0) { DEBUG_XV("no adapter selected, video frames will not be processed."); return; } DEBUG_XV("selected %ld", xv->xv_port); attr = XvQueryPortAttributes(xfi->display, xv->xv_port, &ret); for (i = 0; i < (unsigned int)ret; i++) { if (strcmp(attr[i].name, "XV_COLORKEY") == 0) { xv->xv_colorkey_atom = XInternAtom(xfi->display, "XV_COLORKEY", FALSE); XvSetPortAttribute(xfi->display, xv->xv_port, xv->xv_colorkey_atom, attr[i].min_value + 1); break; } } XFree(attr); #ifdef WITH_DEBUG_XV fprintf(stderr, "xf_tsmf_init: pixel format "); #endif fo = XvListImageFormats(xfi->display, xv->xv_port, &ret); if (ret > 0) { xv->xv_pixfmts = (UINT32*) malloc((ret + 1) * sizeof(UINT32)); ZeroMemory(xv->xv_pixfmts, (ret + 1) * sizeof(UINT32)); for (i = 0; i < ret; i++) { xv->xv_pixfmts[i] = fo[i].id; #ifdef WITH_DEBUG_XV fprintf(stderr, "%c%c%c%c ", ((char*)(xv->xv_pixfmts + i))[0], ((char*)(xv->xv_pixfmts + i))[1], ((char*)(xv->xv_pixfmts + i))[2], ((char*)(xv->xv_pixfmts + i))[3]); #endif } xv->xv_pixfmts[i] = 0; } XFree(fo); #ifdef WITH_DEBUG_XV fprintf(stderr, "\n"); #endif }
int find_yuv_port(Display* display, XvPortID* port, fourcc_t* format) { int i, j, k; /* XvQueryExtension */ unsigned int version, release, request_base, event_base, error_base; /* XvQueryAdaptors */ unsigned int num_adaptors; XvAdaptorInfo* adaptor_info = NULL; XvPortID port_id; /* XvListImageFormats */ int num_formats; XvImageFormatValues* format_list = NULL; switch (XvQueryExtension(display, &version, &release, &request_base, &event_base, &error_base)) { case Success: break; case XvBadExtension: printf("XvQueryExtension returned XvBadExtension.\n"); return 0; case XvBadAlloc: printf("XvQueryExtension returned XvBadAlloc.\n"); return 0; default: printf("XvQueryExtension returned unknown error.\n"); return 0; } switch (XvQueryAdaptors(display, DefaultRootWindow(display), &num_adaptors, &adaptor_info)) { case Success: break; case XvBadExtension: printf("XvQueryAdaptors returned XvBadExtension.\n"); return 0; case XvBadAlloc: printf("XvQueryAdaptors returned XvBadAlloc.\n"); return 0; default: printf("XvQueryAdaptors returned unknown error.\n"); return 0; } /* Find YUV capable adaptor. */ for (i = 0; i < (int)num_adaptors; i++) { if (!(adaptor_info[i].type & XvInputMask && adaptor_info[i].type & XvImageMask)) { continue; } format_list = XvListImageFormats(display, adaptor_info[i].base_id, &num_formats); for (j = 0; j < (int)(sizeof(fourcc_list) / sizeof(*fourcc_list)); j++) { if (format->id && fourcc_list[j].id != format->id) { continue; } for (k = 0; k < num_formats; k++) { if (format_list[k].id != fourcc_list[j].id) { continue; } for (port_id = adaptor_info[i].base_id; port_id < adaptor_info[i].base_id + adaptor_info[i].num_ports; port_id++) { if (XvGrabPort(display, port_id, CurrentTime) != Success) { continue; } *port = port_id; *format = fourcc_list[j]; XFree(format_list); XvFreeAdaptorInfo(adaptor_info); return 1; } } } XFree(format_list); } XvFreeAdaptorInfo(adaptor_info); printf("No suitable Xv YUV adaptor/port available.\n"); return 0; }
int find_yuv_port(Display* display, XvPortID* port, fourcc_t* format, int *overlay) { int i, j, k, found_one = 0, is_overlay; /* XvQueryExtension */ unsigned int version, release, request_base, event_base, error_base; /* XvQueryAdaptors */ unsigned int num_adaptors; XvAdaptorInfo* adaptor_info = NULL; XvPortID port_id; /* XvListImageFormats */ int num_formats; XvImageFormatValues* format_list = NULL; switch (XvQueryExtension(display, &version, &release, &request_base, &event_base, &error_base)) { case Success: break; case XvBadExtension: printf("XvQueryExtension returned XvBadExtension.\n"); return 0; case XvBadAlloc: printf("XvQueryExtension returned XvBadAlloc.\n"); return 0; default: printf("XvQueryExtension returned unknown error.\n"); return 0; } switch (XvQueryAdaptors(display, DefaultRootWindow(display), &num_adaptors, &adaptor_info)) { case Success: break; case XvBadExtension: printf("XvQueryAdaptors returned XvBadExtension.\n"); return 0; case XvBadAlloc: printf("XvQueryAdaptors returned XvBadAlloc.\n"); return 0; default: printf("XvQueryAdaptors returned unknown error.\n"); return 0; } /* Find YUV capable adaptor. */ for (i = 0; i < (int)num_adaptors; i++) { if (!(adaptor_info[i].type & XvInputMask && adaptor_info[i].type & XvImageMask)) { continue; } /* Textured video is not an overlay */ is_overlay = !strstr(adaptor_info[i].name, "Textured"); format_list = XvListImageFormats(display, adaptor_info[i].base_id, &num_formats); for (j = 0; j < (int)(sizeof(fourcc_list) / sizeof(*fourcc_list)); j++) { if (format->id && fourcc_list[j].id != format->id) { continue; } for (k = 0; k < num_formats; k++) { if (format_list[k].id != fourcc_list[j].id) { continue; } for (port_id = adaptor_info[i].base_id; port_id < adaptor_info[i].base_id + adaptor_info[i].num_ports; port_id++) { if (XvGrabPort(display, port_id, CurrentTime) != Success) { continue; } if (found_one) { if (!*overlay && is_overlay) { XvUngrabPort(display, port_id, CurrentTime); continue; /* Prefer non-overlay as that one can handle more than one windows */ } XvUngrabPort(display, *port, CurrentTime); } *port = port_id; *format = fourcc_list[j]; *overlay = is_overlay; found_one = 1; } } } XFree(format_list); } XvFreeAdaptorInfo(adaptor_info); if (!found_one) { printf("No suitable Xv YUV adaptor/port available.\n"); } return found_one; }
int main (int argc, char* argv[]) { int yuv_width = 1024; int yuv_height = 768; int xv_port = -1; int adaptor, encodings, attributes, formats; int i, j, ret, p, _d, _w, _h; long secsb, secsa, frames; XvAdaptorInfo *ai; XvEncodingInfo *ei; XvAttribute *at; XvImageFormatValues *fo; XvImage *yuv_image; #define GUID_YUV12_PLANAR 0x32315659 unsigned int p_version, p_release, p_request_base, p_event_base, p_error_base; int p_num_adaptors; Display *dpy; Window window, _dw; XSizeHints hint; XSetWindowAttributes xswa; XVisualInfo vinfo; int screen; unsigned long mask; XEvent event; GC gc; /** for shm */ int shmem_flag = 0; XShmSegmentInfo yuv_shminfo; int CompletionType; printf("starting up video testapp...\n\n"); adaptor = -1; dpy = XOpenDisplay(NULL); if (dpy == NULL) { printf("Cannot open Display.\n"); exit (-1); } screen = DefaultScreen(dpy); /** find best display */ if (XMatchVisualInfo(dpy, screen, 24, TrueColor, &vinfo)) { printf(" found 24bit TrueColor\n"); } else if (XMatchVisualInfo(dpy, screen, 16, TrueColor, &vinfo)) { printf(" found 16bit TrueColor\n"); } else if (XMatchVisualInfo(dpy, screen, 15, TrueColor, &vinfo)) { printf(" found 15bit TrueColor\n"); } else if (XMatchVisualInfo(dpy, screen, 8, PseudoColor, &vinfo)) { printf(" found 8bit PseudoColor\n"); } else if (XMatchVisualInfo(dpy, screen, 8, GrayScale, &vinfo)) { printf(" found 8bit GrayScale\n"); } else if (XMatchVisualInfo(dpy, screen, 8, StaticGray, &vinfo)) { printf(" found 8bit StaticGray\n"); } else if (XMatchVisualInfo(dpy, screen, 1, StaticGray, &vinfo)) { printf(" found 1bit StaticGray\n"); } else { printf("requires 16 bit display\n"); exit (-1); } CompletionType = -1; hint.x = 1; hint.y = 1; hint.width = yuv_width; hint.height = yuv_height; hint.flags = PPosition | PSize; xswa.colormap = XCreateColormap(dpy, DefaultRootWindow(dpy), vinfo.visual, AllocNone); xswa.event_mask = StructureNotifyMask | ExposureMask; xswa.background_pixel = 0; xswa.border_pixel = 0; mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; window = XCreateWindow(dpy, DefaultRootWindow(dpy), 0, 0, yuv_width, yuv_height, 0, vinfo.depth, InputOutput, vinfo.visual, mask, &xswa); XStoreName(dpy, window, "XV"); XSetIconName(dpy, window, "XV"); XSelectInput(dpy, window, StructureNotifyMask); /** Map window */ XMapWindow(dpy, window); /** Wait for map. */ do { XNextEvent(dpy, &event); } while (event.type != MapNotify || event.xmap.event != window); if (XShmQueryExtension(dpy)) shmem_flag = 1; if (!shmem_flag) { printf("no shmem available.\n"); exit (-1); } if (shmem_flag==1) CompletionType = XShmGetEventBase(dpy) + ShmCompletion; /**--------------------------------- XV ------------------------------------*/ printf("beginning to parse the Xvideo extension...\n\n"); /** query and print Xvideo properties */ ret = XvQueryExtension(dpy, &p_version, &p_release, &p_request_base, &p_event_base, &p_error_base); if (ret != Success) { if (ret == XvBadExtension) printf("XvBadExtension returned at XvQueryExtension.\n"); else if (ret == XvBadAlloc) printf("XvBadAlloc returned at XvQueryExtension.\n"); else printf("other error happened at XvQueryExtension.\n"); } printf("========================================\n"); printf("XvQueryExtension returned the following:\n"); printf("p_version : %u\n", p_version); printf("p_release : %u\n", p_release); printf("p_request_base : %u\n", p_request_base); printf("p_event_base : %u\n", p_event_base); printf("p_error_base : %u\n", p_error_base); printf("========================================\n"); ret = XvQueryAdaptors(dpy, DefaultRootWindow(dpy), &p_num_adaptors, &ai); if (ret != Success) { if (ret == XvBadExtension) printf("XvBadExtension returned at XvQueryExtension.\n"); else if (ret == XvBadAlloc) printf("XvBadAlloc returned at XvQueryExtension.\n"); else printf("other error happaned at XvQueryAdaptors.\n"); } printf("=======================================\n"); printf("XvQueryAdaptors returned the following:\n"); printf("%d adaptors available.\n", p_num_adaptors); for (i = 0; i < p_num_adaptors; i++) { printf(" name: %s\n" " type: %s%s%s%s%s\n" " ports: %ld\n" " first port: %ld\n", ai[i].name, (ai[i].type & XvInputMask) ? "input | " : "", (ai[i].type & XvOutputMask) ? "output | " : "", (ai[i].type & XvVideoMask) ? "video | " : "", (ai[i].type & XvStillMask) ? "still | " : "", (ai[i].type & XvImageMask) ? "image | " : "", ai[i].num_ports, ai[i].base_id); xv_port = ai[i].base_id; printf("adaptor %d ; format list:\n", i); for (j = 0; j < ai[i].num_formats; j++) { printf(" depth=%d, visual=%ld\n", ai[i].formats[j].depth, ai[i].formats[j].visual_id); } for (p = ai[i].base_id; p < ai[i].base_id+ai[i].num_ports; p++) { printf(" encoding list for port %d\n", p); if (XvQueryEncodings(dpy, p, &encodings, &ei) != Success) { printf("XvQueryEncodings failed.\n"); continue; } for (j = 0; j < encodings; j++) { printf(" id=%ld, name=%s, size=%ldx%ld, numerator=%d, denominator=%d\n", ei[j].encoding_id, ei[j].name, ei[j].width, ei[j].height, ei[j].rate.numerator, ei[j].rate.denominator); } XvFreeEncodingInfo(ei); printf(" attribute list for port %d\n", p); at = XvQueryPortAttributes(dpy, p, &attributes); for (j = 0; j < attributes; j++) { printf(" name: %s\n" " flags: %s%s\n" " min_color: %i\n" " max_color: %i\n", at[j].name, (at[j].flags & XvGettable) ? " get" : "", (at[j].flags & XvSettable) ? " set" : "", at[j].min_value, at[j].max_value); } if (at) XFree(at); printf(" image format list for port %d\n", p); fo = XvListImageFormats(dpy, p, &formats); for (j = 0; j < formats; j++) { printf(" 0x%x (%4.4s) %s\n", fo[j].id, (char *)&fo[j].id, (fo[j].format == XvPacked) ? "packed" : "planar"); } if (fo) XFree(fo); } printf("\n"); } if (p_num_adaptors > 0) XvFreeAdaptorInfo(ai); if (xv_port == -1) exit (0); gc = XCreateGC(dpy, window, 0, 0); yuv_image = XvShmCreateImage(dpy, xv_port, GUID_YUV12_PLANAR, 0, yuv_width, yuv_height, &yuv_shminfo); yuv_shminfo.shmid = shmget(IPC_PRIVATE, yuv_image->data_size, IPC_CREAT | 0777); yuv_shminfo.shmaddr = yuv_image->data = shmat(yuv_shminfo.shmid, 0, 0); yuv_shminfo.readOnly = False; if (!XShmAttach(dpy, &yuv_shminfo)) { printf("XShmAttach failed !\n"); exit (-1); } for (i = 0; i < yuv_image->height; i++) { for (j = 0; j < yuv_image->width; j++) { yuv_image->data[yuv_image->width*i + j] = i*j; } } printf("%d\n", yuv_image->data_size); int joe = 0; while (1) { frames = secsa = secsb = 0; time(&secsa); while (frames < 200) { XGetGeometry(dpy, window, &_dw, &_d, &_d, &_w, &_h, &_d, &_d); for (i = 0; i < yuv_image->height * 1.5; i++) { for (j = 0; j < yuv_image->width; j++) { yuv_image->data[yuv_image->width*i + j] = (i + j + joe / 5); } } XvShmPutImage(dpy, xv_port, window, gc, yuv_image, 0, 0, yuv_image->width, yuv_image->height, 0, 0, _w, _h, True); /* XFlush(dpy); */ joe++; frames++; } time(&secsb); printf("%ld frames in %ld seconds; %.4f fps\n", frames, secsb-secsa, (double) frames/(secsb-secsa)); } return 0; }
static void x11video_prepare(MSFilter *f){ X11Video *s=(X11Video*)f->data; unsigned int n; unsigned int nadaptors; int i; XvAdaptorInfo *xai=NULL; XvPortID port=-1; int imgfmt_id=0; XShmSegmentInfo *shminfo=&s->shminfo; XWindowAttributes wa = {0}; if (s->display==NULL) return; if (s->window_id==0){ if(s->auto_window) { s->window_id=createX11Window(s); } if (s->window_id==0) return; s->own_window=TRUE; } /* Make sure X11 window is ready to use*/ XSync(s->display, False); if (s->own_window==FALSE){ /*we need to register for resize events*/ XSelectInput(s->display,s->window_id,StructureNotifyMask); } XGetWindowAttributes(s->display,s->window_id,&wa); XClearWindow(s->display,s->window_id); ms_message("x11video_prepare(): Window has size %ix%i, received video is %ix%i",wa.width,wa.height,s->vsize.width,s->vsize.height); if (wa.width<MS_LAYOUT_MIN_SIZE || wa.height<MS_LAYOUT_MIN_SIZE){ return; } s->wsize.width=wa.width; s->wsize.height=wa.height; s->fbuf.w=s->vsize.width; s->fbuf.h=s->vsize.height; s->port=-1; if (XvQueryExtension(s->display, &n, &n, &n, &n, &n)!=0){ ms_error("Fail to query xv extension"); return; } if (XShmQueryExtension(s->display)==0){ ms_error("Fail to query xshm extension"); return; } if (XvQueryAdaptors(s->display,DefaultRootWindow(s->display), &nadaptors, &xai)!=0){ ms_error("XvQueryAdaptors failed."); return; } for (n=0;n<nadaptors && port==-1;++n){ XvAdaptorInfo *ai=&xai[n]; XvImageFormatValues *imgfmt; int nimgfmt=0; ms_message("Found output adaptor; name=%s num_ports=%i, with %i formats:", ai->name,(int)ai->num_ports,(int)ai->num_formats); imgfmt=XvListImageFormats(s->display,ai->base_id,&nimgfmt); for(i=0;i<nimgfmt;++i){ char fcc[5]={0}; memcpy(fcc,&imgfmt[i].id,4); ms_message("type=%s/%s id=%s", imgfmt[i].type == XvYUV ? "YUV" : "RGB", imgfmt[i].format==XvPlanar ? "Planar" : "Packed",fcc); if (port==-1 && imgfmt[i].format==XvPlanar && strcasecmp(fcc,"YV12")==0){ int k; /*we found a format interesting to us*/ for(k=0;k<ai->num_ports;++k){ if (XvGrabPort(s->display,ai->base_id+k,CurrentTime)==0){ ms_message("Grabbed port %i",(int)ai->base_id+k); port=ai->base_id+k; imgfmt_id=imgfmt[i].id; break; } } } } if (imgfmt) XFree(imgfmt); } XvFreeAdaptorInfo(xai); if (port==-1){ ms_error("Could not find suitable format or Xv port to work with."); return; } s->port=port; /*create the shared memory XvImage*/ memset(shminfo,0,sizeof(*shminfo)); s->xv_image=XvShmCreateImage(s->display,s->port,imgfmt_id,NULL,s->fbuf.w,s->fbuf.h,shminfo); if (s->xv_image==NULL){ ms_error("XvShmCreateImage failed."); x11video_unprepare(f); return; } /*allocate some shared memory to receive the pixel data */ shminfo->shmid=shmget(IPC_PRIVATE, s->xv_image->data_size,IPC_CREAT | 0777); if (shminfo->shmid==-1){ ms_error("Could not allocate %i bytes of shared memory: %s", s->xv_image->data_size, strerror(errno)); x11video_unprepare(f); return; } shminfo->shmaddr=shmat(shminfo->shmid,NULL,0); if (shminfo->shmaddr==(void*)-1){ ms_error("shmat() failed: %s",strerror(errno)); shminfo->shmaddr=NULL; x11video_unprepare(f); return; } /*ask the x-server to attach this shared memory segment*/ x11_error=FALSE; if (!XShmAttach(s->display,shminfo)){ ms_error("XShmAttach failed !"); x11video_unprepare(f); return ; } s->xv_image->data=s->shminfo.shmaddr; s->fbuf.planes[0]=(void*)s->xv_image->data; s->fbuf.planes[2]=s->fbuf.planes[0]+(s->xv_image->height*s->xv_image->pitches[0]); s->fbuf.planes[1]=s->fbuf.planes[2]+((s->xv_image->height/2)*s->xv_image->pitches[1]); s->fbuf.strides[0]=s->xv_image->pitches[0]; s->fbuf.strides[2]=s->xv_image->pitches[1]; s->fbuf.strides[1]=s->xv_image->pitches[2]; /* set picture black */ x11video_fill_background(f); /*Create a GC*/ s->gc=XCreateGC(s->display,s->window_id,0,NULL); if (s->gc==NULL){ ms_error("XCreateGC() failed."); x11video_unprepare(f); return ; } s->ready=TRUE; }
static int X11_GetXVideoPort(GF_VideoOutput *vout, u32 pixel_format, Bool check_color) { XWindow *xwin = (XWindow *)vout->opaque; Bool has_color_key = 0; XvAdaptorInfo *adaptors; unsigned int i; unsigned int nb_adaptors; int selected_port; if (XvQueryExtension(xwin->display, &i, &i, &i, &i, &i ) != Success) return -1; if (XvQueryAdaptors(xwin->display, DefaultRootWindow(xwin->display), &nb_adaptors, &adaptors) != Success) return -1; selected_port = -1; for (i=0; i < nb_adaptors; i++) { XvImageFormatValues *formats; int j, num_formats, port; if( !( adaptors[i].type & XvInputMask ) || !(adaptors[i].type & XvImageMask ) ) continue; /* Check for our format... */ formats = XvListImageFormats(xwin->display, adaptors[i].base_id, &num_formats); for (j=0; j<num_formats && (selected_port == -1 ); j++) { XvAttribute *attr; int k, nb_attributes; u32 pformat = X11_GetPixelFormat(formats[j].id); if( !is_same_yuv(pformat, pixel_format) ) continue; /* Grab first port supporting this format */ for (port=adaptors[i].base_id; (port < (int)(adaptors[i].base_id + adaptors[i].num_ports) ) && (selected_port == -1); port++) { if (port==xwin->xvport) continue; attr = XvQueryPortAttributes(xwin->display, port, &nb_attributes); for (k=0; k<nb_attributes; k++ ) { if (!strcmp(attr[k].name, "XV_COLORKEY")) { const Atom ckey = XInternAtom(xwin->display, "XV_COLORKEY", False); XvGetPortAttribute(xwin->display, port, ckey, &vout->overlay_color_key); has_color_key = 1; vout->overlay_color_key |= 0xFF000000; } /* else if (!strcmp(attr[k].name, "XV_AUTOPAINT_COLORKEY")) { const Atom paint = XInternAtom(xwin->display, "XV_AUTOPAINT_COLORKEY", False); XvSetPortAttribute(xwin->display, port, paint, 1); } */ } if (check_color && !has_color_key) continue; if (XvGrabPort(xwin->display, port, CurrentTime) == Success) { selected_port = port; xwin->xv_pf_format = formats[j].id; } } if (selected_port == -1 ) continue; } if (formats != NULL) XFree(formats); } if (nb_adaptors > 0) XvFreeAdaptorInfo(adaptors); return selected_port; }
int XVWindow::init(Display* dp, Window rootWindow, int x, int y, int windowWidth, int windowHeight, int imageWidth, int imageHeight) { // local variables needed for creation of window and initialization of XV extension unsigned int i; unsigned int ver, rel, req, ev, err, adapt; XSetWindowAttributes xswattributes; XWindowAttributes xwattributes; XVisualInfo xvinfo; XvAdaptorInfo *xvainfo; unsigned int candidateXVPort=0; unsigned int busyPorts=0; _display=dp; _rootWindow=rootWindow; _state.origLayer=0; // initialize atoms WM_DELETE_WINDOW = XInternAtom(_display, "WM_DELETE_WINDOW", False); XA_WIN_PROTOCOLS = XInternAtom(_display, "_WIN_PROTOCOLS", False); XA_NET_SUPPORTED = XInternAtom(_display, "_NET_SUPPORTED", False); XA_NET_WM_STATE = XInternAtom(_display, "_NET_WM_STATE", False); XA_NET_WM_STATE_FULLSCREEN = XInternAtom(_display, "_NET_WM_STATE_FULLSCREEN", False); XA_NET_WM_STATE_ABOVE = XInternAtom(_display, "_NET_WM_STATE_ABOVE", False); XA_NET_WM_STATE_STAYS_ON_TOP = XInternAtom(_display, "_NET_WM_STATE_STAYS_ON_TOP", False); XA_NET_WM_STATE_BELOW = XInternAtom(_display, "_NET_WM_STATE_BELOW", False); XGetWindowAttributes(_display, _rootWindow, &xwattributes); XMatchVisualInfo(_display, DefaultScreen(_display), xwattributes.depth, TrueColor, &xvinfo); // define window properties and create the window xswattributes.colormap = XCreateColormap(_display, _rootWindow, xvinfo.visual, AllocNone); xswattributes.event_mask = StructureNotifyMask | ExposureMask; xswattributes.background_pixel = 0; xswattributes.border_pixel = 0; _XVWindow = XCreateWindow(_display, _rootWindow, x, y, windowWidth, windowHeight, 0, xvinfo.depth, InputOutput, xvinfo.visual, CWBackPixel|CWBorderPixel|CWColormap|CWEventMask, &xswattributes); // define inputs events XSelectInput(_display, _XVWindow, StructureNotifyMask | KeyPressMask | ButtonPressMask); setSizeHints(DEFAULT_X,DEFAULT_Y, imageWidth, imageHeight, windowWidth, windowHeight); // map the window XMapWindow(_display, _XVWindow); XSetWMProtocols(_display, _XVWindow, &WM_DELETE_WINDOW,1); // check if SHM XV window is possible if (Success != XvQueryExtension(_display, &ver, &rel, &req, &ev, &err)) { LOG_DEBUG("[x11] XQueryExtension failed"); return 0; } if (!XShmQueryExtension(_display)) { LOG_DEBUG("[x11] XQueryShmExtension failed"); return 0; } if (Success != XvQueryAdaptors(_display, _rootWindow, &adapt, &xvainfo)) { LOG_DEBUG("[x11] XQueryAdaptor failed"); XFree(xvainfo); return 0; } // look for a usable XV port for (i = 0; i < adapt && _XVPort == 0; i++) { if ((xvainfo[i].type & XvInputMask) && (xvainfo[i].type & XvImageMask)) { for (candidateXVPort = xvainfo[i].base_id; candidateXVPort < xvainfo[i].base_id + xvainfo[i].num_ports; ++candidateXVPort) if (!XvGrabPort(_display, candidateXVPort, CurrentTime)) { _XVPort = candidateXVPort; break; } else { LOG_DEBUG("[x11] Could not grab port: " + String::fromNumber(candidateXVPort)); ++busyPorts; } } } XvFreeAdaptorInfo(xvainfo); if (!_XVPort) { if (busyPorts) { LOG_WARN("[x11] Could not find free Xvideo port - maybe another process is already using it."); } else { LOG_WARN("[x11] It seems there is no Xvideo support for your video card available."); } return 0; } else { LOG_WARN("[x11] Use XVideo port: " + String::fromNumber(_XVPort)); } _gc = XCreateGC(_display, _XVWindow, 0, 0); // create the shared memory portion _XVImage = XvShmCreateImage(_display, _XVPort, GUID_I420_PLANAR, 0, imageWidth, imageHeight, &_XShmInfo); _XShmInfo.shmid = shmget(IPC_PRIVATE, _XVImage->data_size, IPC_CREAT | 0777); _XShmInfo.shmaddr = (char *) shmat(_XShmInfo.shmid, 0, 0); _XVImage->data = _XShmInfo.shmaddr; _XShmInfo.readOnly = False; if (!XShmAttach(_display, &_XShmInfo)) { LOG_WARN("[x11] XShmAttach failed"); return 0; } else { _isInitialized = true; } // detect the window manager type _wmType=getWMType(); return 1; }
// setup x or xvideo void ffmpegWidget::xvSetup() { XvAdaptorInfo * ainfo; XvEncodingInfo *encodings; unsigned int adaptors, nencode; unsigned int ver, rel, extmaj, extev, exterr; // get display number this->dpy = x11Info().display(); // Grab the window id and setup a graphics context this->w = this->winId(); this->gc = XCreateGC(this->dpy, this->w, 0, 0); // Now try and setup xv // return version and release of extension if (XvQueryExtension(this->dpy, &ver, &rel, &extmaj, &extev, &exterr) != Success) { printf("XvQueryExtension failed, using QImage fallback mode\n"); return; } //printf("Ver: %d, Rel: %d, ExtMajor: %d, ExtEvent: %d, ExtError: %d\n", ver, rel, extmaj, extev, exterr); //Ver: 2, Rel: 2, ExtMajor: 140, ExtEvent: 75, ExtError: 150 // return adaptor information for the screen if (XvQueryAdaptors(this->dpy, QX11Info::appRootWindow(), &adaptors, &ainfo) != Success) { printf("XvQueryAdaptors failed, using QImage fallback mode\n"); return; } // see if we have any adapters if (adaptors <= 0) { printf("No xv adaptors found, using QImage fallback mode\n"); return; } // grab the port from the first adaptor int gotPort = 0; for(int p = 0; p < (int) ainfo[0].num_ports; p++) { if(XvGrabPort(this->dpy, ainfo[0].base_id + p, CurrentTime) == Success) { this->xv_port = ainfo[0].base_id + p; gotPort = 1; break; } } // if we didn't find a port if (!gotPort) { printf("No xv ports free, using QImage fallback mode\n"); return; } // get max XV Image size int gotEncodings = 0; XvQueryEncodings(this->dpy, ainfo[0].base_id, &nencode, &encodings); if (encodings && nencode && (ainfo[0].type & XvImageMask)) { for(unsigned int n = 0; n < nencode; n++) { if(!strcmp(encodings[n].name, "XV_IMAGE")) { this->maxW = encodings[n].width; this->maxH = encodings[n].height; gotEncodings = 1; break; } } } // if we didn't find a list of encodings if (!gotEncodings) { printf("No encodings information, using QImage fallback mode\n"); return; } // only support I420 mode for now int num_formats = 0; XvImageFormatValues * vals = XvListImageFormats(this->dpy, this->xv_port, &num_formats); for (int i=0; i<num_formats; i++) { if (strcmp(vals->guid, "I420") == 0) { this->xv_format = vals->id; this->ff_fmt = PIX_FMT_YUVJ420P; // Widget is responsible for painting all its pixels with an opaque color setAttribute(Qt::WA_OpaquePaintEvent); setAttribute(Qt::WA_PaintOnScreen); return; } vals++; } printf("Display doesn't support I420 mode, using QImage fallback mode\n"); return; }
SDL_Overlay *X11_CreateYUVOverlay(_THIS, int width, int height, Uint32 format, SDL_Surface *display) { SDL_Overlay *overlay; struct private_yuvhwdata *hwdata; int xv_port; int i, j; int adaptors; XvAdaptorInfo *ainfo; XShmSegmentInfo *yuvshm; xv_port = -1; if ( (Success == XvQueryExtension(GFX_Display, &j, &j, &j, &j, &j)) && (Success == XvQueryAdaptors(GFX_Display, RootWindow(GFX_Display, SDL_Screen), &adaptors, &ainfo)) ) { for ( i=0; (i<adaptors) && (xv_port == -1); ++i ) { if ( (ainfo[i].type & XvInputMask) && (ainfo[i].type & XvImageMask) ) { int num_formats; XvImageFormatValues *formats; formats = XvListImageFormats(GFX_Display, ainfo[i].base_id, &num_formats); for ( j=0; j<num_formats; ++j ) { if ( (Uint32)formats[j].id == format ) { xv_port = ainfo[i].base_id; break; } } } } } if ( xv_port == -1 ) { SDL_SetError("No available video ports for requested format"); return(NULL); } /* Create the overlay structure */ overlay = (SDL_Overlay *)malloc(sizeof *overlay); if ( overlay == NULL ) { SDL_OutOfMemory(); return(NULL); } memset(overlay, 0, (sizeof *overlay)); /* Fill in the basic members */ overlay->format = format; overlay->w = width; overlay->h = height; /* Set up the YUV surface function structure */ overlay->hwfuncs = &x11_yuvfuncs; /* Create the pixel data and lookup tables */ hwdata = (struct private_yuvhwdata *)malloc(sizeof *hwdata); overlay->hwdata = hwdata; if ( hwdata == NULL ) { SDL_OutOfMemory(); SDL_FreeYUVOverlay(overlay); return(NULL); } yuvshm = &hwdata->yuvshm; memset(yuvshm, 0, sizeof(*yuvshm)); hwdata->port = xv_port; hwdata->image = XvShmCreateImage(GFX_Display, xv_port, format, 0, width, height, yuvshm); if ( hwdata->image == NULL ) { SDL_OutOfMemory(); SDL_FreeYUVOverlay(overlay); return(NULL); } yuvshm->shmid = shmget(IPC_PRIVATE, hwdata->image->data_size, IPC_CREAT | 0777); if ( yuvshm->shmid < 0 ) { SDL_SetError("Unable to get %d bytes shared memory", hwdata->image->data_size); SDL_FreeYUVOverlay(overlay); return(NULL); } yuvshm->shmaddr = (caddr_t) shmat(yuvshm->shmid, 0, 0); yuvshm->readOnly = False; hwdata->image->data = yuvshm->shmaddr; XShmAttach(GFX_Display, yuvshm); XSync(GFX_Display, False); shmctl(yuvshm->shmid, IPC_RMID, 0); /* We're all done.. */ return(overlay); }