Commit 3de64989 authored by Romain Vimont's avatar Romain Vimont Committed by Jean-Baptiste Kempf

core: replace picture_sys_t* by void*

See #17078
Signed-off-by: Jean-Baptiste Kempf's avatarJean-Baptiste Kempf <jb@videolan.org>
parent 6429b8ea
......@@ -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;
......
......@@ -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;
}
......
......@@ -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; i<D3D11_MAX_SHADER_VIEW; i++) {
if (pic->p_sys->texture[i])
ID3D11Texture2D_Release(pic->p_sys->texture[i]);
if (pic_sys->texture[i])
ID3D11Texture2D_Release(pic_sys->texture[i]);
}
}
}
......
......@@ -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,
......
......@@ -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,
&copyBox);
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 )
{
......
......@@ -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;
......
......@@ -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;
}
......
......@@ -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;
}
......
......@@ -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;
}
......@@ -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)
......
......@@ -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;
......
......@@ -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)
{
......
......@@ -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);
......
......@@ -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;
}
}
......
......@@ -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
......
......@@ -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,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment