static void thread_resume(struct ao *ao)
{
struct wasapi_state *state = ao->priv;
HRESULT hr;
MP_DBG(state, "Thread Resume\n");
UINT32 padding = 0;
hr = IAudioClient_GetCurrentPadding(state->pAudioClient, &padding);
if (hr != S_OK) {
MP_ERR(state, "IAudioClient_GetCurrentPadding returned %s\n",
mp_HRESULT_to_str(hr));
}
// Fill the buffer before starting, but only if there is no audio queued to
// play. This prevents overfilling the buffer, which leads to problems in
// exclusive mode
if (padding < (UINT32) state->bufferFrameCount)
thread_feed(ao);
// start feeding next wakeup if something else hasn't been requested
int expected = WASAPI_THREAD_RESUME;
atomic_compare_exchange_strong(&state->thread_state, &expected,
WASAPI_THREAD_FEED);
hr = IAudioClient_Start(state->pAudioClient);
if (hr != S_OK) {
MP_ERR(state, "IAudioClient_Start returned %s\n",
mp_HRESULT_to_str(hr));
}
return;
}
static void dump_decoder_info(struct lavc_ctx *s,
GUID *device_guids, UINT n_guids)
{
struct priv *p = s->hwdec_priv;
MP_VERBOSE(p, "%u decoder devices:\n", (unsigned)n_guids);
for (UINT i = 0; i < n_guids; i++) {
GUID *guid = &device_guids[i];
char *description = d3d_decoder_guid_to_desc(guid);
D3DFORMAT *formats = NULL;
UINT n_formats = 0;
HRESULT hr = IDirectXVideoDecoderService_GetDecoderRenderTargets(
p->decoder_service, guid, &n_formats, &formats);
if (FAILED(hr)) {
MP_ERR(p, "Failed to get render targets for decoder %s:%s\n",
description, mp_HRESULT_to_str(hr));
}
char fmts[256] = {0};
for (UINT j = 0; j < n_formats; j++) {
mp_snprintf_cat(fmts, sizeof(fmts),
" %s", mp_tag_str(formats[j]));
}
CoTaskMemFree(formats);
MP_VERBOSE(p, "%s %s\n", description, fmts);
}
}
HRESULT wasapi_change_init(struct ao *ao, bool is_hotplug)
{
struct wasapi_state *state = ao->priv;
struct change_notify *change = &state->change;
HRESULT hr;
/* COM voodoo to emulate c++ class */
change->client.lpVtbl = &sIMMDeviceEnumeratorVtbl_vtbl;
/* register the change notification client */
hr = IMMDeviceEnumerator_RegisterEndpointNotificationCallback(
state->pEnumerator, (IMMNotificationClient *)change);
EXIT_ON_ERROR(hr);
/* so the callbacks can access the ao */
change->ao = ao;
/* whether or not this is the hotplug instance */
change->is_hotplug = is_hotplug;
if (is_hotplug) {
MP_DBG(ao, "Monitoring for hotplug events\n");
} else {
/* Get the device string to compare with the pwstrDeviceId */
hr = IMMDevice_GetId(state->pDevice, &change->monitored);
EXIT_ON_ERROR(hr);
MP_VERBOSE(ao, "Monitoring changes in device %S\n", change->monitored);
}
return hr;
exit_label:
MP_ERR(state, "Error setting up device change monitoring: %s\n",
mp_HRESULT_to_str(hr));
wasapi_change_uninit(ao);
return hr;
}
static HRESULT get_device_delay(struct wasapi_state *state, double *delay) {
UINT64 sample_count = atomic_load(&state->sample_count);
UINT64 position, qpc_position;
HRESULT hr;
hr = IAudioClock_GetPosition(state->pAudioClock, &position, &qpc_position);
/* GetPosition succeeded, but the result may be inaccurate due to the length of the call */
/* http://msdn.microsoft.com/en-us/library/windows/desktop/dd370889%28v=vs.85%29.aspx */
if (hr == S_FALSE) {
MP_DBG(state, "Possibly inaccurate device position.\n");
hr = S_OK;
}
EXIT_ON_ERROR(hr);
LARGE_INTEGER qpc_count;
QueryPerformanceCounter(&qpc_count);
double qpc_diff = (qpc_count.QuadPart * 1e7 / state->qpc_frequency.QuadPart) - qpc_position;
position += state->clock_frequency * (uint64_t) (qpc_diff / 1e7);
/* convert position to the same base as sample_count */
position = position * state->format.Format.nSamplesPerSec / state->clock_frequency;
double diff = sample_count - position;
*delay = diff / state->format.Format.nSamplesPerSec;
MP_TRACE(state, "Device delay: %g samples (%g ms)\n", diff, *delay * 1000);
return S_OK;
exit_label:
MP_ERR(state, "Error getting device delay: %s\n", mp_HRESULT_to_str(hr));
return hr;
}
static DWORD get_dxfmt_cb(struct lavc_ctx *s, const GUID *guid, int depth)
{
DWORD ret = 0;
struct priv *p = s->hwdec_priv;
D3DFORMAT *formats = NULL;
UINT n_formats = 0;
HRESULT hr = IDirectXVideoDecoderService_GetDecoderRenderTargets(
p->decoder_service, guid, &n_formats, &formats);
if (FAILED(hr)) {
MP_ERR(p, "Callback failed to get render targets for decoder %s: %s",
d3d_decoder_guid_to_desc(guid), mp_HRESULT_to_str(hr));
return 0;
}
for (int i = 0; i < MP_ARRAY_SIZE(d3d9_formats); i++) {
const struct d3d9_format *d3d9_fmt = &d3d9_formats[i];
if (d3d9_fmt->depth < depth)
continue;
for (UINT j = 0; j < n_formats; j++) {
if (formats[i] == d3d9_fmt->format) {
ret = formats[i];
MP_VERBOSE(p, "Selecting %s %s\n",
d3d_decoder_guid_to_desc(guid),
mp_tag_str(ret));
goto done;
}
}
}
done:
CoTaskMemFree(formats);
return ret;
}
static struct mp_image *d3d11va_retrieve_image(struct lavc_ctx *s,
struct mp_image *img)
{
HRESULT hr;
struct priv *p = s->hwdec_priv;
ID3D11Texture2D *staging = p->decoder->staging;
if (img->imgfmt != IMGFMT_D3D11VA)
return img;
ID3D11Texture2D *texture = (void *)img->planes[1];
int subindex = (intptr_t)img->planes[2];
if (!texture) {
MP_ERR(p, "Failed to get Direct3D texture and surface from mp_image\n");
return img;
}
D3D11_TEXTURE2D_DESC texture_desc;
ID3D11Texture2D_GetDesc(texture, &texture_desc);
if (texture_desc.Width < img->w || texture_desc.Height < img->h) {
MP_ERR(p, "Direct3D11 texture smaller than mp_image dimensions\n");
return img;
}
// copy to the staging texture
ID3D11DeviceContext_CopySubresourceRegion(
p->device_ctx,
(ID3D11Resource *)staging, 0, 0, 0, 0,
(ID3D11Resource *)texture, subindex, NULL);
struct mp_image *sw_img = mp_image_pool_get(p->sw_pool,
p->decoder->mpfmt_decoded,
texture_desc.Width,
texture_desc.Height);
if (!sw_img) {
MP_ERR(p, "Failed to get %s surface from CPU pool\n",
mp_imgfmt_to_name(p->decoder->mpfmt_decoded));
return img;
}
// copy staging texture to the cpu mp_image
D3D11_MAPPED_SUBRESOURCE lock;
hr = ID3D11DeviceContext_Map(p->device_ctx, (ID3D11Resource *)staging,
0, D3D11_MAP_READ, 0, &lock);
if (FAILED(hr)) {
MP_ERR(p, "Failed to map D3D11 surface: %s\n", mp_HRESULT_to_str(hr));
talloc_free(sw_img);
return img;
}
copy_nv12(sw_img, lock.pData, lock.RowPitch, texture_desc.Height);
ID3D11DeviceContext_Unmap(p->device_ctx, (ID3D11Resource *)staging, 0);
mp_image_set_size(sw_img, img->w, img->h);
mp_image_copy_attributes(sw_img, img);
talloc_free(img);
return sw_img;
}
static struct mp_image *d3d11va_retrieve_image(struct lavc_ctx *s,
struct mp_image *img)
{
HRESULT hr;
struct priv *p = s->hwdec_priv;
ID3D11Texture2D *staging = p->decoder->staging;
ID3D11Texture2D *texture = d3d11_texture_in_mp_image(img);
ID3D11VideoDecoderOutputView *surface = d3d11_surface_in_mp_image(img);
if (!texture || !surface) {
MP_ERR(p, "Failed to get Direct3D texture and surface from mp_image\n");
return img;
}
D3D11_TEXTURE2D_DESC texture_desc;
ID3D11Texture2D_GetDesc(texture, &texture_desc);
if (texture_desc.Width < img->w || texture_desc.Height < img->h) {
MP_ERR(p, "Direct3D11 texture smaller than mp_image dimensions\n");
return img;
}
// copy to the staging texture
D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC surface_desc;
ID3D11VideoDecoderOutputView_GetDesc(surface, &surface_desc);
ID3D11DeviceContext_CopySubresourceRegion(
p->device_ctx,
(ID3D11Resource *)staging, 0, 0, 0, 0,
(ID3D11Resource *)texture, surface_desc.Texture2D.ArraySlice, NULL);
struct mp_image *sw_img = mp_image_pool_get(p->sw_pool,
p->decoder->mpfmt_decoded,
texture_desc.Width,
texture_desc.Height);
if (!sw_img) {
MP_ERR(p, "Failed to get %s surface from CPU pool\n",
mp_imgfmt_to_name(p->decoder->mpfmt_decoded));
return img;
}
// copy staging texture to the cpu mp_image
D3D11_MAPPED_SUBRESOURCE lock;
hr = ID3D11DeviceContext_Map(p->device_ctx, (ID3D11Resource *)staging,
0, D3D11_MAP_READ, 0, &lock);
if (FAILED(hr)) {
MP_ERR(p, "Failed to map D3D11 surface: %s\n", mp_HRESULT_to_str(hr));
talloc_free(sw_img);
return img;
}
copy_nv12(sw_img, lock.pData, lock.RowPitch, texture_desc.Height);
ID3D11DeviceContext_Unmap(p->device_ctx, (ID3D11Resource *)staging, 0);
mp_image_set_size(sw_img, img->w, img->h);
mp_image_copy_attributes(sw_img, img);
talloc_free(img);
return sw_img;
}
static void thread_reset(struct ao *ao)
{
struct wasapi_state *state = ao->priv;
HRESULT hr;
MP_DBG(state, "Thread Reset\n");
hr = IAudioClient_Stop(state->pAudioClient);
/* we may get S_FALSE if the stream is already stopped */
if (hr != S_OK && hr != S_FALSE)
MP_ERR(state, "IAudioClient_Stop returned: %s\n", mp_HRESULT_to_str(hr));
/* we may get S_FALSE if the stream is already reset */
hr = IAudioClient_Reset(state->pAudioClient);
if (hr != S_OK && hr != S_FALSE)
MP_ERR(state, "IAudioClient_Reset returned: %s\n", mp_HRESULT_to_str(hr));
atomic_store(&state->sample_count, 0);
// start feeding next wakeup if something else hasn't been requested
int expected = WASAPI_THREAD_RESET;
atomic_compare_exchange_strong(&state->thread_state, &expected, WASAPI_THREAD_FEED);
return;
}
static bool d3d11_format_supported(struct lavc_ctx *s, const GUID *guid,
const struct d3d_decoded_format *format)
{
struct priv *p = s->hwdec_priv;
BOOL is_supported = FALSE;
HRESULT hr = ID3D11VideoDevice_CheckVideoDecoderFormat(
p->video_dev, guid, format->dxfmt, &is_supported);
if (FAILED(hr)) {
MP_ERR(p, "Check decoder output format %s for decoder %s: %s\n",
format->name, d3d_decoder_guid_to_desc(guid),
mp_HRESULT_to_str(hr));
}
return is_supported;
}
static int hotplug_init(struct ao *ao)
{
MP_DBG(ao, "Hotplug init\n");
struct wasapi_state *state = ao->priv;
state->log = ao->log;
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
HRESULT hr = wasapi_change_init(ao, true);
EXIT_ON_ERROR(hr);
return 0;
exit_label:
MP_ERR(state, "Error setting up audio hotplug: %s\n", mp_HRESULT_to_str(hr));
hotplug_uninit(ao);
return -1;
}
static bool try_format_exclusive(struct ao *ao, WAVEFORMATEXTENSIBLE *wformat)
{
struct wasapi_state *state = ao->priv;
MP_VERBOSE(ao, "Trying %s (exclusive)\n",
waveformat_to_str(&wformat->Format));
HRESULT hr = IAudioClient_IsFormatSupported(state->pAudioClient,
AUDCLNT_SHAREMODE_EXCLUSIVE,
&wformat->Format, NULL);
if (hr != AUDCLNT_E_UNSUPPORTED_FORMAT)
EXIT_ON_ERROR(hr);
return SUCCEEDED(hr);
exit_label:
MP_ERR(state, "Error testing exclusive format: %s\n", mp_HRESULT_to_str(hr));
return false;
}
static void thread_feed(struct ao *ao)
{
struct wasapi_state *state = ao->priv;
HRESULT hr;
UINT32 frame_count = state->bufferFrameCount;
if (state->share_mode == AUDCLNT_SHAREMODE_SHARED) {
UINT32 padding = 0;
hr = IAudioClient_GetCurrentPadding(state->pAudioClient, &padding);
EXIT_ON_ERROR(hr);
frame_count -= padding;
MP_TRACE(ao, "Frame to fill: %"PRIu32". Padding: %"PRIu32"\n",
frame_count, padding);
}
double delay_us;
hr = get_device_delay(state, &delay_us);
EXIT_ON_ERROR(hr);
// add the buffer delay
delay_us += frame_count * 1e6 / state->format.Format.nSamplesPerSec;
BYTE *pData;
hr = IAudioRenderClient_GetBuffer(state->pRenderClient,
frame_count, &pData);
EXIT_ON_ERROR(hr);
BYTE *data[1] = {pData};
ao_read_data(ao, (void **)data, frame_count,
mp_time_us() + (int64_t)llrint(delay_us));
// note, we can't use ao_read_data return value here since we already
// commited to frame_count above in the GetBuffer call
hr = IAudioRenderClient_ReleaseBuffer(state->pRenderClient,
frame_count, 0);
EXIT_ON_ERROR(hr);
atomic_fetch_add(&state->sample_count, frame_count);
return;
exit_label:
MP_ERR(state, "Error feeding audio: %s\n", mp_HRESULT_to_str(hr));
MP_VERBOSE(ao, "Requesting ao reload\n");
ao_request_reload(ao);
return;
}
static struct mp_image *dxva2_retrieve_image(struct lavc_ctx *s,
struct mp_image *img)
{
HRESULT hr;
struct priv *p = s->hwdec_priv;
IDirect3DSurface9 *surface = img->imgfmt == IMGFMT_DXVA2 ?
(IDirect3DSurface9 *)img->planes[3] : NULL;
if (!surface) {
MP_ERR(p, "Failed to get Direct3D surface from mp_image\n");
return img;
}
D3DSURFACE_DESC surface_desc;
IDirect3DSurface9_GetDesc(surface, &surface_desc);
if (surface_desc.Width < img->w || surface_desc.Height < img->h) {
MP_ERR(p, "Direct3D11 texture smaller than mp_image dimensions\n");
return img;
}
struct mp_image *sw_img = mp_image_pool_get(p->sw_pool,
p->mpfmt_decoded,
surface_desc.Width,
surface_desc.Height);
if (!sw_img) {
MP_ERR(p, "Failed to get %s surface from CPU pool\n",
mp_imgfmt_to_name(p->mpfmt_decoded));
return img;
}
D3DLOCKED_RECT lock;
hr = IDirect3DSurface9_LockRect(surface, &lock, NULL, D3DLOCK_READONLY);
if (FAILED(hr)) {
MP_ERR(p, "Unable to lock DXVA2 surface: %s\n",
mp_HRESULT_to_str(hr));
talloc_free(sw_img);
return img;
}
copy_nv12(sw_img, lock.pBits, lock.Pitch, surface_desc.Height);
IDirect3DSurface9_UnlockRect(surface);
mp_image_set_size(sw_img, img->w, img->h);
mp_image_copy_attributes(sw_img, img);
talloc_free(img);
return sw_img;
}
static int hotplug_init(struct ao *ao)
{
MP_DBG(ao, "Hotplug init\n");
struct wasapi_state *state = ao->priv;
state->log = ao->log;
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
HRESULT hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL,
&IID_IMMDeviceEnumerator, (void **)&state->pEnumerator);
EXIT_ON_ERROR(hr);
hr = wasapi_change_init(ao, true);
EXIT_ON_ERROR(hr);
return 0;
exit_label:
MP_ERR(state, "Error setting up audio hotplug: %s\n", mp_HRESULT_to_str(hr));
hotplug_uninit(ao);
return -1;
}
static HRESULT get_device_delay(struct wasapi_state *state, double *delay_us) {
UINT64 sample_count = atomic_load(&state->sample_count);
UINT64 position, qpc_position;
HRESULT hr;
hr = IAudioClock_GetPosition(state->pAudioClock, &position, &qpc_position);
// GetPosition succeeded, but the result may be
// inaccurate due to the length of the call
// http://msdn.microsoft.com/en-us/library/windows/desktop/dd370889%28v=vs.85%29.aspx
if (hr == S_FALSE) {
MP_VERBOSE(state, "Possibly inaccurate device position.\n");
hr = S_OK;
}
EXIT_ON_ERROR(hr);
// convert position to number of samples careful to avoid overflow
UINT64 sample_position = uint64_scale(position,
state->format.Format.nSamplesPerSec,
state->clock_frequency);
INT64 diff = sample_count - sample_position;
*delay_us = diff * 1e6 / state->format.Format.nSamplesPerSec;
// Correct for any delay in IAudioClock_GetPosition above.
// This should normally be very small (<1 us), but just in case. . .
LARGE_INTEGER qpc;
QueryPerformanceCounter(&qpc);
INT64 qpc_diff = av_rescale(qpc.QuadPart, 10000000, state->qpc_frequency.QuadPart)
- qpc_position;
// ignore the above calculation if it yeilds more than 10 seconds (due to
// possible overflow inside IAudioClock_GetPosition)
if (qpc_diff < 10 * 10000000) {
*delay_us -= qpc_diff / 10.0; // convert to us
} else {
MP_VERBOSE(state, "Insane qpc delay correction of %g seconds. "
"Ignoring it.\n", qpc_diff / 10000000.0);
}
MP_TRACE(state, "Device delay: %g us\n", *delay_us);
return S_OK;
exit_label:
MP_ERR(state, "Error getting device delay: %s\n", mp_HRESULT_to_str(hr));
return hr;
}
HRESULT wasapi_change_init(struct ao *ao, bool is_hotplug)
{
struct wasapi_state *state = ao->priv;
struct change_notify *change = &state->change;
HRESULT hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL,
&IID_IMMDeviceEnumerator,
(void **)&change->pEnumerator);
EXIT_ON_ERROR(hr);
// COM voodoo to emulate c++ class
change->client.lpVtbl = &sIMMNotificationClientVtbl;
// register the change notification client
hr = IMMDeviceEnumerator_RegisterEndpointNotificationCallback(
change->pEnumerator, (IMMNotificationClient *)change);
EXIT_ON_ERROR(hr);
// so the callbacks can access the ao
change->ao = ao;
// whether or not this is the hotplug instance
change->is_hotplug = is_hotplug;
if (is_hotplug) {
MP_DBG(ao, "Monitoring for hotplug events\n");
} else {
// Get the device string to compare with the pwstrDeviceId
change->monitored = state->deviceID;
MP_VERBOSE(ao, "Monitoring changes in device %S\n", change->monitored);
}
return hr;
exit_label:
MP_ERR(state, "Error setting up device change monitoring: %s\n",
mp_HRESULT_to_str(hr));
wasapi_change_uninit(ao);
return hr;
}
static bool dxva2_format_supported(struct lavc_ctx *s, const GUID *guid,
const struct d3d_decoded_format *format)
{
bool ret = false;
struct priv *p = s->hwdec_priv;
D3DFORMAT *formats = NULL;
UINT n_formats = 0;
HRESULT hr = IDirectXVideoDecoderService_GetDecoderRenderTargets(
p->decoder_service, guid, &n_formats, &formats);
if (FAILED(hr)) {
MP_ERR(p, "Callback failed to get render targets for decoder %s: %s",
d3d_decoder_guid_to_desc(guid), mp_HRESULT_to_str(hr));
return 0;
}
for (int i = 0; i < n_formats; i++) {
ret = formats[i] == format->dxfmt;
if (ret)
break;
}
CoTaskMemFree(formats);
return ret;
}
static int d3d11va_init_decoder(struct lavc_ctx *s, int w, int h)
{
HRESULT hr;
int ret = -1;
struct priv *p = s->hwdec_priv;
TA_FREEP(&p->decoder);
ID3D11Texture2D *texture = NULL;
void *tmp = talloc_new(NULL);
UINT n_guids = ID3D11VideoDevice_GetVideoDecoderProfileCount(p->video_dev);
GUID *device_guids = talloc_array(tmp, GUID, n_guids);
for (UINT i = 0; i < n_guids; i++) {
GUID *guid = &device_guids[i];
hr = ID3D11VideoDevice_GetVideoDecoderProfile(p->video_dev, i, guid);
if (FAILED(hr)) {
MP_ERR(p, "Failed to get VideoDecoderProfile %d: %s\n",
i, mp_HRESULT_to_str(hr));
goto done;
}
dump_decoder_info(s, guid);
}
struct d3d_decoder_fmt fmt =
d3d_select_decoder_mode(s, device_guids, n_guids,
d3d11_formats, MP_ARRAY_SIZE(d3d11_formats),
d3d11_format_supported);
if (!fmt.format) {
MP_ERR(p, "Failed to find a suitable decoder\n");
goto done;
}
struct d3d11va_decoder *decoder = talloc_zero(tmp, struct d3d11va_decoder);
talloc_set_destructor(decoder, d3d11va_destroy_decoder);
decoder->mpfmt_decoded = fmt.format->mpfmt;
int n_surfaces = hwdec_get_max_refs(s) + ADDITIONAL_SURFACES;
int w_align = w, h_align = h;
d3d_surface_align(s, &w_align, &h_align);
D3D11_TEXTURE2D_DESC tex_desc = {
.Width = w_align,
.Height = h_align,
.MipLevels = 1,
.Format = fmt.format->dxfmt,
.SampleDesc.Count = 1,
.MiscFlags = 0,
.ArraySize = n_surfaces,
.Usage = D3D11_USAGE_DEFAULT,
.BindFlags = D3D11_BIND_DECODER | D3D11_BIND_SHADER_RESOURCE,
.CPUAccessFlags = 0,
};
hr = ID3D11Device_CreateTexture2D(p->device, &tex_desc, NULL, &texture);
if (FAILED(hr)) {
MP_ERR(p, "Failed to create Direct3D11 texture with %d surfaces: %s\n",
n_surfaces, mp_HRESULT_to_str(hr));
goto done;
}
if (s->hwdec->type == HWDEC_D3D11VA_COPY) {
// create staging texture shared with the CPU with mostly the same
// parameters as the above decoder-bound texture
ID3D11Texture2D_GetDesc(texture, &tex_desc);
tex_desc.MipLevels = 1;
tex_desc.MiscFlags = 0;
tex_desc.ArraySize = 1;
tex_desc.Usage = D3D11_USAGE_STAGING;
tex_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
tex_desc.BindFlags = 0;
hr = ID3D11Device_CreateTexture2D(p->device, &tex_desc, NULL,
&decoder->staging);
if (FAILED(hr)) {
MP_ERR(p, "Failed to create staging texture: %s\n",
mp_HRESULT_to_str(hr));
goto done;
}
}
// pool to hold the mp_image wrapped surfaces
decoder->pool = talloc_steal(decoder, mp_image_pool_new(n_surfaces));
// array of the same surfaces (needed by ffmpeg)
ID3D11VideoDecoderOutputView **surfaces =
talloc_array_ptrtype(decoder->pool, surfaces, n_surfaces);
D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC view_desc = {
.DecodeProfile = *fmt.guid,
.ViewDimension = D3D11_VDOV_DIMENSION_TEXTURE2D,
};
for (int i = 0; i < n_surfaces; i++) {
ID3D11VideoDecoderOutputView **surface = &surfaces[i];
view_desc.Texture2D.ArraySlice = i;
hr = ID3D11VideoDevice_CreateVideoDecoderOutputView(
p->video_dev, (ID3D11Resource *)texture, &view_desc, surface);
if (FAILED(hr)) {
MP_ERR(p, "Failed getting decoder output view %d: %s\n",
i, mp_HRESULT_to_str(hr));
goto done;
}
struct mp_image *img = d3d11va_new_ref(*surface, w, h);
ID3D11VideoDecoderOutputView_Release(*surface); // transferred to img
if (!img) {
MP_ERR(p, "Failed to create D3D11VA image %d\n", i);
goto done;
}
mp_image_pool_add(decoder->pool, img); // transferred to pool
}
D3D11_VIDEO_DECODER_DESC decoder_desc = {
.Guid = *fmt.guid,
.SampleWidth = w,
.SampleHeight = h,
.OutputFormat = fmt.format->dxfmt,
};
UINT n_cfg;
hr = ID3D11VideoDevice_GetVideoDecoderConfigCount(p->video_dev,
&decoder_desc, &n_cfg);
if (FAILED(hr)) {
MP_ERR(p, "Failed to get number of decoder configurations: %s)",
mp_HRESULT_to_str(hr));
goto done;
}
// pick the config with the highest score
D3D11_VIDEO_DECODER_CONFIG *decoder_config =
talloc_zero(decoder, D3D11_VIDEO_DECODER_CONFIG);
unsigned max_score = 0;
for (UINT i = 0; i < n_cfg; i++) {
D3D11_VIDEO_DECODER_CONFIG cfg;
hr = ID3D11VideoDevice_GetVideoDecoderConfig(p->video_dev,
&decoder_desc,
i, &cfg);
if (FAILED(hr)) {
MP_ERR(p, "Failed to get decoder config %d: %s\n",
i, mp_HRESULT_to_str(hr));
goto done;
}
unsigned score = d3d_decoder_config_score(
s, &cfg.guidConfigBitstreamEncryption, cfg.ConfigBitstreamRaw);
if (score > max_score) {
max_score = score;
*decoder_config = cfg;
}
}
if (!max_score) {
MP_ERR(p, "Failed to find a suitable decoder configuration\n");
goto done;
}
hr = ID3D11VideoDevice_CreateVideoDecoder(p->video_dev, &decoder_desc,
decoder_config,
&decoder->decoder);
if (FAILED(hr)) {
MP_ERR(p, "Failed to create video decoder: %s\n",
mp_HRESULT_to_str(hr));
goto done;
}
struct AVD3D11VAContext *avd3d11va_ctx = s->avctx->hwaccel_context;
avd3d11va_ctx->decoder = decoder->decoder;
avd3d11va_ctx->video_context = p->video_ctx;
avd3d11va_ctx->cfg = decoder_config;
avd3d11va_ctx->surface_count = n_surfaces;
avd3d11va_ctx->surface = surfaces;
avd3d11va_ctx->workaround = is_clearvideo(fmt.guid) ?
FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO : 0;
p->decoder = talloc_steal(NULL, decoder);
ret = 0;
done:
// still referenced by pool images / surfaces
if (texture)
ID3D11Texture2D_Release(texture);
talloc_free(tmp);
return ret;
}
static void destroy_device(struct lavc_ctx *s)
{
struct priv *p = s->hwdec_priv;
if (p->device)
ID3D11Device_Release(p->device);
if (p->device_ctx)
ID3D11DeviceContext_Release(p->device_ctx);
}
static bool create_device(struct lavc_ctx *s, BOOL thread_safe)
{
HRESULT hr;
struct priv *p = s->hwdec_priv;
d3d_load_dlls();
if (!d3d11_dll) {
MP_ERR(p, "Failed to load D3D11 library\n");
return false;
}
PFN_D3D11_CREATE_DEVICE CreateDevice =
(void *)GetProcAddress(d3d11_dll, "D3D11CreateDevice");
if (!CreateDevice) {
MP_ERR(p, "Failed to get D3D11CreateDevice symbol from DLL: %s\n",
mp_LastError_to_str());
return false;
}
hr = CreateDevice(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL,
D3D11_CREATE_DEVICE_VIDEO_SUPPORT, NULL, 0,
D3D11_SDK_VERSION, &p->device, NULL, &p->device_ctx);
if (FAILED(hr)) {
MP_ERR(p, "Failed to create D3D11 Device: %s\n",
mp_HRESULT_to_str(hr));
return false;
}
ID3D10Multithread *multithread;
hr = ID3D11Device_QueryInterface(p->device, &IID_ID3D10Multithread,
(void **)&multithread);
if (FAILED(hr)) {
MP_ERR(p, "Failed to get Multithread interface: %s\n",
mp_HRESULT_to_str(hr));
return false;
}
ID3D10Multithread_SetMultithreadProtected(multithread, thread_safe);
ID3D10Multithread_Release(multithread);
return true;
}
static void d3d11va_uninit(struct lavc_ctx *s)
{
struct priv *p = s->hwdec_priv;
if (!p)
return;
talloc_free(p->decoder);
av_freep(&s->avctx->hwaccel_context);
if (p->video_dev)
ID3D11VideoDevice_Release(p->video_dev);
if (p->video_ctx)
ID3D11VideoContext_Release(p->video_ctx);
destroy_device(s);
TA_FREEP(&s->hwdec_priv);
}
static int d3d11va_init(struct lavc_ctx *s)
{
HRESULT hr;
struct priv *p = talloc_zero(NULL, struct priv);
if (!p)
return -1;
s->hwdec_priv = p;
p->log = mp_log_new(s, s->log, "d3d11va");
if (s->hwdec->type == HWDEC_D3D11VA_COPY) {
mp_check_gpu_memcpy(p->log, NULL);
p->sw_pool = talloc_steal(p, mp_image_pool_new(17));
}
p->device = hwdec_devices_load(s->hwdec_devs, s->hwdec->type);
if (p->device) {
ID3D11Device_AddRef(p->device);
ID3D11Device_GetImmediateContext(p->device, &p->device_ctx);
if (!p->device_ctx)
goto fail;
MP_VERBOSE(p, "Using VO-supplied device %p.\n", p->device);
} else if (s->hwdec->type == HWDEC_D3D11VA) {
MP_ERR(p, "No Direct3D device provided for native d3d11 decoding\n");
goto fail;
} else {
if (!create_device(s, FALSE))
goto fail;
}
hr = ID3D11DeviceContext_QueryInterface(p->device_ctx,
&IID_ID3D11VideoContext,
(void **)&p->video_ctx);
if (FAILED(hr)) {
MP_ERR(p, "Failed to get VideoContext interface: %s\n",
mp_HRESULT_to_str(hr));
goto fail;
}
hr = ID3D11Device_QueryInterface(p->device,
&IID_ID3D11VideoDevice,
(void **)&p->video_dev);
if (FAILED(hr)) {
MP_ERR(p, "Failed to get VideoDevice interface. %s\n",
mp_HRESULT_to_str(hr));
goto fail;
}
s->avctx->hwaccel_context = av_d3d11va_alloc_context();
if (!s->avctx->hwaccel_context) {
MP_ERR(p, "Failed to allocate hwaccel_context\n");
goto fail;
}
return 0;
fail:
d3d11va_uninit(s);
return -1;
}
static int d3d11va_probe(struct lavc_ctx *ctx, struct vd_lavc_hwdec *hwdec,
const char *codec)
{
// d3d11va-copy can do without external context; dxva2 requires it.
if (hwdec->type != HWDEC_D3D11VA_COPY) {
if (!hwdec_devices_load(ctx->hwdec_devs, HWDEC_D3D11VA))
return HWDEC_ERR_NO_CTX;
}
return d3d_probe_codec(codec);
}
const struct vd_lavc_hwdec mp_vd_lavc_d3d11va = {
.type = HWDEC_D3D11VA,
.image_format = IMGFMT_D3D11VA,
.probe = d3d11va_probe,
.init = d3d11va_init,
.uninit = d3d11va_uninit,
.init_decoder = d3d11va_init_decoder,
.allocate_image = d3d11va_allocate_image,
.process_image = d3d11va_update_image_attribs,
};
const struct vd_lavc_hwdec mp_vd_lavc_d3d11va_copy = {
.type = HWDEC_D3D11VA_COPY,
.copying = true,
.image_format = IMGFMT_D3D11VA,
.probe = d3d11va_probe,
.init = d3d11va_init,
.uninit = d3d11va_uninit,
.init_decoder = d3d11va_init_decoder,
.allocate_image = d3d11va_allocate_image,
.process_image = d3d11va_retrieve_image,
.delay_queue = HWDEC_DELAY_QUEUE_COUNT,
};
static int dxva2_init_decoder(struct lavc_ctx *s, int w, int h)
{
HRESULT hr;
int ret = -1;
struct priv *p = s->hwdec_priv;
TA_FREEP(&p->decoder_pool);
int n_surfaces = hwdec_get_max_refs(s) + ADDITIONAL_SURFACES;
IDirect3DSurface9 **surfaces = NULL;
IDirectXVideoDecoder *decoder = NULL;
void *tmp = talloc_new(NULL);
UINT n_guids;
GUID *device_guids;
hr = IDirectXVideoDecoderService_GetDecoderDeviceGuids(
p->decoder_service, &n_guids, &device_guids);
if (FAILED(hr)) {
MP_ERR(p, "Failed to retrieve decoder device GUIDs: %s\n",
mp_HRESULT_to_str(hr));
goto done;
}
dump_decoder_info(s, device_guids, n_guids);
struct d3d_decoder_fmt fmt =
d3d_select_decoder_mode(s, device_guids, n_guids,
d3d9_formats, MP_ARRAY_SIZE(d3d9_formats),
dxva2_format_supported);
CoTaskMemFree(device_guids);
if (!fmt.format) {
MP_ERR(p, "Failed to find a suitable decoder\n");
goto done;
}
p->mpfmt_decoded = fmt.format->mpfmt;
struct mp_image_pool *decoder_pool =
talloc_steal(tmp, mp_image_pool_new(n_surfaces));
DXVA2_ConfigPictureDecode *decoder_config =
talloc_zero(decoder_pool, DXVA2_ConfigPictureDecode);
int w_align = w, h_align = h;
d3d_surface_align(s, &w_align, &h_align);
DXVA2_VideoDesc video_desc ={
.SampleWidth = w,
.SampleHeight = h,
.Format = fmt.format->dxfmt,
};
UINT n_configs = 0;
DXVA2_ConfigPictureDecode *configs = NULL;
hr = IDirectXVideoDecoderService_GetDecoderConfigurations(
p->decoder_service, fmt.guid, &video_desc, NULL,
&n_configs, &configs);
if (FAILED(hr)) {
MP_ERR(p, "Unable to retrieve decoder configurations: %s\n",
mp_HRESULT_to_str(hr));
goto done;
}
unsigned max_score = 0;
for (UINT i = 0; i < n_configs; i++) {
unsigned score = d3d_decoder_config_score(
s, &configs[i].guidConfigBitstreamEncryption,
configs[i].ConfigBitstreamRaw);
if (score > max_score) {
max_score = score;
*decoder_config = configs[i];
}
}
CoTaskMemFree(configs);
if (!max_score) {
MP_ERR(p, "Failed to find a suitable decoder configuration\n");
goto done;
}
surfaces = talloc_zero_array(decoder_pool, IDirect3DSurface9*, n_surfaces);
hr = IDirectXVideoDecoderService_CreateSurface(
p->decoder_service,
w_align, h_align,
n_surfaces - 1, fmt.format->dxfmt, D3DPOOL_DEFAULT, 0,
DXVA2_VideoDecoderRenderTarget, surfaces, NULL);
if (FAILED(hr)) {
MP_ERR(p, "Failed to create %d video surfaces: %s\n",
n_surfaces, mp_HRESULT_to_str(hr));
goto done;
}
hr = IDirectXVideoDecoderService_CreateVideoDecoder(
p->decoder_service, fmt.guid, &video_desc, decoder_config,
surfaces, n_surfaces, &decoder);
if (FAILED(hr)) {
MP_ERR(p, "Failed to create DXVA2 video decoder: %s\n",
mp_HRESULT_to_str(hr));
goto done;
}
for (int i = 0; i < n_surfaces; i++) {
struct mp_image *img = dxva2_new_ref(decoder, surfaces[i], w, h);
if (!img) {
MP_ERR(p, "Failed to create DXVA2 image\n");
goto done;
}
mp_image_pool_add(decoder_pool, img); // transferred to pool
}
// Pass required information on to ffmpeg.
struct dxva_context *dxva_ctx = s->avctx->hwaccel_context;
dxva_ctx->cfg = decoder_config;
dxva_ctx->decoder = decoder;
dxva_ctx->surface_count = n_surfaces;
dxva_ctx->surface = surfaces;
dxva_ctx->workaround = is_clearvideo(fmt.guid) ?
FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO : 0;
p->decoder_pool = talloc_steal(NULL, decoder_pool);
ret = 0;
done:
// On success, `p->decoder_pool` mp_images still hold refs to `surfaces` and
// `decoder`, so the pointers in the ffmpeg `dxva_context` strcture remain
// valid for the lifetime of the pool.
if (surfaces) {
for (int i = 0; i < n_surfaces; i++)
IDirect3DSurface9_Release(surfaces[i]);
}
if (decoder)
IDirectXVideoDecoder_Release(decoder);
talloc_free(tmp);
return ret;
}
static void destroy_device(struct lavc_ctx *s)
{
struct priv *p = s->hwdec_priv;
if (p->device)
IDirect3DDevice9_Release(p->device);
if (p->d3d9)
IDirect3D9_Release(p->d3d9);
}
static bool create_device(struct lavc_ctx *s)
{
struct priv *p = s->hwdec_priv;
d3d_load_dlls();
if (!d3d9_dll) {
MP_ERR(p, "Failed to load D3D9 library\n");
return false;
}
HRESULT (WINAPI *Direct3DCreate9Ex)(UINT, IDirect3D9Ex **) =
(void *)GetProcAddress(d3d9_dll, "Direct3DCreate9Ex");
if (!Direct3DCreate9Ex) {
MP_ERR(p, "Failed to locate Direct3DCreate9Ex\n");
return false;
}
IDirect3D9Ex *d3d9ex = NULL;
HRESULT hr = Direct3DCreate9Ex(D3D_SDK_VERSION, &d3d9ex);
if (FAILED(hr)) {
MP_ERR(p, "Failed to create IDirect3D9Ex object\n");
return false;
}
UINT adapter = D3DADAPTER_DEFAULT;
D3DDISPLAYMODEEX modeex = {0};
IDirect3D9Ex_GetAdapterDisplayModeEx(d3d9ex, adapter, &modeex, NULL);
D3DPRESENT_PARAMETERS present_params = {
.Windowed = TRUE,
.BackBufferWidth = 640,
.BackBufferHeight = 480,
.BackBufferCount = 0,
.BackBufferFormat = modeex.Format,
.SwapEffect = D3DSWAPEFFECT_DISCARD,
.Flags = D3DPRESENTFLAG_VIDEO,
};
IDirect3DDevice9Ex *exdev = NULL;
hr = IDirect3D9Ex_CreateDeviceEx(d3d9ex, adapter,
D3DDEVTYPE_HAL,
GetShellWindow(),
D3DCREATE_SOFTWARE_VERTEXPROCESSING |
D3DCREATE_MULTITHREADED |
D3DCREATE_FPU_PRESERVE,
&present_params,
NULL,
&exdev);
if (FAILED(hr)) {
MP_ERR(p, "Failed to create Direct3D device: %s\n",
mp_HRESULT_to_str(hr));
IDirect3D9_Release(d3d9ex);
return false;
}
p->d3d9 = (IDirect3D9 *)d3d9ex;
p->device = (IDirect3DDevice9 *)exdev;
return true;
}
static void dxva2_uninit(struct lavc_ctx *s)
{
struct priv *p = s->hwdec_priv;
if (!p)
return;
av_freep(&s->avctx->hwaccel_context);
talloc_free(p->decoder_pool);
if (p->decoder_service)
IDirectXVideoDecoderService_Release(p->decoder_service);
if (p->device_manager && p->device_handle != INVALID_HANDLE_VALUE)
IDirect3DDeviceManager9_CloseDeviceHandle(p->device_manager, p->device_handle);
if (p->device_manager)
IDirect3DDeviceManager9_Release(p->device_manager);
destroy_device(s);
TA_FREEP(&s->hwdec_priv);
}
static int dxva2_init(struct lavc_ctx *s)
{
HRESULT hr;
struct priv *p = talloc_zero(NULL, struct priv);
if (!p)
return -1;
s->hwdec_priv = p;
p->device_handle = INVALID_HANDLE_VALUE;
p->log = mp_log_new(s, s->log, "dxva2");
if (s->hwdec->type == HWDEC_DXVA2_COPY) {
mp_check_gpu_memcpy(p->log, NULL);
p->sw_pool = talloc_steal(p, mp_image_pool_new(17));
}
p->device = hwdec_devices_load(s->hwdec_devs, s->hwdec->type);
if (p->device) {
IDirect3D9_AddRef(p->device);
MP_VERBOSE(p, "Using VO-supplied device %p.\n", p->device);
} else if (s->hwdec->type == HWDEC_DXVA2) {
MP_ERR(p, "No Direct3D device provided for native dxva2 decoding\n");
goto fail;
} else {
if (!create_device(s))
goto fail;
}
d3d_load_dlls();
if (!dxva2_dll) {
MP_ERR(p, "Failed to load DXVA2 library\n");
goto fail;
}
HRESULT (WINAPI *CreateDeviceManager9)(UINT *, IDirect3DDeviceManager9 **) =
(void *)GetProcAddress(dxva2_dll, "DXVA2CreateDirect3DDeviceManager9");
if (!CreateDeviceManager9) {
MP_ERR(p, "Failed to locate DXVA2CreateDirect3DDeviceManager9\n");
goto fail;
}
unsigned reset_token = 0;
hr = CreateDeviceManager9(&reset_token, &p->device_manager);
if (FAILED(hr)) {
MP_ERR(p, "Failed to create Direct3D device manager: %s\n",
mp_HRESULT_to_str(hr));
goto fail;
}
hr = IDirect3DDeviceManager9_ResetDevice(p->device_manager,
p->device, reset_token);
if (FAILED(hr)) {
MP_ERR(p, "Failed to bind Direct3D device to device manager: %s\n",
mp_HRESULT_to_str(hr));
goto fail;
}
hr = IDirect3DDeviceManager9_OpenDeviceHandle(p->device_manager,
&p->device_handle);
if (FAILED(hr)) {
MP_ERR(p, "Failed to open device handle: %s\n",
mp_HRESULT_to_str(hr));
goto fail;
}
hr = IDirect3DDeviceManager9_GetVideoService(
p->device_manager, p->device_handle, &IID_IDirectXVideoDecoderService,
(void **)&p->decoder_service);
if (FAILED(hr)) {
MP_ERR(p, "Failed to create IDirectXVideoDecoderService: %s\n",
mp_HRESULT_to_str(hr));
goto fail;
}
s->avctx->hwaccel_context = av_mallocz(sizeof(struct dxva_context));
if (!s->avctx->hwaccel_context)
goto fail;
return 0;
fail:
dxva2_uninit(s);
return -1;
}
static int dxva2_probe(struct lavc_ctx *ctx, struct vd_lavc_hwdec *hwdec,
const char *codec)
{
// dxva2-copy can do without external context; dxva2 requires it.
if (hwdec->type == HWDEC_DXVA2) {
if (!hwdec_devices_load(ctx->hwdec_devs, HWDEC_DXVA2))
return HWDEC_ERR_NO_CTX;
} else {
hwdec_devices_load(ctx->hwdec_devs, HWDEC_DXVA2_COPY);
}
return d3d_probe_codec(codec);
}
const struct vd_lavc_hwdec mp_vd_lavc_dxva2 = {
.type = HWDEC_DXVA2,
.image_format = IMGFMT_DXVA2,
.probe = dxva2_probe,
.init = dxva2_init,
.uninit = dxva2_uninit,
.init_decoder = dxva2_init_decoder,
.allocate_image = dxva2_allocate_image,
};
const struct vd_lavc_hwdec mp_vd_lavc_dxva2_copy = {
.type = HWDEC_DXVA2_COPY,
.copying = true,
.image_format = IMGFMT_DXVA2,
.probe = dxva2_probe,
.init = dxva2_init,
.uninit = dxva2_uninit,
.init_decoder = dxva2_init_decoder,
.allocate_image = dxva2_allocate_image,
.process_image = dxva2_retrieve_image,
.delay_queue = HWDEC_DELAY_QUEUE_COUNT,
};
static int init(struct ra_hwdec *hw)
{
struct priv_owner *p = hw->priv;
if (!ra_is_gl(hw->ra))
return -1;
GL *gl = ra_gl_get(hw->ra);
if (!(gl->mpgl_caps & MPGL_CAP_DXINTEROP))
return -1;
// AMD drivers won't open multiple dxinterop HANDLES on the same D3D device,
// so we request the one already in use by context_dxinterop
p->device_h = mpgl_get_native_display(gl, "dxinterop_device_HANDLE");
if (!p->device_h)
return -1;
// But we also still need the actual D3D device
p->device = mpgl_get_native_display(gl, "IDirect3DDevice9Ex");
if (!p->device)
return -1;
IDirect3DDevice9Ex_AddRef(p->device);
p->hwctx = (struct mp_hwdec_ctx){
.driver_name = hw->driver->name,
.av_device_ref = d3d9_wrap_device_ref((IDirect3DDevice9 *)p->device),
};
hwdec_devices_add(hw->devs, &p->hwctx);
return 0;
}
static void mapper_uninit(struct ra_hwdec_mapper *mapper)
{
struct priv *p = mapper->priv;
GL *gl = ra_gl_get(mapper->ra);
if (p->rtarget_h && p->device_h) {
if (!gl->DXUnlockObjectsNV(p->device_h, 1, &p->rtarget_h)) {
MP_ERR(mapper, "Failed unlocking texture for access by OpenGL: %s\n",
mp_LastError_to_str());
}
}
if (p->rtarget_h) {
if (!gl->DXUnregisterObjectNV(p->device_h, p->rtarget_h)) {
MP_ERR(mapper, "Failed to unregister Direct3D surface with OpenGL: %s\n",
mp_LastError_to_str());
} else {
p->rtarget_h = 0;
}
}
gl->DeleteTextures(1, &p->texture);
p->texture = 0;
if (p->rtarget) {
IDirect3DSurface9_Release(p->rtarget);
p->rtarget = NULL;
}
ra_tex_free(mapper->ra, &mapper->tex[0]);
}
static int mapper_init(struct ra_hwdec_mapper *mapper)
{
struct priv_owner *p_owner = mapper->owner->priv;
struct priv *p = mapper->priv;
GL *gl = ra_gl_get(mapper->ra);
HRESULT hr;
p->device = p_owner->device;
p->device_h = p_owner->device_h;
HANDLE share_handle = NULL;
hr = IDirect3DDevice9Ex_CreateRenderTarget(
p->device,
mapper->src_params.w, mapper->src_params.h,
SHARED_SURFACE_D3DFMT, D3DMULTISAMPLE_NONE, 0, FALSE,
&p->rtarget, &share_handle);
if (FAILED(hr)) {
MP_ERR(mapper, "Failed creating offscreen Direct3D surface: %s\n",
mp_HRESULT_to_str(hr));
return -1;
}
if (share_handle &&
!gl->DXSetResourceShareHandleNV(p->rtarget, share_handle)) {
MP_ERR(mapper, "Failed setting Direct3D/OpenGL share handle for surface: %s\n",
mp_LastError_to_str());
return -1;
}
gl->GenTextures(1, &p->texture);
gl->BindTexture(GL_TEXTURE_2D, p->texture);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
gl->BindTexture(GL_TEXTURE_2D, 0);
p->rtarget_h = gl->DXRegisterObjectNV(p->device_h, p->rtarget, p->texture,
GL_TEXTURE_2D,
WGL_ACCESS_READ_ONLY_NV);
if (!p->rtarget_h) {
MP_ERR(mapper, "Failed to register Direct3D surface with OpenGL: %s\n",
mp_LastError_to_str());
return -1;
}
if (!gl->DXLockObjectsNV(p->device_h, 1, &p->rtarget_h)) {
MP_ERR(mapper, "Failed locking texture for access by OpenGL %s\n",
mp_LastError_to_str());
return -1;
}
struct ra_tex_params params = {
.dimensions = 2,
.w = mapper->src_params.w,
.h = mapper->src_params.h,
.d = 1,
.format = ra_find_unorm_format(mapper->ra, 1, 4),
.render_src = true,
.src_linear = true,
};
if (!params.format)
return -1;
mapper->tex[0] = ra_create_wrapped_tex(mapper->ra, ¶ms, p->texture);
if (!mapper->tex[0])
return -1;
mapper->dst_params = mapper->src_params;
mapper->dst_params.imgfmt = IMGFMT_RGB0;
mapper->dst_params.hw_subfmt = 0;
return 0;
}
static int mapper_map(struct ra_hwdec_mapper *mapper)
{
struct priv *p = mapper->priv;
GL *gl = ra_gl_get(mapper->ra);
HRESULT hr;
if (!gl->DXUnlockObjectsNV(p->device_h, 1, &p->rtarget_h)) {
MP_ERR(mapper, "Failed unlocking texture for access by OpenGL: %s\n",
mp_LastError_to_str());
return -1;
}
IDirect3DSurface9* hw_surface = (IDirect3DSurface9 *)mapper->src->planes[3];
RECT rc = {0, 0, mapper->src->w, mapper->src->h};
hr = IDirect3DDevice9Ex_StretchRect(p->device,
hw_surface, &rc,
p->rtarget, &rc,
D3DTEXF_NONE);
if (FAILED(hr)) {
MP_ERR(mapper, "Direct3D RGB conversion failed: %s", mp_HRESULT_to_str(hr));
return -1;
}
if (!gl->DXLockObjectsNV(p->device_h, 1, &p->rtarget_h)) {
MP_ERR(mapper, "Failed locking texture for access by OpenGL: %s\n",
mp_LastError_to_str());
return -1;
}
return 0;
}
const struct ra_hwdec_driver ra_hwdec_dxva2gldx = {
.name = "dxva2-dxinterop",
.priv_size = sizeof(struct priv_owner),
.imgfmts = {IMGFMT_DXVA2, 0},
.init = init,
.uninit = uninit,
.mapper = &(const struct ra_hwdec_mapper_driver){
.priv_size = sizeof(struct priv),
.init = mapper_init,
.uninit = mapper_uninit,
.map = mapper_map,
},
};
