/***********************************************************************
* dibdrv_wglMakeCurrent
*/
static BOOL dibdrv_wglMakeCurrent( HDC hdc, struct wgl_context *context )
{
HBITMAP bitmap;
BITMAPOBJ *bmp;
dib_info dib;
GLenum type;
BOOL ret = FALSE;
if (!context)
{
pOSMesaMakeCurrent( NULL, NULL, GL_UNSIGNED_BYTE, 0, 0 );
return TRUE;
}
if (GetPixelFormat( hdc ) != context->format)
FIXME( "mismatched pixel formats %u/%u not supported yet\n",
GetPixelFormat( hdc ), context->format );
bitmap = GetCurrentObject( hdc, OBJ_BITMAP );
bmp = GDI_GetObjPtr( bitmap, OBJ_BITMAP );
if (!bmp) return FALSE;
if (init_dib_info_from_bitmapobj( &dib, bmp ))
{
char *bits;
int width = dib.rect.right - dib.rect.left;
int height = dib.rect.bottom - dib.rect.top;
if (dib.stride < 0)
bits = (char *)dib.bits.ptr + (dib.rect.bottom - 1) * dib.stride;
else
bits = (char *)dib.bits.ptr + dib.rect.top * dib.stride;
bits += dib.rect.left * dib.bit_count / 8;
TRACE( "context %p bits %p size %ux%u\n", context, bits, width, height );
if (pixel_formats[context->format - 1].mesa == OSMESA_RGB_565)
type = GL_UNSIGNED_SHORT_5_6_5;
else
type = GL_UNSIGNED_BYTE;
ret = pOSMesaMakeCurrent( context->context, bits, type, width, height );
if (ret)
{
pOSMesaPixelStore( OSMESA_ROW_LENGTH, abs( dib.stride ) * 8 / dib.bit_count );
pOSMesaPixelStore( OSMESA_Y_UP, 1 ); /* Windows seems to assume bottom-up */
}
}
GDI_ReleaseObj( bitmap );
return ret;
}
void Image::InsertImage(const Image* image, uint32 dstX, uint32 dstY,
uint32 srcX /* = 0 */, uint32 srcY /* = 0 */,
uint32 srcWidth /* = -1 */, uint32 srcHeight /* = -1 */)
{
if (GetPixelFormat() != image->GetPixelFormat())
{
return;
}
if (image == NULL || dstX >= width || dstY >= height ||
srcX >= image->GetWidth() || srcY >= image->GetHeight())
{
return;
}
uint32 insertWidth = (srcWidth == (uint32)-1) ? image->GetWidth() : srcWidth;
uint32 insertHeight = (srcHeight == (uint32)-1) ? image->GetHeight() : srcHeight;
if (srcX + insertWidth > image->GetWidth())
{
insertWidth = image->GetWidth() - srcX;
}
if (dstX + insertWidth > width)
{
insertWidth = width - dstX;
}
if (srcY + insertHeight > image->GetHeight())
{
insertHeight = image->GetHeight() - srcY;
}
if (dstY + insertHeight > height)
{
insertHeight = height - dstY;
}
PixelFormat format = GetPixelFormat();
int32 formatSize = PixelFormatDescriptor::GetPixelFormatSizeInBytes(format);
uint8* srcData = image->GetData();
uint8* dstData = data;
for (uint32 i = 0; i < insertHeight; ++i)
{
memcpy(dstData + (width * (dstY + i) + dstX) * formatSize,
srcData + (image->GetWidth() * (srcY + i) + srcX) * formatSize,
formatSize * insertWidth);
}
}
void CIrrWindow::createIrrDevice()
{
// create irr device
SIrrlichtCreationParameters param;
param.WindowId = (void*)getHandle();
param.ZBufferBits = 32;
param.DriverType = video::EDT_OPENGL;
m_device = createDeviceEx(param);
m_driver = m_device->getVideoDriver();
m_smgr = m_device->getSceneManager();
// init opengl
HDC HDc = GetDC( getHandle() );
PIXELFORMATDESCRIPTOR pfd={0};
pfd.nSize=sizeof(PIXELFORMATDESCRIPTOR);
int pf = GetPixelFormat(HDc);
DescribePixelFormat(HDc, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
pfd.dwFlags |= PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
pfd.cDepthBits=16;
pf = ChoosePixelFormat(HDc, &pfd);
SetPixelFormat(HDc, pf, &pfd);
// share video data
m_videoData.OpenGLWin32.HWnd = NULL;
m_videoData.OpenGLWin32.HDc = HDc;
m_videoData.OpenGLWin32.HRc = wglCreateContext(HDc);
// share for multithread
wglShareLists((HGLRC)m_driver->getExposedVideoData().OpenGLWin32.HRc, (HGLRC)m_videoData.OpenGLWin32.HRc);
g_irrView = this;
initScene();
}
static GLint getInternalFormat(void)
{
switch (glctx.type) {
#ifdef CONFIG_GL_WIN32
case GLTYPE_W32:
{
PIXELFORMATDESCRIPTOR pfd;
HDC vo_hdc = vo_w32_get_dc(vo_w32_window);
int pf = GetPixelFormat(vo_hdc);
if (!DescribePixelFormat(vo_hdc, pf, sizeof pfd, &pfd)) {
r_sz = g_sz = b_sz = a_sz = 0;
} else {
r_sz = pfd.cRedBits;
g_sz = pfd.cGreenBits;
b_sz = pfd.cBlueBits;
a_sz = pfd.cAlphaBits;
}
vo_w32_release_dc(vo_w32_window, vo_hdc);
}
break;
#endif
#ifdef CONFIG_GL_X11
case GLTYPE_X11:
if (glXGetConfig(mDisplay, glctx.vinfo.x11, GLX_RED_SIZE, &r_sz) != 0) r_sz = 0;
if (glXGetConfig(mDisplay, glctx.vinfo.x11, GLX_GREEN_SIZE, &g_sz) != 0) g_sz = 0;
if (glXGetConfig(mDisplay, glctx.vinfo.x11, GLX_BLUE_SIZE, &b_sz) != 0) b_sz = 0;
if (glXGetConfig(mDisplay, glctx.vinfo.x11, GLX_ALPHA_SIZE, &a_sz) != 0) a_sz = 0;
break;
#endif
}
rgb_sz=r_sz+g_sz+b_sz;
if(rgb_sz<=0) rgb_sz=24;
#ifdef TEXTUREFORMAT_ALWAYS
return TEXTUREFORMAT_ALWAYS;
#else
if(r_sz==3 && g_sz==3 && b_sz==2 && a_sz==0)
return GL_R3_G3_B2;
if(r_sz==4 && g_sz==4 && b_sz==4 && a_sz==0)
return GL_RGB4;
if(r_sz==5 && g_sz==5 && b_sz==5 && a_sz==0)
return GL_RGB5;
if(r_sz==8 && g_sz==8 && b_sz==8 && a_sz==0)
return GL_RGB8;
if(r_sz==10 && g_sz==10 && b_sz==10 && a_sz==0)
return GL_RGB10;
if(r_sz==2 && g_sz==2 && b_sz==2 && a_sz==2)
return GL_RGBA2;
if(r_sz==4 && g_sz==4 && b_sz==4 && a_sz==4)
return GL_RGBA4;
if(r_sz==5 && g_sz==5 && b_sz==5 && a_sz==1)
return GL_RGB5_A1;
if(r_sz==8 && g_sz==8 && b_sz==8 && a_sz==8)
return GL_RGBA8;
if(r_sz==10 && g_sz==10 && b_sz==10 && a_sz==2)
return GL_RGB10_A2;
#endif
return GL_RGB;
}
//
// 지정된영역의 백버퍼데이타를 읽어서 surface에 옮긴다.
// GL은 프론트만 읽을수 있는줄알았는데 반대였다. 백버퍼만 읽을수 있다
// w,y,width,height: 스크린 좌표
void XGraphicsOpenGL::ScreenToSurface( int x, int y, int width, int height, XSurface *pSurface )
{
if( GetPixelFormat() != xPIXELFORMAT_RGB565 )
XERROR( "아직은 RGB565포맷만 사용가능함." );
int px, py, pw, ph; // 물리적스크린크기와 좌표.
float fRatioX, fRatioY;
// phyScreen과 screen의 비율로 좌표들을 변환.
fRatioX = (float)GetPhyScreenWidth() / GetScreenWidth();
fRatioY = (float)GetPhyScreenHeight() / GetScreenHeight();
px = x * fRatioX; py = y * fRatioY; // screen->physcreen 좌표로 변환
pw = width * fRatioX; ph = height * fRatioY;
//GL_NO_ERROR
DWORD *pdwBuffer = new DWORD[ pw * ph ];
glReadPixels(px, py, pw, ph, GL_RGBA, GL_UNSIGNED_BYTE, pdwBuffer ); // 위아래 뒤집혀진 이미지
DWORD *pDst = new DWORD[ pw * ph ];
// 위아래를 바꿈
for( int i = 0; i < ph; i ++ )
for( int j = 0; j < pw; j ++ )
pDst[ i * pw + j ] = pdwBuffer[ (ph-1-i) * pw + j ];
SAFE_DELETE_ARRAY( pdwBuffer );
pSurface->Create( pw, ph, 0, 0, xALPHA, pDst, sizeof(DWORD), 0, 0 );
#pragma messages( "pdwBuffer를 XSurfaceOpenGL::Create()내부에서 뽀개주도록 바꿔야 한다. 버그날까봐 일단 이상태로 놔둠" )
}
/**
* Compute a mask of CR_*_BIT flags which reflects the attributes of
* the pixel format of the given hdc.
*/
static GLuint ComputeVisBits( HDC hdc )
{
PIXELFORMATDESCRIPTOR pfd;
int iPixelFormat;
GLuint b = 0;
iPixelFormat = GetPixelFormat( hdc );
DescribePixelFormat( hdc, iPixelFormat, sizeof(pfd), &pfd );
if (pfd.cDepthBits > 0)
b |= CR_DEPTH_BIT;
if (pfd.cAccumBits > 0)
b |= CR_ACCUM_BIT;
if (pfd.cColorBits > 8)
b |= CR_RGB_BIT;
if (pfd.cStencilBits > 0)
b |= CR_STENCIL_BIT;
if (pfd.cAlphaBits > 0)
b |= CR_ALPHA_BIT;
if (pfd.dwFlags & PFD_DOUBLEBUFFER)
b |= CR_DOUBLE_BIT;
if (pfd.dwFlags & PFD_STEREO)
b |= CR_STEREO_BIT;
return b;
}
HRESULT CDecD3D11::DeliverD3D11Readback(LAVFrame *pFrame)
{
AVFrame *src = (AVFrame *)pFrame->priv_data;
AVFrame *dst = av_frame_alloc();
int ret = av_hwframe_transfer_data(dst, src, 0);
if (ret < 0)
{
ReleaseFrame(&pFrame);
av_frame_free(&dst);
return E_FAIL;
}
// free the source frame
av_frame_free(&src);
// and store the dst frame in LAVFrame
pFrame->priv_data = dst;
GetPixelFormat(&pFrame->format, &pFrame->bpp);
ASSERT((dst->format == AV_PIX_FMT_NV12 && pFrame->format == LAVPixFmt_NV12) || (dst->format == AV_PIX_FMT_P010 && pFrame->format == LAVPixFmt_P016));
for (int i = 0; i < 4; i++) {
pFrame->data[i] = dst->data[i];
pFrame->stride[i] = dst->linesize[i];
}
return Deliver(pFrame);
}
static HPALETTE YsCreatePalette(HDC dc)
{
HPALETTE neo;
PIXELFORMATDESCRIPTOR pfd;
LOGPALETTE *lp;
int n,i;
n=GetPixelFormat(dc);
DescribePixelFormat(dc,n,sizeof(PIXELFORMATDESCRIPTOR),&pfd);
if(pfd.dwFlags & PFD_NEED_PALETTE)
{
n=1<<pfd.cColorBits;
lp=(LOGPALETTE *)malloc(sizeof(LOGPALETTE)+n*sizeof(PALETTEENTRY));
lp->palVersion=0x300;
lp->palNumEntries=(WORD)n;
for (i=0; i<n; i++)
{
lp->palPalEntry[i].peRed =YsPalVal(i,pfd.cRedBits,pfd.cRedShift);
lp->palPalEntry[i].peGreen=YsPalVal(i,pfd.cGreenBits,pfd.cGreenShift);
lp->palPalEntry[i].peBlue =YsPalVal(i,pfd.cBlueBits,pfd.cBlueShift);
lp->palPalEntry[i].peFlags=0;
}
neo=CreatePalette(lp);
free(lp);
return neo;
}
return NULL;
}
void Image::Draw(float x, float y) const
{
if(!m_uWidth)
return;
SetMemAlign(m_uWidth, FALSE);
glRasterPos2f(x, y);
glDrawPixels(m_uWidth, m_uHeight, GetPixelFormat(), GL_UNSIGNED_BYTE, GetDataPtr());
}
FString UTextureCube::GetDesc()
{
return FString::Printf(TEXT("Cube: %dx%d [%s]"),
GetSizeX(),
GetSizeY(),
GPixelFormats[GetPixelFormat()].Name
);
}
JNIEXPORT jint JNICALL WGL_NATIVE(GetPixelFormat)
(JNIEnv *env, jclass that, jintLong arg0)
{
jint rc = 0;
WGL_NATIVE_ENTER(env, that, GetPixelFormat_FUNC);
rc = (jint)GetPixelFormat((HDC)arg0);
WGL_NATIVE_EXIT(env, that, GetPixelFormat_FUNC);
return rc;
}
int wxIDirectFBSurface::GetDepth()
{
DFBSurfacePixelFormat format = DSPF_UNKNOWN;
if ( !GetPixelFormat(&format) )
return -1;
return DFB_BITS_PER_PIXEL(format);
}
// 백버퍼의 픽셀을 읽어서 pBuffer에 담아줌.
// m_nWidth는 논리적서피스의 크기이고 work와 같고, back,frame 버퍼는 실제물리적 해상도인것으로 구분해줄 필요 있다.
void* XGraphicsOpenGL::ReadBackBuffer( int phywidth, int phyheight, void *pBuffer )
{
if( GetPixelFormat() != xPIXELFORMAT_RGB565 )
XERROR( "아직은 RGB565포맷만 사용가능함." );
// glReadBufferOES( GL_BACK ); // gl1.2 ES엔 없는듯.
// gl1.x에선 프론트가 아니고 백버퍼만 읽을수 있는듯 하다. 잘못알고 있었음-_-;;
glReadPixels(0, 0, phywidth, phyheight, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, pBuffer );
return pBuffer;
}
DHGLRC APIENTRY
DrvCreateLayerContext(
HDC hdc,
INT iLayerPlane )
{
int iPixelFormat;
const struct stw_pixelformat_info *pfi;
struct st_context_attribs attribs;
struct stw_context *ctx = NULL;
if(!stw_dev)
return 0;
if (iLayerPlane != 0)
return 0;
iPixelFormat = GetPixelFormat(hdc);
if(!iPixelFormat)
return 0;
pfi = stw_pixelformat_get_info( iPixelFormat - 1 );
ctx = CALLOC_STRUCT( stw_context );
if (ctx == NULL)
goto no_ctx;
ctx->hdc = hdc;
ctx->iPixelFormat = iPixelFormat;
memset(&attribs, 0, sizeof(attribs));
attribs.profile = ST_PROFILE_DEFAULT;
attribs.visual = pfi->stvis;
ctx->st = stw_dev->stapi->create_context(stw_dev->stapi,
stw_dev->smapi, &attribs, NULL);
if (ctx->st == NULL)
goto no_st_ctx;
ctx->st->st_manager_private = (void *) ctx;
pipe_mutex_lock( stw_dev->ctx_mutex );
ctx->dhglrc = handle_table_add(stw_dev->ctx_table, ctx);
pipe_mutex_unlock( stw_dev->ctx_mutex );
if (!ctx->dhglrc)
goto no_hglrc;
return ctx->dhglrc;
no_hglrc:
ctx->st->destroy(ctx->st);
no_st_ctx:
FREE(ctx);
no_ctx:
return 0;
}
Colormap
XCreateColormap(Display* display, Window root, Visual* visual, int alloc)
{
/* KLUDGE: this function needs XHDC to be set to the HDC currently
being operated on before it is invoked! */
PIXELFORMATDESCRIPTOR pfd;
LOGPALETTE *logical;
HPALETTE palette;
int n;
/* grab the pixel format */
memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
DescribePixelFormat(XHDC, GetPixelFormat(XHDC),
sizeof(PIXELFORMATDESCRIPTOR), &pfd);
if (!(pfd.dwFlags & PFD_NEED_PALETTE ||
pfd.iPixelType == PFD_TYPE_COLORINDEX))
{
return 0;
}
n = 1 << pfd.cColorBits;
/* allocate a bunch of memory for the logical palette (assume 256
colors in a Win32 palette */
logical = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +
sizeof(PALETTEENTRY) * n);
memset(logical, 0, sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * n);
/* set the entries in the logical palette */
logical->palVersion = 0x300;
logical->palNumEntries = n;
/* start with a copy of the current system palette */
GetSystemPaletteEntries(XHDC, 0, 256, &logical->palPalEntry[0]);
if (pfd.iPixelType == PFD_TYPE_RGBA) {
int redMask = (1 << pfd.cRedBits) - 1;
int greenMask = (1 << pfd.cGreenBits) - 1;
int blueMask = (1 << pfd.cBlueBits) - 1;
int i;
/* fill in an RGBA color palette */
for (i = 0; i < n; ++i) {
logical->palPalEntry[i].peRed =
(((i >> pfd.cRedShift) & redMask) * 255) / redMask;
logical->palPalEntry[i].peGreen =
(((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
logical->palPalEntry[i].peBlue =
(((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;
logical->palPalEntry[i].peFlags = 0;
}
}
void TextureData2D :: Upload ( int target )
{
glTexImage2D ( target,
0,
GetInternalFormat ( ),
Width,
Height,
0,
GetPixelFormat ( ),
GL_FLOAT,
Pixels );
}
XnStatus XnSensorImageGenerator::SetPixelFormat(XnPixelFormat Format)
{
if (GetPixelFormat() == Format)
{
return (XN_STATUS_OK);
}
XN_PROPERTY_SET_CREATE_ON_STACK(props);
XnStatus nRetVal = XnPropertySetAddModule(&props, m_strModule);
XN_IS_STATUS_OK(nRetVal);
XnOutputFormats OutputFormat;
XnUInt32* anAllowedInputFormats = NULL;
XnUInt32 nAllowedInputFormats = 0;
switch (Format)
{
case XN_PIXEL_FORMAT_RGB24:
OutputFormat = XN_OUTPUT_FORMAT_RGB24;
anAllowedInputFormats = g_anAllowedRGBFormats;
nAllowedInputFormats = sizeof(g_anAllowedRGBFormats)/sizeof(XnUInt32);
break;
case XN_PIXEL_FORMAT_YUV422:
OutputFormat = XN_OUTPUT_FORMAT_YUV422;
anAllowedInputFormats = g_anAllowedYUVFormats;
nAllowedInputFormats = sizeof(g_anAllowedYUVFormats)/sizeof(XnUInt32);
break;
case XN_PIXEL_FORMAT_GRAYSCALE_8_BIT:
OutputFormat = XN_OUTPUT_FORMAT_GRAYSCALE8;
anAllowedInputFormats = g_anAllowedGray8Formats;
nAllowedInputFormats = sizeof(g_anAllowedGray8Formats)/sizeof(XnUInt32);
break;
case XN_PIXEL_FORMAT_MJPEG:
OutputFormat = XN_OUTPUT_FORMAT_JPEG;
anAllowedInputFormats = g_anAllowedJPEGFormats;
nAllowedInputFormats = sizeof(g_anAllowedJPEGFormats)/sizeof(XnUInt32);
break;
default:
return XN_STATUS_INVALID_OPERATION;
}
XnUInt32 nInputFormat = FindSupportedInputFormat(anAllowedInputFormats, nAllowedInputFormats);
if (nInputFormat == INVALID_INPUT_FORMAT)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Cannot set pixel format to %s - no matching input format.", xnPixelFormatToString(Format));
}
XnPropertySetAddIntProperty(&props, m_strModule, XN_STREAM_PROPERTY_INPUT_FORMAT, (XnUInt64)nInputFormat);
XnPropertySetAddIntProperty(&props, m_strModule, XN_STREAM_PROPERTY_OUTPUT_FORMAT, (XnUInt64)OutputFormat);
return m_pSensor->BatchConfig(&props);
}
//*********************************************************************************
// Setup OpenGL renderer
//
void SetupOpenGL(void)
{
PIXELFORMATDESCRIPTOR PFD;
int s32PixelIndex;
//--- Retrieve window DC
g_hDC = ::GetDC(g_hAppWnd);
if (!g_hDC)
return;
//--- Init desired pixel format
memset(&PFD, 0, sizeof(PFD));
PFD.nSize = sizeof(PFD);
PFD.nVersion = 1;
PFD.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_GENERIC_ACCELERATED | PFD_DOUBLEBUFFER;
PFD.iPixelType = PFD_TYPE_RGBA;
PFD.cColorBits = 24;
PFD.cAlphaBits = 8;
PFD.cDepthBits = 24;
PFD.iLayerType = PFD_MAIN_PLANE;
//--- Try to match the desired pixel format
s32PixelIndex = ChoosePixelFormat(g_hDC, &PFD);
if (!s32PixelIndex)
s32PixelIndex = 1;
//--- Get pixel format description
memset(&PFD, 0, sizeof(PFD));
if (!DescribePixelFormat(g_hDC, s32PixelIndex, sizeof(PFD), &PFD))
return;
//--- Set pixel format
if (s32PixelIndex != GetPixelFormat(g_hDC))
if (!SetPixelFormat(g_hDC, s32PixelIndex, &PFD))
return;
//--- Create GL render context
g_hGLContext = (HGLRC)wglCreateContext(g_hDC);
//--- Activate render context
wglMakeCurrent(g_hDC, g_hGLContext);
}
// 팔래트 초기화 함수
void NaGsView::InitializePalette(void)
{
PIXELFORMATDESCRIPTOR pfd;
LOGPALETTE* pPal;
int pixelFormat = GetPixelFormat(m_hDC);
int paletteSize;
DescribePixelFormat(m_hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
/*
** Determine if a palette is needed and if so what size.
*/
if (pfd.dwFlags & PFD_NEED_PALETTE)
{
paletteSize = 1 << pfd.cColorBits;
}else
if (pfd.iPixelType == PFD_TYPE_COLORINDEX)
{
paletteSize = 4096;
}else
{
return;
}
pPal = (LOGPALETTE*)
malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
pPal->palVersion = 0x300;
pPal->palNumEntries = paletteSize;
if (pfd.iPixelType == PFD_TYPE_RGBA)
{
/*
** Fill the logical paletee with RGB color ramps
*/
int redMask = (1 << pfd.cRedBits) - 1;
int greenMask = (1 << pfd.cGreenBits) - 1;
int blueMask = (1 << pfd.cBlueBits) - 1;
int i;
for (i=0; i<paletteSize; ++i)
{
pPal->palPalEntry[i].peRed =
(((i >> pfd.cRedShift) & redMask) * 255) / redMask;
pPal->palPalEntry[i].peGreen =
(((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
pPal->palPalEntry[i].peBlue =
(((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;
pPal->palPalEntry[i].peFlags = 0;
}
}else
void setupPalette(HDC hDC)
{
int pixelFormat = GetPixelFormat(hDC);
PIXELFORMATDESCRIPTOR pfd;
DescribePixelFormat(hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
if (pfd.dwFlags & PFD_NEED_PALETTE)
{
//dbgFatal(DBG_Loc, "rndInit: needs paletted display");
}
else
{
return;
}
}
void UTextureCube::GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const
{
#if WITH_EDITOR
int32 SizeX = Source.GetSizeX();
int32 SizeY = Source.GetSizeY();
#else
int32 SizeX = 0;
int32 SizeY = 0;
#endif
const FString Dimensions = FString::Printf(TEXT("%dx%d"), SizeX, SizeY);
OutTags.Add( FAssetRegistryTag("Dimensions", Dimensions, FAssetRegistryTag::TT_Dimensional) );
OutTags.Add( FAssetRegistryTag("Format", GPixelFormats[GetPixelFormat()].Name, FAssetRegistryTag::TT_Alphabetical) );
Super::GetAssetRegistryTags(OutTags);
}
int CheckHardwareSupport(HDC hdc)
{
int PixelFormat = GetPixelFormat(hdc);
PIXELFORMATDESCRIPTOR pfd;
DescribePixelFormat(hdc,PixelFormat,sizeof(PIXELFORMATDESCRIPTOR),&pfd);
if ((pfd.dwFlags & PFD_GENERIC_FORMAT) && !(pfd.dwFlags & PFD_GENERIC_ACCELERATED))
return 0; // Software acceleration OpenGL
else if ((pfd.dwFlags & PFD_GENERIC_FORMAT) && (pfd.dwFlags & PFD_GENERIC_ACCELERATED))
return 1; // Half hardware acceleration OpenGL (MCD driver)
else if ( !(pfd.dwFlags & PFD_GENERIC_FORMAT) && !(pfd.dwFlags & PFD_GENERIC_ACCELERATED))
return 2; // Full hardware acceleration OpenGL
return -1; // check error
}
BOOL APIENTRY
DrvSetPixelFormat(HDC hdc, LONG iPixelFormat)
{
uint count;
uint index;
struct stw_framebuffer *fb;
if (!stw_dev)
return FALSE;
index = (uint) iPixelFormat - 1;
count = stw_pixelformat_get_count();
if (index >= count)
return FALSE;
fb = stw_framebuffer_from_hdc_locked(hdc);
if (fb) {
/*
* SetPixelFormat must be called only once. However ignore
* pbuffers, for which the framebuffer object is created first.
*/
boolean bPbuffer = fb->bPbuffer;
stw_framebuffer_unlock( fb );
return bPbuffer;
}
fb = stw_framebuffer_create(hdc, iPixelFormat);
if (!fb) {
return FALSE;
}
stw_framebuffer_unlock( fb );
/* Some applications mistakenly use the undocumented wglSetPixelFormat
* function instead of SetPixelFormat, so we call SetPixelFormat here to
* avoid opengl32.dll's wglCreateContext to fail */
if (GetPixelFormat(hdc) == 0) {
BOOL bRet = SetPixelFormat(hdc, iPixelFormat, NULL);
if (!bRet) {
debug_printf("SetPixelFormat failed\n");
}
}
return TRUE;
}
egl::Error WindowSurfaceWGL::initialize()
{
mDeviceContext = GetDC(mWindow);
if (!mDeviceContext)
{
return egl::Error(EGL_BAD_NATIVE_WINDOW, "Failed to get the device context from the native window, "
"error: 0x%X.", GetLastError());
}
// Require that the pixel format for this window has not been set yet or is equal to the Display's pixel format.
int windowPixelFormat = GetPixelFormat(mDeviceContext);
if (windowPixelFormat == 0)
{
PIXELFORMATDESCRIPTOR pixelFormatDescriptor = { 0 };
if (!DescribePixelFormat(mDeviceContext, mPixelFormat, sizeof(pixelFormatDescriptor), &pixelFormatDescriptor))
{
return egl::Error(EGL_BAD_NATIVE_WINDOW, "Failed to DescribePixelFormat, error: 0x%X.", GetLastError());
}
if (!SetPixelFormat(mDeviceContext, mPixelFormat, &pixelFormatDescriptor))
{
return egl::Error(EGL_NOT_INITIALIZED, "Failed to set the pixel format on the device context, "
"error: 0x%X.", GetLastError());
}
}
else if (windowPixelFormat != mPixelFormat)
{
return egl::Error(EGL_NOT_INITIALIZED, "Pixel format of the NativeWindow and NativeDisplayType must match.");
}
// Check for the swap behavior of this pixel format
switch (
wgl::QueryWGLFormatAttrib(mDeviceContext, mPixelFormat, WGL_SWAP_METHOD_ARB, mFunctionsWGL))
{
case WGL_SWAP_COPY_ARB:
mSwapBehavior = EGL_BUFFER_PRESERVED;
break;
case WGL_SWAP_EXCHANGE_ARB:
case WGL_SWAP_UNDEFINED_ARB:
default:
mSwapBehavior = EGL_BUFFER_DESTROYED;
break;
}
return egl::Error(EGL_SUCCESS);
}
XnStatus XnSensorImageGenerator::SetPixelFormat(XnPixelFormat Format)
{
if (GetPixelFormat() == Format)
{
return (XN_STATUS_OK);
}
XnUInt64 nCurrentInputFormat;
GetIntProperty(XN_STREAM_PROPERTY_INPUT_FORMAT, nCurrentInputFormat);
XN_PROPERTY_SET_CREATE_ON_STACK(props);
XnStatus nRetVal = XnPropertySetAddModule(&props, m_strModule);
XN_IS_STATUS_OK(nRetVal);
XnOutputFormats OutputFormat;
switch (Format)
{
case XN_PIXEL_FORMAT_RGB24:
OutputFormat = XN_OUTPUT_FORMAT_RGB24;
break;
case XN_PIXEL_FORMAT_YUV422:
OutputFormat = XN_OUTPUT_FORMAT_YUV422;
break;
case XN_PIXEL_FORMAT_GRAYSCALE_8_BIT:
OutputFormat = XN_OUTPUT_FORMAT_GRAYSCALE8;
break;
case XN_PIXEL_FORMAT_MJPEG:
OutputFormat = XN_OUTPUT_FORMAT_JPEG;
break;
default:
return XN_STATUS_INVALID_OPERATION;
}
if (nCurrentInputFormat != XN_IO_IMAGE_FORMAT_JPEG && OutputFormat == XN_OUTPUT_FORMAT_JPEG)
{
XnPropertySetAddIntProperty(&props, m_strModule, XN_STREAM_PROPERTY_INPUT_FORMAT, (XnUInt64)XN_IO_IMAGE_FORMAT_JPEG);
}
else if (nCurrentInputFormat == XN_IO_IMAGE_FORMAT_JPEG && OutputFormat != XN_OUTPUT_FORMAT_JPEG)
{
XnPropertySetAddIntProperty(&props, m_strModule, XN_STREAM_PROPERTY_INPUT_FORMAT, (XnUInt64)XN_IMAGE_STREAM_DEFAULT_INPUT_FORMAT);
}
XnPropertySetAddIntProperty(&props, m_strModule, XN_STREAM_PROPERTY_OUTPUT_FORMAT, (XnUInt64)OutputFormat);
return m_pSensor->BatchConfig(&props);
}
void
setupPalette(HDC hDC)
{
int pixelFormat = GetPixelFormat(hDC);
PIXELFORMATDESCRIPTOR pfd;
LOGPALETTE* pPal;
int paletteSize;
DescribePixelFormat(hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
if (pfd.dwFlags & PFD_NEED_PALETTE) {
paletteSize = 1 << pfd.cColorBits;
} else {
return;
}
pPal = (LOGPALETTE*)
malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
pPal->palVersion = 0x300;
pPal->palNumEntries = paletteSize;
/* build a simple RGB color palette */
{
int redMask = (1 << pfd.cRedBits) - 1;
int greenMask = (1 << pfd.cGreenBits) - 1;
int blueMask = (1 << pfd.cBlueBits) - 1;
int i;
for (i=0; i<paletteSize; ++i) {
pPal->palPalEntry[i].peRed =
(((i >> pfd.cRedShift) & redMask) * 255) / redMask;
pPal->palPalEntry[i].peGreen =
(((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
pPal->palPalEntry[i].peBlue =
(((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;
pPal->palPalEntry[i].peFlags = 0;
}
}
hPalette = CreatePalette(pPal);
free(pPal);
if (hPalette) {
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
}
}
BOOL createRGBPalette(HDC hDC)
{
PIXELFORMATDESCRIPTOR pfd;
LOGPALETTE* pPal;
HPALETTE hPal;
int i,j,n;
/* Check to see if we need a palette */
n = GetPixelFormat(hDC);
DescribePixelFormat(hDC, n, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
if (!(pfd.dwFlags & PFD_NEED_PALETTE)) return FALSE ;
/* Allocate a log pal and fill it with the color table info */
pPal = (LOGPALETTE*) malloc(sizeof(LOGPALETTE) + 256 * sizeof(PALETTEENTRY));
pPal->palVersion = 0x300; /* Windows 3.0 */
pPal->palNumEntries = 256; /* table size */
/*/ Create palette */
n = 1 << pfd.cColorBits;
for (i=0; i<n; i++)
{
pPal->palPalEntry[i].peRed =
ComponentFromIndex(i, pfd.cRedBits, pfd.cRedShift);
pPal->palPalEntry[i].peGreen =
ComponentFromIndex(i, pfd.cGreenBits, pfd.cGreenShift);
pPal->palPalEntry[i].peBlue =
ComponentFromIndex(i, pfd.cBlueBits, pfd.cBlueShift);
pPal->palPalEntry[i].peFlags = 0;
}
if ((pfd.cColorBits == 8) &&
(pfd.cRedBits == 3) && (pfd.cRedShift == 0) &&
(pfd.cGreenBits == 3) && (pfd.cGreenShift == 3) &&
(pfd.cBlueBits == 2) && (pfd.cBlueShift == 6))
{
for (j = 1 ; j <= 12 ; j++)
pPal->palPalEntry[m_defaultOverride[j]] = m_defaultPalEntry[j];
}
hPal = CreatePalette(pPal);
SelectPalette(hDC,hPal,FALSE);
return TRUE;
}
wxIDirectFBSurfacePtr
wxIDirectFBSurface::CreateCompatible(const wxSize& sz, int flags)
{
wxSize size(sz);
if ( size == wxDefaultSize )
{
if ( !GetSize(&size.x, &size.y) )
return NULL;
}
wxCHECK_MSG( size.x > 0 && size.y > 0, NULL, "invalid size" );
DFBSurfaceDescription desc;
desc.flags = (DFBSurfaceDescriptionFlags)(
DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT);
GetCapabilities(&desc.caps);
GetPixelFormat(&desc.pixelformat);
desc.width = size.x;
desc.height = size.y;
// filter out caps that don't make sense for a new compatible surface:
int caps = desc.caps;
caps &= ~DSCAPS_PRIMARY;
caps &= ~DSCAPS_SUBSURFACE;
if ( flags & CreateCompatible_NoBackBuffer )
{
caps &= ~DSCAPS_DOUBLE;
caps &= ~DSCAPS_TRIPLE;
}
desc.caps = (DFBSurfaceCapabilities)caps;
wxIDirectFBSurfacePtr snew(wxIDirectFB::Get()->CreateSurface(&desc));
if ( !snew )
return NULL;
if ( desc.pixelformat == DSPF_LUT8 )
{
wxIDirectFBPalettePtr pal(GetPalette());
if ( pal )
{
if ( !snew->SetPalette(pal) )
return NULL;
}
}
return snew;
}
void OGLWindow::setupPalette()
{
int pixelFormat = GetPixelFormat(hDC ());
PIXELFORMATDESCRIPTOR pfd;
LOGPALETTE* pPal;
int paletteSize;
int redMask, greenMask, blueMask;
int i;
DescribePixelFormat(hDC (), pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
if (pfd.dwFlags & PFD_NEED_PALETTE)
paletteSize = 1 << pfd.cColorBits;
else
return;
pPal = (LOGPALETTE*)LocalAlloc(LPTR, sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
pPal->palVersion = 0x300;
pPal->palNumEntries = (short)paletteSize;
// build a simple RGB color palette
redMask = (1 << pfd.cRedBits) - 1;
greenMask = (1 << pfd.cGreenBits) - 1;
blueMask = (1 << pfd.cBlueBits) - 1;
for (i=0; i<paletteSize; ++i)
{ pPal->palPalEntry[i].peRed = (BYTE)(
(((i >> pfd.cRedShift) & redMask) * 255) / redMask);
pPal->palPalEntry[i].peGreen = (BYTE)(
(((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask);
pPal->palPalEntry[i].peBlue = (BYTE)(
(((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask);
pPal->palPalEntry[i].peFlags = 0;
}
hPalette_ = CreatePalette(pPal);
LocalFree(pPal);
if (hPalette_)
{
DeleteObject(SelectPalette(hDC (), hPalette_, FALSE));
RealizePalette(hDC ());
}
}
HRESULT CDecD3D11::DeliverD3D11ReadbackDirect(LAVFrame *pFrame)
{
AVD3D11VADeviceContext *pDeviceContext = (AVD3D11VADeviceContext *)((AVHWDeviceContext *)m_pDevCtx->data)->hwctx;
AVFrame *src = (AVFrame *)pFrame->priv_data;
if (m_pD3D11StagingTexture == nullptr)
{
D3D11_TEXTURE2D_DESC texDesc = { 0 };
((ID3D11Texture2D *)src->data[0])->GetDesc(&texDesc);
texDesc.ArraySize = 1;
texDesc.Usage = D3D11_USAGE_STAGING;
texDesc.BindFlags = 0;
texDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
HRESULT hr = pDeviceContext->device->CreateTexture2D(&texDesc, nullptr, &m_pD3D11StagingTexture);
if (FAILED(hr))
{
ReleaseFrame(&pFrame);
return E_FAIL;
}
}
pDeviceContext->lock(pDeviceContext->lock_ctx);
pDeviceContext->device_context->CopySubresourceRegion(m_pD3D11StagingTexture, 0, 0, 0, 0, (ID3D11Texture2D *)src->data[0], (UINT)(intptr_t)src->data[1], nullptr);
pDeviceContext->unlock(pDeviceContext->lock_ctx);
av_frame_free(&src);
D3D11DirectPrivate *c = new D3D11DirectPrivate;
c->pDeviceContex = av_buffer_ref(m_pDevCtx);
c->pStagingTexture = m_pD3D11StagingTexture;
m_pD3D11StagingTexture->AddRef();
pFrame->priv_data = c;
pFrame->destruct = d3d11_direct_free;
GetPixelFormat(&pFrame->format, &pFrame->bpp);
pFrame->direct = true;
pFrame->direct_lock = d3d11_direct_lock;
pFrame->direct_unlock = d3d11_direct_unlock;
return Deliver(pFrame);
}
