context_handle->Unmap (index_buffer.Get (), 0);
quad = gst_d3d11_quad_new (self->device,
- ps.Get (), vs.Get (), layout.Get (), NULL, NULL, NULL, NULL,
+ ps.Get (), vs.Get (), layout.Get (), NULL,
vertex_buffer.Get (), sizeof (VertexData), index_buffer.Get (),
DXGI_FORMAT_R16_UINT, 6);
if (!quad) {
}
return gst_d3d11_draw_quad_unlocked (self->checker_background,
- &self->viewport, 1, NULL, 0, &rtv, 1, NULL, NULL, NULL);
+ &self->viewport, 1, NULL, 0, &rtv, 1, NULL, NULL, NULL, 0);
}
/* Must be called with d3d11 device lock */
ID3D11Buffer *vertex_buffer;
gboolean update_vertex;
+ ID3D11SamplerState *linear_sampler;
+
ConvertInfo convert_info;
};
ComPtr<ID3D11PixelShader> ps[CONVERTER_MAX_QUADS];
ComPtr<ID3D11VertexShader> vs;
ComPtr<ID3D11InputLayout> layout;
- ComPtr<ID3D11SamplerState> sampler;
+ ComPtr<ID3D11SamplerState> linear_sampler;
ComPtr<ID3D11Buffer> const_buffer;
ComPtr<ID3D11Buffer> vertex_buffer;
ComPtr<ID3D11Buffer> index_buffer;
sampler_desc.MinLOD = 0;
sampler_desc.MaxLOD = D3D11_FLOAT32_MAX;
- hr = device_handle->CreateSamplerState (&sampler_desc, &sampler);
+ hr = device_handle->CreateSamplerState (&sampler_desc, &linear_sampler);
if (!gst_d3d11_result (hr, device)) {
GST_ERROR ("Couldn't create sampler state, hr: 0x%x", (guint) hr);
return FALSE;
gst_d3d11_device_unlock (device);
self->quad[0] = gst_d3d11_quad_new (device,
- ps[0].Get (), vs.Get (), layout.Get (), sampler.Get (), NULL, NULL,
+ ps[0].Get (), vs.Get (), layout.Get (),
const_buffer.Get (), vertex_buffer.Get (), sizeof (VertexData),
index_buffer.Get (), DXGI_FORMAT_R16_UINT, index_count);
if (ps[1]) {
self->quad[1] = gst_d3d11_quad_new (device,
- ps[1].Get (), vs.Get (), layout.Get (), sampler.Get (), NULL, NULL,
+ ps[1].Get (), vs.Get (), layout.Get (),
const_buffer.Get (), vertex_buffer.Get (), sizeof (VertexData),
index_buffer.Get (), DXGI_FORMAT_R16_UINT, index_count);
}
self->input_texture_width = GST_VIDEO_INFO_WIDTH (in_info);
self->input_texture_height = GST_VIDEO_INFO_HEIGHT (in_info);
+ self->linear_sampler = linear_sampler.Detach ();
+
return TRUE;
}
}
GST_D3D11_CLEAR_COM (converter->vertex_buffer);
+ GST_D3D11_CLEAR_COM (converter->linear_sampler);
gst_clear_object (&converter->device);
g_free (converter);
}
ret = gst_d3d11_draw_quad_unlocked (converter->quad[0], converter->viewport,
- 1, srv, converter->num_input_view, rtv, 1, NULL, blend, blend_factor);
+ 1, srv, converter->num_input_view, rtv, 1, blend, blend_factor,
+ &converter->linear_sampler, 1);
if (!ret)
return FALSE;
ret = gst_d3d11_draw_quad_unlocked (converter->quad[1],
&converter->viewport[1], converter->num_output_view - 1,
srv, converter->num_input_view, &rtv[1], converter->num_output_view - 1,
- NULL, blend, blend_factor);
+ blend, blend_factor, &converter->linear_sampler, 1);
if (!ret)
return FALSE;
overlay->texture = texture.Detach ();
overlay->srv = srv.Detach ();
overlay->quad = gst_d3d11_quad_new (device,
- self->ps, self->vs, self->layout, self->sampler, self->blend, NULL, NULL,
+ self->ps, self->vs, self->layout, NULL,
vertex_buffer.Get (), sizeof (VertexData),
self->index_buffer, DXGI_FORMAT_R16_UINT, index_count);
(GstD3D11CompositionOverlay *) iter->data;
ret = gst_d3d11_draw_quad_unlocked (overlay->quad,
- &compositor->viewport, 1, &overlay->srv, 1, rtv, 1, NULL, NULL, NULL);
+ &compositor->viewport, 1, &overlay->srv, 1, rtv, 1,
+ compositor->blend, NULL, &compositor->sampler, 1);
if (!ret)
break;
ID3D11PixelShader *ps;
ID3D11VertexShader *vs;
ID3D11InputLayout *layout;
- ID3D11SamplerState *sampler;
- ID3D11BlendState *blend;
- ID3D11DepthStencilState *depth_stencil;
ID3D11Buffer *const_buffer;
ID3D11Buffer *vertex_buffer;
guint vertex_stride;
GstD3D11Quad *
gst_d3d11_quad_new (GstD3D11Device * device, ID3D11PixelShader * pixel_shader,
ID3D11VertexShader * vertex_shader, ID3D11InputLayout * layout,
- ID3D11SamplerState * sampler, ID3D11BlendState * blend,
- ID3D11DepthStencilState * depth_stencil,
ID3D11Buffer * const_buffer,
ID3D11Buffer * vertex_buffer, guint vertex_stride,
ID3D11Buffer * index_buffer, DXGI_FORMAT index_format, guint index_count)
quad->ps = pixel_shader;
quad->vs = vertex_shader;
quad->layout = layout;
- quad->sampler = sampler;
- quad->blend = blend;
- quad->depth_stencil = depth_stencil;
quad->vertex_buffer = vertex_buffer;
quad->vertex_stride = vertex_stride;
quad->index_buffer = index_buffer;
vertex_buffer->AddRef ();
index_buffer->AddRef ();
- if (sampler)
- sampler->AddRef ();
-
- if (blend)
- blend->AddRef ();
-
- if (depth_stencil)
- depth_stencil->AddRef ();
-
if (const_buffer) {
quad->const_buffer = const_buffer;
const_buffer->AddRef ();
GST_D3D11_CLEAR_COM (quad->ps);
GST_D3D11_CLEAR_COM (quad->vs);
GST_D3D11_CLEAR_COM (quad->layout);
- GST_D3D11_CLEAR_COM (quad->sampler);
- GST_D3D11_CLEAR_COM (quad->blend);
- GST_D3D11_CLEAR_COM (quad->depth_stencil);
GST_D3D11_CLEAR_COM (quad->const_buffer);
GST_D3D11_CLEAR_COM (quad->vertex_buffer);
GST_D3D11_CLEAR_COM (quad->index_buffer);
D3D11_VIEWPORT viewport[GST_VIDEO_MAX_PLANES], guint num_viewport,
ID3D11ShaderResourceView * srv[GST_VIDEO_MAX_PLANES], guint num_srv,
ID3D11RenderTargetView * rtv[GST_VIDEO_MAX_PLANES], guint num_rtv,
- ID3D11DepthStencilView * dsv, ID3D11BlendState * blend,
- gfloat blend_factor[4])
+ ID3D11BlendState * blend, gfloat blend_factor[4],
+ ID3D11SamplerState ** sampler, guint num_sampler)
{
gboolean ret;
gst_d3d11_device_lock (quad->device);
ret = gst_d3d11_draw_quad_unlocked (quad, viewport, num_viewport,
- srv, num_srv, rtv, num_viewport, dsv, blend, blend_factor);
+ srv, num_srv, rtv, num_viewport, blend, blend_factor, sampler,
+ num_sampler);
gst_d3d11_device_unlock (quad->device);
return ret;
D3D11_VIEWPORT viewport[GST_VIDEO_MAX_PLANES], guint num_viewport,
ID3D11ShaderResourceView * srv[GST_VIDEO_MAX_PLANES], guint num_srv,
ID3D11RenderTargetView * rtv[GST_VIDEO_MAX_PLANES], guint num_rtv,
- ID3D11DepthStencilView * dsv, ID3D11BlendState * blend,
- gfloat blend_factor[4])
+ ID3D11BlendState * blend, gfloat blend_factor[4],
+ ID3D11SamplerState ** sampler, guint num_sampler)
{
ID3D11DeviceContext *context;
UINT offsets = 0;
&offsets);
context->IASetIndexBuffer (quad->index_buffer, quad->index_format, 0);
- if (quad->sampler)
- context->PSSetSamplers (0, 1, &quad->sampler);
+ if (sampler)
+ context->PSSetSamplers (0, num_sampler, sampler);
context->VSSetShader (quad->vs, NULL, 0);
context->PSSetShader (quad->ps, NULL, 0);
context->RSSetViewports (num_viewport, viewport);
if (srv)
context->PSSetShaderResources (0, num_srv, srv);
- context->OMSetRenderTargets (num_rtv, rtv, dsv);
- if (!blend_state)
- blend_state = quad->blend;
+ context->OMSetRenderTargets (num_rtv, rtv, NULL);
context->OMSetBlendState (blend_state, blend_factor, 0xffffffff);
- context->OMSetDepthStencilState (quad->depth_stencil, 1);
context->DrawIndexed (quad->index_count, 0, 0);
ID3D11PixelShader * pixel_shader,
ID3D11VertexShader * vertex_shader,
ID3D11InputLayout * layout,
- ID3D11SamplerState * sampler,
- ID3D11BlendState * blend,
- ID3D11DepthStencilState *depth_stencil,
ID3D11Buffer * const_buffer,
ID3D11Buffer * vertex_buffer,
guint vertex_stride,
guint num_srv,
ID3D11RenderTargetView *rtv[GST_VIDEO_MAX_PLANES],
guint num_rtv,
- ID3D11DepthStencilView *dsv,
ID3D11BlendState *blend,
- gfloat blend_factor[4]);
+ gfloat blend_factor[4],
+ ID3D11SamplerState ** sampler,
+ guint num_sampler);
gboolean gst_d3d11_draw_quad_unlocked (GstD3D11Quad * quad,
D3D11_VIEWPORT viewport[GST_VIDEO_MAX_PLANES],
guint num_srv,
ID3D11RenderTargetView *rtv[GST_VIDEO_MAX_PLANES],
guint num_rtv,
- ID3D11DepthStencilView *dsv,
ID3D11BlendState *blend,
- gfloat blend_factor[4]);
+ gfloat blend_factor[4],
+ ID3D11SamplerState ** sampler,
+ guint num_sampler);
G_END_DECLS