it-swarm.com.ru

Самый быстрый способ захвата экрана в Windows

Я хочу написать программу для скринкастинга для платформы Windows, но не знаю, как сделать снимок экрана. Единственный известный мне метод - это использовать GDI, но мне любопытно, есть ли другие способы сделать это, и, если есть, то какие издержки наименьшие? Скорость является приоритетом.

Программа для создания скринкастинга будет предназначена для записи игровых материалов, хотя, если это сузит варианты, я по-прежнему открыт для любых других предложений, которые выпадают из этой области. Знание не плохо, в конце концов.

Редактировать : я наткнулся на эту статью: Различные способы захвата экрана . Он познакомил меня со способом Windows Media API и способом DirectX. В заключении упоминается, что отключение аппаратного ускорения может значительно повысить производительность приложения захвата. Мне любопытно, почему это так. Может ли кто-нибудь заполнить пропущенные для меня пробелы?

Редактировать : я читал, что программы для создания скриншотов, такие как Camtasia, используют собственный драйвер захвата. Может ли кто-нибудь дать мне подробное объяснение того, как это работает, и почему это быстрее? Мне также может понадобиться руководство по реализации чего-то подобного, но я уверен, что в любом случае существует документация.

Также теперь я знаю, как FRAPS записывает экран. Он перехватывает базовый графический API для чтения из заднего буфера. Из того, что я понимаю, это быстрее, чем чтение из переднего буфера, потому что вы читаете из системной памяти, а не видео-памяти. Вы можете прочитать статью здесь .

146
someguy

Это то, что я использую, чтобы собирать отдельные кадры, но если вы измените это и будете постоянно держать две цели открытыми, то вы можете "передать" их на диск, используя статический счетчик для имени файла. - Я не могу вспомнить, где я нашел это, но это было изменено, спасибо кому бы то ни было!

void dump_buffer()
{
   IDirect3DSurface9* pRenderTarget=NULL;
   IDirect3DSurface9* pDestTarget=NULL;
     const char file[] = "Pickture.bmp";
   // sanity checks.
   if (Device == NULL)
      return;

   // get the render target surface.
   HRESULT hr = Device->GetRenderTarget(0, &pRenderTarget);
   // get the current adapter display mode.
   //hr = pDirect3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT,&d3ddisplaymode);

   // create a destination surface.
   hr = Device->CreateOffscreenPlainSurface(DisplayMde.Width,
                         DisplayMde.Height,
                         DisplayMde.Format,
                         D3DPOOL_SYSTEMMEM,
                         &pDestTarget,
                         NULL);
   //copy the render target to the destination surface.
   hr = Device->GetRenderTargetData(pRenderTarget, pDestTarget);
   //save its contents to a bitmap file.
   hr = D3DXSaveSurfaceToFile(file,
                              D3DXIFF_BMP,
                              pDestTarget,
                              NULL,
                              NULL);

   // clean up.
   pRenderTarget->Release();
   pDestTarget->Release();
}
55
Brandrew

Правка: я вижу, что это указано в вашей первой ссылке для редактирования как "GDI way". Это по-прежнему достойный способ, даже если учесть рекомендации по производительности на этом сайте, я думаю, вы можете легко получить 30fps.

Из этого комментария (у меня нет такого опыта, я просто ссылаюсь на того, кто это делает):

HDC hdc = GetDC(NULL); // get the desktop device context
HDC hDest = CreateCompatibleDC(hdc); // create a device context to use yourself

// get the height and width of the screen
int height = GetSystemMetrics(SM_CYVIRTUALSCREEN);
int width = GetSystemMetrics(SM_CXVIRTUALSCREEN);

// create a bitmap
HBITMAP hbDesktop = CreateCompatibleBitmap( hdc, width, height);

// use the previously created device context with the bitmap
SelectObject(hDest, hbDesktop);

// copy from the desktop device context to the bitmap device context
// call this once per 'frame'
BitBlt(hDest, 0,0, width, height, hdc, 0, 0, SRCCOPY);

// after the recording is done, release the desktop context you got..
ReleaseDC(NULL, hdc);

// ..delete the bitmap you were using to capture frames..
DeleteObject(hbDesktop);

// ..and delete the context you created
DeleteDC(hDest);

Я не говорю, что это самый быстрый способ, но операция BitBlt обычно выполняется очень быстро, если вы копируете между контекстами совместимого устройства.

Для справки, Open Broadcaster Software реализует нечто подобное как часть их метода "dc_capture" , хотя вместо создания контекста назначения hDest с использованием CreateCompatibleDC они используют IDXGISurface1 , который работает с DirectX 10+. Если это не поддерживается, они возвращаются к CreateCompatibleDC.

Чтобы изменить его на использование определенного приложения, вам нужно изменить первую строку на GetDC(game), где game - дескриптор окна игры, а затем установить правильные height и width окна игры.

Как только у вас есть пиксели в hDest/hbDesktop, вам все равно нужно сохранить их в файл, но если вы делаете снимок экрана, то я думаю, что вы захотите зарезервировать определенное количество их в памяти и сохранить в видеофайл. в кусках, поэтому я не буду указывать на код для сохранения статического образа на диск.

27
darvids0n

Я написал программное обеспечение для захвата видео, похожее на FRAPS для приложений DirectX. Исходный код доступен, и моя статья объясняет общую технику. Смотрите http://blog.nektra.com/main/2013/07/23/instrumenting-direct3d-applications-to-capture-video-and-calculate-frames-per-second/

Уважение к вашим вопросам, связанным с производительностью,

  • DirectX должен быть быстрее, чем GDI, за исключением случаев, когда вы читаете с фронт-буфера, который очень медленный. Мой подход похож на FRAPS (чтение из буфера). Я перехватываю множество методов из интерфейсов Direct3D.

  • Для записи видео в реальном времени (с минимальным воздействием на приложение) необходим быстрый кодек. FRAPS использует собственный видеокодек без потерь. Lagarith и HUFFYUV - это универсальные видеокодеки без потерь, разработанные для приложений реального времени. Вы должны посмотреть на них, если вы хотите выводить видео файлы.

  • Другим подходом к записи скринкастов может быть написание Зеркального драйвера. Согласно Википедии: Когда видео зеркалирование активно, каждый раз, когда система обращается к первичному видеоустройству в месте внутри зеркальной области, копия операции рисования выполняется на зеркальном видеоустройстве. в режиме реального времени. См. драйверы зеркал в MSDN: http://msdn.Microsoft.com/en-us/library/windows/hardware/ff568315 (v = vs. 85) .aspx .

17
Hernán

Я использую d3d9, чтобы получить буфер, и сохраняю его в файл png, используя библиотеку d3dx:

 IDirect3DSurface9 * surface; 
 
 //  GetBackBuffer  
 Idirect3ddevice9-> GetBackBuffer (0, 0, D3DBACKBUFFER_TYPE_MONO, & surface); 
 
 // сохранить поверхность 
 D3DXSaveSurfaceToFileA ("filename.png", D3DXIFF_PNG, поверхность, NULL, NULL); 
 
 SAFE_RELEASE (поверхность); 

Для этого вы должны создать свой swapbuffer с

d3dpps.SwapEffect = D3DSWAPEFFECT_COPY ; // for screenshots.

(Таким образом, вы гарантируете, что задний буфер не будет поврежден до того, как вы сделаете скриншот).

15
bobobobo

В моем впечатлении подход GDI и ​​подход DX различны по своей природе. При рисовании с использованием GDI применяется метод FLUSH, подход FLUSH рисует кадр, затем очищает его и перерисовывает другой кадр в том же буфере, это приведет к мерцанию в играх, требующих высокой частоты кадров.

  1. ПОЧЕМУ DX быстрее? в DX (или графическом мире) применяется более зрелый метод, называемый рендерингом с двойным буфером, где присутствуют два буфера, когда при представлении переднего буфера аппаратному обеспечению вы можете также выполнить рендеринг в другой буфер, а затем после кадра 1 После завершения рендеринга система переходит в другой буфер (блокируя его для представления на аппаратном уровне и освобождая предыдущий буфер), таким образом, эффективность неэффективности рендеринга значительно улучшается.
  2. ПОЧЕМУ отказ от аппаратного ускорения? хотя при рендеринге с двойным буфером FPS улучшается, но время рендеринга все еще ограничено. Современное графическое оборудование обычно требует значительных оптимизаций при рендеринге, как правило, таких как сглаживание, это требует больших вычислительных ресурсов, если вам не требуется высококачественная графика, конечно, вы можете просто отключить эту опцию. и это сэкономит вам время.

Я думаю, что вам действительно нужна система воспроизведения, я полностью согласен с тем, что обсуждали люди.

10
zinking

Я написал класс, в котором реализован метод GDI для захвата экрана. Я тоже хотел получить дополнительную скорость, поэтому, обнаружив метод DirectX (через GetFrontBuffer), я попробовал это, ожидая, что он будет быстрее.

Я с ужасом обнаружил, что GDI работает примерно в 2,5 раза быстрее. После 100 попыток захвата моего дисплея с двумя мониторами реализация GDI в среднем составляла 0,65 с на каждый снимок экрана, а метод DirectX - 1,72 с. Так что, согласно моим тестам, GDI определенно быстрее, чем GetFrontBuffer.

Мне не удалось заставить код Brandrew работать для тестирования DirectX через GetRenderTargetData. Экранная копия вышла чисто черной. Тем не менее, он может скопировать этот пустой экран очень быстро! Я продолжу возиться с этим и надеюсь получить рабочую версию, чтобы увидеть реальные результаты.

9
rotanimod

Несколько вещей, которые я смог найти: очевидно, "зеркальный драйвер" работает быстро, хотя я не знаю об OSS.

Почему RDP такой быстрый по сравнению с другими программами дистанционного управления?

Также очевидно, что использование некоторых сверток StretchRect быстрее, чем BitBlt

http://betterlogic.com/roger/2010/07/fast-screen-capture/comment-page-1/#comment-519

И тот, который вы упомянули (подключение Fraps к D3D dll), вероятно, является единственным способом для приложений D3D, но он не будет работать с захватом рабочего стола Windows XP. Так что теперь я просто хотел бы, чтобы по обычным окнам рабочего стола был эквивалентный Fraps. Кто-нибудь?

(Я думаю, что с помощью aero вы могли бы использовать фрейп-подобные хуки, но XP пользователям не повезет).

Также очевидно изменение битовой глубины экрана и/или отключение аппаратного ускорения. может помочь (и/или отключить аэро).

https://github.com/rdp/screen-capture-recorder-program включает в себя достаточно быструю утилиту захвата на основе BitBlt и тестовый модуль в составе своей установки, который может позволить вам измерять скорости BitBlt до оптимизировать их.

VirtualDub также имеет модуль захвата экрана "opengl", который, как говорят, быстр и делает такие вещи, как обнаружение изменений http://www.virtualdub.org/blog/pivot/entry.php?id=29

8
rogerdpack

Для C++ вы можете использовать: http://www.pinvoke.net/default.aspx/gdi32/BitBlt.html
Это может не работать на всех типах 3D-приложений/видео приложений. Тогда эта ссылка может быть более полезным, так как описывает 3 различных метода, которые вы можете использовать.

Старый ответ (C #):
Вы можете использовать System.Drawing.Graphics.Copy , но это не очень быстро.

Пример проекта, который я написал, делает именно это: http://blog.tedd.no/index.php/2010/08/16/c-image-analysis-auto-gaming-with-source/

Я планирую обновить этот образец, используя более быстрый метод, такой как Direct3D: http://spazzarama.com/2009/02/07/screencapture-with-direct3d/

А вот ссылка для захвата видео: Как сделать снимок экрана для видео с помощью C # .Net?

8
Tedd Hansen

Вы можете попробовать проект с открытым исходным кодом c ++ WinRobot @git , мощный захват экрана

CComPtr<IWinRobotService> pService;
hr = pService.CoCreateInstance(__uuidof(ServiceHost) );

//get active console session
CComPtr<IUnknown> pUnk;
hr = pService->GetActiveConsoleSession(&pUnk);
CComQIPtr<IWinRobotSession> pSession = pUnk;

// capture screen
pUnk = 0;
hr = pSession->CreateScreenCapture(0,0,1280,800,&pUnk);

// get screen image data(with file mapping)
CComQIPtr<IScreenBufferStream> pBuffer = pUnk;

Служба поддержки :

  • Окно UAC
  • Winlogon
  • DirectShowOverlay
5
Cayman

Я понимаю, что следующее предложение не отвечает на ваш вопрос, но самый простой метод, который я нашел для захвата быстро меняющегося представления DirectX, это подключить видеокамера к порту S-video видео карту и запишите изображения в виде фильма. Затем перенесите видео с камеры обратно в файл MPG, WMV, AVI и т.д. На компьютере.

3
Pierre

я сам делаю это с Directx и думаю, что это так быстро, как вы бы этого хотели. у меня нет быстрого примера кода, но я нашел это , что должно быть полезно. версия для DirectX11 не должна сильно отличаться, возможно, DirectX9 немного больше, но это путь

3
cppanda

В Windows 8 Microsoft представила API дублирования рабочего стола Windows. Это официально рекомендуемый способ сделать это. Одна приятная особенность, которую он имеет для показа экрана, заключается в том, что он обнаруживает движение окна, поэтому вы можете передавать дельты блоков при перемещении окон вместо необработанных пикселей. Кроме того, он сообщает вам, какие прямоугольники были изменены, от одного кадра к другому.

Пример кода Microsoft довольно сложный, но API на самом деле прост и удобен в использовании. Я собрал пример проекта, который намного проще, чем официальный пример:

https://github.com/bmharper/WindowsDesktopDuplicationSample

Документы: https://docs.Microsoft.com/en-gb/windows/desktop/direct3ddxgi/desktop-dup-api

Официальный пример кода Microsoft: https://code.msdn.Microsoft.com/windowsdesktop/Desktop-Duplication-Sample-da4c696a

2
Ben Harper