void QueryXv() { int num_adaptors; int num_formats; XvImageFormatValues *formats = NULL; int i, j; char xv_name[5]; XvQueryAdaptors(display, DefaultRootWindow(display), (unsigned int*) &num_adaptors, &info); for (i = 0; i < num_adaptors; i++) { formats = XvListImageFormats(display, info[i].base_id, &num_formats); for (j = 0; j < num_formats; j++) { xv_name[4] = 0; memcpy(xv_name, &formats[j].id, 4); if (formats[j].id == format) { if (verbose) fprintf(stderr, "using Xv format 0x%x %s %s\n", formats[j].id, xv_name, (formats[j].format == XvPacked) ? "packed" : "planar"); if (adaptor < 0) adaptor = i; } } } XFree(formats); if (adaptor < 0) fprintf(stderr, "No suitable Xv adaptor found"); }
void QueryXv() { uint32_t num_adaptors; int num_formats; XvImageFormatValues *formats=NULL; int i,j; char xv_name[5]; XvQueryAdaptors(display,DefaultRootWindow(display),&num_adaptors,&info); for(i=0;i<num_adaptors;i++) { formats=XvListImageFormats(display,info[i].base_id,&num_formats); for(j=0;j<num_formats;j++) { xv_name[4]=0; memcpy(xv_name,&formats[j].id,4); if(formats[j].id==format) { dc1394_log_error("using Xv format 0x%x %s %s",formats[j].id,xv_name,(formats[j].format==XvPacked)?"packed":"planar"); if(adaptor<0)adaptor=i; } } } XFree(formats); if(adaptor<0) dc1394_log_error("No suitable Xv adaptor found"); }
// _________________________________________________ // // _________________________________________________ uint8_t GUI_XvList(Display * dis, uint32_t port, uint32_t * fmt) { XvImageFormatValues *formatValues; int imgfmt; int k, f = 0; formatValues = XvListImageFormats(dis, port, &imgfmt); // when "formatValues" is NULL, imgfmt should be zero, too // if (formatValues) // this will run endless or segfault if the colorspace searched for isn't found // for (k = 0; !f || (k < imgfmt); k++) for (k = 0; !f && (k < imgfmt); k++) { #ifdef VERBOSE_XV printf("\n %lx %d --> %s", port, formatValues[k].id, formatValues[k].guid); #endif #ifdef COLORSPACE_YV12 if (!strcmp(formatValues[k].guid, "YV12")) #else if (!strcmp(formatValues[k].guid, "YUY2")) #endif { f = 1; *fmt = formatValues[k].id; } }// else // f = 0; // f has already been initialized zero if (formatValues) //checking if it's no NULL-pointer won't hurt XFree(formatValues); return f; }
static int find_best_xv_image_format(Display* dpy, XvPortID port, int* image_format_id, char* error_text, int text_len) { XvImageFormatValues* formats; int num_formats; int i; const int FORMAT_I420 = 0x30323449; DEBUG_PRINTF("looking for image formats...\n"); formats = XvListImageFormats(dpy, port, &num_formats); if (formats == 0 || num_formats == 0) { snprintf(error_text, text_len, "XvListImageFormats returned 0 formats"); } for(i = 0; i < num_formats; i++) { XvImageFormatValues* format = formats + i; DEBUG_PRINTF("Xvideo image format: 0x%x (%4.4s) %s\n", format->id, (char*)& format->id, (format->format == XvPacked) ? "packed" : "planar"); DEBUG_PRINTF("bpp = %i, type = %s\n", format->bits_per_pixel, (format->type == XvRGB) ? "rgb" : "yuv"); if (format->type == XvYUV) { DEBUG_PRINTF(" sample bits (y,u,v) = (%i, %i, %i)\n", format->y_sample_bits, format->u_sample_bits, format->v_sample_bits); DEBUG_PRINTF(" horz period (y,u,v) = (%i, %i, %i)\n", format->horz_y_period, format->horz_u_period, format->horz_v_period); DEBUG_PRINTF(" vert period (y,u,v) = (%i, %i, %i)\n", format->vert_y_period, format->vert_u_period, format->vert_v_period); DEBUG_PRINTF(" component order %.32s\n", format->component_order); DEBUG_PRINTF(" orientation = %s\n", format->scanline_order == XvTopToBottom ? "top to bottom" : "bottom to top"); if (format->id == FORMAT_I420) { DEBUG_PRINTF(" found i420\n"); *image_format_id = format->id; return 1; } } } snprintf(error_text, text_len, "Could not find good image format"); return 0; }
void XVWindow::DumpCapabilities (int port) { XvImageFormatValues *xviformats = 0; XvAttribute *xvattributes = NULL; XvEncodingInfo *xveinfo = NULL; unsigned int numXveinfo = 0; unsigned int i = 0; int numXvattributes = 0; int j = 0; int numXviformats = 0; char info[512]; if (XvQueryEncodings (_display, port, &numXveinfo, &xveinfo) != Success) { PTRACE(4, "XVideo\tXvQueryEncodings failed\n"); return; } for (i = 0 ; i < numXveinfo ; i++) { PTRACE(4, "XVideo\tEncoding List for Port " << port << ": " << " id=" << xveinfo [i].encoding_id << " name=" << xveinfo [i].name << " size=" << xveinfo [i].width << "x" << xveinfo[i].height << " numerator=" << xveinfo [i].rate.numerator << " denominator=" << xveinfo [i].rate.denominator); } XvFreeEncodingInfo(xveinfo); PTRACE(4, "XVideo\tAttribute List for Port " << port << ":"); xvattributes = XvQueryPortAttributes (_display, port, &numXvattributes); for (j = 0 ; j < numXvattributes ; j++) { PTRACE(4, " �name: � � � " << xvattributes [j].name); PTRACE(4, " �flags: � � " << ((xvattributes [j].flags & XvGettable) ? " get" : "") << ((xvattributes [j].flags & XvSettable) ? " set" : "")); PTRACE(4, " �min_color: �" << xvattributes [j].min_value); PTRACE(4, " �max_color: �" << xvattributes [j].max_value); } if (xvattributes) XFree (xvattributes); PTRACE (4, "XVideo\tImage format list for Port " << port << ":"); xviformats = XvListImageFormats (_display, port, &numXviformats); for (j = 0 ; j < numXviformats ; j++) { sprintf (info, " 0x%x (%4.4s) %s, order: %s", xviformats [j].id, (char *) &xviformats [j].id, (xviformats [j].format == XvPacked) ? "packed" : "planar", xviformats [j].component_order); PTRACE(4, info); } if (xviformats) XFree (xviformats); }
static int xv_port_has_yuy2( XvPortID port ) { XvImageFormatValues *formatValues; int formats; int i; formatValues = XvListImageFormats( display, port, &formats ); for( i = 0; i < formats; i++ ) { if((formatValues[ i ].id == FOURCC_YUY2) && (!(strcmp( formatValues[ i ].guid, "YUY2" )))) { XFree (formatValues); return 1; } } XFree( formatValues ); return 0; }
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 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; }
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; }
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; }
// 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; }
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 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; }
unsigned int XVWindow::FindXVPort () { XvAdaptorInfo *xvainfo = NULL; XvImageFormatValues *xviformats = NULL; unsigned int numXvainfo = 0; unsigned int i = 0; unsigned int candidateXVPort = 0; unsigned int busyPorts = 0; int numXviformats = 0; int j = 0; int result = 0; bool supportsYV12 = false; if (Success != XvQueryAdaptors (_display, _rootWindow, &numXvainfo, &xvainfo)) { PTRACE (1, "XVideo\tXQueryAdaptor failed"); return 0; } for (i = 0; i < numXvainfo; i++) { char adaptorInfo [512]; sprintf (adaptorInfo, "XVideo\t#%d, Adaptor: %s, type: %s%s%s%s%s, ports: %ld, first port:�%ld", i, xvainfo[i].name, (xvainfo[i].type & XvInputMask)?"input | ":"", (xvainfo[i].type & XvOutputMask)?"output | ":"", (xvainfo[i].type & XvVideoMask)?"video | ":"", (xvainfo[i].type & XvStillMask)?"still | ":"", (xvainfo[i].type & XvImageMask)?"image | ":"", xvainfo[i].num_ports, xvainfo[i].base_id); PTRACE (4, adaptorInfo); 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 (grabbedPorts.find(candidateXVPort) != grabbedPorts.end()) { PTRACE(4, "XVideo\tPort " << candidateXVPort << " already grabbed by ourselves"); ++busyPorts; continue; } #if PTRACING DumpCapabilities (candidateXVPort); #endif // Check if the Port supports YV12/YUV colorspace supportsYV12 = false; xviformats = XvListImageFormats (_display, candidateXVPort, &numXviformats); for (j = 0 ; j < numXviformats ; j++) if (xviformats [j].id == GUID_YV12_PLANAR) supportsYV12 = true; if (xviformats) XFree (xviformats); if (!supportsYV12) { PTRACE(4, "XVideo\tPort " << candidateXVPort << " does not support YV12 colorspace"); } else { result = XvGrabPort (_display, candidateXVPort, CurrentTime); if ( result == Success) { PTRACE(4, "XVideo\tGrabbed Port: " << candidateXVPort); XvFreeAdaptorInfo (xvainfo); grabbedPorts.insert(candidateXVPort); return candidateXVPort; } else { switch (result) { case XvInvalidTime: PTRACE (4, "XVideo\tCould not grab port " << candidateXVPort << ": requested time is older than the current port time"); break; case XvAlreadyGrabbed: PTRACE (4, "XVideo\tCould not grab port " << candidateXVPort << ": port is already grabbed by another client"); break; case XvBadExtension: PTRACE (4, "XVideo\tCould not grab port " << candidateXVPort << ": XV extension is unavailable"); break; case XvBadAlloc: PTRACE (4, "XVideo\tCould not grab port " << candidateXVPort << ": XvGrabPort failed to allocate memory to process the request"); break; case XvBadPort: PTRACE(4, "XVideo\tCould not grab port " << candidateXVPort << ": port does not exist"); break; default: PTRACE(4, "XVideo\tCould not grab port " << candidateXVPort); } ++busyPorts; } } } } } if (busyPorts) PTRACE(1, "XVideo\tCould not find any free Xvideo port - maybe other processes are already using them"); else PTRACE(1, "XVideo\tIt seems there is no Xvideo support for your video card available"); XvFreeAdaptorInfo (xvainfo); 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; }
void fconfig_setdefaultsfromdpy(Display *dpy) { rrcs::safelock l(fcmutex); if (fconfig.compress < 0) { bool usesunray = false; Atom atom = None; if ((atom = XInternAtom(dpy, "_SUN_SUNRAY_SESSION", True)) != None) usesunray = true; const char *dstr = DisplayString(dpy); if ((strlen(dstr) && dstr[0] == ':') || (strlen(dstr) > 5 && !strnicmp(dstr, "unix", 4))) { if (usesunray) fconfig_setcompress(fconfig, RRCOMP_XV); else fconfig_setcompress(fconfig, RRCOMP_PROXY); } else { if (usesunray) fconfig_setcompress(fconfig, RRCOMP_YUV); else fconfig_setcompress(fconfig, RRCOMP_JPEG); } } if (fconfig.port < 0) { fconfig.port = fconfig.ssl ? RR_DEFAULTSSLPORT : RR_DEFAULTPORT; Atom atom = None; unsigned long n = 0, bytesleft = 0; int actualformat = 0; Atom actualtype = None; unsigned short *prop = NULL; if ((atom = XInternAtom(dpy, fconfig.ssl ? "_VGLCLIENT_SSLPORT" : "_VGLCLIENT_PORT", True)) != None) { if (XGetWindowProperty(dpy, RootWindow(dpy, DefaultScreen(dpy)), atom, 0, 1, False, XA_INTEGER, &actualtype, &actualformat, &n, &bytesleft, (unsigned char **)&prop) == Success && n >= 1 && actualformat == 16 && actualtype == XA_INTEGER && prop) fconfig.port = *prop; if (prop) XFree(prop); } } #ifdef USEXV int k, port, nformats, dummy1, dummy2, dummy3; unsigned int i, j, nadaptors = 0; XvAdaptorInfo *ai = NULL; XvImageFormatValues *ifv = NULL; if (XQueryExtension(dpy, "XVideo", &dummy1, &dummy2, &dummy3) && XvQueryAdaptors(dpy, DefaultRootWindow(dpy), &nadaptors, &ai) == Success && nadaptors >= 1 && ai) { port = -1; for (i = 0; i < nadaptors; i++) { for (j = ai[i].base_id; j < ai[i].base_id + ai[i].num_ports; j++) { nformats = 0; ifv = XvListImageFormats(dpy, j, &nformats); if (ifv && nformats > 0) { for (k = 0; k < nformats; k++) { if (ifv[k].id == 0x30323449) { XFree(ifv); port = j; goto found; } } } XFree(ifv); } } found: XvFreeAdaptorInfo(ai); ai = NULL; if (port != -1) fconfig.transvalid[RRTRANS_XV] = 1; } #endif }
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 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); } }
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 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; }
static void player_av_load (Player *self, Entry *entry) { gint i; PlayerAVPrivate *priv = PLAYER_AV (self)->priv; player_av_close (self); if (av_open_input_file (&priv->fctx, entry_get_location (entry), NULL, 0, NULL) != 0) return; if (av_find_stream_info (priv->fctx) < 0) return; priv->fctx->flags = AVFMT_FLAG_GENPTS; dump_format(priv->fctx, 0, entry_get_location (entry), 0); priv->astream = priv->vstream = -1; for (i = 0; i < priv->fctx->nb_streams; i++) { if (priv->fctx->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO) { priv->vstream = i; } if (priv->fctx->streams[i]->codec->codec_type == CODEC_TYPE_AUDIO) { priv->astream = i; } if (priv->vstream != -1 && priv->astream != -1) break; } // Setup Audio Stream if (priv->astream != -1) { priv->actx = priv->fctx->streams[priv->astream]->codec; AVCodec *acodec = avcodec_find_decoder (priv->actx->codec_id); if (acodec && avcodec_open (priv->actx, acodec) < 0) { g_print ("Error opening audio stream\n"); return; } } else { priv->actx = NULL; } // Setup Video Stream if (priv->vstream != -1) { priv->vctx = priv->fctx->streams[priv->vstream]->codec; AVCodec *vcodec = avcodec_find_decoder (priv->vctx->codec_id); if(vcodec && avcodec_open (priv->vctx, vcodec) < 0) { g_print ("Error opening video stream\n"); return; } } else { priv->vctx = NULL; } if (priv->vctx) { priv->vctx->get_buffer = player_av_av_get_buffer; priv->vctx->release_buffer = player_av_av_release_buffer; priv->display = gdk_x11_display_get_xdisplay (gdk_display_get_default ()); priv->root = DefaultRootWindow (priv->display); priv->win = GDK_WINDOW_XID (priv->em_da->window); XSetWindowBackgroundPixmap (priv->display, priv->win, None); int nb_adaptors; XvAdaptorInfo *adaptors; XvQueryAdaptors (priv->display, priv->root, &nb_adaptors, &adaptors); int adaptor_no = 0, j, res; priv->xv_port_id = 0; for (i = 0; i < nb_adaptors && !priv->xv_port_id; i++) { adaptor_no = i; for (j = 0; j < adaptors[adaptor_no].num_ports && !priv->xv_port_id; j++) { res = XvGrabPort (priv->display, adaptors[adaptor_no].base_id + j, 0); if (Success == res) { priv->xv_port_id = adaptors[adaptor_no].base_id + j; } } } XvFreeAdaptorInfo (adaptors); int nb_formats; XvImageFormatValues *formats = XvListImageFormats (priv->display, priv->xv_port_id, &nb_formats); unsigned int vfmt = avcodec_pix_fmt_to_codec_tag (priv->vctx->pix_fmt); for (i = 0; i < nb_formats; i++) { if (vfmt == formats[i].id) { break; } } enum PixelFormat ofmt = PIX_FMT_NONE; priv->vframe = avcodec_alloc_frame (); priv->vframe_xv = avcodec_alloc_frame(); if (i < nb_formats) { ofmt = priv->vctx->pix_fmt; } else { for (i = 0; i < nb_formats; i++) { ofmt = avcodec_codec_tag_to_pix_fmt (formats[i].id); if (ofmt != PIX_FMT_NONE) { break; } } } int num_bytes = avpicture_get_size (ofmt, priv->vctx->width + priv->vctx->width % 4, priv->vctx->height); priv->vbuffer_xv = (uint8_t*) av_malloc (num_bytes * sizeof (uint8_t)); avpicture_fill ((AVPicture*) priv->vframe_xv, priv->vbuffer_xv, ofmt, priv->vctx->width + priv->vctx->width % 4, priv->vctx->height); priv->sws_ctx = sws_getContext ( priv->vctx->width, priv->vctx->height, priv->vctx->pix_fmt, priv->vctx->width, priv->vctx->height, ofmt, SWS_POINT, NULL, NULL, NULL); priv->xvimage = XvCreateImage ( priv->display, priv->xv_port_id, formats[i].id, priv->vbuffer_xv, priv->vctx->width, priv->vctx->height); XFree (formats); priv->xv_gc = XCreateGC (priv->display, priv->win, 0, &priv->values); } priv->entry = entry; g_object_ref (entry); priv->vpos = 0; priv->start_time = -1; priv->stop_time = -1; }
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; }
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; }
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 }
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; }
bool QX11VideoSurface::findPort() { unsigned int count = 0; XvAdaptorInfo *adaptors = 0; bool portFound = false; if (XvQueryAdaptors(QX11Info::display(), m_winId, &count, &adaptors) == Success) { #ifdef Q_WS_MAEMO_5 //the overlay xvideo adapter fails to switch winId, //prefer the "SGX Textured Video" adapter instead for (int i = count-1; i >= 0 && !portFound; --i) { #else for (unsigned int i = 0; i < count && !portFound; ++i) { #endif if (adaptors[i].type & XvImageMask) { m_portId = adaptors[i].base_id; for (unsigned int j = 0; j < adaptors[i].num_ports && !portFound; ++j, ++m_portId) portFound = XvGrabPort(QX11Info::display(), m_portId, 0) == Success; } } XvFreeAdaptorInfo(adaptors); } return portFound; } void QX11VideoSurface::querySupportedFormats() { int count = 0; if (XvImageFormatValues *imageFormats = XvListImageFormats( QX11Info::display(), m_portId, &count)) { const int rgbCount = sizeof(qt_xvRgbLookup) / sizeof(XvFormatRgb); const int yuvCount = sizeof(qt_xvYuvLookup) / sizeof(XvFormatYuv); for (int i = 0; i < count; ++i) { switch (imageFormats[i].type) { case XvRGB: for (int j = 0; j < rgbCount; ++j) { if (imageFormats[i] == qt_xvRgbLookup[j]) { m_supportedPixelFormats.append(qt_xvRgbLookup[j].pixelFormat); m_formatIds.append(imageFormats[i].id); break; } } break; case XvYUV: for (int j = 0; j < yuvCount; ++j) { if (imageFormats[i] == qt_xvYuvLookup[j]) { m_supportedPixelFormats.append(qt_xvYuvLookup[j].pixelFormat); m_formatIds.append(imageFormats[i].id); break; } } break; } } XFree(imageFormats); } m_brightnessRange = qMakePair(0, 0); m_contrastRange = qMakePair(0, 0); m_hueRange = qMakePair(0, 0); m_saturationRange = qMakePair(0, 0); if (XvAttribute *attributes = XvQueryPortAttributes(QX11Info::display(), m_portId, &count)) { for (int i = 0; i < count; ++i) { if (qstrcmp(attributes[i].name, "XV_BRIGHTNESS") == 0) m_brightnessRange = qMakePair(attributes[i].min_value, attributes[i].max_value); else if (qstrcmp(attributes[i].name, "XV_CONTRAST") == 0) m_contrastRange = qMakePair(attributes[i].min_value, attributes[i].max_value); else if (qstrcmp(attributes[i].name, "XV_HUE") == 0) m_hueRange = qMakePair(attributes[i].min_value, attributes[i].max_value); else if (qstrcmp(attributes[i].name, "XV_SATURATION") == 0) m_saturationRange = qMakePair(attributes[i].min_value, attributes[i].max_value); } XFree(attributes); } }
int S9xXVDisplayDriver::init (void) { int padding; int depth = 0, num_formats, num_attrs, highest_formats = 0; XvImageFormatValues *formats = NULL; XvAdaptorInfo *adaptors; XvAttribute *port_attr; VisualID visualid = None; unsigned int num_adaptors; GdkScreen *screen; GdkWindow *root; buffer[0] = malloc (image_padded_size); buffer[1] = malloc (scaled_padded_size); padding = (image_padded_size - image_size) / 2; padded_buffer[0] = (void *) (((uint8 *) buffer[0]) + padding); padding = (scaled_padded_size - scaled_size) / 2; padded_buffer[1] = (void *) (((uint8 *) buffer[1]) + padding); memset (buffer[0], 0, image_padded_size); memset (buffer[1], 0, scaled_padded_size); /* Setup XV */ gtk_widget_realize (drawing_area); display = gdk_x11_drawable_get_xdisplay (GDK_DRAWABLE (gtk_widget_get_window (drawing_area))); screen = gtk_widget_get_screen (drawing_area); root = gdk_screen_get_root_window (screen); xv_portid = -1; XvQueryAdaptors (display, GDK_WINDOW_XWINDOW (root), &num_adaptors, &adaptors); for (int i = 0; i < (int) num_adaptors; i++) { if (adaptors[i].type & XvInputMask && adaptors[i].type & XvImageMask) { formats = XvListImageFormats (display, adaptors[i].base_id, &num_formats); if (num_formats > highest_formats) { xv_portid = adaptors[i].base_id; highest_formats = num_formats; visualid = adaptors[i].formats->visual_id; } free (formats); } } XvFreeAdaptorInfo (adaptors); if (xv_portid < 0) { fprintf (stderr, "Could not open Xv output port.\n"); return -1; } /* Set XV_AUTOPAINT_COLORKEY _only_ if available */ port_attr = XvQueryPortAttributes (display, xv_portid, &num_attrs); for (int i = 0; i < num_attrs; i++) { if (!strcmp (port_attr[i].name, "XV_AUTOPAINT_COLORKEY")) { Atom colorkey = None; colorkey = XInternAtom (display, "XV_AUTOPAINT_COLORKEY", True); if (colorkey != None) XvSetPortAttribute (display, xv_portid, colorkey, 1); } } /* Try to find an RGB format */ format = FOURCC_YUY2; bpp = 100; formats = XvListImageFormats (display, xv_portid, &num_formats); for (int i = 0; i < num_formats; i++) { if (formats[i].id == 0x3 || formats[i].type == XvRGB) { if (formats[i].bits_per_pixel < bpp) { format = formats[i].id; bpp = formats[i].bits_per_pixel; bytes_per_pixel = (bpp == 15) ? 2 : bpp >> 3; depth = formats[i].depth; this->rshift = get_inv_shift (formats[i].red_mask, bpp); this->gshift = get_inv_shift (formats[i].green_mask, bpp); this->bshift = get_inv_shift (formats[i].blue_mask, bpp); /* Check for red-blue inversion on SiliconMotion drivers */ if (formats[i].red_mask == 0x001f && formats[i].blue_mask == 0x7c00) { int copy = this->rshift; this->rshift = this->bshift; this->bshift = copy; } /* on big-endian Xv still seems to like LSB order */ if (config->force_inverted_byte_order) S9xSetEndianess (ENDIAN_MSB); else S9xSetEndianess (ENDIAN_LSB); } } }
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); }