diff options
author | Uoti Urpala <uau@glyph.nonexistent.invalid> | 2009-05-06 23:42:24 +0300 |
---|---|---|
committer | Uoti Urpala <uau@glyph.nonexistent.invalid> | 2009-08-29 21:01:54 +0300 |
commit | 35dbbc9e3130f79fdcd3e207ecb0ea70c0e1bcf1 (patch) | |
tree | ba062afbccb2142f9a736ffd9bfbb5110d5aff65 | |
parent | 8a26256b87f674764b27a5844e892bce281a0fb9 (diff) | |
download | mpv-35dbbc9e3130f79fdcd3e207ecb0ea70c0e1bcf1.tar.bz2 mpv-35dbbc9e3130f79fdcd3e207ecb0ea70c0e1bcf1.tar.xz |
vo_vdpau: Move things to context struct
-rw-r--r-- | libvo/vo_vdpau.c | 511 |
1 files changed, 257 insertions, 254 deletions
diff --git a/libvo/vo_vdpau.c b/libvo/vo_vdpau.c index 3db31dbb08..219a64cfbc 100644 --- a/libvo/vo_vdpau.c +++ b/libvo/vo_vdpau.c @@ -91,56 +91,54 @@ struct vdp_functions { struct vdpctx { struct vdp_functions *vdp; -}; -/* Declaration for all variables of win_x11_init_vdpau_procs() and - * win_x11_init_vdpau_flip_queue() functions - */ -static VdpDevice vdp_device; -static VdpDeviceCreateX11 *vdp_device_create; -static VdpGetProcAddress *vdp_get_proc_address; - -static VdpPresentationQueueTarget vdp_flip_target; -static VdpPresentationQueue vdp_flip_queue; - -static void *vdpau_lib_handle; -/* output_surfaces[NUM_OUTPUT_SURFACES] is misused for OSD. */ -#define osd_surface output_surfaces[NUM_OUTPUT_SURFACES] -static VdpOutputSurface output_surfaces[NUM_OUTPUT_SURFACES + 1]; -static VdpVideoSurface deint_surfaces[3]; -static mp_image_t *deint_mpi[2]; -static int output_surface_width, output_surface_height; - -static VdpVideoMixer video_mixer; -static int deint; -static int deint_type; -static int deint_counter; -static int deint_buffer_past_frames; -static int pullup; -static float denoise; -static float sharpen; -static int chroma_deint; -static int top_field_first; - -static VdpDecoder decoder; -static int decoder_max_refs; - -static VdpRect src_rect_vid; -static VdpRect out_rect_vid; -static int border_x, border_y; - -static struct vdpau_render_state surface_render[MAX_VIDEO_SURFACES]; -static int surface_num; -static int vid_surface_num; -static uint32_t vid_width, vid_height; -static uint32_t image_format; -static VdpChromaType vdp_chroma_type; -static VdpYCbCrFormat vdp_pixel_format; - -/* draw_osd */ -static unsigned char *index_data; -static int index_data_size; -static uint32_t palette[PALETTE_SIZE]; + VdpDevice vdp_device; + VdpDeviceCreateX11 *vdp_device_create; + VdpGetProcAddress *vdp_get_proc_address; + + VdpPresentationQueueTarget flip_target; + VdpPresentationQueue flip_queue; + + void *vdpau_lib_handle; + + /* output_surfaces[NUM_OUTPUT_SURFACES] is misused for OSD. */ +#define osd_surface vc->output_surfaces[NUM_OUTPUT_SURFACES] + VdpOutputSurface output_surfaces[NUM_OUTPUT_SURFACES + 1]; + VdpVideoSurface deint_surfaces[3]; + mp_image_t *deint_mpi[2]; + int output_surface_width, output_surface_height; + + VdpVideoMixer video_mixer; + int deint; + int deint_type; + int deint_counter; + int deint_buffer_past_frames; + int pullup; + float denoise; + float sharpen; + int chroma_deint; + int top_field_first; + + VdpDecoder decoder; + int decoder_max_refs; + + VdpRect src_rect_vid; + VdpRect out_rect_vid; + int border_x, border_y; + + struct vdpau_render_state surface_render[MAX_VIDEO_SURFACES]; + int surface_num; + int vid_surface_num; + uint32_t vid_width, vid_height; + uint32_t image_format; + VdpChromaType vdp_chroma_type; + VdpYCbCrFormat vdp_pixel_format; + + /* draw_osd */ + unsigned char *index_data; + int index_data_size; + uint32_t palette[PALETTE_SIZE]; +}; // EOSD // Pool of surfaces @@ -171,11 +169,12 @@ static VdpProcamp procamp; static int visible_buf; static int int_pause; -static void push_deint_surface(VdpVideoSurface surface) +static void push_deint_surface(struct vo *vo, VdpVideoSurface surface) { - deint_surfaces[2] = deint_surfaces[1]; - deint_surfaces[1] = deint_surfaces[0]; - deint_surfaces[0] = surface; + struct vdpctx *vc = vo->priv; + vc->deint_surfaces[2] = vc->deint_surfaces[1]; + vc->deint_surfaces[1] = vc->deint_surfaces[0]; + vc->deint_surfaces[0] = surface; } static void flip_page(struct vo *vo); @@ -186,13 +185,13 @@ static void video_to_output_surface(struct vo *vo) VdpTime dummy; VdpStatus vdp_st; int i; - if (vid_surface_num < 0) + if (vc->vid_surface_num < 0) return; - if (deint < 2 || deint_surfaces[0] == VDP_INVALID_HANDLE) - push_deint_surface(surface_render[vid_surface_num].surface); + if (vc->deint < 2 || vc->deint_surfaces[0] == VDP_INVALID_HANDLE) + push_deint_surface(vo, vc->surface_render[vc->vid_surface_num].surface); - for (i = 0; i <= !!(deint > 1); i++) { + for (i = 0; i <= !!(vc->deint > 1); i++) { int field = VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME; VdpOutputSurface output_surface; if (i) { @@ -200,25 +199,25 @@ static void video_to_output_surface(struct vo *vo) //draw_osd(vo, NULL); flip_page(vo); } - if (deint) - field = (top_field_first == i) ^ (deint > 1) ? + if (vc->deint) + field = (vc->top_field_first == i) ^ (vc->deint > 1) ? VDP_VIDEO_MIXER_PICTURE_STRUCTURE_BOTTOM_FIELD: VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD; - output_surface = output_surfaces[surface_num]; - vdp_st = vdp->presentation_queue_block_until_surface_idle(vdp_flip_queue, + output_surface = vc->output_surfaces[vc->surface_num]; + vdp_st = vdp->presentation_queue_block_until_surface_idle(vc->flip_queue, output_surface, &dummy); CHECK_ST_WARNING("Error when calling vdp->presentation_queue_block_until_surface_idle") - vdp_st = vdp->video_mixer_render(video_mixer, VDP_INVALID_HANDLE, 0, - field, 2, deint_surfaces + 1, - deint_surfaces[0], - 1, &surface_render[vid_surface_num].surface, - &src_rect_vid, + vdp_st = vdp->video_mixer_render(vc->video_mixer, VDP_INVALID_HANDLE, 0, + field, 2, vc->deint_surfaces + 1, + vc->deint_surfaces[0], + 1, &vc->surface_render[vc->vid_surface_num].surface, + &vc->src_rect_vid, output_surface, - NULL, &out_rect_vid, 0, NULL); + NULL, &vc->out_rect_vid, 0, NULL); CHECK_ST_WARNING("Error when calling vdp_video_mixer_render") - push_deint_surface(surface_render[vid_surface_num].surface); + push_deint_surface(vo, vc->surface_render[vc->vid_surface_num].surface); } } @@ -231,42 +230,42 @@ static void resize(struct vo *vo) struct vo_rect src_rect; struct vo_rect dst_rect; struct vo_rect borders; - calc_src_dst_rects(vo, vid_width, vid_height, &src_rect, &dst_rect, + calc_src_dst_rects(vo, vc->vid_width, vc->vid_height, &src_rect, &dst_rect, &borders, NULL); - out_rect_vid.x0 = dst_rect.left; - out_rect_vid.x1 = dst_rect.right; - out_rect_vid.y0 = dst_rect.top; - out_rect_vid.y1 = dst_rect.bottom; - src_rect_vid.x0 = src_rect.left; - src_rect_vid.x1 = src_rect.right; - src_rect_vid.y0 = src_rect.top; - src_rect_vid.y1 = src_rect.bottom; - border_x = borders.left; - border_y = borders.top; + vc->out_rect_vid.x0 = dst_rect.left; + vc->out_rect_vid.x1 = dst_rect.right; + vc->out_rect_vid.y0 = dst_rect.top; + vc->out_rect_vid.y1 = dst_rect.bottom; + vc->src_rect_vid.x0 = src_rect.left; + vc->src_rect_vid.x1 = src_rect.right; + vc->src_rect_vid.y0 = src_rect.top; + vc->src_rect_vid.y1 = src_rect.bottom; + vc->border_x = borders.left; + vc->border_y = borders.top; #ifdef CONFIG_FREETYPE // adjust font size to display size force_load_font = 1; #endif vo_osd_changed(OSDTYPE_OSD); - if (output_surface_width < vo->dwidth || output_surface_height < vo->dheight) { - if (output_surface_width < vo->dwidth) { - output_surface_width += output_surface_width >> 1; - output_surface_width = FFMAX(output_surface_width, vo->dwidth); + if (vc->output_surface_width < vo->dwidth || vc->output_surface_height < vo->dheight) { + if (vc->output_surface_width < vo->dwidth) { + vc->output_surface_width += vc->output_surface_width >> 1; + vc->output_surface_width = FFMAX(vc->output_surface_width, vo->dwidth); } - if (output_surface_height < vo->dheight) { - output_surface_height += output_surface_height >> 1; - output_surface_height = FFMAX(output_surface_height, vo->dheight); + if (vc->output_surface_height < vo->dheight) { + vc->output_surface_height += vc->output_surface_height >> 1; + vc->output_surface_height = FFMAX(vc->output_surface_height, vo->dheight); } // Creation of output_surfaces for (i = 0; i <= NUM_OUTPUT_SURFACES; i++) { - if (output_surfaces[i] != VDP_INVALID_HANDLE) - vdp->output_surface_destroy(output_surfaces[i]); - vdp_st = vdp->output_surface_create(vdp_device, VDP_RGBA_FORMAT_B8G8R8A8, - output_surface_width, output_surface_height, - &output_surfaces[i]); + if (vc->output_surfaces[i] != VDP_INVALID_HANDLE) + vdp->output_surface_destroy(vc->output_surfaces[i]); + vdp_st = vdp->output_surface_create(vc->vdp_device, VDP_RGBA_FORMAT_B8G8R8A8, + vc->output_surface_width, vc->output_surface_height, + &vc->output_surfaces[i]); CHECK_ST_WARNING("Error when calling vdp->output_surface_create") - mp_msg(MSGT_VO, MSGL_DBG2, "OUT CREATE: %u\n", output_surfaces[i]); + mp_msg(MSGT_VO, MSGL_DBG2, "OUT CREATE: %u\n", vc->output_surfaces[i]); } } video_to_output_surface(vo); @@ -297,8 +296,8 @@ static int win_x11_init_vdpau_procs(struct vo *vo) {0, -1} }; - vdp_st = vdp_device_create(x11->display, x11->screen, - &vdp_device, &vdp_get_proc_address); + vdp_st = vc->vdp_device_create(x11->display, x11->screen, + &vc->vdp_device, &vc->vdp_get_proc_address); if (vdp_st != VDP_STATUS_OK) { mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Error when calling vdp_device_create_x11: %i\n", vdp_st); return -1; @@ -306,7 +305,7 @@ static int win_x11_init_vdpau_procs(struct vo *vo) vdp->get_error_string = NULL; for (dsc = vdp_func; dsc->offset >= 0; dsc++) { - vdp_st = vdp_get_proc_address(vdp_device, dsc->id, + vdp_st = vc->vdp_get_proc_address(vc->vdp_device, dsc->id, (void **)((char *)vdp + dsc->offset)); if (vdp_st != VDP_STATUS_OK) { mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Error when calling vdp_get_proc_address(function id %d): %s\n", dsc->id, vdp->get_error_string ? vdp->get_error_string(vdp_st) : "?"); @@ -324,12 +323,12 @@ static int win_x11_init_vdpau_flip_queue(struct vo *vo) struct vo_x11_state *x11 = vo->x11; VdpStatus vdp_st; - vdp_st = vdp->presentation_queue_target_create_x11(vdp_device, x11->window, - &vdp_flip_target); + vdp_st = vdp->presentation_queue_target_create_x11(vc->vdp_device, x11->window, + &vc->flip_target); CHECK_ST_ERROR("Error when calling vdp->presentation_queue_target_create_x11") - vdp_st = vdp->presentation_queue_create(vdp_device, vdp_flip_target, - &vdp_flip_queue); + vdp_st = vdp->presentation_queue_create(vc->vdp_device, vc->flip_target, + &vc->flip_queue); CHECK_ST_ERROR("Error when calling vdp->presentation_queue_create") return 0; @@ -347,9 +346,9 @@ static int create_vdp_mixer(struct vo *vo, VdpChromaType vdp_chroma_type) VdpVideoMixerFeature features[MAX_NUM_FEATURES]; VdpBool feature_enables[MAX_NUM_FEATURES]; static const VdpVideoMixerAttribute denoise_attrib[] = {VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL}; - const void * const denoise_value[] = {&denoise}; + const void * const denoise_value[] = {&vc->denoise}; static const VdpVideoMixerAttribute sharpen_attrib[] = {VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL}; - const void * const sharpen_value[] = {&sharpen}; + const void * const sharpen_value[] = {&vc->sharpen}; static const VdpVideoMixerAttribute skip_chroma_attrib[] = {VDP_VIDEO_MIXER_ATTRIBUTE_SKIP_CHROMA_DEINTERLACE}; const uint8_t skip_chroma_value = 1; const void * const skip_chroma_value_ptr[] = {&skip_chroma_value}; @@ -359,37 +358,37 @@ static int create_vdp_mixer(struct vo *vo, VdpChromaType vdp_chroma_type) VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE }; const void *const parameter_values[VDP_NUM_MIXER_PARAMETER] = { - &vid_width, - &vid_height, + &vc->vid_width, + &vc->vid_height, &vdp_chroma_type }; features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL; - if (deint == 4) + if (vc->deint == 4) features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL; - if (pullup) + if (vc->pullup) features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE; - if (denoise) + if (vc->denoise) features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION; - if (sharpen) + if (vc->sharpen) features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_SHARPNESS; - vdp_st = vdp->video_mixer_create(vdp_device, feature_count, features, + vdp_st = vdp->video_mixer_create(vc->vdp_device, feature_count, features, VDP_NUM_MIXER_PARAMETER, parameters, parameter_values, - &video_mixer); + &vc->video_mixer); CHECK_ST_ERROR("Error when calling vdp_video_mixer_create") for (i = 0; i < feature_count; i++) feature_enables[i] = VDP_TRUE; - if (deint < 3) + if (vc->deint < 3) feature_enables[0] = VDP_FALSE; if (feature_count) - vdp->video_mixer_set_feature_enables(video_mixer, feature_count, features, feature_enables); - if (denoise) - vdp->video_mixer_set_attribute_values(video_mixer, 1, denoise_attrib, denoise_value); - if (sharpen) - vdp->video_mixer_set_attribute_values(video_mixer, 1, sharpen_attrib, sharpen_value); - if (!chroma_deint) - vdp->video_mixer_set_attribute_values(video_mixer, 1, skip_chroma_attrib, skip_chroma_value_ptr); + vdp->video_mixer_set_feature_enables(vc->video_mixer, feature_count, features, feature_enables); + if (vc->denoise) + vdp->video_mixer_set_attribute_values(vc->video_mixer, 1, denoise_attrib, denoise_value); + if (vc->sharpen) + vdp->video_mixer_set_attribute_values(vc->video_mixer, 1, sharpen_attrib, sharpen_value); + if (!vc->chroma_deint) + vdp->video_mixer_set_attribute_values(vc->video_mixer, 1, skip_chroma_attrib, skip_chroma_value_ptr); return 0; } @@ -402,33 +401,33 @@ static void free_video_specific(struct vo *vo) int i; VdpStatus vdp_st; - if (decoder != VDP_INVALID_HANDLE) - vdp->decoder_destroy(decoder); - decoder = VDP_INVALID_HANDLE; - decoder_max_refs = -1; + if (vc->decoder != VDP_INVALID_HANDLE) + vdp->decoder_destroy(vc->decoder); + vc->decoder = VDP_INVALID_HANDLE; + vc->decoder_max_refs = -1; for (i = 0; i < 3; i++) - deint_surfaces[i] = VDP_INVALID_HANDLE; + vc->deint_surfaces[i] = VDP_INVALID_HANDLE; for (i = 0; i < 2; i++) - if (deint_mpi[i]) { - deint_mpi[i]->usage_count--; - deint_mpi[i] = NULL; + if (vc->deint_mpi[i]) { + vc->deint_mpi[i]->usage_count--; + vc->deint_mpi[i] = NULL; } for (i = 0; i < MAX_VIDEO_SURFACES; i++) { - if (surface_render[i].surface != VDP_INVALID_HANDLE) { - vdp_st = vdp->video_surface_destroy(surface_render[i].surface); + if (vc->surface_render[i].surface != VDP_INVALID_HANDLE) { + vdp_st = vdp->video_surface_destroy(vc->surface_render[i].surface); CHECK_ST_WARNING("Error when calling vdp_video_surface_destroy") } - surface_render[i].surface = VDP_INVALID_HANDLE; + vc->surface_render[i].surface = VDP_INVALID_HANDLE; } - if (video_mixer != VDP_INVALID_HANDLE) { - vdp_st = vdp->video_mixer_destroy(video_mixer); + if (vc->video_mixer != VDP_INVALID_HANDLE) { + vdp_st = vdp->video_mixer_destroy(vc->video_mixer); CHECK_ST_WARNING("Error when calling vdp_video_mixer_destroy") } - video_mixer = VDP_INVALID_HANDLE; + vc->video_mixer = VDP_INVALID_HANDLE; } static int create_vdp_decoder(struct vo *vo, int max_refs) @@ -437,9 +436,9 @@ static int create_vdp_decoder(struct vo *vo, int max_refs) struct vdp_functions *vdp = vc->vdp; VdpStatus vdp_st; VdpDecoderProfile vdp_decoder_profile; - if (decoder != VDP_INVALID_HANDLE) - vdp->decoder_destroy(decoder); - switch (image_format) { + if (vc->decoder != VDP_INVALID_HANDLE) + vdp->decoder_destroy(vc->decoder); + switch (vc->image_format) { case IMGFMT_VDPAU_MPEG1: vdp_decoder_profile = VDP_DECODER_PROFILE_MPEG1; break; @@ -457,15 +456,15 @@ static int create_vdp_decoder(struct vo *vo, int max_refs) vdp_decoder_profile = VDP_DECODER_PROFILE_VC1_ADVANCED; break; } - vdp_st = vdp->decoder_create(vdp_device, vdp_decoder_profile, - vid_width, vid_height, max_refs, &decoder); + vdp_st = vdp->decoder_create(vc->vdp_device, vdp_decoder_profile, + vc->vid_width, vc->vid_height, max_refs, &vc->decoder); CHECK_ST_WARNING("Failed creating VDPAU decoder"); if (vdp_st != VDP_STATUS_OK) { - decoder = VDP_INVALID_HANDLE; - decoder_max_refs = 0; + vc->decoder = VDP_INVALID_HANDLE; + vc->decoder_max_refs = 0; return 0; } - decoder_max_refs = max_refs; + vc->decoder_max_refs = max_refs; return 1; } @@ -477,6 +476,7 @@ static int config(struct vo *vo, uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t flags, char *title, uint32_t format) { + struct vdpctx *vc = vo->priv; struct vo_x11_state *x11 = vo->x11; XVisualInfo vinfo; XSetWindowAttributes xswa; @@ -488,11 +488,11 @@ static int config(struct vo *vo, uint32_t width, uint32_t height, int vm = flags & VOFLAG_MODESWITCHING; #endif - image_format = format; - vid_width = width; - vid_height = height; + vc->image_format = format; + vc->vid_width = width; + vc->vid_height = height; free_video_specific(vo); - if (IMGFMT_IS_VDPAU(image_format) && !create_vdp_decoder(vo, 2)) + if (IMGFMT_IS_VDPAU(vc->image_format) && !create_vdp_decoder(vo, 2)) return -1; visible_buf = 0; @@ -536,33 +536,33 @@ static int config(struct vo *vo, uint32_t width, uint32_t height, vo_fs = 1; /* -----VDPAU related code here -------- */ - if (vdp_flip_queue == VDP_INVALID_HANDLE + if (vc->flip_queue == VDP_INVALID_HANDLE && win_x11_init_vdpau_flip_queue(vo)) return -1; - vdp_chroma_type = VDP_CHROMA_TYPE_420; - switch (image_format) { + vc->vdp_chroma_type = VDP_CHROMA_TYPE_420; + switch (vc->image_format) { case IMGFMT_YV12: case IMGFMT_I420: case IMGFMT_IYUV: - vdp_pixel_format = VDP_YCBCR_FORMAT_YV12; + vc->vdp_pixel_format = VDP_YCBCR_FORMAT_YV12; break; case IMGFMT_NV12: - vdp_pixel_format = VDP_YCBCR_FORMAT_NV12; + vc->vdp_pixel_format = VDP_YCBCR_FORMAT_NV12; break; case IMGFMT_YUY2: - vdp_pixel_format = VDP_YCBCR_FORMAT_YUYV; - vdp_chroma_type = VDP_CHROMA_TYPE_422; + vc->vdp_pixel_format = VDP_YCBCR_FORMAT_YUYV; + vc->vdp_chroma_type = VDP_CHROMA_TYPE_422; break; case IMGFMT_UYVY: - vdp_pixel_format = VDP_YCBCR_FORMAT_UYVY; - vdp_chroma_type = VDP_CHROMA_TYPE_422; + vc->vdp_pixel_format = VDP_YCBCR_FORMAT_UYVY; + vc->vdp_chroma_type = VDP_CHROMA_TYPE_422; } - if (create_vdp_mixer(vo, vdp_chroma_type)) + if (create_vdp_mixer(vo, vc->vdp_chroma_type)) return -1; - surface_num = 0; - vid_surface_num = -1; + vc->surface_num = 0; + vc->vid_surface_num = -1; resize(vo); return 0; @@ -583,8 +583,8 @@ static void check_events(struct vo *vo) if (visible_buf) { /* redraw the last visible buffer */ VdpStatus vdp_st; - vdp_st = vdp->presentation_queue_display(vdp_flip_queue, - output_surfaces[surface_num], + vdp_st = vdp->presentation_queue_display(vc->flip_queue, + vc->output_surfaces[vc->surface_num], vo->dwidth, vo->dheight, 0); CHECK_ST_WARNING("Error when calling vdp->presentation_queue_display") @@ -598,7 +598,7 @@ static void draw_osd_I8A8(void *ctx, int x0, int y0, int w, int h, struct vo *vo = ctx; struct vdpctx *vc = vo->priv; struct vdp_functions *vdp = vc->vdp; - VdpOutputSurface output_surface = output_surfaces[surface_num]; + VdpOutputSurface output_surface = vc->output_surfaces[vc->surface_num]; VdpStatus vdp_st; int i, j; int pitch; @@ -610,16 +610,16 @@ static void draw_osd_I8A8(void *ctx, int x0, int y0, int w, int h, return; index_data_size_required = 2*w*h; - if (index_data_size < index_data_size_required) { - index_data = realloc(index_data, index_data_size_required); - index_data_size = index_data_size_required; + if (vc->index_data_size < index_data_size_required) { + vc->index_data = realloc(vc->index_data, index_data_size_required); + vc->index_data_size = index_data_size_required; } // index_data creation, component order - I, A, I, A, ..... for (i = 0; i < h; i++) for (j = 0; j < w; j++) { - index_data[i*2*w + j*2] = src [i*stride+j]; - index_data[i*2*w + j*2 + 1] = -srca[i*stride+j]; + vc->index_data[i*2*w + j*2] = src [i*stride+j]; + vc->index_data[i*2*w + j*2 + 1] = -srca[i*stride+j]; } output_indexed_rect_vid.x0 = x0; @@ -632,11 +632,11 @@ static void draw_osd_I8A8(void *ctx, int x0, int y0, int w, int h, // write source_data to osd_surface. vdp_st = vdp->output_surface_put_bits_indexed(osd_surface, VDP_INDEXED_FORMAT_I8A8, - (const void *const*)&index_data, + (const void *const*)&vc->index_data, &pitch, &output_indexed_rect_vid, VDP_COLOR_TABLE_FORMAT_B8G8R8X8, - (void *)palette); + (void *)vc->palette); CHECK_ST_WARNING("Error when calling vdp->output_surface_put_bits_indexed") blend_state.struct_version = VDP_OUTPUT_SURFACE_RENDER_BLEND_STATE_VERSION; @@ -662,7 +662,7 @@ static void draw_eosd(struct vo *vo) struct vdpctx *vc = vo->priv; struct vdp_functions *vdp = vc->vdp; VdpStatus vdp_st; - VdpOutputSurface output_surface = output_surfaces[surface_num]; + VdpOutputSurface output_surface = vc->output_surfaces[vc->surface_num]; VdpOutputSurfaceRenderBlendState blend_state; int i; @@ -739,7 +739,7 @@ static void generate_eosd(struct vo *vo, mp_eosd_images_t *imgs) eosd_surfaces[j].in_use = 0; } } - vdp_st = vdp->bitmap_surface_create(vdp_device, VDP_RGBA_FORMAT_A8, + vdp_st = vdp->bitmap_surface_create(vc->vdp_device, VDP_RGBA_FORMAT_A8, i->w, i->h, VDP_TRUE, &eosd_surfaces[found].surface); CHECK_ST_WARNING("EOSD: error when creating surface") eosd_surfaces[found].w = i->w; @@ -779,10 +779,11 @@ eosd_skip_upload: static void draw_osd(struct vo *vo, struct osd_state *osd) { + struct vdpctx *vc = vo->priv; mp_msg(MSGT_VO, MSGL_DBG2, "DRAW_OSD\n"); - osd_draw_text_ext(osd, vo->dwidth, vo->dheight, border_x, border_y, - border_x, border_y, vid_width, vid_height, + osd_draw_text_ext(osd, vo->dwidth, vo->dheight, vc->border_x, vc->border_y, + vc->border_x, vc->border_y, vc->vid_width, vc->vid_height, draw_osd_I8A8, vo); } @@ -792,14 +793,14 @@ static void flip_page(struct vo *vo) struct vdp_functions *vdp = vc->vdp; VdpStatus vdp_st; mp_msg(MSGT_VO, MSGL_DBG2, "\nFLIP_PAGE VID:%u -> OUT:%u\n", - surface_render[vid_surface_num].surface, output_surfaces[surface_num]); + vc->surface_render[vc->vid_surface_num].surface, vc->output_surfaces[vc->surface_num]); - vdp_st = vdp->presentation_queue_display(vdp_flip_queue, output_surfaces[surface_num], + vdp_st = vdp->presentation_queue_display(vc->flip_queue, vc->output_surfaces[vc->surface_num], vo->dwidth, vo->dheight, 0); CHECK_ST_WARNING("Error when calling vdp->presentation_queue_display") - surface_num = (surface_num + 1) % NUM_OUTPUT_SURFACES; + vc->surface_num = (vc->surface_num + 1) % NUM_OUTPUT_SURFACES; visible_buf = 1; } @@ -810,14 +811,14 @@ static int draw_slice(struct vo *vo, uint8_t *image[], int stride[], int w, struct vdp_functions *vdp = vc->vdp; VdpStatus vdp_st; struct vdpau_render_state *rndr = (struct vdpau_render_state *)image[0]; - int max_refs = image_format == IMGFMT_VDPAU_H264 ? rndr->info.h264.num_ref_frames : 2; - if (!IMGFMT_IS_VDPAU(image_format)) + int max_refs = vc->image_format == IMGFMT_VDPAU_H264 ? rndr->info.h264.num_ref_frames : 2; + if (!IMGFMT_IS_VDPAU(vc->image_format)) return VO_FALSE; - if ((decoder == VDP_INVALID_HANDLE || decoder_max_refs < max_refs) + if ((vc->decoder == VDP_INVALID_HANDLE || vc->decoder_max_refs < max_refs) && !create_vdp_decoder(vo, max_refs)) return VO_FALSE; - vdp_st = vdp->decoder_render(decoder, rndr->surface, (void *)&rndr->info, rndr->bitstream_buffers_used, rndr->bitstream_buffers); + vdp_st = vdp->decoder_render(vc->decoder, rndr->surface, (void *)&rndr->info, rndr->bitstream_buffers_used, rndr->bitstream_buffers); CHECK_ST_WARNING("Failed VDPAU decoder rendering"); return VO_TRUE; } @@ -835,17 +836,17 @@ static struct vdpau_render_state *get_surface(struct vo *vo, int number) if (number > MAX_VIDEO_SURFACES) return NULL; - if (surface_render[number].surface == VDP_INVALID_HANDLE) { + if (vc->surface_render[number].surface == VDP_INVALID_HANDLE) { VdpStatus vdp_st; - vdp_st = vdp->video_surface_create(vdp_device, vdp_chroma_type, - vid_width, vid_height, - &surface_render[number].surface); + vdp_st = vdp->video_surface_create(vc->vdp_device, vc->vdp_chroma_type, + vc->vid_width, vc->vid_height, + &vc->surface_render[number].surface); CHECK_ST_WARNING("Error when calling vdp_video_surface_create") if (vdp_st != VDP_STATUS_OK) return NULL; } - mp_msg(MSGT_VO, MSGL_DBG2, "VID CREATE: %u\n", surface_render[number].surface); - return &surface_render[number]; + mp_msg(MSGT_VO, MSGL_DBG2, "VID CREATE: %u\n", vc->surface_render[number].surface); + return &vc->surface_render[number]; } static uint32_t draw_image(struct vo *vo, mp_image_t *mpi) @@ -853,34 +854,34 @@ static uint32_t draw_image(struct vo *vo, mp_image_t *mpi) struct vdpctx *vc = vo->priv; struct vdp_functions *vdp = vc->vdp; - if (IMGFMT_IS_VDPAU(image_format)) { + if (IMGFMT_IS_VDPAU(vc->image_format)) { struct vdpau_render_state *rndr = mpi->priv; - vid_surface_num = rndr - surface_render; - if (deint_buffer_past_frames) { + vc->vid_surface_num = rndr - vc->surface_render; + if (vc->deint_buffer_past_frames) { mpi->usage_count++; - if (deint_mpi[1]) - deint_mpi[1]->usage_count--; - deint_mpi[1] = deint_mpi[0]; - deint_mpi[0] = mpi; + if (vc->deint_mpi[1]) + vc->deint_mpi[1]->usage_count--; + vc->deint_mpi[1] = vc->deint_mpi[0]; + vc->deint_mpi[0] = mpi; } } else if (!(mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)) { VdpStatus vdp_st; void *destdata[3] = {mpi->planes[0], mpi->planes[2], mpi->planes[1]}; - struct vdpau_render_state *rndr = get_surface(vo, deint_counter); - deint_counter = (deint_counter + 1) % 3; - vid_surface_num = rndr - surface_render; - if (image_format == IMGFMT_NV12) + struct vdpau_render_state *rndr = get_surface(vo, vc->deint_counter); + vc->deint_counter = (vc->deint_counter + 1) % 3; + vc->vid_surface_num = rndr - vc->surface_render; + if (vc->image_format == IMGFMT_NV12) destdata[1] = destdata[2]; vdp_st = vdp->video_surface_put_bits_y_cb_cr(rndr->surface, - vdp_pixel_format, + vc->vdp_pixel_format, (const void *const*)destdata, mpi->stride); // pitch CHECK_ST_ERROR("Error when calling vdp_video_surface_put_bits_y_cb_cr") } if (mpi->fields & MP_IMGFIELD_ORDERED) - top_field_first = !!(mpi->fields & MP_IMGFIELD_TOP_FIRST); + vc->top_field_first = !!(mpi->fields & MP_IMGFIELD_TOP_FIRST); else - top_field_first = 1; + vc->top_field_first = 1; video_to_output_surface(vo); return VO_TRUE; @@ -888,10 +889,11 @@ static uint32_t draw_image(struct vo *vo, mp_image_t *mpi) static uint32_t get_image(struct vo *vo, mp_image_t *mpi) { + struct vdpctx *vc = vo->priv; struct vdpau_render_state *rndr; // no dr for non-decoding for now - if (!IMGFMT_IS_VDPAU(image_format)) return VO_FALSE; + if (!IMGFMT_IS_VDPAU(vc->image_format)) return VO_FALSE; if (mpi->type != MP_IMGTYPE_NUMBERED) return VO_FALSE; rndr = get_surface(vo, mpi->number); @@ -941,15 +943,15 @@ static void destroy_vdpau_objects(struct vo *vo) free_video_specific(vo); - vdp_st = vdp->presentation_queue_destroy(vdp_flip_queue); + vdp_st = vdp->presentation_queue_destroy(vc->flip_queue); CHECK_ST_WARNING("Error when calling vdp->presentation_queue_destroy") - vdp_st = vdp->presentation_queue_target_destroy(vdp_flip_target); + vdp_st = vdp->presentation_queue_target_destroy(vc->flip_target); CHECK_ST_WARNING("Error when calling vdp->presentation_queue_target_destroy") for (i = 0; i <= NUM_OUTPUT_SURFACES; i++) { - vdp_st = vdp->output_surface_destroy(output_surfaces[i]); - output_surfaces[i] = VDP_INVALID_HANDLE; + vdp_st = vdp->output_surface_destroy(vc->output_surfaces[i]); + vc->output_surfaces[i] = VDP_INVALID_HANDLE; CHECK_ST_WARNING("Error when calling vdp->output_surface_destroy") } @@ -961,12 +963,14 @@ static void destroy_vdpau_objects(struct vo *vo) eosd_surfaces[i].surface = VDP_INVALID_HANDLE; } - vdp_st = vdp->device_destroy(vdp_device); + vdp_st = vdp->device_destroy(vc->vdp_device); CHECK_ST_WARNING("Error when calling vdp_device_destroy") } static void uninit(struct vo *vo) { + struct vdpctx *vc = vo->priv; + if (!vo->config_count) return; visible_buf = 0; @@ -974,8 +978,8 @@ static void uninit(struct vo *vo) /* Destroy all vdpau objects */ destroy_vdpau_objects(vo); - free(index_data); - index_data = NULL; + free(vc->index_data); + vc->index_data = NULL; free(eosd_surfaces); eosd_surfaces = NULL; @@ -987,18 +991,9 @@ static void uninit(struct vo *vo) #endif vo_x11_uninit(vo); - dlclose(vdpau_lib_handle); + dlclose(vc->vdpau_lib_handle); } -static const opt_t subopts[] = { - {"deint", OPT_ARG_INT, &deint, (opt_test_f)int_non_neg}, - {"chroma-deint", OPT_ARG_BOOL, &chroma_deint, NULL}, - {"pullup", OPT_ARG_BOOL, &pullup, NULL}, - {"denoise", OPT_ARG_FLOAT, &denoise, NULL}, - {"sharpen", OPT_ARG_FLOAT, &sharpen, NULL}, - {NULL} -}; - static const char help_msg[] = "\n-vo vdpau command line help:\n" "Example: mplayer -vo vdpau:deint=2\n" @@ -1027,34 +1022,42 @@ static int preinit(struct vo *vo, const char *arg) struct vdpctx *vc = talloc_zero(vo, struct vdpctx); vo->priv = vc; - deint = 0; - deint_type = 3; - deint_counter = 0; - deint_buffer_past_frames = 0; - deint_mpi[0] = deint_mpi[1] = NULL; - chroma_deint = 1; - pullup = 0; - denoise = 0; - sharpen = 0; + vc->deint = 0; + vc->deint_type = 3; + vc->deint_counter = 0; + vc->deint_buffer_past_frames = 0; + vc->deint_mpi[0] = vc->deint_mpi[1] = NULL; + vc->chroma_deint = 1; + vc->pullup = 0; + vc->denoise = 0; + vc->sharpen = 0; + const opt_t subopts[] = { + {"deint", OPT_ARG_INT, &vc->deint, (opt_test_f)int_non_neg}, + {"chroma-deint", OPT_ARG_BOOL, &vc->chroma_deint, NULL}, + {"pullup", OPT_ARG_BOOL, &vc->pullup, NULL}, + {"denoise", OPT_ARG_FLOAT, &vc->denoise, NULL}, + {"sharpen", OPT_ARG_FLOAT, &vc->sharpen, NULL}, + {NULL} + }; if (subopt_parse(arg, subopts) != 0) { mp_msg(MSGT_VO, MSGL_FATAL, help_msg); return -1; } - if (deint) - deint_type = deint; - if (deint > 1) - deint_buffer_past_frames = 1; + if (vc->deint) + vc->deint_type = vc->deint; + if (vc->deint > 1) + vc->deint_buffer_past_frames = 1; char *vdpaulibrary = "libvdpau.so.1"; char *vdpau_device_create = "vdp_device_create_x11"; - vdpau_lib_handle = dlopen(vdpaulibrary, RTLD_LAZY); - if (!vdpau_lib_handle) { + vc->vdpau_lib_handle = dlopen(vdpaulibrary, RTLD_LAZY); + if (!vc->vdpau_lib_handle) { mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Could not open dynamic library %s\n", vdpaulibrary); return -1; } - |