HRESULT CheckRenderD3D10::ResourceToPPM(ID3D10Device *pDevice, ID3D10Resource *pResource, const char *zFileName)
{
D3D10_RESOURCE_DIMENSION rType;
pResource->GetType(&rType);
if (rType != D3D10_RESOURCE_DIMENSION_TEXTURE2D)
{
printf("SurfaceToPPM: pResource is not a 2D texture! Aborting...\n");
return E_FAIL;
}
ID3D10Texture2D *pSourceTexture = (ID3D10Texture2D *)pResource;
ID3D10Texture2D *pTargetTexture = NULL;
D3D10_TEXTURE2D_DESC desc;
pSourceTexture->GetDesc(&desc);
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
desc.Usage = D3D10_USAGE_STAGING;
if (FAILED(pDevice->CreateTexture2D(&desc,NULL,&pTargetTexture)))
{
printf("SurfaceToPPM: Unable to create target Texture resoruce! Aborting... \n");
return E_FAIL;
}
pDevice->CopyResource(pTargetTexture,pSourceTexture);
D3D10_MAPPED_TEXTURE2D mappedTex2D;
pTargetTexture->Map(0,D3D10_MAP_READ,0,&mappedTex2D);
// Need to convert from dx pitch to pitch=width
unsigned char *pPPMData = new unsigned char[desc.Width*desc.Height*4];
for (unsigned int iHeight = 0; iHeight<desc.Height; iHeight++)
{
memcpy(&(pPPMData[iHeight*desc.Width*4]),(unsigned char *)(mappedTex2D.pData)+iHeight*mappedTex2D.RowPitch,desc.Width*4);
}
pTargetTexture->Unmap(0);
// Prepends the PPM header info and bumps byte data afterwards
sdkSavePPM4ub(zFileName, pPPMData, desc.Width, desc.Height);
delete [] pPPMData;
pTargetTexture->Release();
return S_OK;
}
void ExtractValuesFromImageFile(CHAR * szImageFile, void ** ppData,
DWORD dwStride, DWORD * pdwImageWidth, DWORD * pdwImageHeight)
{
CHAR file[MAX_PATH];
InsertDirectory(g_szFileDir, szImageFile, file);
D3DX10_IMAGE_INFO imageInfo;
D3DX10GetImageInfoFromFileA(file, 0, &imageInfo, 0);
DWORD width = imageInfo.Width;
if (pdwImageWidth) *pdwImageWidth = width;
DWORD height = imageInfo.Height;
if (pdwImageHeight) *pdwImageHeight = height;
D3DX10_IMAGE_LOAD_INFO loadInfo;
loadInfo.Width = width;
loadInfo.Height = height;
loadInfo.Depth = imageInfo.Depth;
loadInfo.FirstMipLevel = 0;
loadInfo.MipLevels = imageInfo.MipLevels;
loadInfo.Usage = D3D10_USAGE_STAGING;
loadInfo.BindFlags = 0;
loadInfo.CpuAccessFlags = D3D10_CPU_ACCESS_READ;
loadInfo.MiscFlags = 0;
loadInfo.Format = imageInfo.Format;
loadInfo.Filter = D3DX10_FILTER_NONE;
loadInfo.MipFilter = D3DX10_FILTER_NONE;
loadInfo.pSrcInfo = 0;
ID3D10Texture2D * tex;
if (FAILED(D3DX10CreateTextureFromFileA(g_pD3DDevice, file, &loadInfo, 0, (ID3D10Resource**)&tex, NULL))) {
DxUtSendErrorEx("ExtractValuesFromImageFile could not load the image file.", file);
}
*ppData = new CHAR[dwStride*width*height];
D3D10_MAPPED_TEXTURE2D map;
tex->Map(0, D3D10_MAP_READ, 0, &map);
BYTE * ar = (BYTE*)map.pData;
for (DWORD i=0; i<height; i++) {
DWORD rowStart1 = i*dwStride*width;
DWORD rowStart2 = i*dwStride*map.RowPitch/4;
for (DWORD j=0; j<dwStride*width; j++) {
((BYTE*)(*ppData))[rowStart1 + j] = ar[rowStart2 + j];
}
}
tex->Unmap(0);
ReleaseX(tex);
}
//----------------------------------------------------------------------------//
void Direct3D10Texture::blitToMemory(void* targetData)
{
if (!d_texture)
return;
String exception_msg;
D3D10_TEXTURE2D_DESC tex_desc;
d_texture->GetDesc(&tex_desc);
tex_desc.Usage = D3D10_USAGE_STAGING;
tex_desc.BindFlags = 0;
tex_desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
ID3D10Texture2D* offscreen;
if (SUCCEEDED(d_device.CreateTexture2D(&tex_desc, 0, &offscreen)))
{
d_device.CopyResource(offscreen, d_texture);
D3D10_MAPPED_TEXTURE2D mapped_tex;
if (SUCCEEDED(offscreen->Map(0, D3D10_MAP_READ, 0, &mapped_tex)))
{
blitFromSurface(static_cast<uint32*>(mapped_tex.pData),
static_cast<uint32*>(targetData),
Sizef(static_cast<float>(tex_desc.Width),
static_cast<float>(tex_desc.Height)),
mapped_tex.RowPitch);
offscreen->Unmap(0);
}
else
exception_msg.assign("ID3D10Texture2D::Map failed.");
offscreen->Release();
}
else
exception_msg.assign(
"ID3D10Device::CreateTexture2D failed for 'offscreen'.");
if (!exception_msg.empty())
CEGUI_THROW(RendererException(exception_msg));
}
void D10State::blit(unsigned int x, unsigned int y, unsigned int w, unsigned int h) {
HRESULT hr;
ods("D3D10: Blit %d %d %d %d", x, y, w, h);
if (! pTexture || ! pSRView || uiLeft == uiRight)
return;
D3D10_MAPPED_TEXTURE2D mappedTex;
hr = pTexture->Map(D3D10CalcSubresource(0, 0, 1), D3D10_MAP_WRITE_DISCARD, 0, &mappedTex);
if (FAILED(hr)) {
ods("D3D10: Failed map");
}
UCHAR* pTexels = (UCHAR*)mappedTex.pData;
for (unsigned int r=0;r< uiHeight; ++r) {
unsigned char *sptr = a_ucTexture + r * uiWidth * 4;
unsigned char *dptr = reinterpret_cast<unsigned char *>(pTexels) + r * mappedTex.RowPitch;
memcpy(dptr, sptr, uiWidth * 4);
}
pTexture->Unmap(D3D10CalcSubresource(0, 0, 1));
}
ID3D10ShaderResourceView * TextureHandler::getTextureArray(std::string textureNames) const
{
int nrOfTextures = 1;
for(unsigned int i=0;i<textureNames.size();i++)
{
if(textureNames[i]==',')
{
nrOfTextures++;
}
}
ID3D10Texture2D *GPUTexArray;
D3D10_TEXTURE2D_DESC arrayDesc;
for(int i=0;i<nrOfTextures;i++)
{
int pos = textureNames.find_first_of(",");
string name;
if(pos==string::npos)
{
name = textureNames;
textureNames.clear();
}
else
{
name = textureNames.substr(0,pos);
textureNames.erase(0,pos+1);
}
bool textureFound = false;
for(unsigned int j=0;j<mTextures.size();j++)
{
if(name==mTextures[j]->getName())
{
ID3D10Texture2D * texture;
texture = mTextures[j]->getCPUTexture();
if(i==0)
{
D3D10_TEXTURE2D_DESC firstTexDesc;
texture->GetDesc(&firstTexDesc);
ZeroMemory(&arrayDesc, sizeof(D3D10_TEXTURE2D_DESC));
arrayDesc.Width = firstTexDesc.Width;
arrayDesc.Height = firstTexDesc.Height;
arrayDesc.MipLevels = 1;
arrayDesc.Format = firstTexDesc.Format;
arrayDesc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
arrayDesc.Usage = D3D10_USAGE_DEFAULT;
arrayDesc.ArraySize = nrOfTextures;
arrayDesc.SampleDesc = firstTexDesc.SampleDesc;
arrayDesc.CPUAccessFlags = 0;
arrayDesc.MiscFlags = 0;
if(FAILED(mpDevice->CreateTexture2D(&arrayDesc, NULL, &GPUTexArray)))
{
DEBUG_MESSAGE("Failed to create GPUTexArray.");
return NULL;
}
}
else
{
D3D10_TEXTURE2D_DESC texDesc;
texture->GetDesc(&texDesc);
if(texDesc.Width!=arrayDesc.Width)
{
DEBUG_MESSAGE("Trying to create a texture array from textures with different width.");
return NULL;
}
else if(texDesc.Height!=arrayDesc.Height)
{
DEBUG_MESSAGE("Trying to create a texture array from textures with different height.");
return NULL;
}
}
D3D10_MAPPED_TEXTURE2D texMap;
texture->Map(0,D3D10_MAP_READ,0,&texMap);
unsigned int SRIndex = D3D10CalcSubresource(0,i,1);
mpDevice->UpdateSubresource(GPUTexArray, SRIndex, NULL, texMap.pData, texMap.RowPitch, 1);
texture->Unmap(0);
textureFound = true;
break;
}
}
if(!textureFound)
{
DEBUG_MESSAGE("Could not find a texture with the name: "<<name);
return NULL;
}
}
D3D10_SHADER_RESOURCE_VIEW_DESC SRVDesc;
ZeroMemory(&SRVDesc, sizeof(D3D10_SHADER_RESOURCE_VIEW_DESC));
SRVDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2DARRAY;
SRVDesc.Format = arrayDesc.Format;
SRVDesc.Texture2DArray.ArraySize = nrOfTextures;
SRVDesc.Texture2DArray.FirstArraySlice = 0;
SRVDesc.Texture2DArray.MipLevels = 1;
SRVDesc.Texture2DArray.MostDetailedMip = 0;
ID3D10ShaderResourceView *texArraySRV = NULL;
if(FAILED(mpDevice->CreateShaderResourceView(GPUTexArray, &SRVDesc, &texArraySRV)))
{
DEBUG_MESSAGE("Failed to create Tex2DArray ShaderResourceView.");
return NULL;
}
return texArraySRV;
}
// Detour function that replaces the IDXGISwapChain::Present() API
DllExport HRESULT __stdcall
hook_DXGISwapChainPresent(
IDXGISwapChain * This,
UINT SyncInterval,
UINT Flags
)
{
static int frame_interval;
static LARGE_INTEGER initialTv, captureTv, freq;
static int capture_initialized = 0;
//
int i;
struct pooldata *data;
struct vsource_frame *frame;
//
DXGI_SWAP_CHAIN_DESC pDESC;
HRESULT hr = pDXGISwapChainPresent(This, SyncInterval, Flags);
if(resolution_retrieved == 0) {
if(DXGI_get_resolution(This) >= 0) {
resolution_retrieved = 1;
}
return hr;
}
if(vsource_initialized == 0) {
ga_error("video source not initialized.\n");
return hr;
}
This->GetDesc(&pDESC);
pDXGI_FORMAT = pDESC.BufferDesc.Format; // extract screen format for sws_scale
if(pDESC.BufferDesc.Width != game_width
|| pDESC.BufferDesc.Height != game_height) {
ga_error("game width/height mismatched (%dx%d) != (%dx%d)\n",
pDESC.BufferDesc.Width, pDESC.BufferDesc.Height,
game_width, game_height);
return hr;
}
//
if (enable_server_rate_control && ga_hook_video_rate_control() < 0)
return hr;
if (dx_version == dx_none) {
//bool check_result = FALSE;
if (check_dx_device_version(This, IID_ID3D10Device)) {
dx_version = dx_10;
ga_error("[DXGISwapChain] DirectX 10\n");
} else if (check_dx_device_version(This, IID_ID3D10Device1)) {
dx_version = dx_10_1;
ga_error("[DXGISwapChain] DirectX 10.1\n");
} else if (check_dx_device_version(This, IID_ID3D11Device)) {
dx_version = dx_11;
ga_error("[DXGISwapChain] DirectX 11\n");
}
}
if (capture_initialized == 0) {
frame_interval = 1000000/video_fps; // in the unif of us
frame_interval++;
QueryPerformanceFrequency(&freq);
QueryPerformanceCounter(&initialTv);
capture_initialized = 1;
} else {
QueryPerformanceCounter(&captureTv);
}
hr = 0;
// d3d10 / d3d10.1
if (dx_version == dx_10 || dx_version == dx_10_1) {
void *ppDevice;
ID3D10Device *pDevice;
//IUnknown *pDevice;
if (dx_version == dx_10) {
This->GetDevice(IID_ID3D10Device, &ppDevice);
pDevice = (ID3D10Device *)ppDevice;
} else if (dx_version == dx_10_1) {
This->GetDevice(IID_ID3D10Device1, &ppDevice);
pDevice = (ID3D10Device1 *)ppDevice;
} else {
OutputDebugString("Invalid DirectX version in IDXGISwapChain::Present");
return hr;
}
ID3D10RenderTargetView *pRTV = NULL;
ID3D10Resource *pSrcResource = NULL;
pDevice->OMGetRenderTargets(1, &pRTV, NULL);
pRTV->GetResource(&pSrcResource);
ID3D10Texture2D* pSrcBuffer = (ID3D10Texture2D *)pSrcResource;
ID3D10Texture2D* pDstBuffer = NULL;
D3D10_TEXTURE2D_DESC desc;
pSrcBuffer->GetDesc(&desc);
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
desc.Usage = D3D10_USAGE_STAGING;
hr = pDevice->CreateTexture2D(&desc, NULL, &pDstBuffer);
if (FAILED(hr)) {
OutputDebugString("Failed to create texture2D");
//assert(exp_state == exp_none);
}
pDevice->CopyResource(pDstBuffer, pSrcBuffer);
D3D10_MAPPED_TEXTURE2D mapped_screen;
hr = pDstBuffer->Map(0, D3D10_MAP_READ, 0, &mapped_screen);
if (FAILED(hr)) {
OutputDebugString("Failed to map from DstBuffer");
//assert(exp_state == exp_none);
}
// copy image
do {
unsigned char *src, *dst;
data = g_pipe[0]->allocate_data();
frame = (struct vsource_frame*) data->ptr;
frame->pixelformat = PIX_FMT_BGRA;
frame->realwidth = desc.Width;
frame->realheight = desc.Height;
frame->realstride = desc.Width<<2;
frame->realsize = frame->realwidth * frame->realstride;
frame->linesize[0] = frame->realstride;//frame->stride;
//
src = (unsigned char*) mapped_screen.pData;
dst = (unsigned char*) frame->imgbuf;
for (i = 0; i < encoder_height; i++) {
CopyMemory(dst, src, frame->realstride/*frame->stride*/);
src += mapped_screen.RowPitch;
dst += frame->realstride;//frame->stride;
}
frame->imgpts = pcdiff_us(captureTv, initialTv, freq)/frame_interval;
} while(0);
// duplicate from channel 0 to other channels
for(i = 1; i < SOURCES; i++) {
int j;
struct pooldata *dupdata;
struct vsource_frame *dupframe;
dupdata = g_pipe[i]->allocate_data();
dupframe = (struct vsource_frame*) dupdata->ptr;
//
vsource_dup_frame(frame, dupframe);
//
g_pipe[i]->store_data(dupdata);
g_pipe[i]->notify_all();
}
g_pipe[0]->store_data(data);
g_pipe[0]->notify_all();
pDstBuffer->Unmap(0);
pDevice->Release();
pSrcResource->Release();
pSrcBuffer->Release();
pRTV->Release();
pDstBuffer->Release();
// d11
} else if (dx_version == dx_11) {
void *ppDevice;
This->GetDevice(IID_ID3D11Device, &ppDevice);
ID3D11Device *pDevice = (ID3D11Device*) ppDevice;
This->GetDevice(IID_ID3D11DeviceContext, &ppDevice);
ID3D11DeviceContext *pDeviceContext = (ID3D11DeviceContext *) ppDevice;
ID3D11RenderTargetView *pRTV = NULL;
ID3D11Resource *pSrcResource = NULL;
pDeviceContext->OMGetRenderTargets(1, &pRTV, NULL);
pRTV->GetResource(&pSrcResource);
ID3D11Texture2D *pSrcBuffer = (ID3D11Texture2D *)pSrcResource;
ID3D11Texture2D *pDstBuffer = NULL;
D3D11_TEXTURE2D_DESC desc;
pSrcBuffer->GetDesc(&desc);
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
desc.Usage = D3D11_USAGE_STAGING;
hr = pDevice->CreateTexture2D(&desc, NULL, &pDstBuffer);
if (FAILED(hr)) {
OutputDebugString("Failed to create buffer");
//assert(exp_state == exp_none);
}
pDeviceContext->CopyResource(pDstBuffer, pSrcBuffer);
D3D11_MAPPED_SUBRESOURCE mapped_screen;
hr = pDeviceContext->Map(pDstBuffer, 0, D3D11_MAP_READ, 0, &mapped_screen);
if (FAILED(hr)) {
OutputDebugString("Failed to map from DeviceContext");
//assert(exp_state == exp_none);
}
// copy image
do {
unsigned char *src, *dst;
data = g_pipe[0]->allocate_data();
frame = (struct vsource_frame*) data->ptr;
frame->pixelformat = PIX_FMT_BGRA;
frame->realwidth = desc.Width;
frame->realheight = desc.Height;
frame->realstride = desc.Width<<2;
frame->realsize = frame->realwidth * frame->realstride;
frame->linesize[0] = frame->realstride;//frame->stride;
//
src = (unsigned char*) mapped_screen.pData;
dst = (unsigned char*) frame->imgbuf;
for (i = 0; i < encoder_height; i++) {
CopyMemory(dst, src, frame->realstride/*frame->stride*/);
src += mapped_screen.RowPitch;
dst += frame->realstride;//frame->stride;
}
frame->imgpts = pcdiff_us(captureTv, initialTv, freq)/frame_interval;
} while(0);
// duplicate from channel 0 to other channels
for(i = 1; i < SOURCES; i++) {
int j;
struct pooldata *dupdata;
struct vsource_frame *dupframe;
dupdata = g_pipe[i]->allocate_data();
dupframe = (struct vsource_frame*) dupdata->ptr;
//
vsource_dup_frame(frame, dupframe);
//
g_pipe[i]->store_data(dupdata);
g_pipe[i]->notify_all();
}
g_pipe[0]->store_data(data);
g_pipe[0]->notify_all();
pDeviceContext->Unmap(pDstBuffer, 0);
pDevice->Release();
pDeviceContext->Release();
pSrcResource->Release();
pSrcBuffer->Release();
pRTV->Release();
pDstBuffer->Release();
}
return hr;
}
ID3D10ShaderResourceView * TextureHandler::getTextureArraySize(SizeTypes sizeType) const
{
ID3D10Texture2D *GPUTexArray = NULL;
D3D10_TEXTURE2D_DESC arrayDesc;
ZeroMemory(&arrayDesc, sizeof(D3D10_TEXTURE2D_DESC));
if(sizeType == SizeType_128)
{
if(mTextures128.empty())
{
return NULL;
}
for(unsigned int i=0; i<mTextures128.size(); i++)
{
ID3D10Texture2D * texture = mTextures128[i]->getCPUTexture();
D3D10_TEXTURE2D_DESC texDesc;
texture->GetDesc(&texDesc);
if(i == 0)
{
ZeroMemory(&arrayDesc, sizeof(D3D10_TEXTURE2D_DESC));
arrayDesc.Width = 128;
arrayDesc.Height = 128;
arrayDesc.MipLevels = 1;
arrayDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
arrayDesc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
arrayDesc.Usage = D3D10_USAGE_DEFAULT;
arrayDesc.ArraySize = mTextures128.size();
arrayDesc.SampleDesc = texDesc.SampleDesc;
arrayDesc.CPUAccessFlags = 0;
arrayDesc.MiscFlags = 0;
if(FAILED(mpDevice->CreateTexture2D(&arrayDesc, NULL, &GPUTexArray)))
{
ERROR_MESSAGE("Failed to create GPUTexArray.");
return NULL;
}
}
D3D10_BOX box;
box.left = 0;
box.right = texDesc.Width;
box.top = 0;
box.bottom = texDesc.Height;
box.front = 0;
box.back = 1;
D3D10_MAPPED_TEXTURE2D texMap;
texture->Map(0,D3D10_MAP_READ,0,&texMap);
mpDevice->UpdateSubresource(GPUTexArray, D3D10CalcSubresource(0,i,1), &box, texMap.pData, texMap.RowPitch, 1);
texture->Unmap(0);
}
D3D10_SHADER_RESOURCE_VIEW_DESC SRVDesc;
ZeroMemory(&SRVDesc, sizeof(D3D10_SHADER_RESOURCE_VIEW_DESC));
SRVDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2DARRAY;
SRVDesc.Format = arrayDesc.Format;
SRVDesc.Texture2DArray.ArraySize = mTextures128.size();
SRVDesc.Texture2DArray.FirstArraySlice = 0;
SRVDesc.Texture2DArray.MipLevels = 1;
SRVDesc.Texture2DArray.MostDetailedMip = 0;
ID3D10ShaderResourceView *texArraySRV = NULL;
HRESULT error = mpDevice->CreateShaderResourceView(GPUTexArray, &SRVDesc, &texArraySRV);
if(FAILED(error))
{
ERROR_MESSAGE("Failed to create Tex2DArray ShaderResourceView.");
ERROR_MESSAGE(DXGetErrorDescriptionA(error));
return NULL;
}
return texArraySRV;
}
else if(sizeType == SizeType_256)
{
if(mTextures256.empty())
{
return NULL;
}
for(unsigned int i=0; i<mTextures256.size(); i++)
{
ID3D10Texture2D * texture = mTextures256[i]->getCPUTexture();
D3D10_TEXTURE2D_DESC texDesc;
texture->GetDesc(&texDesc);
if(i == 0)
{
ZeroMemory(&arrayDesc, sizeof(D3D10_TEXTURE2D_DESC));
arrayDesc.Width = 256;
arrayDesc.Height = 256;
arrayDesc.MipLevels = 1;
arrayDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
arrayDesc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
arrayDesc.Usage = D3D10_USAGE_DEFAULT;
arrayDesc.ArraySize = mTextures256.size();
arrayDesc.SampleDesc = texDesc.SampleDesc;
arrayDesc.CPUAccessFlags = 0;
arrayDesc.MiscFlags = 0;
if(FAILED(mpDevice->CreateTexture2D(&arrayDesc, NULL, &GPUTexArray)))
{
ERROR_MESSAGE("Failed to create GPUTexArray.");
return NULL;
}
}
D3D10_BOX box;
box.left = 0;
box.right = texDesc.Width;
box.top = 0;
box.bottom = texDesc.Height;
box.front = 0;
box.back = 1;
D3D10_MAPPED_TEXTURE2D texMap;
texture->Map(0,D3D10_MAP_READ,0,&texMap);
mpDevice->UpdateSubresource(GPUTexArray, D3D10CalcSubresource(0,i,1), &box, texMap.pData, texMap.RowPitch, 1);
texture->Unmap(0);
}
D3D10_SHADER_RESOURCE_VIEW_DESC SRVDesc;
ZeroMemory(&SRVDesc, sizeof(D3D10_SHADER_RESOURCE_VIEW_DESC));
SRVDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2DARRAY;
SRVDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
SRVDesc.Texture2DArray.ArraySize = mTextures256.size();
SRVDesc.Texture2DArray.FirstArraySlice = 0;
SRVDesc.Texture2DArray.MipLevels = 1;
SRVDesc.Texture2DArray.MostDetailedMip = 0;
ID3D10ShaderResourceView *texArraySRV = NULL;
HRESULT error = mpDevice->CreateShaderResourceView(GPUTexArray, &SRVDesc, &texArraySRV);
if(FAILED(error))
{
ERROR_MESSAGE("Failed to create Tex2DArray ShaderResourceView.");
ERROR_MESSAGE(DXGetErrorDescriptionA(error));
return NULL;
}
return texArraySRV;
}else if(sizeType == SizeType_512)
{
if(mTextures512.empty())
{
return NULL;
}
for(unsigned int i=0; i<mTextures512.size(); i++)
{
ID3D10Texture2D * texture = mTextures512[i]->getCPUTexture();
D3D10_TEXTURE2D_DESC texDesc;
texture->GetDesc(&texDesc);
if(i == 0)
{
ZeroMemory(&arrayDesc, sizeof(D3D10_TEXTURE2D_DESC));
arrayDesc.Width = 512;
arrayDesc.Height = 512;
arrayDesc.MipLevels = 1;
arrayDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
arrayDesc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
arrayDesc.Usage = D3D10_USAGE_DEFAULT;
arrayDesc.ArraySize = mTextures512.size();
arrayDesc.SampleDesc = texDesc.SampleDesc;
arrayDesc.CPUAccessFlags = 0;
arrayDesc.MiscFlags = 0;
if(FAILED(mpDevice->CreateTexture2D(&arrayDesc, NULL, &GPUTexArray)))
{
ERROR_MESSAGE("Failed to create GPUTexArray.");
return NULL;
}
}
D3D10_BOX box;
box.left = 0;
box.right = texDesc.Width;
box.top = 0;
box.bottom = texDesc.Height;
box.front = 0;
box.back = 1;
D3D10_MAPPED_TEXTURE2D texMap;
texture->Map(0,D3D10_MAP_READ,0,&texMap);
mpDevice->UpdateSubresource(GPUTexArray, D3D10CalcSubresource(0,i,1), &box, texMap.pData, texMap.RowPitch, 1);
texture->Unmap(0);
}
D3D10_SHADER_RESOURCE_VIEW_DESC SRVDesc;
ZeroMemory(&SRVDesc, sizeof(D3D10_SHADER_RESOURCE_VIEW_DESC));
SRVDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2DARRAY;
SRVDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
SRVDesc.Texture2DArray.ArraySize = mTextures512.size();
SRVDesc.Texture2DArray.FirstArraySlice = 0;
SRVDesc.Texture2DArray.MipLevels = 1;
SRVDesc.Texture2DArray.MostDetailedMip = 0;
ID3D10ShaderResourceView *texArraySRV = NULL;
HRESULT error = mpDevice->CreateShaderResourceView(GPUTexArray, &SRVDesc, &texArraySRV);
if(FAILED(error))
{
ERROR_MESSAGE("Failed to create Tex2DArray ShaderResourceView.");
ERROR_MESSAGE(DXGetErrorDescriptionA(error));
return NULL;
}
return texArraySRV;
}
else if(sizeType == SizeType_1024)
{
if(mTextures1024.empty())
{
return NULL;
}
for(unsigned int i=0; i<mTextures1024.size(); i++)
{
ID3D10Texture2D * texture = mTextures1024[i]->getCPUTexture();
D3D10_TEXTURE2D_DESC texDesc;
texture->GetDesc(&texDesc);
if(i == 0)
{
ZeroMemory(&arrayDesc, sizeof(D3D10_TEXTURE2D_DESC));
arrayDesc.Width = 1024;
arrayDesc.Height = 1024;
arrayDesc.MipLevels = 1;
arrayDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
arrayDesc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
arrayDesc.Usage = D3D10_USAGE_DEFAULT;
arrayDesc.ArraySize = mTextures1024.size();
arrayDesc.SampleDesc = texDesc.SampleDesc;
arrayDesc.CPUAccessFlags = 0;
arrayDesc.MiscFlags = 0;
if(FAILED(mpDevice->CreateTexture2D(&arrayDesc, NULL, &GPUTexArray)))
{
ERROR_MESSAGE("Failed to create GPUTexArray.");
return NULL;
}
}
D3D10_BOX box;
box.left = 0;
box.right = texDesc.Width;
box.top = 0;
box.bottom = texDesc.Height;
box.front = 0;
box.back = 1;
D3D10_MAPPED_TEXTURE2D texMap;
texture->Map(0,D3D10_MAP_READ,0,&texMap);
mpDevice->UpdateSubresource(GPUTexArray, D3D10CalcSubresource(0,i,1), &box, texMap.pData, texMap.RowPitch, 1);
texture->Unmap(0);
}
D3D10_SHADER_RESOURCE_VIEW_DESC SRVDesc;
ZeroMemory(&SRVDesc, sizeof(D3D10_SHADER_RESOURCE_VIEW_DESC));
SRVDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2DARRAY;
SRVDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
SRVDesc.Texture2DArray.ArraySize = mTextures1024.size();
SRVDesc.Texture2DArray.FirstArraySlice = 0;
SRVDesc.Texture2DArray.MipLevels = 1;
SRVDesc.Texture2DArray.MostDetailedMip = 0;
ID3D10ShaderResourceView *texArraySRV = NULL;
HRESULT error = mpDevice->CreateShaderResourceView(GPUTexArray, &SRVDesc, &texArraySRV);
if(FAILED(error))
{
ERROR_MESSAGE("Failed to create Tex2DArray ShaderResourceView.");
ERROR_MESSAGE(DXGetErrorDescriptionA(error));
return NULL;
}
return texArraySRV;
}
return NULL;
}
void TextureHandler::addTexture(std::string fileName, std::string textureName)
{
ID3D10ShaderResourceView * rv;
ID3D10Texture2D * GPUTexture;
ID3D10Texture2D * CPUTexture;
D3DX10_IMAGE_LOAD_INFO loadInfo;
ZeroMemory(&loadInfo,sizeof(D3DX10_IMAGE_LOAD_INFO));
loadInfo.Width = D3DX10_DEFAULT;
loadInfo.Height = D3DX10_DEFAULT;
loadInfo.BindFlags = 0;
loadInfo.Depth = D3DX10_DEFAULT;
loadInfo.Filter = D3DX10_DEFAULT;
loadInfo.FirstMipLevel = D3DX10_DEFAULT;
loadInfo.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
loadInfo.MipFilter = D3DX10_DEFAULT;
loadInfo.MiscFlags = D3DX10_DEFAULT;
loadInfo.pSrcInfo = 0;
loadInfo.Usage = D3D10_USAGE_STAGING;
loadInfo.CpuAccessFlags = D3D10_CPU_ACCESS_READ | D3D10_CPU_ACCESS_WRITE;
HRESULT hr = D3DX10CreateTextureFromFile(mpDevice, fileName.c_str(), &loadInfo, NULL, (ID3D10Resource**)&CPUTexture, NULL );
if(FAILED(hr))
{
ERROR_MESSAGE("Failed to create CPU texture from file: "<<fileName);
return;
}
D3D10_TEXTURE2D_DESC texDesc;
CPUTexture->GetDesc(&texDesc);
if(texDesc.Width > 1024)
{
ERROR_MESSAGE("Can't load textures wider than 1024 pixels. filename: "<<fileName);
return;
}
else if(texDesc.Height > 1024)
{
ERROR_MESSAGE("Can't load textures higher than 1024 pixels. filename: "<<fileName);
return;
}
SizeTypes type;
if(texDesc.Width > 512 || texDesc.Height > 512)
{
type = TextureHandler::SizeType_1024;
}
else if(texDesc.Width > 256 || texDesc.Height > 256)
{
type = TextureHandler::SizeType_512;
}
else if(texDesc.Width > 128 || texDesc.Height > 128)
{
type = TextureHandler::SizeType_256;
}
else
{
type = TextureHandler::SizeType_128;
}
D3D10_MAPPED_TEXTURE2D texMap;
CPUTexture->Map(0, D3D10_MAP_WRITE, 0, &texMap);
((byte*)texMap.pData)[0] = percent(texDesc.Width, type);
((byte*)texMap.pData)[1] = percent(texDesc.Height, type);
((byte*)texMap.pData)[texDesc.Width] = 255;
ZeroMemory(&loadInfo,sizeof(D3DX10_IMAGE_LOAD_INFO));
loadInfo.Width = D3DX10_DEFAULT;
loadInfo.Height = D3DX10_DEFAULT;
loadInfo.BindFlags = D3D10_BIND_SHADER_RESOURCE;
loadInfo.Depth = D3DX10_DEFAULT;
loadInfo.Filter = D3DX10_DEFAULT;
loadInfo.FirstMipLevel = D3DX10_DEFAULT;
loadInfo.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
loadInfo.MipFilter = D3DX10_DEFAULT;
loadInfo.MiscFlags = D3DX10_DEFAULT;
loadInfo.pSrcInfo = 0;
loadInfo.Usage = D3D10_USAGE_DEFAULT;
loadInfo.CpuAccessFlags = 0;
hr = D3DX10CreateTextureFromFile(mpDevice, fileName.c_str(), &loadInfo, NULL, (ID3D10Resource**)&GPUTexture, NULL );
if(FAILED(hr))
{
ERROR_MESSAGE("Failed to create GPU texture from file: "<<fileName);
return;
}
byte * n00b = myNew byte[1024 * 1024 * 4];
for(unsigned int y=0; y<texDesc.Height; y++)
{
for(unsigned int x=0; x<texDesc.Width; x++)
{
n00b[y * texDesc.Width * 4 + x * 4 + 0] = ((byte*)texMap.pData)[y * texDesc.Width * 4 + x * 4 + 0];
n00b[y * texDesc.Width * 4 + x * 4 + 1] = ((byte*)texMap.pData)[y * texDesc.Width * 4 + x * 4 + 1];
n00b[y * texDesc.Width * 4 + x * 4 + 2] = ((byte*)texMap.pData)[y * texDesc.Width * 4 + x * 4 + 2];
n00b[y * texDesc.Width * 4 + x * 4 + 3] = 255;
}
}
CPUTexture->Unmap(0);
//n00b[0] = 255;//percent(texDesc.Width);
//n00b[1] = 255;//100;//percent(texDesc.Height);
mpDevice->UpdateSubresource(GPUTexture, D3D10CalcSubresource(0, 0, 1), NULL, n00b, texDesc.Width * 4, texDesc.Width * texDesc.Height * 4);
SAFE_DELETE(n00b);
D3D10_SHADER_RESOURCE_VIEW_DESC viewDesc;
viewDesc.Format = texDesc.Format;
viewDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D;
viewDesc.Texture2D.MipLevels = 1;
viewDesc.Texture2D.MostDetailedMip = 0;
hr = mpDevice->CreateShaderResourceView(GPUTexture,&viewDesc,&rv);
GPUTexture->Release();
if(FAILED(hr))
{
ERROR_MESSAGE("Failed to create GPU resource View. Filename: "<<fileName);
ERROR_MESSAGE(DXGetErrorDescriptionA(hr));
return;
}
Texture * texture = myNew Texture(rv, CPUTexture, textureName);
if(texDesc.Width > 512 || texDesc.Height > 512)
{
mTextures1024.push_back(texture);
}
else if(texDesc.Width > 256 || texDesc.Height > 256)
{
mTextures512.push_back(texture);
}
else if(texDesc.Width > 128 || texDesc.Height > 128)
{
mTextures256.push_back(texture);
}
else
{
mTextures128.push_back(texture);
}
mTextures.push_back(texture);
}
//todo: this function is an abomination, this is just disgusting. fix it.
//...seriously, this is really, really horrible. I mean this is amazingly bad.
void OBS::MainCaptureLoop()
{
int curRenderTarget = 0, curYUVTexture = 0, curCopyTexture = 0;
int copyWait = NUM_RENDER_BUFFERS-1;
bSentHeaders = false;
bFirstAudioPacket = true;
bool bLogLongFramesProfile = GlobalConfig->GetInt(TEXT("General"), TEXT("LogLongFramesProfile"), LOGLONGFRAMESDEFAULT) != 0;
float logLongFramesProfilePercentage = GlobalConfig->GetFloat(TEXT("General"), TEXT("LogLongFramesProfilePercentage"), 10.f);
Vect2 baseSize = Vect2(float(baseCX), float(baseCY));
Vect2 outputSize = Vect2(float(outputCX), float(outputCY));
Vect2 scaleSize = Vect2(float(scaleCX), float(scaleCY));
HANDLE hMatrix = yuvScalePixelShader->GetParameterByName(TEXT("yuvMat"));
HANDLE hScaleVal = yuvScalePixelShader->GetParameterByName(TEXT("baseDimensionI"));
//----------------------------------------
// x264 input buffers
int curOutBuffer = 0;
bool bUsingQSV = videoEncoder->isQSV();//GlobalConfig->GetInt(TEXT("Video Encoding"), TEXT("UseQSV")) != 0;
bUsing444 = false;
EncoderPicture lastPic;
EncoderPicture outPics[NUM_OUT_BUFFERS];
for(int i=0; i<NUM_OUT_BUFFERS; i++)
{
if(bUsingQSV)
{
outPics[i].mfxOut = new mfxFrameSurface1;
memset(outPics[i].mfxOut, 0, sizeof(mfxFrameSurface1));
mfxFrameData& data = outPics[i].mfxOut->Data;
videoEncoder->RequestBuffers(&data);
}
else
{
outPics[i].picOut = new x264_picture_t;
x264_picture_init(outPics[i].picOut);
}
}
if(bUsing444)
{
for(int i=0; i<NUM_OUT_BUFFERS; i++)
{
outPics[i].picOut->img.i_csp = X264_CSP_BGRA; //although the x264 input says BGR, x264 actually will expect packed UYV
outPics[i].picOut->img.i_plane = 1;
}
}
else
{
if(!bUsingQSV)
for(int i=0; i<NUM_OUT_BUFFERS; i++)
x264_picture_alloc(outPics[i].picOut, X264_CSP_NV12, outputCX, outputCY);
}
int bCongestionControl = AppConfig->GetInt (TEXT("Video Encoding"), TEXT("CongestionControl"), 0);
bool bDynamicBitrateSupported = App->GetVideoEncoder()->DynamicBitrateSupported();
int defaultBitRate = AppConfig->GetInt(TEXT("Video Encoding"), TEXT("MaxBitrate"), 1000);
int currentBitRate = defaultBitRate;
QWORD lastAdjustmentTime = 0;
UINT adjustmentStreamId = 0;
//std::unique_ptr<ProfilerNode> encodeThreadProfiler;
//----------------------------------------
// time/timestamp stuff
bool bWasLaggedFrame = false;
totalStreamTime = 0;
lastAudioTimestamp = 0;
//----------------------------------------
// start audio capture streams
desktopAudio->StartCapture();
if(micAudio) micAudio->StartCapture();
//----------------------------------------
// status bar/statistics stuff
DWORD fpsCounter = 0;
int numLongFrames = 0;
int numTotalFrames = 0;
bytesPerSec = 0;
captureFPS = 0;
curFramesDropped = 0;
curStrain = 0.0;
PostMessage(hwndMain, OBS_UPDATESTATUSBAR, 0, 0);
QWORD lastBytesSent[3] = {0, 0, 0};
DWORD lastFramesDropped = 0;
double bpsTime = 0.0;
double lastStrain = 0.0f;
DWORD numSecondsWaited = 0;
//----------------------------------------
// 444->420 thread data
int numThreads = MAX(OSGetTotalCores()-2, 1);
HANDLE *h420Threads = (HANDLE*)Allocate(sizeof(HANDLE)*numThreads);
Convert444Data *convertInfo = (Convert444Data*)Allocate(sizeof(Convert444Data)*numThreads);
zero(h420Threads, sizeof(HANDLE)*numThreads);
zero(convertInfo, sizeof(Convert444Data)*numThreads);
for(int i=0; i<numThreads; i++)
{
convertInfo[i].width = outputCX;
convertInfo[i].height = outputCY;
convertInfo[i].hSignalConvert = CreateEvent(NULL, FALSE, FALSE, NULL);
convertInfo[i].hSignalComplete = CreateEvent(NULL, FALSE, FALSE, NULL);
convertInfo[i].bNV12 = bUsingQSV;
convertInfo[i].numThreads = numThreads;
if(i == 0)
convertInfo[i].startY = 0;
else
convertInfo[i].startY = convertInfo[i-1].endY;
if(i == (numThreads-1))
convertInfo[i].endY = outputCY;
else
convertInfo[i].endY = ((outputCY/numThreads)*(i+1)) & 0xFFFFFFFE;
}
bool bEncode;
bool bFirstFrame = true;
bool bFirstImage = true;
bool bFirstEncode = true;
bool bUseThreaded420 = bUseMultithreadedOptimizations && (OSGetTotalCores() > 1) && !bUsing444;
List<HANDLE> completeEvents;
if(bUseThreaded420)
{
for(int i=0; i<numThreads; i++)
{
h420Threads[i] = OSCreateThread((XTHREAD)Convert444Thread, convertInfo+i);
completeEvents << convertInfo[i].hSignalComplete;
}
}
//----------------------------------------
QWORD streamTimeStart = GetQPCTimeNS();
QWORD lastStreamTime = 0;
QWORD firstFrameTimeMS = streamTimeStart/1000000;
QWORD frameLengthNS = 1000000000/fps;
while(WaitForSingleObject(hVideoEvent, INFINITE) == WAIT_OBJECT_0)
{
if (bShutdownVideoThread)
break;
QWORD renderStartTime = GetQPCTimeNS();
totalStreamTime = DWORD((renderStartTime-streamTimeStart)/1000000);
bool bRenderView = !IsIconic(hwndMain) && bRenderViewEnabled;
QWORD renderStartTimeMS = renderStartTime/1000000;
QWORD curStreamTime = latestVideoTimeNS;
if (!lastStreamTime)
lastStreamTime = curStreamTime-frameLengthNS;
QWORD frameDelta = curStreamTime-lastStreamTime;
//if (!lastStreamTime)
// lastStreamTime = renderStartTime-frameLengthNS;
//QWORD frameDelta = renderStartTime-lastStreamTime;
double fSeconds = double(frameDelta)*0.000000001;
//lastStreamTime = renderStartTime;
bool bUpdateBPS = false;
profileIn("video thread frame");
//Log(TEXT("Stream Time: %llu"), curStreamTime);
//Log(TEXT("frameDelta: %lf"), fSeconds);
//------------------------------------
if(bRequestKeyframe && keyframeWait > 0)
{
keyframeWait -= int(frameDelta);
if(keyframeWait <= 0)
{
GetVideoEncoder()->RequestKeyframe();
bRequestKeyframe = false;
}
}
if(!pushToTalkDown && pushToTalkTimeLeft > 0)
{
pushToTalkTimeLeft -= int(frameDelta);
OSDebugOut(TEXT("time left: %d\r\n"), pushToTalkTimeLeft);
if(pushToTalkTimeLeft <= 0)
{
pushToTalkTimeLeft = 0;
bPushToTalkOn = false;
}
}
//------------------------------------
OSEnterMutex(hSceneMutex);
if (bPleaseEnableProjector)
ActuallyEnableProjector();
else if(bPleaseDisableProjector)
DisableProjector();
if(bResizeRenderView)
{
GS->ResizeView();
bResizeRenderView = false;
}
//------------------------------------
if(scene)
{
profileIn("scene->Preprocess");
scene->Preprocess();
for(UINT i=0; i<globalSources.Num(); i++)
globalSources[i].source->Preprocess();
profileOut;
scene->Tick(float(fSeconds));
for(UINT i=0; i<globalSources.Num(); i++)
globalSources[i].source->Tick(float(fSeconds));
}
//------------------------------------
QWORD curBytesSent = 0;
if (network) {
curBytesSent = network->GetCurrentSentBytes();
curFramesDropped = network->NumDroppedFrames();
} else if (numSecondsWaited) {
//reset stats if the network disappears
bytesPerSec = 0;
bpsTime = 0;
numSecondsWaited = 0;
curBytesSent = 0;
zero(lastBytesSent, sizeof(lastBytesSent));
}
bpsTime += fSeconds;
if(bpsTime > 1.0f)
{
if(numSecondsWaited < 3)
++numSecondsWaited;
//bytesPerSec = DWORD(curBytesSent - lastBytesSent);
bytesPerSec = DWORD(curBytesSent - lastBytesSent[0]) / numSecondsWaited;
if(bpsTime > 2.0)
bpsTime = 0.0f;
else
bpsTime -= 1.0;
if(numSecondsWaited == 3)
{
lastBytesSent[0] = lastBytesSent[1];
lastBytesSent[1] = lastBytesSent[2];
lastBytesSent[2] = curBytesSent;
}
else
lastBytesSent[numSecondsWaited] = curBytesSent;
captureFPS = fpsCounter;
fpsCounter = 0;
bUpdateBPS = true;
}
fpsCounter++;
if(network) curStrain = network->GetPacketStrain();
EnableBlending(TRUE);
BlendFunction(GS_BLEND_SRCALPHA, GS_BLEND_INVSRCALPHA);
//------------------------------------
// render the mini render texture
LoadVertexShader(mainVertexShader);
LoadPixelShader(mainPixelShader);
SetRenderTarget(mainRenderTextures[curRenderTarget]);
Ortho(0.0f, baseSize.x, baseSize.y, 0.0f, -100.0f, 100.0f);
SetViewport(0, 0, baseSize.x, baseSize.y);
if(scene)
scene->Render();
//------------------------------------
if(bTransitioning)
{
if(!transitionTexture)
{
transitionTexture = CreateTexture(baseCX, baseCY, GS_BGRA, NULL, FALSE, TRUE);
if(transitionTexture)
{
D3D10Texture *d3dTransitionTex = static_cast<D3D10Texture*>(transitionTexture);
D3D10Texture *d3dSceneTex = static_cast<D3D10Texture*>(mainRenderTextures[lastRenderTarget]);
GetD3D()->CopyResource(d3dTransitionTex->texture, d3dSceneTex->texture);
}
else
bTransitioning = false;
}
else if(transitionAlpha >= 1.0f)
{
delete transitionTexture;
transitionTexture = NULL;
bTransitioning = false;
}
}
if(bTransitioning)
{
EnableBlending(TRUE);
transitionAlpha += float(fSeconds)*5.0f;
if(transitionAlpha > 1.0f)
transitionAlpha = 1.0f;
}
else
EnableBlending(FALSE);
//------------------------------------
// render the mini view thingy
if (bProjector) {
SetRenderTarget(projectorTexture);
Vect2 renderFrameSize, renderFrameOffset;
Vect2 projectorSize = Vect2(float(projectorWidth), float(projectorHeight));
float projectorAspect = (projectorSize.x / projectorSize.y);
float baseAspect = (baseSize.x / baseSize.y);
if (projectorAspect < baseAspect) {
float fProjectorWidth = float(projectorWidth);
renderFrameSize = Vect2(fProjectorWidth, fProjectorWidth / baseAspect);
renderFrameOffset = Vect2(0.0f, (projectorSize.y-renderFrameSize.y) * 0.5f);
} else {
float fProjectorHeight = float(projectorHeight);
renderFrameSize = Vect2(fProjectorHeight * baseAspect, fProjectorHeight);
renderFrameOffset = Vect2((projectorSize.x-renderFrameSize.x) * 0.5f, 0.0f);
}
DrawPreview(renderFrameSize, renderFrameOffset, projectorSize, curRenderTarget, Preview_Projector);
SetRenderTarget(NULL);
}
if(bRenderView)
{
// Cache
const Vect2 renderFrameSize = GetRenderFrameSize();
const Vect2 renderFrameOffset = GetRenderFrameOffset();
const Vect2 renderFrameCtrlSize = GetRenderFrameControlSize();
SetRenderTarget(NULL);
DrawPreview(renderFrameSize, renderFrameOffset, renderFrameCtrlSize, curRenderTarget,
bFullscreenMode ? Preview_Fullscreen : Preview_Standard);
//draw selections if in edit mode
if(bEditMode && !bSizeChanging)
{
if(scene) {
LoadVertexShader(solidVertexShader);
LoadPixelShader(solidPixelShader);
solidPixelShader->SetColor(solidPixelShader->GetParameter(0), 0xFF0000);
scene->RenderSelections(solidPixelShader);
}
}
}
else if(bForceRenderViewErase)
{
InvalidateRect(hwndRenderFrame, NULL, TRUE);
UpdateWindow(hwndRenderFrame);
bForceRenderViewErase = false;
}
//------------------------------------
// actual stream output
LoadVertexShader(mainVertexShader);
LoadPixelShader(yuvScalePixelShader);
Texture *yuvRenderTexture = yuvRenderTextures[curRenderTarget];
SetRenderTarget(yuvRenderTexture);
switch(colorDesc.matrix)
{
case ColorMatrix_GBR:
yuvScalePixelShader->SetMatrix(hMatrix, colorDesc.fullRange ? (float*)yuvFullMat[0] : (float*)yuvMat[0]);
break;
case ColorMatrix_YCgCo:
yuvScalePixelShader->SetMatrix(hMatrix, colorDesc.fullRange ? (float*)yuvFullMat[1] : (float*)yuvMat[1]);
break;
case ColorMatrix_BT2020NCL:
yuvScalePixelShader->SetMatrix(hMatrix, colorDesc.fullRange ? (float*)yuvFullMat[2] : (float*)yuvMat[2]);
break;
case ColorMatrix_BT709:
yuvScalePixelShader->SetMatrix(hMatrix, colorDesc.fullRange ? (float*)yuvFullMat[3] : (float*)yuvMat[3]);
break;
case ColorMatrix_SMPTE240M:
yuvScalePixelShader->SetMatrix(hMatrix, colorDesc.fullRange ? (float*)yuvFullMat[4] : (float*)yuvMat[4]);
break;
default:
yuvScalePixelShader->SetMatrix(hMatrix, colorDesc.fullRange ? (float*)yuvFullMat[5] : (float*)yuvMat[5]);
}
if(downscale < 2.01)
yuvScalePixelShader->SetVector2(hScaleVal, 1.0f/baseSize);
else if(downscale < 3.01)
yuvScalePixelShader->SetVector2(hScaleVal, 1.0f/(outputSize*3.0f));
Ortho(0.0f, outputSize.x, outputSize.y, 0.0f, -100.0f, 100.0f);
SetViewport(0.0f, 0.0f, outputSize.x, outputSize.y);
//why am I using scaleSize instead of outputSize for the texture?
//because outputSize can be trimmed by up to three pixels due to 128-bit alignment.
//using the scale function with outputSize can cause slightly inaccurate scaled images
if(bTransitioning)
{
BlendFunction(GS_BLEND_ONE, GS_BLEND_ZERO);
DrawSpriteEx(transitionTexture, 0xFFFFFFFF, 0.0f, 0.0f, scaleSize.x, scaleSize.y, 0.0f, 0.0f, 1.0f, 1.0f);
BlendFunction(GS_BLEND_FACTOR, GS_BLEND_INVFACTOR, transitionAlpha);
}
DrawSpriteEx(mainRenderTextures[curRenderTarget], 0xFFFFFFFF, 0.0f, 0.0f, outputSize.x, outputSize.y, 0.0f, 0.0f, 1.0f, 1.0f);
//------------------------------------
if (bProjector && !copyWait)
projectorSwap->Present(0, 0);
if(bRenderView && !copyWait)
static_cast<D3D10System*>(GS)->swap->Present(0, 0);
OSLeaveMutex(hSceneMutex);
//------------------------------------
// present/upload
profileIn("GPU download and conversion");
bEncode = true;
if(copyWait)
{
copyWait--;
bEncode = false;
}
else
{
//audio sometimes takes a bit to start -- do not start processing frames until audio has started capturing
if(!bRecievedFirstAudioFrame)
{
static bool bWarnedAboutNoAudio = false;
if (renderStartTimeMS-firstFrameTimeMS > 10000 && !bWarnedAboutNoAudio)
{
bWarnedAboutNoAudio = true;
//AddStreamInfo (TEXT ("WARNING: OBS is not receiving audio frames. Please check your audio devices."), StreamInfoPriority_Critical);
}
bEncode = false;
}
else if(bFirstFrame)
{
firstFrameTimestamp = lastStreamTime/1000000;
bFirstFrame = false;
}
if(!bEncode)
{
if(curYUVTexture == (NUM_RENDER_BUFFERS-1))
curYUVTexture = 0;
else
curYUVTexture++;
}
}
lastStreamTime = curStreamTime;
if(bEncode)
{
UINT prevCopyTexture = (curCopyTexture == 0) ? NUM_RENDER_BUFFERS-1 : curCopyTexture-1;
ID3D10Texture2D *copyTexture = copyTextures[curCopyTexture];
profileIn("CopyResource");
if(!bFirstEncode && bUseThreaded420)
{
WaitForMultipleObjects(completeEvents.Num(), completeEvents.Array(), TRUE, INFINITE);
copyTexture->Unmap(0);
}
D3D10Texture *d3dYUV = static_cast<D3D10Texture*>(yuvRenderTextures[curYUVTexture]);
GetD3D()->CopyResource(copyTexture, d3dYUV->texture);
profileOut;
ID3D10Texture2D *prevTexture = copyTextures[prevCopyTexture];
if(bFirstImage) //ignore the first frame
bFirstImage = false;
else
{
HRESULT result;
D3D10_MAPPED_TEXTURE2D map;
if(SUCCEEDED(result = prevTexture->Map(0, D3D10_MAP_READ, 0, &map)))
{
int prevOutBuffer = (curOutBuffer == 0) ? NUM_OUT_BUFFERS-1 : curOutBuffer-1;
int nextOutBuffer = (curOutBuffer == NUM_OUT_BUFFERS-1) ? 0 : curOutBuffer+1;
EncoderPicture &prevPicOut = outPics[prevOutBuffer];
EncoderPicture &picOut = outPics[curOutBuffer];
EncoderPicture &nextPicOut = outPics[nextOutBuffer];
if(!bUsing444)
{
profileIn("conversion to 4:2:0");
if(bUseThreaded420)
{
for(int i=0; i<numThreads; i++)
{
convertInfo[i].input = (LPBYTE)map.pData;
convertInfo[i].inPitch = map.RowPitch;
if(bUsingQSV)
{
mfxFrameData& data = nextPicOut.mfxOut->Data;
videoEncoder->RequestBuffers(&data);
convertInfo[i].outPitch = data.Pitch;
convertInfo[i].output[0] = data.Y;
convertInfo[i].output[1] = data.UV;
}
else
{
convertInfo[i].output[0] = nextPicOut.picOut->img.plane[0];
convertInfo[i].output[1] = nextPicOut.picOut->img.plane[1];
convertInfo[i].output[2] = nextPicOut.picOut->img.plane[2];
}
SetEvent(convertInfo[i].hSignalConvert);
}
if(bFirstEncode)
bFirstEncode = bEncode = false;
}
else
{
if(bUsingQSV)
{
mfxFrameData& data = picOut.mfxOut->Data;
videoEncoder->RequestBuffers(&data);
LPBYTE output[] = {data.Y, data.UV};
Convert444toNV12((LPBYTE)map.pData, outputCX, map.RowPitch, data.Pitch, outputCY, 0, outputCY, output);
}
else
Convert444toNV12((LPBYTE)map.pData, outputCX, map.RowPitch, outputCX, outputCY, 0, outputCY, picOut.picOut->img.plane);
prevTexture->Unmap(0);
}
profileOut;
}
if(bEncode)
{
//encodeThreadProfiler.reset(::new ProfilerNode(TEXT("EncodeThread"), true));
//encodeThreadProfiler->MonitorThread(hEncodeThread);
curFramePic = &picOut;
}
curOutBuffer = nextOutBuffer;
}
else
{
//We have to crash, or we end up deadlocking the thread when the convert threads are never signalled
if (result == DXGI_ERROR_DEVICE_REMOVED)
{
String message;
HRESULT reason = GetD3D()->GetDeviceRemovedReason();
switch (reason)
{
case DXGI_ERROR_DEVICE_RESET:
case DXGI_ERROR_DEVICE_HUNG:
message = TEXT("Your video card or driver froze and was reset. Please check for possible hardware / driver issues.");
break;
case DXGI_ERROR_DEVICE_REMOVED:
message = TEXT("Your video card disappeared from the system. Please check for possible hardware / driver issues.");
break;
case DXGI_ERROR_DRIVER_INTERNAL_ERROR:
message = TEXT("Your video driver reported an internal error. Please check for possible hardware / driver issues.");
break;
case DXGI_ERROR_INVALID_CALL:
message = TEXT("Your video driver reported an invalid call. Please check for possible driver issues.");
break;
default:
message = TEXT("DXGI_ERROR_DEVICE_REMOVED");
break;
}
message << TEXT(" This error can also occur if you have enabled opencl in x264 custom settings.");
CrashError (TEXT("Texture->Map failed: 0x%08x 0x%08x\r\n\r\n%s"), result, reason, message.Array());
}
else
CrashError (TEXT("Texture->Map failed: 0x%08x"), result);
}
}
if(curCopyTexture == (NUM_RENDER_BUFFERS-1))
curCopyTexture = 0;
else
curCopyTexture++;
if(curYUVTexture == (NUM_RENDER_BUFFERS-1))
curYUVTexture = 0;
else
curYUVTexture++;
if (bCongestionControl && bDynamicBitrateSupported && !bTestStream && totalStreamTime > 15000)
{
if (curStrain > 25)
{
if (renderStartTimeMS - lastAdjustmentTime > 1500)
{
if (currentBitRate > 100)
{
currentBitRate = (int)(currentBitRate * (1.0 - (curStrain / 400)));
App->GetVideoEncoder()->SetBitRate(currentBitRate, -1);
if (!adjustmentStreamId)
adjustmentStreamId = App->AddStreamInfo (FormattedString(TEXT("Congestion detected, dropping bitrate to %d kbps"), currentBitRate).Array(), StreamInfoPriority_Low);
else
App->SetStreamInfo(adjustmentStreamId, FormattedString(TEXT("Congestion detected, dropping bitrate to %d kbps"), currentBitRate).Array());
bUpdateBPS = true;
}
lastAdjustmentTime = renderStartTimeMS;
}
}
else if (currentBitRate < defaultBitRate && curStrain < 5 && lastStrain < 5)
{
if (renderStartTimeMS - lastAdjustmentTime > 5000)
{
if (currentBitRate < defaultBitRate)
{
currentBitRate += (int)(defaultBitRate * 0.05);
if (currentBitRate > defaultBitRate)
currentBitRate = defaultBitRate;
}
App->GetVideoEncoder()->SetBitRate(currentBitRate, -1);
/*if (!adjustmentStreamId)
App->AddStreamInfo (FormattedString(TEXT("Congestion clearing, raising bitrate to %d kbps"), currentBitRate).Array(), StreamInfoPriority_Low);
else
App->SetStreamInfo(adjustmentStreamId, FormattedString(TEXT("Congestion clearing, raising bitrate to %d kbps"), currentBitRate).Array());*/
App->RemoveStreamInfo(adjustmentStreamId);
adjustmentStreamId = 0;
bUpdateBPS = true;
lastAdjustmentTime = renderStartTimeMS;
}
}
}
}
lastRenderTarget = curRenderTarget;
if(curRenderTarget == (NUM_RENDER_BUFFERS-1))
curRenderTarget = 0;
else
curRenderTarget++;
if(bUpdateBPS || !CloseDouble(curStrain, lastStrain) || curFramesDropped != lastFramesDropped)
{
PostMessage(hwndMain, OBS_UPDATESTATUSBAR, 0, 0);
lastStrain = curStrain;
lastFramesDropped = curFramesDropped;
}
//------------------------------------
// we're about to sleep so we should flush the d3d command queue
profileIn("flush");
GetD3D()->Flush();
profileOut;
profileOut;
profileOut; //frame
//------------------------------------
// frame sync
//QWORD renderStopTime = GetQPCTimeNS();
if(bWasLaggedFrame = (frameDelta > frameLengthNS))
{
numLongFrames++;
if(bLogLongFramesProfile && (numLongFrames/float(max(1, numTotalFrames)) * 100.) > logLongFramesProfilePercentage)
DumpLastProfileData();
}
//OSDebugOut(TEXT("Frame adjust time: %d, "), frameTimeAdjust-totalTime);
numTotalFrames++;
}
DisableProjector();
//encodeThreadProfiler.reset();
if(!bUsing444)
{
if(bUseThreaded420)
{
for(int i=0; i<numThreads; i++)
{
if(h420Threads[i])
{
convertInfo[i].bKillThread = true;
SetEvent(convertInfo[i].hSignalConvert);
OSTerminateThread(h420Threads[i], 10000);
h420Threads[i] = NULL;
}
if(convertInfo[i].hSignalConvert)
{
CloseHandle(convertInfo[i].hSignalConvert);
convertInfo[i].hSignalConvert = NULL;
}
if(convertInfo[i].hSignalComplete)
{
CloseHandle(convertInfo[i].hSignalComplete);
convertInfo[i].hSignalComplete = NULL;
}
}
if(!bFirstEncode)
{
ID3D10Texture2D *copyTexture = copyTextures[curCopyTexture];
copyTexture->Unmap(0);
}
}
if(bUsingQSV)
for(int i = 0; i < NUM_OUT_BUFFERS; i++)
delete outPics[i].mfxOut;
else
for(int i=0; i<NUM_OUT_BUFFERS; i++)
{
x264_picture_clean(outPics[i].picOut);
delete outPics[i].picOut;
}
}
Free(h420Threads);
Free(convertInfo);
Log(TEXT("Total frames rendered: %d, number of late frames: %d (%0.2f%%) (it's okay for some frames to be late)"), numTotalFrames, numLongFrames, (numTotalFrames > 0) ? (double(numLongFrames)/double(numTotalFrames))*100.0 : 0.0f);
}
//todo: this function is an abomination, this is just disgusting. fix it.
//...seriously, this is really, really horrible. I mean this is amazingly bad.
void OBS::MainCaptureLoop()
{
int curRenderTarget = 0, curYUVTexture = 0, curCopyTexture = 0;
int copyWait = NUM_RENDER_BUFFERS-1;
bSentHeaders = false;
bFirstAudioPacket = true;
bool bLogLongFramesProfile = GlobalConfig->GetInt(TEXT("General"), TEXT("LogLongFramesProfile"), LOGLONGFRAMESDEFAULT) != 0;
float logLongFramesProfilePercentage = GlobalConfig->GetFloat(TEXT("General"), TEXT("LogLongFramesProfilePercentage"), 10.f);
Vect2 baseSize = Vect2(float(baseCX), float(baseCY));
Vect2 outputSize = Vect2(float(outputCX), float(outputCY));
Vect2 scaleSize = Vect2(float(scaleCX), float(scaleCY));
HANDLE hScaleVal = yuvScalePixelShader->GetParameterByName(TEXT("baseDimensionI"));
//----------------------------------------
// x264 input buffers
int curOutBuffer = 0;
bool bUsingQSV = videoEncoder->isQSV();//GlobalConfig->GetInt(TEXT("Video Encoding"), TEXT("UseQSV")) != 0;
if(bUsingQSV)
bUsing444 = false;
EncoderPicture lastPic;
EncoderPicture outPics[NUM_OUT_BUFFERS];
DWORD outTimes[NUM_OUT_BUFFERS] = {0, 0, 0};
for(int i=0; i<NUM_OUT_BUFFERS; i++)
{
if(bUsingQSV)
{
outPics[i].mfxOut = new mfxFrameSurface1;
memset(outPics[i].mfxOut, 0, sizeof(mfxFrameSurface1));
mfxFrameData& data = outPics[i].mfxOut->Data;
videoEncoder->RequestBuffers(&data);
}
else
{
outPics[i].picOut = new x264_picture_t;
x264_picture_init(outPics[i].picOut);
}
}
if(bUsing444)
{
for(int i=0; i<NUM_OUT_BUFFERS; i++)
{
outPics[i].picOut->img.i_csp = X264_CSP_BGRA; //although the x264 input says BGR, x264 actually will expect packed UYV
outPics[i].picOut->img.i_plane = 1;
}
}
else
{
if(!bUsingQSV)
for(int i=0; i<NUM_OUT_BUFFERS; i++)
x264_picture_alloc(outPics[i].picOut, X264_CSP_NV12, outputCX, outputCY);
}
int bCongestionControl = AppConfig->GetInt (TEXT("Video Encoding"), TEXT("CongestionControl"), 0);
bool bDynamicBitrateSupported = App->GetVideoEncoder()->DynamicBitrateSupported();
int defaultBitRate = AppConfig->GetInt(TEXT("Video Encoding"), TEXT("MaxBitrate"), 1000);
int currentBitRate = defaultBitRate;
QWORD lastAdjustmentTime = 0;
UINT adjustmentStreamId = 0;
//----------------------------------------
// time/timestamp stuff
bufferedTimes.Clear();
ctsOffsets.Clear();
int bufferedFrames = 1; //to avoid constantly polling number of frames
#ifdef USE_100NS_TIME
QWORD streamTimeStart = GetQPCTime100NS();
QWORD frameTime100ns = 10000000/fps;
QWORD sleepTargetTime = 0;
bool bWasLaggedFrame = false;
#else
DWORD streamTimeStart = OSGetTime();
DWORD fpsTimeAdjust = 0;
#endif
totalStreamTime = 0;
lastAudioTimestamp = 0;
latestVideoTime = firstSceneTimestamp = GetQPCTimeMS();
DWORD fpsTimeNumerator = 1000-(frameTime*fps);
DWORD fpsTimeDenominator = fps;
DWORD cfrTime = 0;
DWORD cfrTimeAdjust = 0;
//----------------------------------------
// start audio capture streams
desktopAudio->StartCapture();
if(micAudio) micAudio->StartCapture();
//----------------------------------------
// status bar/statistics stuff
DWORD fpsCounter = 0;
int numLongFrames = 0;
int numTotalFrames = 0;
int numTotalDuplicatedFrames = 0;
bytesPerSec = 0;
captureFPS = 0;
curFramesDropped = 0;
curStrain = 0.0;
PostMessage(hwndMain, OBS_UPDATESTATUSBAR, 0, 0);
QWORD lastBytesSent[3] = {0, 0, 0};
DWORD lastFramesDropped = 0;
#ifdef USE_100NS_TIME
double bpsTime = 0.0;
#else
float bpsTime = 0.0f;
#endif
double lastStrain = 0.0f;
DWORD numSecondsWaited = 0;
//----------------------------------------
// 444->420 thread data
int numThreads = MAX(OSGetTotalCores()-2, 1);
HANDLE *h420Threads = (HANDLE*)Allocate(sizeof(HANDLE)*numThreads);
Convert444Data *convertInfo = (Convert444Data*)Allocate(sizeof(Convert444Data)*numThreads);
zero(h420Threads, sizeof(HANDLE)*numThreads);
zero(convertInfo, sizeof(Convert444Data)*numThreads);
for(int i=0; i<numThreads; i++)
{
convertInfo[i].width = outputCX;
convertInfo[i].height = outputCY;
convertInfo[i].hSignalConvert = CreateEvent(NULL, FALSE, FALSE, NULL);
convertInfo[i].hSignalComplete = CreateEvent(NULL, FALSE, FALSE, NULL);
convertInfo[i].bNV12 = bUsingQSV;
if(i == 0)
convertInfo[i].startY = 0;
else
convertInfo[i].startY = convertInfo[i-1].endY;
if(i == (numThreads-1))
convertInfo[i].endY = outputCY;
else
convertInfo[i].endY = ((outputCY/numThreads)*(i+1)) & 0xFFFFFFFE;
}
bool bFirstFrame = true;
bool bFirstImage = true;
bool bFirst420Encode = true;
bool bUseThreaded420 = bUseMultithreadedOptimizations && (OSGetTotalCores() > 1) && !bUsing444;
List<HANDLE> completeEvents;
if(bUseThreaded420)
{
for(int i=0; i<numThreads; i++)
{
h420Threads[i] = OSCreateThread((XTHREAD)Convert444Thread, convertInfo+i);
completeEvents << convertInfo[i].hSignalComplete;
}
}
//----------------------------------------
QWORD curStreamTime = 0, lastStreamTime, firstFrameTime = GetQPCTimeMS();
#ifdef USE_100NS_TIME
lastStreamTime = GetQPCTime100NS()-frameTime100ns;
#else
lastStreamTime = firstFrameTime-frameTime;
#endif
//bool bFirstAudioPacket = true;
List<ProfilerNode> threadedProfilers;
bool bUsingThreadedProfilers = false;
while(bRunning || bufferedFrames)
{
#ifdef USE_100NS_TIME
QWORD renderStartTime = GetQPCTime100NS();
totalStreamTime = DWORD((renderStartTime-streamTimeStart)/10000);
if(sleepTargetTime == 0 || bWasLaggedFrame)
sleepTargetTime = renderStartTime;
#else
DWORD renderStartTime = OSGetTime();
totalStreamTime = renderStartTime-streamTimeStart;
DWORD frameTimeAdjust = frameTime;
fpsTimeAdjust += fpsTimeNumerator;
if(fpsTimeAdjust > fpsTimeDenominator)
{
fpsTimeAdjust -= fpsTimeDenominator;
++frameTimeAdjust;
}
#endif
bool bRenderView = !IsIconic(hwndMain) && bRenderViewEnabled;
profileIn("frame");
#ifdef USE_100NS_TIME
QWORD qwTime = renderStartTime/10000;
latestVideoTime = qwTime;
QWORD frameDelta = renderStartTime-lastStreamTime;
double fSeconds = double(frameDelta)*0.0000001;
//Log(TEXT("frameDelta: %f"), fSeconds);
lastStreamTime = renderStartTime;
#else
QWORD qwTime = GetQPCTimeMS();
latestVideoTime = qwTime;
QWORD frameDelta = qwTime-lastStreamTime;
float fSeconds = float(frameDelta)*0.001f;
//Log(TEXT("frameDelta: %llu"), frameDelta);
lastStreamTime = qwTime;
#endif
bool bUpdateBPS = false;
profileIn("frame preprocessing and rendering");
//------------------------------------
if(bRequestKeyframe && keyframeWait > 0)
{
keyframeWait -= int(frameDelta);
if(keyframeWait <= 0)
{
GetVideoEncoder()->RequestKeyframe();
bRequestKeyframe = false;
}
}
if(!bPushToTalkDown && pushToTalkTimeLeft > 0)
{
pushToTalkTimeLeft -= int(frameDelta);
OSDebugOut(TEXT("time left: %d\r\n"), pushToTalkTimeLeft);
if(pushToTalkTimeLeft <= 0)
{
pushToTalkTimeLeft = 0;
bPushToTalkOn = false;
}
}
//------------------------------------
OSEnterMutex(hSceneMutex);
if(bResizeRenderView)
{
GS->ResizeView();
bResizeRenderView = false;
}
//------------------------------------
if(scene)
{
profileIn("scene->Preprocess");
scene->Preprocess();
for(UINT i=0; i<globalSources.Num(); i++)
globalSources[i].source->Preprocess();
profileOut;
scene->Tick(float(fSeconds));
for(UINT i=0; i<globalSources.Num(); i++)
globalSources[i].source->Tick(float(fSeconds));
}
//------------------------------------
QWORD curBytesSent = network->GetCurrentSentBytes();
curFramesDropped = network->NumDroppedFrames();
bpsTime += fSeconds;
if(bpsTime > 1.0f)
{
if(numSecondsWaited < 3)
++numSecondsWaited;
//bytesPerSec = DWORD(curBytesSent - lastBytesSent);
bytesPerSec = DWORD(curBytesSent - lastBytesSent[0]) / numSecondsWaited;
if(bpsTime > 2.0)
bpsTime = 0.0f;
else
bpsTime -= 1.0;
if(numSecondsWaited == 3)
{
lastBytesSent[0] = lastBytesSent[1];
lastBytesSent[1] = lastBytesSent[2];
lastBytesSent[2] = curBytesSent;
}
else
lastBytesSent[numSecondsWaited] = curBytesSent;
captureFPS = fpsCounter;
fpsCounter = 0;
bUpdateBPS = true;
}
fpsCounter++;
curStrain = network->GetPacketStrain();
EnableBlending(TRUE);
BlendFunction(GS_BLEND_SRCALPHA, GS_BLEND_INVSRCALPHA);
//------------------------------------
// render the mini render texture
LoadVertexShader(mainVertexShader);
LoadPixelShader(mainPixelShader);
SetRenderTarget(mainRenderTextures[curRenderTarget]);
Ortho(0.0f, baseSize.x, baseSize.y, 0.0f, -100.0f, 100.0f);
SetViewport(0, 0, baseSize.x, baseSize.y);
if(scene)
scene->Render();
//------------------------------------
if(bTransitioning)
{
if(!transitionTexture)
{
transitionTexture = CreateTexture(baseCX, baseCY, GS_BGRA, NULL, FALSE, TRUE);
if(transitionTexture)
{
D3D10Texture *d3dTransitionTex = static_cast<D3D10Texture*>(transitionTexture);
D3D10Texture *d3dSceneTex = static_cast<D3D10Texture*>(mainRenderTextures[lastRenderTarget]);
GetD3D()->CopyResource(d3dTransitionTex->texture, d3dSceneTex->texture);
}
else
bTransitioning = false;
}
else if(transitionAlpha >= 1.0f)
{
delete transitionTexture;
transitionTexture = NULL;
bTransitioning = false;
}
}
if(bTransitioning)
{
EnableBlending(TRUE);
transitionAlpha += float(fSeconds)*5.0f;
if(transitionAlpha > 1.0f)
transitionAlpha = 1.0f;
}
else
EnableBlending(FALSE);
//------------------------------------
// render the mini view thingy
if(bRenderView)
{
// Cache
const Vect2 renderFrameSize = GetRenderFrameSize();
const Vect2 renderFrameOffset = GetRenderFrameOffset();
const Vect2 renderFrameCtrlSize = GetRenderFrameControlSize();
SetRenderTarget(NULL);
LoadVertexShader(mainVertexShader);
LoadPixelShader(mainPixelShader);
Ortho(0.0f, renderFrameCtrlSize.x, renderFrameCtrlSize.y, 0.0f, -100.0f, 100.0f);
if(renderFrameCtrlSize.x != oldRenderFrameCtrlWidth || renderFrameCtrlSize.y != oldRenderFrameCtrlHeight)
{
// User is drag resizing the window. We don't recreate the swap chains so our coordinates are wrong
SetViewport(0.0f, 0.0f, (float)oldRenderFrameCtrlWidth, (float)oldRenderFrameCtrlHeight);
}
else
SetViewport(0.0f, 0.0f, renderFrameCtrlSize.x, renderFrameCtrlSize.y);
// Draw background (Black if fullscreen, window colour otherwise)
if(bFullscreenMode)
ClearColorBuffer(0x000000);
else
ClearColorBuffer(GetSysColor(COLOR_BTNFACE));
if(bTransitioning)
{
BlendFunction(GS_BLEND_ONE, GS_BLEND_ZERO);
DrawSprite(transitionTexture, 0xFFFFFFFF,
renderFrameOffset.x, renderFrameOffset.y,
renderFrameOffset.x + renderFrameSize.x, renderFrameOffset.y + renderFrameSize.y);
BlendFunction(GS_BLEND_FACTOR, GS_BLEND_INVFACTOR, transitionAlpha);
}
DrawSprite(mainRenderTextures[curRenderTarget], 0xFFFFFFFF,
renderFrameOffset.x, renderFrameOffset.y,
renderFrameOffset.x + renderFrameSize.x, renderFrameOffset.y + renderFrameSize.y);
//draw selections if in edit mode
if(bEditMode && !bSizeChanging)
{
if(scene) {
LoadVertexShader(solidVertexShader);
LoadPixelShader(solidPixelShader);
solidPixelShader->SetColor(solidPixelShader->GetParameter(0), 0xFF0000);
scene->RenderSelections(solidPixelShader);
}
}
}
else if(bForceRenderViewErase)
{
InvalidateRect(hwndRenderFrame, NULL, TRUE);
UpdateWindow(hwndRenderFrame);
bForceRenderViewErase = false;
}
//------------------------------------
// actual stream output
LoadVertexShader(mainVertexShader);
LoadPixelShader(yuvScalePixelShader);
Texture *yuvRenderTexture = yuvRenderTextures[curRenderTarget];
SetRenderTarget(yuvRenderTexture);
if(downscale < 2.01)
yuvScalePixelShader->SetVector2(hScaleVal, 1.0f/baseSize);
else if(downscale < 3.01)
yuvScalePixelShader->SetVector2(hScaleVal, 1.0f/(outputSize*3.0f));
Ortho(0.0f, outputSize.x, outputSize.y, 0.0f, -100.0f, 100.0f);
SetViewport(0.0f, 0.0f, outputSize.x, outputSize.y);
//why am I using scaleSize instead of outputSize for the texture?
//because outputSize can be trimmed by up to three pixels due to 128-bit alignment.
//using the scale function with outputSize can cause slightly inaccurate scaled images
if(bTransitioning)
{
BlendFunction(GS_BLEND_ONE, GS_BLEND_ZERO);
DrawSpriteEx(transitionTexture, 0xFFFFFFFF, 0.0f, 0.0f, scaleSize.x, scaleSize.y, 0.0f, 0.0f, 1.0f, 1.0f);
BlendFunction(GS_BLEND_FACTOR, GS_BLEND_INVFACTOR, transitionAlpha);
}
DrawSpriteEx(mainRenderTextures[curRenderTarget], 0xFFFFFFFF, 0.0f, 0.0f, outputSize.x, outputSize.y, 0.0f, 0.0f, 1.0f, 1.0f);
//------------------------------------
if(bRenderView && !copyWait)
static_cast<D3D10System*>(GS)->swap->Present(0, 0);
OSLeaveMutex(hSceneMutex);
profileOut;
//------------------------------------
// present/upload
profileIn("video encoding and uploading");
bool bEncode = true;
if(copyWait)
{
copyWait--;
bEncode = false;
}
else
{
//audio sometimes takes a bit to start -- do not start processing frames until audio has started capturing
if(!bRecievedFirstAudioFrame)
{
static bool bWarnedAboutNoAudio = false;
if (qwTime-firstFrameTime > 10000 && !bWarnedAboutNoAudio)
{
bWarnedAboutNoAudio = true;
//AddStreamInfo (TEXT ("WARNING: OBS is not receiving audio frames. Please check your audio devices."), StreamInfoPriority_Critical);
}
bEncode = false;
}
else if(bFirstFrame)
{
firstFrameTime = qwTime;
bFirstFrame = false;
}
if(!bEncode)
{
if(curYUVTexture == (NUM_RENDER_BUFFERS-1))
curYUVTexture = 0;
else
curYUVTexture++;
}
}
if(bEncode)
{
curStreamTime = qwTime-firstFrameTime;
UINT prevCopyTexture = (curCopyTexture == 0) ? NUM_RENDER_BUFFERS-1 : curCopyTexture-1;
ID3D10Texture2D *copyTexture = copyTextures[curCopyTexture];
profileIn("CopyResource");
if(!bFirst420Encode && bUseThreaded420)
{
WaitForMultipleObjects(completeEvents.Num(), completeEvents.Array(), TRUE, INFINITE);
copyTexture->Unmap(0);
}
D3D10Texture *d3dYUV = static_cast<D3D10Texture*>(yuvRenderTextures[curYUVTexture]);
GetD3D()->CopyResource(copyTexture, d3dYUV->texture);
profileOut;
ID3D10Texture2D *prevTexture = copyTextures[prevCopyTexture];
if(bFirstImage) //ignore the first frame
bFirstImage = false;
else
{
HRESULT result;
D3D10_MAPPED_TEXTURE2D map;
if(SUCCEEDED(result = prevTexture->Map(0, D3D10_MAP_READ, 0, &map)))
{
int prevOutBuffer = (curOutBuffer == 0) ? NUM_OUT_BUFFERS-1 : curOutBuffer-1;
int nextOutBuffer = (curOutBuffer == NUM_OUT_BUFFERS-1) ? 0 : curOutBuffer+1;
EncoderPicture &prevPicOut = outPics[prevOutBuffer];
EncoderPicture &picOut = outPics[curOutBuffer];
EncoderPicture &nextPicOut = outPics[nextOutBuffer];
if(!bUsing444)
{
profileIn("conversion to 4:2:0");
if(bUseThreaded420)
{
outTimes[nextOutBuffer] = (DWORD)curStreamTime;
bool firstRun = threadedProfilers.Num() == 0;
if(firstRun)
threadedProfilers.SetSize(numThreads);
for(int i=0; i<numThreads; i++)
{
convertInfo[i].input = (LPBYTE)map.pData;
convertInfo[i].inPitch = map.RowPitch;
if(bUsingQSV)
{
mfxFrameData& data = nextPicOut.mfxOut->Data;
videoEncoder->RequestBuffers(&data);
convertInfo[i].outPitch = data.Pitch;
convertInfo[i].output[0] = data.Y;
convertInfo[i].output[1] = data.UV;
}
else
{
convertInfo[i].output[0] = nextPicOut.picOut->img.plane[0];
convertInfo[i].output[1] = nextPicOut.picOut->img.plane[1];
convertInfo[i].output[2] = nextPicOut.picOut->img.plane[2];
}
if(!firstRun)
threadedProfilers[i].~ProfilerNode();
::new (&threadedProfilers[i]) ProfilerNode(TEXT("Convert444Threads"), true);
threadedProfilers[i].MonitorThread(h420Threads[i]);
bUsingThreadedProfilers = true;
SetEvent(convertInfo[i].hSignalConvert);
}
if(bFirst420Encode)
bFirst420Encode = bEncode = false;
}
else
{
outTimes[curOutBuffer] = (DWORD)curStreamTime;
if(bUsingQSV)
{
mfxFrameData& data = picOut.mfxOut->Data;
videoEncoder->RequestBuffers(&data);
LPBYTE output[] = {data.Y, data.UV};
Convert444toNV12((LPBYTE)map.pData, outputCX, map.RowPitch, data.Pitch, outputCY, 0, outputCY, output);
}
else
Convert444toNV12((LPBYTE)map.pData, outputCX, map.RowPitch, outputCX, outputCY, 0, outputCY, picOut.picOut->img.plane);
prevTexture->Unmap(0);
}
profileOut;
}
else
{
outTimes[curOutBuffer] = (DWORD)curStreamTime;
picOut.picOut->img.i_stride[0] = map.RowPitch;
picOut.picOut->img.plane[0] = (uint8_t*)map.pData;
}
if(bEncode)
{
DWORD curFrameTimestamp = outTimes[prevOutBuffer];
//Log(TEXT("curFrameTimestamp: %u"), curFrameTimestamp);
//------------------------------------
FrameProcessInfo frameInfo;
frameInfo.firstFrameTime = firstFrameTime;
frameInfo.prevTexture = prevTexture;
if(bDupeFrames)
{
while(cfrTime < curFrameTimestamp)
{
DWORD frameTimeAdjust = frameTime;
cfrTimeAdjust += fpsTimeNumerator;
if(cfrTimeAdjust > fpsTimeDenominator)
{
cfrTimeAdjust -= fpsTimeDenominator;
++frameTimeAdjust;
}
DWORD halfTime = (frameTimeAdjust+1)/2;
EncoderPicture &nextPic = (curFrameTimestamp-cfrTime <= halfTime) ? picOut : prevPicOut;
//Log(TEXT("cfrTime: %u, time: %u"), cfrTime, curFrameTimestamp);
//these lines are just for counting duped frames
if(nextPic == lastPic)
++numTotalDuplicatedFrames;
else
lastPic = nextPic;
frameInfo.pic = &nextPic;
if(bUsingQSV)
frameInfo.pic->mfxOut->Data.TimeStamp = cfrTime;
else
frameInfo.pic->picOut->i_pts = cfrTime;
frameInfo.frameTimestamp = cfrTime;
ProcessFrame(frameInfo);
cfrTime += frameTimeAdjust;
//Log(TEXT("cfrTime: %u, chi frame: %u"), cfrTime, (curFrameTimestamp-cfrTime <= halfTime));
}
}
else
{
if(bUsingQSV)
picOut.mfxOut->Data.TimeStamp = curFrameTimestamp;
else
picOut.picOut->i_pts = curFrameTimestamp;
frameInfo.pic = &picOut;
frameInfo.frameTimestamp = curFrameTimestamp;
ProcessFrame(frameInfo);
}
if (!bRunning)
bufferedFrames = videoEncoder->GetBufferedFrames ();
}
if(bUsing444)
{
prevTexture->Unmap(0);
}
curOutBuffer = nextOutBuffer;
}
else
{
//We have to crash, or we end up deadlocking the thread when the convert threads are never signalled
if (result == DXGI_ERROR_DEVICE_REMOVED)
{
String message;
HRESULT reason = GetD3D()->GetDeviceRemovedReason();
switch (reason)
{
case DXGI_ERROR_DEVICE_RESET:
case DXGI_ERROR_DEVICE_HUNG:
message = TEXT("Your video card or driver froze and was reset. Please check for possible hardware / driver issues.");
break;
case DXGI_ERROR_DEVICE_REMOVED:
message = TEXT("Your video card disappeared from the system. Please check for possible hardware / driver issues.");
break;
case DXGI_ERROR_DRIVER_INTERNAL_ERROR:
message = TEXT("Your video driver reported an internal error. Please check for possible hardware / driver issues.");
break;
case DXGI_ERROR_INVALID_CALL:
message = TEXT("Your video driver reported an invalid call. Please check for possible driver issues.");
break;
default:
message = TEXT("DXGI_ERROR_DEVICE_REMOVED");
break;
}
CrashError (TEXT("Texture->Map failed: 0x%08x 0x%08x\r\n\r\n%s"), result, reason, message.Array());
}
else
CrashError (TEXT("Texture->Map failed: 0x%08x"), result);
}
}
if(curCopyTexture == (NUM_RENDER_BUFFERS-1))
curCopyTexture = 0;
else
curCopyTexture++;
if(curYUVTexture == (NUM_RENDER_BUFFERS-1))
curYUVTexture = 0;
else
curYUVTexture++;
if (bCongestionControl && bDynamicBitrateSupported && !bTestStream)
{
if (curStrain > 25)
{
if (qwTime - lastAdjustmentTime > 1500)
{
if (currentBitRate > 100)
{
currentBitRate = (int)(currentBitRate * (1.0 - (curStrain / 400)));
App->GetVideoEncoder()->SetBitRate(currentBitRate, -1);
if (!adjustmentStreamId)
adjustmentStreamId = App->AddStreamInfo (FormattedString(TEXT("Congestion detected, dropping bitrate to %d kbps"), currentBitRate).Array(), StreamInfoPriority_Low);
else
App->SetStreamInfo(adjustmentStreamId, FormattedString(TEXT("Congestion detected, dropping bitrate to %d kbps"), currentBitRate).Array());
bUpdateBPS = true;
}
lastAdjustmentTime = qwTime;
}
}
else if (currentBitRate < defaultBitRate && curStrain < 5 && lastStrain < 5)
{
if (qwTime - lastAdjustmentTime > 5000)
{
if (currentBitRate < defaultBitRate)
{
currentBitRate += (int)(defaultBitRate * 0.05);
if (currentBitRate > defaultBitRate)
currentBitRate = defaultBitRate;
}
App->GetVideoEncoder()->SetBitRate(currentBitRate, -1);
/*if (!adjustmentStreamId)
App->AddStreamInfo (FormattedString(TEXT("Congestion clearing, raising bitrate to %d kbps"), currentBitRate).Array(), StreamInfoPriority_Low);
else
App->SetStreamInfo(adjustmentStreamId, FormattedString(TEXT("Congestion clearing, raising bitrate to %d kbps"), currentBitRate).Array());*/
bUpdateBPS = true;
lastAdjustmentTime = qwTime;
}
}
}
}
lastRenderTarget = curRenderTarget;
if(curRenderTarget == (NUM_RENDER_BUFFERS-1))
curRenderTarget = 0;
else
curRenderTarget++;
if(bUpdateBPS || !CloseDouble(curStrain, lastStrain) || curFramesDropped != lastFramesDropped)
{
PostMessage(hwndMain, OBS_UPDATESTATUSBAR, 0, 0);
lastStrain = curStrain;
lastFramesDropped = curFramesDropped;
}
//------------------------------------
// we're about to sleep so we should flush the d3d command queue
profileIn("flush");
GetD3D()->Flush();
profileOut;
profileOut; //video encoding and uploading
profileOut; //frame
//------------------------------------
// frame sync
#ifdef USE_100NS_TIME
QWORD renderStopTime = GetQPCTime100NS();
sleepTargetTime += frameTime100ns;
if(bWasLaggedFrame = (sleepTargetTime <= renderStopTime))
{
numLongFrames++;
if(bLogLongFramesProfile && (numLongFrames/float(max(1, numTotalFrames)) * 100.) > logLongFramesProfilePercentage)
DumpLastProfileData();
}
else
SleepTo(sleepTargetTime);
#else
DWORD renderStopTime = OSGetTime();
DWORD totalTime = renderStopTime-renderStartTime;
if(totalTime > frameTimeAdjust)
{
numLongFrames++;
if(bLogLongFramesProfile && (numLongFrames/float(max(1, numTotalFrames)) * 100.) > logLongFramesProfilePercentage)
DumpLastProfileData();
}
else if(totalTime < frameTimeAdjust)
OSSleep(frameTimeAdjust-totalTime);
#endif
//OSDebugOut(TEXT("Frame adjust time: %d, "), frameTimeAdjust-totalTime);
numTotalFrames++;
}
if(!bUsing444)
{
if(bUseThreaded420)
{
for(int i=0; i<numThreads; i++)
{
if(h420Threads[i])
{
convertInfo[i].bKillThread = true;
SetEvent(convertInfo[i].hSignalConvert);
if(bUsingThreadedProfilers)
threadedProfilers[i].~ProfilerNode();
OSTerminateThread(h420Threads[i], 10000);
h420Threads[i] = NULL;
}
if(convertInfo[i].hSignalConvert)
{
CloseHandle(convertInfo[i].hSignalConvert);
convertInfo[i].hSignalConvert = NULL;
}
if(convertInfo[i].hSignalComplete)
{
CloseHandle(convertInfo[i].hSignalComplete);
convertInfo[i].hSignalComplete = NULL;
}
}
if(!bFirst420Encode)
{
ID3D10Texture2D *copyTexture = copyTextures[curCopyTexture];
copyTexture->Unmap(0);
}
}
if(bUsingQSV)
for(int i = 0; i < NUM_OUT_BUFFERS; i++)
delete outPics[i].mfxOut;
else
for(int i=0; i<NUM_OUT_BUFFERS; i++)
{
x264_picture_clean(outPics[i].picOut);
delete outPics[i].picOut;
}
}
Free(h420Threads);
Free(convertInfo);
Log(TEXT("Total frames rendered: %d, number of frames that lagged: %d (%0.2f%%) (it's okay for some frames to lag)"), numTotalFrames, numLongFrames, (double(numLongFrames)/double(numTotalFrames))*100.0);
if(bDupeFrames)
Log(TEXT("Total duplicated frames: %d (%0.2f%%)"), numTotalDuplicatedFrames, (double(numTotalDuplicatedFrames)/double(numTotalFrames))*100.0);
}
bool D3D10App::captureScreenshot(Image &img){
D3D10_TEXTURE2D_DESC desc;
desc.Width = width;
desc.Height = height;
desc.Format = backBufferFormat;
desc.ArraySize = 1;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.BindFlags = 0;
desc.MipLevels = 1;
desc.MiscFlags = 0;
desc.Usage = D3D10_USAGE_STAGING;
desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
bool result = false;
ID3D10Texture2D *texture;
if (SUCCEEDED(device->CreateTexture2D(&desc, NULL, &texture))){
if (msaaSamples > 1){
ID3D10Texture2D *resolved = NULL;
desc.Usage = D3D10_USAGE_DEFAULT;
desc.CPUAccessFlags = 0;
if (SUCCEEDED(device->CreateTexture2D(&desc, NULL, &resolved))){
device->ResolveSubresource(resolved, 0, backBuffer, 0, desc.Format);
device->CopyResource(texture, resolved);
resolved->Release();
}
} else {
device->CopyResource(texture, backBuffer);
}
D3D10_MAPPED_TEXTURE2D map;
if (SUCCEEDED(texture->Map(0, D3D10_MAP_READ, 0, &map))){
if (backBufferFormat == DXGI_FORMAT_R10G10B10A2_UNORM){
uint32 *dst = (uint32 *) img.create(FORMAT_RGB10A2, width, height, 1, 1);
ubyte *src = (ubyte *) map.pData;
for (int y = 0; y < height; y++){
for (int x = 0; x < width; x++){
dst[x] = ((uint32 *) src)[x] | 0xC0000000;
}
dst += width;
src += map.RowPitch;
}
} else {
ubyte *dst = img.create(FORMAT_RGB8, width, height, 1, 1);
ubyte *src = (ubyte *) map.pData;
for (int y = 0; y < height; y++){
for (int x = 0; x < width; x++){
dst[3 * x + 0] = src[4 * x + 0];
dst[3 * x + 1] = src[4 * x + 1];
dst[3 * x + 2] = src[4 * x + 2];
}
dst += width * 3;
src += map.RowPitch;
}
}
result = true;
texture->Unmap(0);
}
texture->Release();
}
return result;
}
void D3D10Grab(ID3D10Texture2D* pBackBuffer) {
D3D10_TEXTURE2D_DESC tex_desc;
pBackBuffer->GetDesc(&tex_desc);
ID3D10Device *pDev;
pBackBuffer->GetDevice(&pDev);
ID3D10Texture2D * pTexture;
D3D10_MAPPED_TEXTURE2D mappedTexture;
tex_desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
tex_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
tex_desc.ArraySize = 1;
tex_desc.MipLevels = 1;
tex_desc.BindFlags = 0;
tex_desc.SampleDesc.Count = 1;
tex_desc.SampleDesc.Quality = 0;
tex_desc.Usage = D3D10_USAGE_STAGING;
tex_desc.MiscFlags = 0;
HRESULT hr = pDev->CreateTexture2D(&tex_desc, NULL, &pTexture);
#ifdef DEBUG
reportLog(EVENTLOG_INFORMATION_TYPE, L"pDev->CreateTexture2D 0x%x", hr);
#endif
pDev->CopyResource(pTexture, pBackBuffer);
D3D10_BOX box = {0, 0, tex_desc.Width, tex_desc.Height, 0, 1};
pDev->CopySubresourceRegion(pTexture, 0, 0, 0, 0, pBackBuffer, 0, &box);
DxgiFrameGrabber *dxgiFrameGrabber = DxgiFrameGrabber::getInstance();
IPCContext *ipcContext = dxgiFrameGrabber->m_ipcContext;
Logger *logger = dxgiFrameGrabber->m_logger;
if (S_OK != (hr = pTexture->Map(D3D10CalcSubresource(0, 0, 1), D3D10_MAP_READ, 0, &mappedTexture))) {
logger->reportLogError(L"d3d10 couldn't map texture, hresult = 0x%x", hr);
goto end;
}
ipcContext->m_memDesc.width = tex_desc.Width;
ipcContext->m_memDesc.height = tex_desc.Height;
ipcContext->m_memDesc.rowPitch = mappedTexture.RowPitch;
ipcContext->m_memDesc.format = BufferFormatAbgr;
ipcContext->m_memDesc.frameId++;
// reportLog(EVENTLOG_INFORMATION_TYPE, L"d3d10 texture description. width: %u, height: %u, pitch: %u", tex_desc.Width, tex_desc.Height, mappedTexture.RowPitch);
DWORD errorcode;
if (WAIT_OBJECT_0 == (errorcode = WaitForSingleObject(ipcContext->m_hMutex, 0))) {
// __asm__("int $3");
// reportLog(EVENTLOG_INFORMATION_TYPE, L"d3d10 writing description to mem mapped file");
memcpy(ipcContext->m_pMemMap, &ipcContext->m_memDesc, sizeof (ipcContext->m_memDesc));
// reportLog(EVENTLOG_INFORMATION_TYPE, L"d3d10 writing data to mem mapped file");
PVOID pMemDataMap = incPtr(ipcContext->m_pMemMap, sizeof (ipcContext->m_memDesc));
if (mappedTexture.RowPitch == tex_desc.Width * 4) {
memcpy(pMemDataMap, mappedTexture.pData, tex_desc.Width * tex_desc.Height * 4);
} else {
UINT cleanOffset = 0, pitchOffset = 0, i = 0;
while (i < tex_desc.Height) {
memcpy(incPtr(pMemDataMap, cleanOffset), incPtr(mappedTexture.pData, pitchOffset), tex_desc.Width * 4);
cleanOffset += tex_desc.Width * 4;
pitchOffset += mappedTexture.RowPitch;
i++;
}
}
ReleaseMutex(ipcContext->m_hMutex);
SetEvent(ipcContext->m_hFrameGrabbedEvent);
} else {
logger->reportLogError(L"d3d10 couldn't wait mutex. errocode = 0x%x", errorcode);
}
pTexture->Unmap(D3D10CalcSubresource(0, 0, 1));
end:
pTexture->Release();
pDev->Release();
}
//--------------------------------------------------------------------------------------
HRESULT SaveSpectogramToFile( ID3D10Device* pd3dDevice, LPCTSTR szFileName, ID3D10Texture2D* pTex )
{
HRESULT hr = S_OK;
DWORD dwBytesWritten = 0;
// Open the file
HANDLE hFile = CreateFile( szFileName, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS,
FILE_FLAG_SEQUENTIAL_SCAN, NULL );
if( INVALID_HANDLE_VALUE == hFile )
return E_FAIL;
// Get the size from the texture
D3D10_TEXTURE2D_DESC desc;
pTex->GetDesc( &desc );
UINT iWidth = ( UINT )desc.Width;
UINT iHeight = ( UINT )desc.Height;
// Fill out the BMP header
BITMAPINFOHEADER bih;
ZeroMemory( &bih, sizeof( BITMAPINFOHEADER ) );
bih.biSize = sizeof( BITMAPINFOHEADER );
bih.biWidth = iHeight;
bih.biHeight = iWidth;
bih.biPlanes = 1;
bih.biBitCount = 24;
bih.biCompression = BI_RGB;
bih.biSizeImage = 0;
// Find our pad amount
int iPadAmt = 0;
if( 0 != ( ( iHeight * 3 ) % 4 ) )
iPadAmt = 4 - ( ( iHeight * 3 ) % 4 );
BITMAPFILEHEADER bfh;
ZeroMemory( &bfh, sizeof( BITMAPFILEHEADER ) );
bfh.bfType = MAKEWORD( 'B', 'M' );
bfh.bfSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + ( iWidth * 3 + iPadAmt ) *
iHeight * sizeof( unsigned char );
bfh.bfOffBits = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER );
// Write out the file header
WriteFile( hFile, &bfh, sizeof( BITMAPFILEHEADER ), &dwBytesWritten, NULL );
WriteFile( hFile, &bih, sizeof( BITMAPINFOHEADER ), &dwBytesWritten, NULL );
// Create a staging resource to get our data back to the CPU
ID3D10Texture2D* pStagingResource = NULL;
D3D10_TEXTURE2D_DESC dstex;
pTex->GetDesc( &dstex );
dstex.Usage = D3D10_USAGE_STAGING; // Staging allows us to copy to and from the GPU
dstex.BindFlags = 0; // Staging resources cannot be bound to ANY part of the pipeline
dstex.CPUAccessFlags = D3D10_CPU_ACCESS_READ; // We want to read from this resource
hr = pd3dDevice->CreateTexture2D( &dstex, NULL, &pStagingResource );
if( FAILED( hr ) )
{
CloseHandle( hFile );
return hr;
}
// Copy the data from the GPU resource to the CPU resource
pd3dDevice->CopyResource( pStagingResource, pTex );
// Map the CPU staging resource
D3D10_MAPPED_TEXTURE2D map;
hr = pStagingResource->Map( 0, D3D10_MAP_READ, NULL, &map );
if( FAILED( hr ) )
{
CloseHandle( hFile );
return hr;
}
float* pColors = ( float* )map.pData;
// Find the maximum data component
unsigned long ulIndex = 0;
float fMaxReal = 0.0f;
float fMaxImag = 0.0f;
for( unsigned long h = 0; h < iHeight; h++ )
{
ulIndex = ( unsigned long )( h * map.RowPitch / sizeof( float ) );
for( unsigned long w = 0; w < iWidth; w++ )
{
if( fMaxReal < fabs( pColors[ ulIndex ] ) )
fMaxReal = fabsf( pColors[ ulIndex ] );
if( fMaxImag < fabs( pColors[ ulIndex + 1 ] ) )
fMaxImag = fabsf( pColors[ ulIndex + 1 ] );
ulIndex += 2;
}
}
fMaxReal = 2.0f;
fMaxImag = 2.0f;
// Write out the bits in a more familiar frequency vs time format
// Basically, swap x and y
float fBlue, fGreen;
unsigned char ucRed, ucGreen, ucBlue;
for( unsigned long w = 0; w < iWidth * 2; w += 2 )
{
for( unsigned long h = 0; h < iHeight; h++ )
{
ulIndex = ( unsigned long )( h * map.RowPitch / sizeof( float ) ) + w;
fBlue = fabsf( pColors[ ulIndex ] ) / fMaxReal;
fGreen = fabsf( pColors[ ulIndex + 1 ] ) / fMaxImag;
if( fBlue > 1.0f )
fBlue = 1.0f;
if( fGreen > 1.0f )
fGreen = 1.0f;
ucBlue = ( unsigned char )( 255.0f * fBlue );
ucGreen = ( unsigned char )( 255.0f * fGreen );
ucRed = 0;
WriteFile( hFile, &ucRed, sizeof( unsigned char ), &dwBytesWritten, NULL );
WriteFile( hFile, &ucGreen, sizeof( unsigned char ), &dwBytesWritten, NULL );
WriteFile( hFile, &ucBlue, sizeof( unsigned char ), &dwBytesWritten, NULL );
}
ucRed = 0;
for( int i = 0; i < iPadAmt; i++ )
{
WriteFile( hFile, &ucRed, sizeof( unsigned char ), &dwBytesWritten, NULL );
}
}
CloseHandle( hFile );
pStagingResource->Unmap( 0 );
SAFE_RELEASE( pStagingResource );
return S_OK;
}
//todo: this function is an abomination, this is just disgusting. fix it.
//...seriously, this is really, really horrible. I mean this is amazingly bad.
void OBS::MainCaptureLoop()
{
int curRenderTarget = 0, curYUVTexture = 0, curCopyTexture = 0;
int copyWait = NUM_RENDER_BUFFERS-1;
bSentHeaders = false;
bFirstAudioPacket = true;
Vect2 baseSize = Vect2(float(baseCX), float(baseCY));
Vect2 outputSize = Vect2(float(outputCX), float(outputCY));
Vect2 scaleSize = Vect2(float(scaleCX), float(scaleCY));
HANDLE hScaleVal = yuvScalePixelShader->GetParameterByName(TEXT("baseDimensionI"));
LPVOID nullBuff = NULL;
//----------------------------------------
// x264 input buffers
int curOutBuffer = 0;
x264_picture_t *lastPic = NULL;
x264_picture_t outPics[NUM_OUT_BUFFERS];
DWORD outTimes[NUM_OUT_BUFFERS] = {0, 0, 0};
for(int i=0; i<NUM_OUT_BUFFERS; i++)
x264_picture_init(&outPics[i]);
if(bUsing444)
{
for(int i=0; i<NUM_OUT_BUFFERS; i++)
{
outPics[i].img.i_csp = X264_CSP_BGRA; //although the x264 input says BGR, x264 actually will expect packed UYV
outPics[i].img.i_plane = 1;
}
}
else
{
for(int i=0; i<NUM_OUT_BUFFERS; i++)
x264_picture_alloc(&outPics[i], X264_CSP_I420, outputCX, outputCY);
}
//----------------------------------------
// time/timestamp stuff
LARGE_INTEGER clockFreq;
QueryPerformanceFrequency(&clockFreq);
bufferedTimes.Clear();
ctsOffsets.Clear();
#ifdef USE_100NS_TIME
QWORD streamTimeStart = GetQPCTime100NS(clockFreq.QuadPart);
QWORD frameTime100ns = 10000000/fps;
QWORD sleepTargetTime = 0;
bool bWasLaggedFrame = false;
#else
DWORD streamTimeStart = OSGetTime();
#endif
totalStreamTime = 0;
lastAudioTimestamp = 0;
latestVideoTime = firstSceneTimestamp = GetQPCTimeMS(clockFreq.QuadPart);
DWORD fpsTimeNumerator = 1000-(frameTime*fps);
DWORD fpsTimeDenominator = fps;
DWORD fpsTimeAdjust = 0;
DWORD cfrTime = 0;
DWORD cfrTimeAdjust = 0;
//----------------------------------------
// start audio capture streams
desktopAudio->StartCapture();
if(micAudio) micAudio->StartCapture();
//----------------------------------------
// status bar/statistics stuff
DWORD fpsCounter = 0;
int numLongFrames = 0;
int numTotalFrames = 0;
int numTotalDuplicatedFrames = 0;
bytesPerSec = 0;
captureFPS = 0;
curFramesDropped = 0;
curStrain = 0.0;
PostMessage(hwndMain, OBS_UPDATESTATUSBAR, 0, 0);
QWORD lastBytesSent[3] = {0, 0, 0};
DWORD lastFramesDropped = 0;
#ifdef USE_100NS_TIME
double bpsTime = 0.0;
#else
float bpsTime = 0.0f;
#endif
double lastStrain = 0.0f;
DWORD numSecondsWaited = 0;
//----------------------------------------
// 444->420 thread data
int numThreads = MAX(OSGetTotalCores()-2, 1);
HANDLE *h420Threads = (HANDLE*)Allocate(sizeof(HANDLE)*numThreads);
Convert444Data *convertInfo = (Convert444Data*)Allocate(sizeof(Convert444Data)*numThreads);
zero(h420Threads, sizeof(HANDLE)*numThreads);
zero(convertInfo, sizeof(Convert444Data)*numThreads);
for(int i=0; i<numThreads; i++)
{
convertInfo[i].width = outputCX;
convertInfo[i].height = outputCY;
convertInfo[i].hSignalConvert = CreateEvent(NULL, FALSE, FALSE, NULL);
convertInfo[i].hSignalComplete = CreateEvent(NULL, FALSE, FALSE, NULL);
if(i == 0)
convertInfo[i].startY = 0;
else
convertInfo[i].startY = convertInfo[i-1].endY;
if(i == (numThreads-1))
convertInfo[i].endY = outputCY;
else
convertInfo[i].endY = ((outputCY/numThreads)*(i+1)) & 0xFFFFFFFE;
}
bool bFirstFrame = true;
bool bFirstImage = true;
bool bFirst420Encode = true;
bool bUseThreaded420 = bUseMultithreadedOptimizations && (OSGetTotalCores() > 1) && !bUsing444;
List<HANDLE> completeEvents;
if(bUseThreaded420)
{
for(int i=0; i<numThreads; i++)
{
h420Threads[i] = OSCreateThread((XTHREAD)Convert444Thread, convertInfo+i);
completeEvents << convertInfo[i].hSignalComplete;
}
}
//----------------------------------------
QWORD curStreamTime = 0, lastStreamTime, firstFrameTime = GetQPCTimeMS(clockFreq.QuadPart);
lastStreamTime = firstFrameTime-frameTime;
bool bFirstAudioPacket = true;
while(bRunning)
{
#ifdef USE_100NS_TIME
QWORD renderStartTime = GetQPCTime100NS(clockFreq.QuadPart);
if(sleepTargetTime == 0 || bWasLaggedFrame)
sleepTargetTime = renderStartTime;
#else
DWORD renderStartTime = OSGetTime();
totalStreamTime = renderStartTime-streamTimeStart;
DWORD frameTimeAdjust = frameTime;
fpsTimeAdjust += fpsTimeNumerator;
if(fpsTimeAdjust > fpsTimeDenominator)
{
fpsTimeAdjust -= fpsTimeDenominator;
++frameTimeAdjust;
}
#endif
bool bRenderView = !IsIconic(hwndMain) && bRenderViewEnabled;
profileIn("frame");
#ifdef USE_100NS_TIME
QWORD qwTime = renderStartTime/10000;
latestVideoTime = qwTime;
QWORD frameDelta = renderStartTime-lastStreamTime;
double fSeconds = double(frameDelta)*0.0000001;
//Log(TEXT("frameDelta: %f"), fSeconds);
lastStreamTime = renderStartTime;
#else
QWORD qwTime = GetQPCTimeMS(clockFreq.QuadPart);
latestVideoTime = qwTime;
QWORD frameDelta = qwTime-lastStreamTime;
float fSeconds = float(frameDelta)*0.001f;
//Log(TEXT("frameDelta: %llu"), frameDelta);
lastStreamTime = qwTime;
#endif
//------------------------------------
if(bRequestKeyframe && keyframeWait > 0)
{
keyframeWait -= int(frameDelta);
if(keyframeWait <= 0)
{
GetVideoEncoder()->RequestKeyframe();
bRequestKeyframe = false;
}
}
if(!bPushToTalkDown && pushToTalkTimeLeft > 0)
{
pushToTalkTimeLeft -= int(frameDelta);
OSDebugOut(TEXT("time left: %d\r\n"), pushToTalkTimeLeft);
if(pushToTalkTimeLeft <= 0)
{
pushToTalkTimeLeft = 0;
bPushToTalkOn = false;
}
}
//------------------------------------
OSEnterMutex(hSceneMutex);
if(bResizeRenderView)
{
GS->ResizeView();
bResizeRenderView = false;
}
//------------------------------------
if(scene)
{
profileIn("scene->Preprocess");
scene->Preprocess();
for(UINT i=0; i<globalSources.Num(); i++)
globalSources[i].source->Preprocess();
profileOut;
scene->Tick(float(fSeconds));
for(UINT i=0; i<globalSources.Num(); i++)
globalSources[i].source->Tick(float(fSeconds));
}
//------------------------------------
QWORD curBytesSent = network->GetCurrentSentBytes();
curFramesDropped = network->NumDroppedFrames();
bool bUpdateBPS = false;
bpsTime += fSeconds;
if(bpsTime > 1.0f)
{
if(numSecondsWaited < 3)
++numSecondsWaited;
//bytesPerSec = DWORD(curBytesSent - lastBytesSent);
bytesPerSec = DWORD(curBytesSent - lastBytesSent[0]) / numSecondsWaited;
if(bpsTime > 2.0)
bpsTime = 0.0f;
else
bpsTime -= 1.0;
if(numSecondsWaited == 3)
{
lastBytesSent[0] = lastBytesSent[1];
lastBytesSent[1] = lastBytesSent[2];
lastBytesSent[2] = curBytesSent;
}
else
lastBytesSent[numSecondsWaited] = curBytesSent;
captureFPS = fpsCounter;
fpsCounter = 0;
bUpdateBPS = true;
}
fpsCounter++;
curStrain = network->GetPacketStrain();
EnableBlending(TRUE);
BlendFunction(GS_BLEND_SRCALPHA, GS_BLEND_INVSRCALPHA);
//------------------------------------
// render the mini render texture
LoadVertexShader(mainVertexShader);
LoadPixelShader(mainPixelShader);
SetRenderTarget(mainRenderTextures[curRenderTarget]);
Ortho(0.0f, baseSize.x, baseSize.y, 0.0f, -100.0f, 100.0f);
SetViewport(0, 0, baseSize.x, baseSize.y);
if(scene)
scene->Render();
//------------------------------------
if(bTransitioning)
{
if(!transitionTexture)
{
transitionTexture = CreateTexture(baseCX, baseCY, GS_BGRA, NULL, FALSE, TRUE);
if(transitionTexture)
{
D3D10Texture *d3dTransitionTex = static_cast<D3D10Texture*>(transitionTexture);
D3D10Texture *d3dSceneTex = static_cast<D3D10Texture*>(mainRenderTextures[lastRenderTarget]);
GetD3D()->CopyResource(d3dTransitionTex->texture, d3dSceneTex->texture);
}
else
bTransitioning = false;
}
else if(transitionAlpha >= 1.0f)
{
delete transitionTexture;
transitionTexture = NULL;
bTransitioning = false;
}
}
if(bTransitioning)
{
EnableBlending(TRUE);
transitionAlpha += float(fSeconds)*5.0f;
if(transitionAlpha > 1.0f)
transitionAlpha = 1.0f;
}
else
EnableBlending(FALSE);
//------------------------------------
// render the mini view thingy
if(bRenderView)
{
Vect2 renderFrameSize = Vect2(float(renderFrameWidth), float(renderFrameHeight));
SetRenderTarget(NULL);
LoadVertexShader(mainVertexShader);
LoadPixelShader(mainPixelShader);
Ortho(0.0f, renderFrameSize.x, renderFrameSize.y, 0.0f, -100.0f, 100.0f);
SetViewport(0.0f, 0.0f, renderFrameSize.x, renderFrameSize.y);
if(bTransitioning)
{
BlendFunction(GS_BLEND_ONE, GS_BLEND_ZERO);
if(renderFrameIn1To1Mode)
DrawSprite(transitionTexture, 0xFFFFFFFF, 0.0f, 0.0f, outputSize.x, outputSize.y);
else
DrawSprite(transitionTexture, 0xFFFFFFFF, 0.0f, 0.0f, renderFrameSize.x, renderFrameSize.y);
BlendFunction(GS_BLEND_FACTOR, GS_BLEND_INVFACTOR, transitionAlpha);
}
if(renderFrameIn1To1Mode)
DrawSprite(mainRenderTextures[curRenderTarget], 0xFFFFFFFF, 0.0f, 0.0f, outputSize.x, outputSize.y);
else
DrawSprite(mainRenderTextures[curRenderTarget], 0xFFFFFFFF, 0.0f, 0.0f, renderFrameSize.x, renderFrameSize.y);
Ortho(0.0f, renderFrameSize.x, renderFrameSize.y, 0.0f, -100.0f, 100.0f);
//draw selections if in edit mode
if(bEditMode && !bSizeChanging)
{
LoadVertexShader(solidVertexShader);
LoadPixelShader(solidPixelShader);
solidPixelShader->SetColor(solidPixelShader->GetParameter(0), 0xFFFF0000);
if(renderFrameIn1To1Mode)
Ortho(0.0f, renderFrameSize.x * downscale, renderFrameSize.y * downscale, 0.0f, -100.0f, 100.0f);
else
Ortho(0.0f, baseSize.x, baseSize.y, 0.0f, -100.0f, 100.0f);
if(scene)
scene->RenderSelections();
}
}
else if(bForceRenderViewErase)
{
InvalidateRect(hwndRenderFrame, NULL, TRUE);
UpdateWindow(hwndRenderFrame);
bForceRenderViewErase = false;
}
//------------------------------------
// actual stream output
LoadVertexShader(mainVertexShader);
LoadPixelShader(yuvScalePixelShader);
Texture *yuvRenderTexture = yuvRenderTextures[curRenderTarget];
SetRenderTarget(yuvRenderTexture);
yuvScalePixelShader->SetVector2(hScaleVal, 1.0f/baseSize);
Ortho(0.0f, outputSize.x, outputSize.y, 0.0f, -100.0f, 100.0f);
SetViewport(0.0f, 0.0f, outputSize.x, outputSize.y);
//why am I using scaleSize instead of outputSize for the texture?
//because outputSize can be trimmed by up to three pixels due to 128-bit alignment.
//using the scale function with outputSize can cause slightly inaccurate scaled images
if(bTransitioning)
{
BlendFunction(GS_BLEND_ONE, GS_BLEND_ZERO);
DrawSpriteEx(transitionTexture, 0xFFFFFFFF, 0.0f, 0.0f, scaleSize.x, scaleSize.y, 0.0f, 0.0f, scaleSize.x, scaleSize.y);
BlendFunction(GS_BLEND_FACTOR, GS_BLEND_INVFACTOR, transitionAlpha);
}
DrawSpriteEx(mainRenderTextures[curRenderTarget], 0xFFFFFFFF, 0.0f, 0.0f, outputSize.x, outputSize.y, 0.0f, 0.0f, outputSize.x, outputSize.y);
//------------------------------------
if(bRenderView && !copyWait)
static_cast<D3D10System*>(GS)->swap->Present(0, 0);
OSLeaveMutex(hSceneMutex);
//------------------------------------
// present/upload
profileIn("video encoding and uploading");
bool bEncode = true;
if(copyWait)
{
copyWait--;
bEncode = false;
}
else
{
//audio sometimes takes a bit to start -- do not start processing frames until audio has started capturing
if(!bRecievedFirstAudioFrame)
bEncode = false;
else if(bFirstFrame)
{
firstFrameTime = qwTime;
bFirstFrame = false;
}
if(!bEncode)
{
if(curYUVTexture == (NUM_RENDER_BUFFERS-1))
curYUVTexture = 0;
else
curYUVTexture++;
}
}
if(bEncode)
{
curStreamTime = qwTime-firstFrameTime;
UINT prevCopyTexture = (curCopyTexture == 0) ? NUM_RENDER_BUFFERS-1 : curCopyTexture-1;
ID3D10Texture2D *copyTexture = copyTextures[curCopyTexture];
profileIn("CopyResource");
if(!bFirst420Encode && bUseThreaded420)
{
WaitForMultipleObjects(completeEvents.Num(), completeEvents.Array(), TRUE, INFINITE);
copyTexture->Unmap(0);
}
D3D10Texture *d3dYUV = static_cast<D3D10Texture*>(yuvRenderTextures[curYUVTexture]);
GetD3D()->CopyResource(copyTexture, d3dYUV->texture);
profileOut;
ID3D10Texture2D *prevTexture = copyTextures[prevCopyTexture];
if(bFirstImage) //ignore the first frame
bFirstImage = false;
else
{
HRESULT result;
D3D10_MAPPED_TEXTURE2D map;
if(SUCCEEDED(result = prevTexture->Map(0, D3D10_MAP_READ, 0, &map)))
{
int prevOutBuffer = (curOutBuffer == 0) ? NUM_OUT_BUFFERS-1 : curOutBuffer-1;
int nextOutBuffer = (curOutBuffer == NUM_OUT_BUFFERS-1) ? 0 : curOutBuffer+1;
x264_picture_t &prevPicOut = outPics[prevOutBuffer];
x264_picture_t &picOut = outPics[curOutBuffer];
x264_picture_t &nextPicOut = outPics[nextOutBuffer];
if(!bUsing444)
{
profileIn("conversion to 4:2:0");
if(bUseThreaded420)
{
outTimes[nextOutBuffer] = (DWORD)curStreamTime;
for(int i=0; i<numThreads; i++)
{
convertInfo[i].input = (LPBYTE)map.pData;
convertInfo[i].pitch = map.RowPitch;
convertInfo[i].output[0] = nextPicOut.img.plane[0];
convertInfo[i].output[1] = nextPicOut.img.plane[1];
convertInfo[i].output[2] = nextPicOut.img.plane[2];
SetEvent(convertInfo[i].hSignalConvert);
}
if(bFirst420Encode)
bFirst420Encode = bEncode = false;
}
else
{
outTimes[curOutBuffer] = (DWORD)curStreamTime;
Convert444to420((LPBYTE)map.pData, outputCX, map.RowPitch, outputCY, 0, outputCY, picOut.img.plane, SSE2Available());
prevTexture->Unmap(0);
}
profileOut;
}
else
{
outTimes[curOutBuffer] = (DWORD)curStreamTime;
picOut.img.i_stride[0] = map.RowPitch;
picOut.img.plane[0] = (uint8_t*)map.pData;
}
if(bEncode)
{
DWORD curFrameTimestamp = outTimes[prevOutBuffer];
//Log(TEXT("curFrameTimestamp: %u"), curFrameTimestamp);
//------------------------------------
FrameProcessInfo frameInfo;
frameInfo.firstFrameTime = firstFrameTime;
frameInfo.prevTexture = prevTexture;
if(bUseCFR)
{
while(cfrTime < curFrameTimestamp)
{
DWORD frameTimeAdjust = frameTime;
cfrTimeAdjust += fpsTimeNumerator;
if(cfrTimeAdjust > fpsTimeDenominator)
{
cfrTimeAdjust -= fpsTimeDenominator;
++frameTimeAdjust;
}
DWORD halfTime = (frameTimeAdjust+1)/2;
x264_picture_t *nextPic = (curFrameTimestamp-cfrTime <= halfTime) ? &picOut : &prevPicOut;
//Log(TEXT("cfrTime: %u, time: %u"), cfrTime, curFrameTimestamp);
//these lines are just for counting duped frames
if(nextPic == lastPic)
++numTotalDuplicatedFrames;
else
lastPic = nextPic;
frameInfo.picOut = nextPic;
frameInfo.picOut->i_pts = cfrTime;
frameInfo.frameTimestamp = cfrTime;
ProcessFrame(frameInfo);
cfrTime += frameTimeAdjust;
//Log(TEXT("cfrTime: %u, chi frame: %u"), cfrTime, (curFrameTimestamp-cfrTime <= halfTime));
}
}
else
{
picOut.i_pts = curFrameTimestamp;
frameInfo.picOut = &picOut;
frameInfo.frameTimestamp = curFrameTimestamp;
ProcessFrame(frameInfo);
}
}
curOutBuffer = nextOutBuffer;
}
else
{
//We have to crash, or we end up deadlocking the thread when the convert threads are never signalled
CrashError (TEXT("Texture->Map failed: 0x%08x"), result);
}
}
if(curCopyTexture == (NUM_RENDER_BUFFERS-1))
curCopyTexture = 0;
else
curCopyTexture++;
if(curYUVTexture == (NUM_RENDER_BUFFERS-1))
curYUVTexture = 0;
else
curYUVTexture++;
}
lastRenderTarget = curRenderTarget;
if(curRenderTarget == (NUM_RENDER_BUFFERS-1))
curRenderTarget = 0;
else
curRenderTarget++;
if(bUpdateBPS || !CloseDouble(curStrain, lastStrain) || curFramesDropped != lastFramesDropped)
{
PostMessage(hwndMain, OBS_UPDATESTATUSBAR, 0, 0);
lastStrain = curStrain;
lastFramesDropped = curFramesDropped;
}
profileOut;
profileOut;
//------------------------------------
// get audio while sleeping or capturing
//ReleaseSemaphore(hRequestAudioEvent, 1, NULL);
//------------------------------------
// frame sync
#ifdef USE_100NS_TIME
QWORD renderStopTime = GetQPCTime100NS(clockFreq.QuadPart);
sleepTargetTime += frameTime100ns;
if(bWasLaggedFrame = (sleepTargetTime <= renderStopTime))
numLongFrames++;
else
SleepTo(clockFreq.QuadPart, sleepTargetTime);
#else
DWORD renderStopTime = OSGetTime();
DWORD totalTime = renderStopTime-renderStartTime;
if(totalTime > frameTimeAdjust)
numLongFrames++;
else if(totalTime < frameTimeAdjust)
OSSleep(frameTimeAdjust-totalTime);
#endif
//OSDebugOut(TEXT("Frame adjust time: %d, "), frameTimeAdjust-totalTime);
numTotalFrames++;
}
if(!bUsing444)
{
if(bUseThreaded420)
{
for(int i=0; i<numThreads; i++)
{
if(h420Threads[i])
{
convertInfo[i].bKillThread = true;
SetEvent(convertInfo[i].hSignalConvert);
OSTerminateThread(h420Threads[i], 10000);
h420Threads[i] = NULL;
}
if(convertInfo[i].hSignalConvert)
{
CloseHandle(convertInfo[i].hSignalConvert);
convertInfo[i].hSignalConvert = NULL;
}
if(convertInfo[i].hSignalComplete)
{
CloseHandle(convertInfo[i].hSignalComplete);
convertInfo[i].hSignalComplete = NULL;
}
}
if(!bFirst420Encode)
{
ID3D10Texture2D *copyTexture = copyTextures[curCopyTexture];
copyTexture->Unmap(0);
}
}
for(int i=0; i<NUM_OUT_BUFFERS; i++)
x264_picture_clean(&outPics[i]);
}
Free(h420Threads);
Free(convertInfo);
Log(TEXT("Total frames rendered: %d, number of frames that lagged: %d (%0.2f%%) (it's okay for some frames to lag)"), numTotalFrames, numLongFrames, (double(numLongFrames)/double(numTotalFrames))*100.0);
if(bUseCFR)
Log(TEXT("Total duplicated CFR frames: %d"), numTotalDuplicatedFrames);
}