From 3de64989180176eb10dc6ea1a012ede660afd7f5 Mon Sep 17 00:00:00 2001 From: Romain Vimont Date: Mon, 23 Apr 2018 18:10:15 +0200 Subject: [PATCH] core: replace picture_sys_t* by void* See #17078 Signed-off-by: Jean-Baptiste Kempf --- include/vlc_picture.h | 2 +- modules/codec/avcodec/d3d11va.c | 19 ++++++++-------- modules/hw/d3d11/d3d11_deinterlace.c | 31 +++++++++++++++------------ modules/hw/d3d11/d3d11_filters.c | 15 +++++++------ modules/hw/d3d11/d3d11_surface.c | 15 +++++++------ modules/hw/d3d9/d3d9_filters.c | 8 +++++-- modules/hw/d3d9/dxa9.c | 11 +++++----- modules/hw/d3d9/dxva2_deinterlace.c | 19 +++++++++------- modules/hw/vaapi/vlc_vaapi.c | 8 ++++--- modules/hw/vdpau/chroma.c | 7 +++--- modules/hw/vdpau/display.c | 3 ++- modules/video_output/opengl/converter_sw.c | 13 ++++++----- modules/video_output/opengl/converter_vdpau.c | 13 ++++++----- modules/video_output/win32/direct3d11.c | 7 +++--- modules/video_output/win32/direct3d9.c | 9 +++++--- modules/video_output/win32/directdraw.c | 19 +++++++++------- 16 files changed, 116 insertions(+), 83 deletions(-) diff --git a/include/vlc_picture.h b/include/vlc_picture.h index 7c0d869821..7364ea94b2 100644 --- a/include/vlc_picture.h +++ b/include/vlc_picture.h @@ -97,7 +97,7 @@ struct picture_t /** Private data - the video output plugin might want to put stuff here to * keep track of the picture */ - picture_sys_t * p_sys; + void *p_sys; /** Next picture in a FIFO a pictures */ struct picture_t *p_next; diff --git a/modules/codec/avcodec/d3d11va.c b/modules/codec/avcodec/d3d11va.c index 45e954b203..7201b599bf 100644 --- a/modules/codec/avcodec/d3d11va.c +++ b/modules/codec/avcodec/d3d11va.c @@ -250,36 +250,37 @@ static struct va_pic_context* NewSurfacePicContext(vlc_va_t *va, int surface_ind static int Get(vlc_va_t *va, picture_t *pic, uint8_t **data) { + picture_sys_t *p_sys = pic->p_sys; #if D3D11_DIRECT_DECODE if (va->sys->dx_sys.can_extern_pool) { /* copy the original picture_sys_t in the va_pic_context */ if (!pic->context) { - assert(pic->p_sys!=NULL); - if (!pic->p_sys->decoder) + assert(p_sys!=NULL); + if (!p_sys->decoder) { HRESULT hr; D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC viewDesc; ZeroMemory(&viewDesc, sizeof(viewDesc)); viewDesc.DecodeProfile = va->sys->dx_sys.input; viewDesc.ViewDimension = D3D11_VDOV_DIMENSION_TEXTURE2D; - viewDesc.Texture2D.ArraySlice = pic->p_sys->slice_index; + viewDesc.Texture2D.ArraySlice = p_sys->slice_index; hr = ID3D11VideoDevice_CreateVideoDecoderOutputView( va->sys->dx_sys.d3ddec, - pic->p_sys->resource[KNOWN_DXGI_INDEX], + p_sys->resource[KNOWN_DXGI_INDEX], &viewDesc, - &pic->p_sys->decoder ); + &p_sys->decoder ); if (FAILED(hr)) return VLC_EGENERIC; } pic->context = (picture_context_t*)CreatePicContext( - pic->p_sys->decoder, - pic->p_sys->resource[KNOWN_DXGI_INDEX], + p_sys->decoder, + p_sys->resource[KNOWN_DXGI_INDEX], va->sys->d3d_dev.d3dcontext, - pic->p_sys->slice_index, - pic->p_sys->resourceView ); + p_sys->slice_index, + p_sys->resourceView ); if (pic->context == NULL) return VLC_EGENERIC; } diff --git a/modules/hw/d3d11/d3d11_deinterlace.c b/modules/hw/d3d11/d3d11_deinterlace.c index 8c87ad5261..d26a144d7a 100644 --- a/modules/hw/d3d11/d3d11_deinterlace.c +++ b/modules/hw/d3d11/d3d11_deinterlace.c @@ -128,6 +128,7 @@ static int RenderPic( filter_t *p_filter, picture_t *p_outpic, picture_t *p_pic, VLC_UNUSED(order); HRESULT hr; filter_sys_t *p_sys = p_filter->p_sys; + picture_sys_t *p_out_sys = p_outpic->p_sys; picture_t *p_prev = p_sys->context.pp_history[0]; picture_t *p_cur = p_sys->context.pp_history[1]; @@ -209,9 +210,9 @@ static int RenderPic( filter_t *p_filter, picture_t *p_outpic, picture_t *p_pic, .back = 1, }; - ID3D11DeviceContext_CopySubresourceRegion(p_outpic->p_sys->context, - p_outpic->p_sys->resource[KNOWN_DXGI_INDEX], - p_outpic->p_sys->slice_index, + ID3D11DeviceContext_CopySubresourceRegion(p_out_sys->context, + p_out_sys->resource[KNOWN_DXGI_INDEX], + p_out_sys->slice_index, 0, 0, 0, p_sys->outResource, 0, &box); @@ -274,15 +275,17 @@ static struct picture_context_t *d3d11_pic_context_copy(struct picture_context_t static picture_t *NewOutputPicture( filter_t *p_filter ) { picture_t *pic = p_filter->p_sys->buffer_new( p_filter ); + picture_sys_t *pic_sys = pic->p_sys; if ( !pic->context ) { bool b_local_texture = false; - if ( !pic->p_sys ) + if ( !pic_sys ) { - pic->p_sys = calloc(1, sizeof(*pic->p_sys)); - if (unlikely(pic->p_sys == NULL)) + pic_sys = calloc(1, sizeof(*pic_sys)); + if (unlikely(pic_sys == NULL)) return NULL; + pic->p_sys = pic_sys; D3D11_TEXTURE2D_DESC dstDesc; ID3D11Texture2D_GetDesc(p_filter->p_sys->outTexture, &dstDesc); @@ -300,7 +303,7 @@ static picture_t *NewOutputPicture( filter_t *p_filter ) } if (unlikely(cfg == NULL)) { - free(pic->p_sys); + free(pic_sys); return NULL; } @@ -309,15 +312,15 @@ static picture_t *NewOutputPicture( filter_t *p_filter ) fmt.i_width = dstDesc.Width; fmt.i_height = dstDesc.Height; if (AllocateTextures(VLC_OBJECT(p_filter), &p_filter->p_sys->d3d_dev, cfg, - &fmt, 1, pic->p_sys->texture) != VLC_SUCCESS) + &fmt, 1, pic_sys->texture) != VLC_SUCCESS) { - free(pic->p_sys); + free(pic_sys); return NULL; } b_local_texture = true; - pic->p_sys->context = p_filter->p_sys->d3d_dev.d3dcontext; - pic->p_sys->formatTexture = dstDesc.Format; + pic_sys->context = p_filter->p_sys->d3d_dev.d3dcontext; + pic_sys->formatTexture = dstDesc.Format; } /* the picture might be duplicated for snapshots so it needs a context */ @@ -326,14 +329,14 @@ static picture_t *NewOutputPicture( filter_t *p_filter ) { pic_ctx->s.destroy = d3d11_pic_context_destroy; pic_ctx->s.copy = d3d11_pic_context_copy; - pic_ctx->picsys = *pic->p_sys; + pic_ctx->picsys = *pic_sys; AcquirePictureSys( &pic_ctx->picsys ); pic->context = &pic_ctx->s; } if (b_local_texture) { for (int i=0; ip_sys->texture[i]) - ID3D11Texture2D_Release(pic->p_sys->texture[i]); + if (pic_sys->texture[i]) + ID3D11Texture2D_Release(pic_sys->texture[i]); } } } diff --git a/modules/hw/d3d11/d3d11_filters.c b/modules/hw/d3d11/d3d11_filters.c index f3e25c47c4..daeb1b4e7d 100644 --- a/modules/hw/d3d11/d3d11_filters.c +++ b/modules/hw/d3d11/d3d11_filters.c @@ -236,7 +236,8 @@ static picture_t *Filter(filter_t *p_filter, picture_t *p_pic) picture_Release( p_pic ); return NULL; } - if (unlikely(!p_outpic->p_sys)) + picture_sys_t *p_out_sys = p_outpic->p_sys; + if (unlikely(!p_out_sys)) { /* the output filter configuration may have changed since the filter * was opened */ @@ -299,9 +300,9 @@ static picture_t *Filter(filter_t *p_filter, picture_t *p_pic) if (count == 0) { - ID3D11DeviceContext_CopySubresourceRegion(p_outpic->p_sys->context, - p_outpic->p_sys->resource[KNOWN_DXGI_INDEX], - p_outpic->p_sys->slice_index, + ID3D11DeviceContext_CopySubresourceRegion(p_out_sys->context, + p_out_sys->resource[KNOWN_DXGI_INDEX], + p_out_sys->slice_index, 0, 0, 0, p_src_sys->resource[KNOWN_DXGI_INDEX], p_src_sys->slice_index, @@ -309,9 +310,9 @@ static picture_t *Filter(filter_t *p_filter, picture_t *p_pic) } else { - ID3D11DeviceContext_CopySubresourceRegion(p_outpic->p_sys->context, - p_outpic->p_sys->resource[KNOWN_DXGI_INDEX], - p_outpic->p_sys->slice_index, + ID3D11DeviceContext_CopySubresourceRegion(p_out_sys->context, + p_out_sys->resource[KNOWN_DXGI_INDEX], + p_out_sys->slice_index, 0, 0, 0, p_sys->out[outputs[idx] == p_sys->procOutput[0] ? 1 : 0].resource, 0, diff --git a/modules/hw/d3d11/d3d11_surface.c b/modules/hw/d3d11/d3d11_surface.c index 35997ef4b9..31aa663a77 100644 --- a/modules/hw/d3d11/d3d11_surface.c +++ b/modules/hw/d3d11/d3d11_surface.c @@ -645,11 +645,13 @@ static void NV12_D3D11(filter_t *p_filter, picture_t *src, picture_t *dst) return; } + picture_sys_t *p_staging_sys = sys->staging_pic->p_sys; + D3D11_TEXTURE2D_DESC texDesc; - ID3D11Texture2D_GetDesc( sys->staging_pic->p_sys->texture[KNOWN_DXGI_INDEX], &texDesc); + ID3D11Texture2D_GetDesc( p_staging_sys->texture[KNOWN_DXGI_INDEX], &texDesc); D3D11_MAPPED_SUBRESOURCE lock; - HRESULT hr = ID3D11DeviceContext_Map(p_sys->context, sys->staging_pic->p_sys->resource[KNOWN_DXGI_INDEX], + HRESULT hr = ID3D11DeviceContext_Map(p_sys->context, p_staging_sys->resource[KNOWN_DXGI_INDEX], 0, D3D11_MAP_WRITE, 0, &lock); if (FAILED(hr)) { msg_Err(p_filter, "Failed to map source surface. (hr=0x%0lx)", hr); @@ -661,7 +663,7 @@ static void NV12_D3D11(filter_t *p_filter, picture_t *src, picture_t *dst) picture_Hold( src ); sys->filter->pf_video_filter(sys->filter, src); - ID3D11DeviceContext_Unmap(p_sys->context, sys->staging_pic->p_sys->resource[KNOWN_DXGI_INDEX], 0); + ID3D11DeviceContext_Unmap(p_sys->context, p_staging_sys->resource[KNOWN_DXGI_INDEX], 0); D3D11_BOX copyBox = { .right = dst->format.i_width, .bottom = dst->format.i_height, .back = 1, @@ -670,7 +672,7 @@ static void NV12_D3D11(filter_t *p_filter, picture_t *src, picture_t *dst) p_sys->resource[KNOWN_DXGI_INDEX], p_sys->slice_index, 0, 0, 0, - sys->staging_pic->p_sys->resource[KNOWN_DXGI_INDEX], 0, + p_staging_sys->resource[KNOWN_DXGI_INDEX], 0, ©Box); if (dst->context == NULL) { @@ -679,7 +681,7 @@ static void NV12_D3D11(filter_t *p_filter, picture_t *src, picture_t *dst) { pic_ctx->s.destroy = d3d11_pic_context_destroy; pic_ctx->s.copy = d3d11_pic_context_copy; - pic_ctx->picsys = *dst->p_sys; + pic_ctx->picsys = *p_sys; AcquirePictureSys(&pic_ctx->picsys); dst->context = &pic_ctx->s; } @@ -827,6 +829,7 @@ int D3D11OpenCPUConverter( vlc_object_t *obj ) msg_Err(p_filter, "Failed to map create the temporary picture."); goto done; } + picture_sys_t *p_dst_sys = p_dst->p_sys; picture_Setup(p_dst, &p_dst->format); texDesc.MipLevels = 1; @@ -845,7 +848,7 @@ int D3D11OpenCPUConverter( vlc_object_t *obj ) } res.p_sys->texture[KNOWN_DXGI_INDEX] = texture; - ID3D11DeviceContext_AddRef(p_dst->p_sys->context); + ID3D11DeviceContext_AddRef(p_dst_sys->context); if ( p_filter->fmt_in.video.i_chroma != d3d_fourcc ) { diff --git a/modules/hw/d3d9/d3d9_filters.c b/modules/hw/d3d9/d3d9_filters.c index c8f445d9ac..680f120b33 100644 --- a/modules/hw/d3d9/d3d9_filters.c +++ b/modules/hw/d3d9/d3d9_filters.c @@ -107,7 +107,11 @@ static picture_t *Filter(filter_t *p_filter, picture_t *p_pic) picture_sys_t *p_src_sys = ActivePictureSys(p_pic); picture_t *p_outpic = filter_NewPicture( p_filter ); - if( !p_outpic || !p_outpic->p_sys || !p_outpic->p_sys->surface ) + if( !p_outpic ) + goto failed; + + picture_sys_t *p_out_sys = p_outpic->p_sys; + if( !p_out_sys || !p_out_sys->surface ) goto failed; picture_CopyProperties( p_outpic, p_pic ); @@ -149,7 +153,7 @@ static picture_t *Filter(filter_t *p_filter, picture_t *p_pic) 1, NULL ); hr = IDirect3DDevice9_StretchRect( p_sys->d3d_dev.dev, p_sys->hw_surface, NULL, - p_outpic->p_sys->surface, NULL, + p_out_sys->surface, NULL, D3DTEXF_NONE); if (FAILED(hr)) goto failed; diff --git a/modules/hw/d3d9/dxa9.c b/modules/hw/d3d9/dxa9.c index 259e0153c4..7235709686 100644 --- a/modules/hw/d3d9/dxa9.c +++ b/modules/hw/d3d9/dxa9.c @@ -251,12 +251,13 @@ static void YV12_D3D9(filter_t *p_filter, picture_t *src, picture_t *dst) { filter_sys_t *sys = p_filter->p_sys; picture_sys_t *p_sys = dst->p_sys; + picture_sys_t *p_staging_sys = sys->staging->p_sys; D3DSURFACE_DESC texDesc; IDirect3DSurface9_GetDesc( p_sys->surface, &texDesc); D3DLOCKED_RECT d3drect; - HRESULT hr = IDirect3DSurface9_LockRect(sys->staging->p_sys->surface, &d3drect, NULL, 0); + HRESULT hr = IDirect3DSurface9_LockRect(p_staging_sys->surface, &d3drect, NULL, 0); if (FAILED(hr)) return; @@ -266,14 +267,14 @@ static void YV12_D3D9(filter_t *p_filter, picture_t *src, picture_t *dst) sys->filter->pf_video_filter(sys->filter, src); - IDirect3DSurface9_UnlockRect(sys->staging->p_sys->surface); + IDirect3DSurface9_UnlockRect(p_staging_sys->surface); RECT visibleSource = { .right = dst->format.i_width, .bottom = dst->format.i_height, }; IDirect3DDevice9_StretchRect( sys->d3d_dev.dev, - sys->staging->p_sys->surface, &visibleSource, - dst->p_sys->surface, &visibleSource, + p_staging_sys->surface, &visibleSource, + p_sys->surface, &visibleSource, D3DTEXF_NONE ); if (dst->context == NULL) @@ -283,7 +284,7 @@ static void YV12_D3D9(filter_t *p_filter, picture_t *src, picture_t *dst) { pic_ctx->s.destroy = d3d9_pic_context_destroy; pic_ctx->s.copy = d3d9_pic_context_copy; - pic_ctx->picsys = *dst->p_sys; + pic_ctx->picsys = *p_sys; AcquirePictureSys(&pic_ctx->picsys); dst->context = &pic_ctx->s; } diff --git a/modules/hw/d3d9/dxva2_deinterlace.c b/modules/hw/d3d9/dxva2_deinterlace.c index 3326fa0318..a2f0a54e23 100644 --- a/modules/hw/d3d9/dxva2_deinterlace.c +++ b/modules/hw/d3d9/dxva2_deinterlace.c @@ -132,6 +132,7 @@ static int RenderPic( filter_t *filter, picture_t *p_outpic, picture_t *src, int order, int i_field ) { filter_sys_t *sys = filter->p_sys; + picture_sys_t *p_out_sys = p_outpic->p_sys; const int i_samples = sys->decoder_caps.NumBackwardRefSamples + 1 + sys->decoder_caps.NumForwardRefSamples; HRESULT hr; @@ -195,7 +196,7 @@ static int RenderPic( filter_t *filter, picture_t *p_outpic, picture_t *src, hr = IDirect3DDevice9_StretchRect( sys->d3d_dev.dev, sys->hw_surface, NULL, - p_outpic->p_sys->surface, NULL, + p_out_sys->surface, NULL, D3DTEXF_NONE); if (FAILED(hr)) return VLC_EGENERIC; @@ -251,32 +252,34 @@ static picture_t *NewOutputPicture( filter_t *p_filter ) { filter_sys_t *p_sys = p_filter->p_sys; picture_t *pic = p_sys->buffer_new( p_filter ); + picture_sys_t *pic_sys = pic->p_sys; if ( !pic->context ) { bool b_local_texture = false; - if (!pic->p_sys ) + if ( !pic_sys ) { D3DSURFACE_DESC dstDesc; if ( !p_sys->hw_surface || FAILED(IDirect3DSurface9_GetDesc( p_sys->hw_surface, &dstDesc )) ) return NULL; - pic->p_sys = calloc(1, sizeof(*pic->p_sys)); - if (unlikely(pic->p_sys == NULL)) + pic_sys = calloc(1, sizeof(*pic_sys)); + if (unlikely(pic_sys == NULL)) return NULL; + pic->p_sys = pic_sys; HRESULT hr = IDirect3DDevice9_CreateOffscreenPlainSurface(p_sys->d3d_dev.dev, p_filter->fmt_out.video.i_width, p_filter->fmt_out.video.i_height, dstDesc.Format, D3DPOOL_DEFAULT, - &pic->p_sys->surface, + &pic_sys->surface, NULL); if (FAILED(hr)) { - free(pic->p_sys); + free(p_sys); pic->p_sys = NULL; return NULL; } @@ -288,12 +291,12 @@ static picture_t *NewOutputPicture( filter_t *p_filter ) { pic_ctx->s.destroy = d3d9_pic_context_destroy; pic_ctx->s.copy = d3d9_pic_context_copy; - pic_ctx->picsys = *pic->p_sys; + pic_ctx->picsys = *pic_sys; AcquirePictureSys( &pic_ctx->picsys ); pic->context = &pic_ctx->s; } if (b_local_texture) - IDirect3DSurface9_Release(pic->p_sys->surface); + IDirect3DSurface9_Release(pic_sys->surface); } return pic; } diff --git a/modules/hw/vaapi/vlc_vaapi.c b/modules/hw/vaapi/vlc_vaapi.c index 1f1f384c99..a44d828852 100644 --- a/modules/hw/vaapi/vlc_vaapi.c +++ b/modules/hw/vaapi/vlc_vaapi.c @@ -712,8 +712,9 @@ vlc_vaapi_PicAttachContext(picture_t *pic) assert(pic->p_sys != NULL); assert(pic->context == NULL); - pic->p_sys->ctx.picref = pic; - pic->context = &pic->p_sys->ctx.s; + picture_sys_t *p_sys = pic->p_sys; + p_sys->ctx.picref = pic; + pic->context = &p_sys->ctx.s; } VASurfaceID @@ -731,5 +732,6 @@ vlc_vaapi_PicGetDisplay(picture_t *pic) ASSERT_VAAPI_CHROMA(pic); assert(pic->context); - return ((struct vaapi_pic_ctx *)pic->context)->picref->p_sys->instance->va_dpy; + picture_sys_t *p_sys = ((struct vaapi_pic_ctx *)pic->context)->picref->p_sys; + return p_sys->instance->va_dpy; } diff --git a/modules/hw/vdpau/chroma.c b/modules/hw/vdpau/chroma.c index d839285d8b..028f3d808c 100644 --- a/modules/hw/vdpau/chroma.c +++ b/modules/hw/vdpau/chroma.c @@ -516,7 +516,8 @@ static picture_t *Render(filter_t *filter, picture_t *src, bool import) if (dst == NULL) goto skip; - assert(dst->p_sys != NULL && dst->p_sys->vdp ==sys->vdp); + picture_sys_t *p_sys = dst->p_sys; + assert(p_sys != NULL && p_sys->vdp == sys->vdp); dst->date = sys->history[MAX_PAST].date; dst->b_force = sys->history[MAX_PAST].force; @@ -589,7 +590,7 @@ static picture_t *Render(filter_t *filter, picture_t *src, bool import) } } - VdpOutputSurface output = dst->p_sys->surface; + VdpOutputSurface output = p_sys->surface; if (swap) { @@ -670,7 +671,7 @@ static picture_t *Render(filter_t *filter, picture_t *src, bool import) if (swap) { err = vdp_output_surface_render_output_surface(sys->vdp, - dst->p_sys->surface, NULL, output, NULL, NULL, NULL, + p_sys->surface, NULL, output, NULL, NULL, NULL, VDP_OUTPUT_SURFACE_RENDER_ROTATE_90); vdp_output_surface_destroy(sys->vdp, output); if (err != VDP_STATUS_OK) diff --git a/modules/hw/vdpau/display.c b/modules/hw/vdpau/display.c index edd6096729..87b1378c6e 100644 --- a/modules/hw/vdpau/display.c +++ b/modules/hw/vdpau/display.c @@ -243,7 +243,8 @@ out:/* Destroy GPU surface */ static void Queue(vout_display_t *vd, picture_t *pic, subpicture_t *subpic) { vout_display_sys_t *sys = vd->sys; - VdpOutputSurface surface = pic->p_sys->surface; + picture_sys_t *p_sys = pic->p_sys; + VdpOutputSurface surface = p_sys->surface; VdpStatus err; VdpPresentationQueueStatus status; diff --git a/modules/video_output/opengl/converter_sw.c b/modules/video_output/opengl/converter_sw.c index 981e0d4e37..2a01ba4215 100644 --- a/modules/video_output/opengl/converter_sw.c +++ b/modules/video_output/opengl/converter_sw.c @@ -216,6 +216,7 @@ tc_pbo_update(const opengl_tex_converter_t *tc, GLuint *textures, struct priv *priv = tc->priv; picture_t *display_pic = priv->pbo.display_pics[priv->pbo.display_idx]; + picture_sys_t *p_sys = display_pic->p_sys; priv->pbo.display_idx = (priv->pbo.display_idx + 1) % PBO_DISPLAY_COUNT; for (int i = 0; i < pic->i_planes; i++) @@ -223,7 +224,7 @@ tc_pbo_update(const opengl_tex_converter_t *tc, GLuint *textures, GLsizeiptr size = pic->p[i].i_lines * pic->p[i].i_pitch; const GLvoid *data = pic->p[i].p_pixels; tc->vt->BindBuffer(GL_PIXEL_UNPACK_BUFFER, - display_pic->p_sys->buffers[i]); + p_sys->buffers[i]); tc->vt->BufferSubData(GL_PIXEL_UNPACK_BUFFER, 0, size, data); tc->vt->ActiveTexture(GL_TEXTURE0 + i); @@ -344,7 +345,7 @@ tc_persistent_update(const opengl_tex_converter_t *tc, GLuint *textures, } picsys->fence = tc->vt->FenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0); - if (pic->p_sys->fence == NULL) + if (picsys->fence == NULL) { /* Error (corner case): don't hold the picture */ hold = false; @@ -355,7 +356,7 @@ tc_persistent_update(const opengl_tex_converter_t *tc, GLuint *textures, if (hold) { /* Hold the picture while it's used by the GPU */ - unsigned index = pic->p_sys->index; + unsigned index = picsys->index; priv->persistent.list |= 1ULL << index; assert(priv->persistent.pics[index] == NULL); @@ -384,11 +385,13 @@ tc_persistent_get_pool(const opengl_tex_converter_t *tc, unsigned requested_coun picture_t *pic = pictures[count] = pbo_picture_create(tc, true); if (pic == NULL) break; + + picture_sys_t *p_sys = pic->p_sys; #ifndef NDEBUG for (int i = 0; i < pic->i_planes; ++i) - assert(pic->p_sys->bytes[i] == pictures[0]->p_sys->bytes[i]); + assert(p_sys->bytes[i] == ((picture_sys_t *) pictures[0]->p_sys)->bytes[i]); #endif - pic->p_sys->index = count; + p_sys->index = count; if (persistent_map(tc, pic) != VLC_SUCCESS) { diff --git a/modules/video_output/opengl/converter_vdpau.c b/modules/video_output/opengl/converter_vdpau.c index f3d807a49b..bb77ae8d26 100644 --- a/modules/video_output/opengl/converter_vdpau.c +++ b/modules/video_output/opengl/converter_vdpau.c @@ -66,9 +66,10 @@ static PFNGLVDPAUUNMAPSURFACESNVPROC _glVDPAUUnmapSurfacesNV; static void pool_pic_destroy_cb(picture_t *pic) { - vdp_output_surface_destroy(pic->p_sys->vdp, pic->p_sys->surface); - vdp_release_x11(pic->p_sys->vdp); - free(pic->p_sys); + picture_sys_t *p_sys = pic->p_sys; + vdp_output_surface_destroy(p_sys->vdp, p_sys->surface); + vdp_release_x11(p_sys->vdp); + free(p_sys); free(pic); } @@ -129,8 +130,10 @@ tc_vdpau_gl_update(opengl_tex_converter_t const *tc, GLuint textures[], VLC_UNUSED(tex_heights); VLC_UNUSED(plane_offsets); + picture_sys_t *p_sys = pic->p_sys; + GLvdpauSurfaceNV *p_gl_nv_surface = - (GLvdpauSurfaceNV *)&pic->p_sys->gl_nv_surface; + (GLvdpauSurfaceNV *)&p_sys->gl_nv_surface; if (*p_gl_nv_surface) { @@ -148,7 +151,7 @@ tc_vdpau_gl_update(opengl_tex_converter_t const *tc, GLuint textures[], *p_gl_nv_surface = INTEROP_CALL(glVDPAURegisterOutputSurfaceNV, - (void *)(size_t)pic->p_sys->surface, + (void *)(size_t)p_sys->surface, GL_TEXTURE_2D, tc->tex_count, textures); INTEROP_CALL(glVDPAUSurfaceAccessNV, *p_gl_nv_surface, GL_READ_ONLY); INTEROP_CALL(glVDPAUMapSurfacesNV, 1, p_gl_nv_surface); diff --git a/modules/video_output/win32/direct3d11.c b/modules/video_output/win32/direct3d11.c index aa4c4ec7ff..d4fc38be56 100644 --- a/modules/video_output/win32/direct3d11.c +++ b/modules/video_output/win32/direct3d11.c @@ -662,11 +662,12 @@ static picture_pool_t *Pool(vout_display_t *vd, unsigned pool_size) { sys->picQuad.resourceCount = DxgiResourceCount(sys->picQuadConfig); for (picture_count = 0; picture_count < pool_size; picture_count++) { - if (!pictures[picture_count]->p_sys->texture[0]) + picture_sys_t *p_sys = pictures[picture_count]->p_sys; + if (!p_sys->texture[0]) continue; if (AllocateShaderView(VLC_OBJECT(vd), sys->d3d_dev.d3ddevice, sys->picQuadConfig, - pictures[picture_count]->p_sys->texture, picture_count, - pictures[picture_count]->p_sys->resourceView)) + p_sys->texture, picture_count, + p_sys->resourceView)) goto error; } } diff --git a/modules/video_output/win32/direct3d9.c b/modules/video_output/win32/direct3d9.c index 31dc070edd..18406428af 100644 --- a/modules/video_output/win32/direct3d9.c +++ b/modules/video_output/win32/direct3d9.c @@ -379,9 +379,10 @@ static void DestroyPicture(picture_t *picture) */ static int Direct3D9LockSurface(picture_t *picture) { + picture_sys_t *p_sys = picture->p_sys; /* Lock the surface to get a valid pointer to the picture buffer */ D3DLOCKED_RECT d3drect; - HRESULT hr = IDirect3DSurface9_LockRect(picture->p_sys->surface, &d3drect, NULL, 0); + HRESULT hr = IDirect3DSurface9_LockRect(p_sys->surface, &d3drect, NULL, 0); if (FAILED(hr)) { return VLC_EGENERIC; } @@ -394,8 +395,9 @@ static int Direct3D9LockSurface(picture_t *picture) */ static void Direct3D9UnlockSurface(picture_t *picture) { + picture_sys_t *p_sys = picture->p_sys; /* Unlock the Surface */ - HRESULT hr = IDirect3DSurface9_UnlockRect(picture->p_sys->surface); + HRESULT hr = IDirect3DSurface9_UnlockRect(p_sys->surface); if (FAILED(hr)) { //msg_Dbg(vd, "Failed IDirect3DSurface9_UnlockRect: 0x%0lx", hr); } @@ -496,7 +498,8 @@ static picture_pool_t *DisplayPool(vout_display_t *vd, unsigned count) static void Prepare(vout_display_t *vd, picture_t *picture, subpicture_t *subpicture) { vout_display_sys_t *sys = vd->sys; - LPDIRECT3DSURFACE9 surface = picture->p_sys->surface; + picture_sys_t *p_sys = picture->p_sys; + LPDIRECT3DSURFACE9 surface = p_sys->surface; d3d9_device_t *p_d3d9_dev = &sys->d3d_dev; /* FIXME it is a bit ugly, we need the surface to be unlocked for diff --git a/modules/video_output/win32/directdraw.c b/modules/video_output/win32/directdraw.c index 142ee0588b..ac3b290ea1 100644 --- a/modules/video_output/win32/directdraw.c +++ b/modules/video_output/win32/directdraw.c @@ -297,6 +297,7 @@ static picture_pool_t *Pool(vout_display_t *vd, unsigned count) static void Display(vout_display_t *vd, picture_t *picture, subpicture_t *subpicture) { vout_display_sys_t *sys = vd->sys; + picture_sys_t *p_sys = picture->p_sys; assert(sys->display); @@ -316,8 +317,8 @@ static void Display(vout_display_t *vd, picture_t *picture, subpicture_t *subpic if (sys->sys.use_overlay) { /* Flip the overlay buffers if we are using back buffers */ - if (picture->p_sys->surface != picture->p_sys->front_surface) { - HRESULT hr = IDirectDrawSurface2_Flip(picture->p_sys->front_surface, + if (p_sys->surface != p_sys->front_surface) { + HRESULT hr = IDirectDrawSurface2_Flip(p_sys->front_surface, NULL, DDFLIP_WAIT); if (hr != DD_OK) msg_Warn(vd, "could not flip overlay (error %li)", hr); @@ -331,7 +332,7 @@ static void Display(vout_display_t *vd, picture_t *picture, subpicture_t *subpic HRESULT hr = IDirectDrawSurface2_Blt(sys->display, &sys->sys.rect_dest_clipped, - picture->p_sys->surface, + p_sys->surface, &sys->sys.rect_src_clipped, DDBLT_ASYNC, &ddbltfx); if (hr != DD_OK) @@ -1270,18 +1271,20 @@ static void DirectXDestroyPictureResource(vout_display_t *vd) static int DirectXLock(picture_t *picture) { + picture_sys_t *p_sys = picture->p_sys; DDSURFACEDESC ddsd; - if (DirectXLockSurface(picture->p_sys->front_surface, - picture->p_sys->surface, &ddsd)) - return CommonUpdatePicture(picture, &picture->p_sys->fallback, NULL, 0); + if (DirectXLockSurface(p_sys->front_surface, + p_sys->surface, &ddsd)) + return CommonUpdatePicture(picture, &p_sys->fallback, NULL, 0); CommonUpdatePicture(picture, NULL, ddsd.lpSurface, ddsd.lPitch); return VLC_SUCCESS; } static void DirectXUnlock(picture_t *picture) { - DirectXUnlockSurface(picture->p_sys->front_surface, - picture->p_sys->surface); + picture_sys_t *p_sys = picture->p_sys; + DirectXUnlockSurface(p_sys->front_surface, + p_sys->surface); } static int DirectXCreatePool(vout_display_t *vd, -- 2.11.4.GIT