/** @brief libvo Callback: Draw OSD/Subtitles,
*/
static void draw_osd(void)
{
// we can not render OSD if we lost the device e.g. because it was uncooperative
if (!priv->d3d_device)
return;
if (vo_osd_changed(0)) {
D3DLOCKED_RECT locked_rect; /**< Offscreen surface we lock in order
to copy MPlayer's frame inside it.*/
/* clear the OSD */
if (FAILED(IDirect3DTexture9_LockRect(priv->d3d_texture_system, 0,
&locked_rect, NULL, 0))) {
mp_msg(MSGT_VO,MSGL_ERR, "<vo_direct3d>OSD texture lock failed.\n");
return;
}
/* clear the whole texture to avoid issues due to interpolation */
memset(locked_rect.pBits, 0, locked_rect.Pitch * priv->osd_texture_height);
/* this unlock is used for both slice_draw path and D3DRenderFrame path */
if (FAILED(IDirect3DTexture9_UnlockRect(priv->d3d_texture_system, 0))) {
mp_msg(MSGT_VO,MSGL_ERR, "<vo_direct3d>OSD texture unlock failed.\n");
return;
}
priv->is_osd_populated = 0;
/* required for if subs are in the boarder region */
priv->is_clear_needed = 1;
vo_draw_text_ext(priv->osd_width, priv->osd_height, priv->border_x, priv->border_y,
priv->border_x, priv->border_y, priv->src_width, priv->src_height, draw_alpha);
if (!priv->device_texture_sys)
{
/* only DMA to the shadow if its required */
if (FAILED(IDirect3DDevice9_UpdateTexture(priv->d3d_device,
(IDirect3DBaseTexture9 *)priv->d3d_texture_system,
(IDirect3DBaseTexture9 *)priv->d3d_texture_osd))) {
mp_msg(MSGT_VO,MSGL_ERR, "<vo_direct3d>OSD texture transfer failed.\n");
return;
}
}
}
/* update OSD */
if (priv->is_osd_populated) {
struct_vertex osd_quad_vb[] = {
{-1.0f, 1.0f, 0.0f, 0, 0 },
{ 1.0f, 1.0f, 0.0f, 1, 0 },
{-1.0f,-1.0f, 0.0f, 0, 1 },
{ 1.0f,-1.0f, 0.0f, 1, 1 }
};
/* calculate the texture coordinates */
osd_quad_vb[1].tu =
osd_quad_vb[3].tu = (float)priv->osd_width / priv->osd_texture_width;
osd_quad_vb[2].tv =
osd_quad_vb[3].tv = (float)priv->osd_height / priv->osd_texture_height;
if (FAILED(IDirect3DDevice9_BeginScene(priv->d3d_device))) {
mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>BeginScene failed.\n");
return;
}
/* turn on alpha test */
IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_ALPHABLENDENABLE, TRUE);
IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_ALPHATESTENABLE, TRUE);
/* need to use a texture here (done here as we may be able to texture from system memory) */
IDirect3DDevice9_SetTexture(priv->d3d_device, 0,
(IDirect3DBaseTexture9 *)(priv->device_texture_sys
? priv->d3d_texture_system : priv->d3d_texture_osd));
IDirect3DDevice9_SetFVF(priv->d3d_device, D3DFVF_MY_VERTEX);
IDirect3DDevice9_DrawPrimitiveUP(priv->d3d_device, D3DPT_TRIANGLESTRIP, 2, osd_quad_vb, sizeof(struct_vertex));
/* turn off alpha test */
IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_ALPHATESTENABLE, FALSE);
IDirect3DDevice9_SetRenderState(priv->d3d_device, D3DRS_ALPHABLENDENABLE, FALSE);
if (FAILED(IDirect3DDevice9_EndScene(priv->d3d_device))) {
mp_msg(MSGT_VO,MSGL_ERR,"<vo_direct3d>EndScene failed.\n");
return;
}
}
}
IDirect3DTexture9* ILAPIENTRY ilutD3D9Texture(IDirect3DDevice9 *Device)
{
IDirect3DTexture9 *Texture;
// D3DLOCKED_RECT Rect;
D3DFORMAT Format;
ILimage *Image;
ILenum DXTCFormat;
ILuint Size;
ILubyte *Buffer;
Image = ilutCurImage = ilGetCurImage();
if (ilutCurImage == NULL) {
ilSetError(ILUT_ILLEGAL_OPERATION);
return NULL;
}
if (!FormatsDX9Checked)
CheckFormatsDX9(Device);
if (ilutGetBoolean(ILUT_D3D_USE_DXTC) && FormatsDX9supported[3] && FormatsDX9supported[4] && FormatsDX9supported[5]) {
if (ilutCurImage->DxtcData != NULL && ilutCurImage->DxtcSize != 0) {
ILuint dxtcFormat = ilutGetInteger(ILUT_DXTC_FORMAT);
Format = D3DGetDXTCNumDX9(ilutCurImage->DxtcFormat);
ilutSetInteger(ILUT_DXTC_FORMAT, ilutCurImage->DxtcFormat);
Texture = iD3DMakeTexture(Device, ilutCurImage->DxtcData, ilutCurImage->DxtcSize,
ilutCurImage->Width, ilutCurImage->Height, Format,
ilutGetInteger(ILUT_D3D_POOL) == D3DPOOL_DEFAULT ? D3DPOOL_SYSTEMMEM : ilutGetInteger(ILUT_D3D_POOL), ilutGetInteger(ILUT_D3D_MIPLEVELS));
if (!Texture)
return NULL;
iD3D9CreateMipmaps(Texture, Image);
if (ilutGetInteger(ILUT_D3D_POOL) == D3DPOOL_DEFAULT) {
IDirect3DTexture9 *SysTex = Texture;
// copy texture to device memory
if (FAILED(IDirect3DDevice9_CreateTexture(Device, ilutCurImage->Width,
ilutCurImage->Height, ilutGetInteger(ILUT_D3D_MIPLEVELS), 0, Format,
D3DPOOL_DEFAULT, &Texture, NULL))) {
IDirect3DTexture9_Release(SysTex);
return NULL;
}
if (FAILED(IDirect3DDevice9_UpdateTexture(Device, (LPDIRECT3DBASETEXTURE9)SysTex, (LPDIRECT3DBASETEXTURE9)Texture))) {
IDirect3DTexture9_Release(SysTex);
return NULL;
}
IDirect3DTexture9_Release(SysTex);
}
ilutSetInteger(ILUT_DXTC_FORMAT, dxtcFormat);
goto success;
}
if (ilutGetBoolean(ILUT_D3D_GEN_DXTC)) {
DXTCFormat = ilutGetInteger(ILUT_DXTC_FORMAT);
/*
Image = MakeD3D9Compliant(Device, &Format);
if (Image == NULL) {
if (Image != ilutCurImage)
ilCloseImage(Image);
return NULL;
}
*/
Size = ilGetDXTCData(NULL, 0, DXTCFormat);
if (Size != 0) {
Buffer = (ILubyte*)ialloc(Size);
if (Buffer == NULL)
return NULL;
Size = ilGetDXTCData(Buffer, Size, DXTCFormat);
if (Size == 0) {
ifree(Buffer);
return NULL;
}
Format = D3DGetDXTCNumDX9(DXTCFormat);
Texture = iD3DMakeTexture(Device, Buffer, Size,
ilutCurImage->Width, ilutCurImage->Height, Format,
ilutGetInteger(ILUT_D3D_POOL) == D3DPOOL_DEFAULT ? D3DPOOL_SYSTEMMEM : ilutGetInteger(ILUT_D3D_POOL), ilutGetInteger(ILUT_D3D_MIPLEVELS));
if (!Texture)
return NULL;
iD3D9CreateMipmaps(Texture, Image);
if (ilutGetInteger(ILUT_D3D_POOL) == D3DPOOL_DEFAULT) {
IDirect3DTexture9 *SysTex = Texture;
if (FAILED(IDirect3DDevice9_CreateTexture(Device, ilutCurImage->Width,
ilutCurImage->Height, ilutGetInteger(ILUT_D3D_MIPLEVELS), 0, Format,
D3DPOOL_DEFAULT, &Texture, NULL))) {
IDirect3DTexture9_Release(SysTex);
return NULL;
}
if (FAILED(IDirect3DDevice9_UpdateTexture(Device, (LPDIRECT3DBASETEXTURE9)SysTex, (LPDIRECT3DBASETEXTURE9)Texture))) {
IDirect3DTexture9_Release(SysTex);
return NULL;
}
IDirect3DTexture9_Release(SysTex);
}
goto success;
}
}
}
Image = MakeD3D9Compliant(Device, &Format);
if (Image == NULL) {
if (Image != ilutCurImage)
ilCloseImage(Image);
return NULL;
}
Texture = iD3DMakeTexture(Device, Image->Data, Image->SizeOfPlane,
Image->Width, Image->Height, Format,
ilutGetInteger(ILUT_D3D_POOL) == D3DPOOL_DEFAULT ? D3DPOOL_SYSTEMMEM : ilutGetInteger(ILUT_D3D_POOL), ilutGetInteger(ILUT_D3D_MIPLEVELS));
if (!Texture)
return NULL;
iD3D9CreateMipmaps(Texture, Image);
if (ilutGetInteger(ILUT_D3D_POOL) == D3DPOOL_DEFAULT) {
IDirect3DTexture9 *SysTex = Texture;
// create texture in system memory
if (FAILED(IDirect3DDevice9_CreateTexture(Device, Image->Width,
Image->Height, ilutGetInteger(ILUT_D3D_MIPLEVELS), 0, Format,
ilutGetInteger(ILUT_D3D_POOL), &Texture, NULL))) {
IDirect3DTexture9_Release(SysTex);
return NULL;
}
if (FAILED(IDirect3DDevice9_UpdateTexture(Device, (LPDIRECT3DBASETEXTURE9)SysTex, (LPDIRECT3DBASETEXTURE9)Texture))) {
IDirect3DTexture9_Release(SysTex);
return NULL;
}
IDirect3DTexture9_Release(SysTex);
}
// if (Image != ilutCurImage)
// ilCloseImage(Image);
success:
if (Image != ilutCurImage)
ilCloseImage(Image);
return Texture;
}
static int
D3D_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels, int pitch)
{
D3D_TextureData *data = (D3D_TextureData *) texture->driverdata;
D3D_RenderData *renderdata = (D3D_RenderData *) renderer->driverdata;
if (data->yuv) {
if (SDL_SW_UpdateYUVTexture(data->yuv, rect, pixels, pitch) < 0) {
return -1;
}
UpdateYUVTextureData(texture);
return 0;
} else {
#ifdef SDL_MEMORY_POOL_DEFAULT
IDirect3DTexture9 *temp;
RECT d3drect;
D3DLOCKED_RECT locked;
const Uint8 *src;
Uint8 *dst;
int row, length;
HRESULT result;
result =
IDirect3DDevice9_CreateTexture(renderdata->device, texture->w,
texture->h, 1, 0,
PixelFormatToD3DFMT(texture->
format),
D3DPOOL_SYSTEMMEM, &temp, NULL);
if (FAILED(result)) {
D3D_SetError("CreateTexture()", result);
return -1;
}
d3drect.left = rect->x;
d3drect.right = rect->x + rect->w;
d3drect.top = rect->y;
d3drect.bottom = rect->y + rect->h;
result = IDirect3DTexture9_LockRect(temp, 0, &locked, &d3drect, 0);
if (FAILED(result)) {
IDirect3DTexture9_Release(temp);
D3D_SetError("LockRect()", result);
return -1;
}
src = pixels;
dst = locked.pBits;
length = rect->w * SDL_BYTESPERPIXEL(texture->format);
for (row = 0; row < rect->h; ++row) {
SDL_memcpy(dst, src, length);
src += pitch;
dst += locked.Pitch;
}
IDirect3DTexture9_UnlockRect(temp, 0);
result =
IDirect3DDevice9_UpdateTexture(renderdata->device,
(IDirect3DBaseTexture9 *) temp,
(IDirect3DBaseTexture9 *)
data->texture);
IDirect3DTexture9_Release(temp);
if (FAILED(result)) {
D3D_SetError("UpdateTexture()", result);
return -1;
}
#else
RECT d3drect;
D3DLOCKED_RECT locked;
const Uint8 *src;
Uint8 *dst;
int row, length;
HRESULT result;
d3drect.left = rect->x;
d3drect.right = rect->x + rect->w;
d3drect.top = rect->y;
d3drect.bottom = rect->y + rect->h;
result =
IDirect3DTexture9_LockRect(data->texture, 0, &locked, &d3drect,
0);
if (FAILED(result)) {
D3D_SetError("LockRect()", result);
return -1;
}
src = pixels;
dst = locked.pBits;
length = rect->w * SDL_BYTESPERPIXEL(texture->format);
for (row = 0; row < rect->h; ++row) {
SDL_memcpy(dst, src, length);
src += pitch;
dst += locked.Pitch;
}
IDirect3DTexture9_UnlockRect(data->texture, 0);
#endif // SDL_MEMORY_POOL_DEFAULT
return 0;
}
}
CR_API CrBool crTextureCommit(CrTexture* self, const void* data)
{
CrTextureImpl* impl = (CrTextureImpl*)self;
if(nullptr == self)
return CrFalse;
if(nullptr == impl->apiFormatMapping)
return CrFalse;
if(self->surfCount == 1) {
HRESULT hr;
size_t i;
IDirect3DTexture9* stageTex;
hr = IDirect3DDevice9_CreateTexture(crContextImpl()->d3ddev, self->width, self->height, self->mipCount, 0, impl->apiFormatMapping->d3dFormat, D3DPOOL_SYSTEMMEM, &stageTex, nullptr);
if(FAILED(hr)) {
crDbgStr("d3d9 failed to create texture %8x", hr);
return CrFalse;
}
for(i=0; i<self->mipCount; ++i) {
size_t mipW, mipH;
D3DLOCKED_RECT locked;
unsigned char* mipdata = crTextureGetMipLevel(self, (unsigned char*)data, 0, i, &mipW, &mipH);
hr = IDirect3DTexture9_LockRect(stageTex, i, &locked, nullptr, 0);
if(FAILED(hr))
continue;
if(CrGpuFormat_UnormR8G8B8A8 != self->format) {
memcpy(locked.pBits, mipdata, mipW * mipH * impl->apiFormatMapping->pixelSize);
}
else {
// CrGpuFormat_UnormR8G8B8A8 need to flip the endian since we actually use the OpenGL's layout
char* dst = locked.pBits;
char* src = mipdata;
size_t cnt = mipW * mipH;
size_t i;
for(i = 0; i<cnt; ++i) {
dst[0] = src[2];
dst[1] = src[1];
dst[2] = src[0];
dst[3] = src[3];
dst += 4;
src += 4;
}
}
IDirect3DTexture9_UnlockRect(stageTex, i);
}
IDirect3DDevice9_UpdateTexture(crContextImpl()->d3ddev, (IDirect3DBaseTexture9*)stageTex, (IDirect3DBaseTexture9*)impl->d3dtex);
IDirect3DTexture9_Release(stageTex);
}
return CrTrue;
}
