示例#1
0
static void ImplementFlip(IUnknown *surf,int version)
{
  IDirectDrawSurface *back = 0;

  videoNeedEncoder();

  if(params.CaptureVideo)
  {
    if(version < 4)
    {
      DDSCAPS caps;
      ZeroMemory(&caps,sizeof(caps));

      caps.dwCaps = DDSCAPS_BACKBUFFER;
      ((IDirectDrawSurface *) surf)->GetAttachedSurface(&caps,&back);
    }
    else
    {
      DDSCAPS2 caps;
      ZeroMemory(&caps,sizeof(caps));

      caps.dwCaps = DDSCAPS_BACKBUFFER;
      ((IDirectDrawSurface4 *) surf)->GetAttachedSurface(&caps,(IDirectDrawSurface4 **) &back);
    }

    if(back)
    {
      VideoCaptureDataLock lock;

      if(Blitter.BlitSurfaceToCapture(back,version))
        encoder->WriteFrame(captureData);

      back->Release();
    }
  }

  nextFrame();
}
示例#2
0
////////////////////////////////////////////////////////////////////////////
//
// @mfunc | CVisRefCntMemBlock | ~CVisRefCntMemBlock |
//
// Destructor called when this object is destroyed.  If this
// object allocated memory in its constructor, that memory
// will be freed when the destructor is called.  The destructor
// is virtual so that other classes can be derived from this
// class.
//
////////////////////////////////////////////////////////////////////////////
CVisRefCntMemBlock::~CVisRefCntMemBlock(void)
{
#ifdef _DEBUG
	if (m_pbData != 0)
	{
		// Decrement the count of blocks of this type.
		if ((m_evismemblock != evismemblockAllocFileMapping)
				&& (m_evismemblock != evismemblockAllocGlobalAlloc)
#ifdef VIS_MEMBLOCK_USE_IMALLOC
			&& (m_evismemblock != evismemblockAllocIMalloc)
#endif // VIS_MEMBLOCK_USE_IMALLOC
			&& (m_evismemblock != evismemblockAllocNewDouble))
		{
			-- s_cBlockExternal;
			s_cbExternalTotal -= m_cbData;
		}
		else
		{
			assert((m_evismemblock > 0) && (m_evismemblock <= cMemBlockAllocators));
			-- s_cBlockAlloc[m_evismemblock];
			s_cbAllocTotal[m_evismemblock] -= m_cbData;
		}

		// Ref count may not be zero if delete is used to destroy this
		// object.
		s_cAddRefTotal -= m_cRef;

		// Remove this memory block to the globals list of all memory blocks
		// currently in use.
		HANDLE hMutex =  CreateMutex(0, FALSE, "CVisRefCntMemBlockDebugMutex");
		assert(hMutex != 0);
		VisWaitForSingleObject(hMutex, INFINITE);

		CVisRefCntMemBlock *pRefCntMemBlockPrev = 0;
		CVisRefCntMemBlock *pRefCntMemBlock = s_pRefCntMemBlockFirst;
		while ((pRefCntMemBlock != this) && (pRefCntMemBlock != 0))
		{
			pRefCntMemBlockPrev = pRefCntMemBlock;
			pRefCntMemBlock = pRefCntMemBlock->m_pRefCntMemBlockNext;
		}

		if (pRefCntMemBlock != 0)
		{
			if (pRefCntMemBlockPrev == 0)
			{
				s_pRefCntMemBlockFirst = m_pRefCntMemBlockNext;
				m_pRefCntMemBlockNext = 0;
			}
			else
			{
				pRefCntMemBlockPrev->m_pRefCntMemBlockNext
						= m_pRefCntMemBlockNext;
				m_pRefCntMemBlockNext = 0;
			}
		}

		ReleaseMutex(hMutex);
		CloseHandle(hMutex);
	}
#endif // _DEBUG

	if (m_evismemblock == evismemblockAllocFileMapping)
	{
		// Free memory allocated using CreateFileMapping.
		assert(m_pbData != 0);
		UnmapViewOfFile(m_pbData);
		CloseHandle(m_hFileMapping);
		m_hFileMapping = 0;
	}
	else if (m_evismemblock == evismemblockAllocNewDouble)
	{
		// Free memory allocated using operator new.
		delete [] (double *) m_pbData;
	}
	else if (m_evismemblock == evismemblockAllocGlobalAlloc)
	{
		// Free memory allocated using GlobalAlloc.
		GlobalFree(m_pbData);
	}
#ifdef VIS_MEMBLOCK_USE_IMALLOC
	else if (m_evismemblock == evismemblockAllocIMalloc)
	{
		// Allocate memory using the OLE task allocator.
		CoTaskMemFree(m_pbData);
	}
#endif // VIS_MEMBLOCK_USE_IMALLOC
	else if (m_evismemblock == evismemblockAllocDirectDrawSurface)
	{
		// Release memory allocated using DirectDrawSurface
		assert(m_pvUser != 0);
		IDirectDrawSurface* pDDS = (IDirectDrawSurface *)m_pvUser;
		pDDS->Release();
	}
	else if (m_pfnCallback != 0)
	{
		m_pfnCallback(m_pbData, m_pvUser);
	}

	m_pbData = 0;
}
示例#3
0
  bool BlitSurfaceToCapture(IDirectDrawSurface *surf,int version)
  {
    IDirectDrawSurface* blitSurface = GetBlitSurface();
    if(!blitSurface || !SetFormatFromSurface(surf))
      return false;

    // blit backbuffer to our readback surface
    RECT rc;
    rc.left = 0;
    rc.top = 0;
    rc.right = captureWidth;
    rc.bottom = captureHeight;

    if(FAILED(blitSurface->Blt(&rc,surf,&rc,DDBLT_WAIT,0)))
    {
      printLog("video: blit failed\n");
      return false;
    }

    LPBYTE surface;
    DWORD pitch;

    if(version < 4)
    {
      DDSURFACEDESC ddsd;
      ZeroMemory(&ddsd,sizeof(ddsd));
      ddsd.dwSize = sizeof(ddsd);

      if(FAILED(blitSurface->Lock(0,&ddsd,DDLOCK_WAIT,0)))
      {
        printLog("video: can't lock surface\n");
        return false;
      }

      surface = (LPBYTE) ddsd.lpSurface;
      pitch = ddsd.lPitch;
    }
    else
    {
      IDirectDrawSurface4 *srf4 = (IDirectDrawSurface4 *) blitSurface;

      DDSURFACEDESC2 ddsd;
      ZeroMemory(&ddsd,sizeof(ddsd));
      ddsd.dwSize = sizeof(ddsd);

      if(FAILED(srf4->Lock(0,&ddsd,DDLOCK_WAIT,0)))
      {
        printLog("video: can't lock surface\n");
        return false;
      }

      surface = (LPBYTE) ddsd.lpSurface;
      pitch = ddsd.lPitch;
    }

    // blit individual lines
    for(int y=0;y<captureHeight;y++)
    {
      unsigned char *src = surface + (captureHeight-1-y) * pitch;
      unsigned char *dst = captureData + y * captureWidth * 3;

      BlitOneLine(src,dst,captureWidth);
    }

    blitSurface->Unlock(surface);
    blitSurface->Release();

    return true;
  }