【C++】DirectX9を利用したスクリーンキャプチャと画像保存処理の実装手法

#include <d3dx9.h>
#include <d3d9.h>
// 例：スクリーンショットをBMP形式で保存する関数
void SaveScreenshot(IDirect3DDevice9* pDevice, const wchar_t* filename)
{
    // バックバッファの取得
    LPDIRECT3DSURFACE9 pBackBuffer = nullptr;
    HRESULT hr = pDevice->GetRenderTarget(0, &pBackBuffer);
    if (FAILED(hr))
    {
        // 取得失敗時の処理
        return;
    }
    // 画像ファイルとして保存
    hr = D3DXSaveSurfaceToFile(
        filename,               // 保存先ファイル名
        D3DXIFF_BMP,            // ファイル形式
        pBackBuffer,            // 保存対象のサーフェイス
        nullptr,                // 追加のサーフェイス(不要)
        nullptr                 // オプション(不要)
    );
    // リソース解放
    pBackBuffer->Release();
}

#include <d3d9.h>
// 例：バックバッファの内容をシステムメモリにコピーする関数
void CopyBackBufferToSystemMemory(IDirect3DDevice9* pDevice, int width, int height, D3DFORMAT format)
{
    LPDIRECT3DSURFACE9 pBackBuffer = nullptr;
    pDevice->GetRenderTarget(0, &pBackBuffer);
    // システムメモリ上にロック可能なサーフェイスを作成
    LPDIRECT3DSURFACE9 pSystemMemorySurface = nullptr;
    HRESULT hr = pDevice->CreateOffscreenPlainSurface(
        width,
        height,
        format,
        D3DPOOL_SYSTEMMEM,
        &pSystemMemorySurface,
        nullptr
    );
    if (FAILED(hr))
    {
        pBackBuffer->Release();
        return;
    }
    // バックバッファの内容をシステムメモリにコピー
    hr = pDevice->GetRenderTargetData(pBackBuffer, pSystemMemorySurface);
    if (FAILED(hr))
    {
        pSystemMemorySurface->Release();
        pBackBuffer->Release();
        return;
    }
    // 以降、pSystemMemorySurfaceをロックして画像データにアクセス可能
    // 例：ロックしてピクセルデータを取得
    D3DLOCKED_RECT lockedRect;
    hr = pSystemMemorySurface->LockRect(&lockedRect, nullptr, D3DLOCK_READONLY);
    if (SUCCEEDED(hr))
    {
        // 画像データの処理
        // 例：ピクセルデータを保存や変換に利用
        pSystemMemorySurface->UnlockRect();
    }
    // リソース解放
    pSystemMemorySurface->Release();
    pBackBuffer->Release();
}

D3DLOCKED_RECT lockedRect;
HRESULT hr = pSurface->LockRect(&lockedRect, nullptr, D3DLOCK_READONLY);
if (SUCCEEDED(hr))
{
    // lockedRect.pBitsにピクセルデータが格納されている
    // ピッチはlockedRect.Pitchに格納されている
    // ピクセルデータのコピーや変換を行う
    pSurface->UnlockRect();
}

// 例：ピクセルデータのコピー
BYTE* pPixelData = static_cast<BYTE*>(lockedRect.pBits);
int lineSize = lockedRect.Pitch;
for (int y = 0; y < height; ++y)
{
    BYTE* pLine = pPixelData + y * lineSize;
    // pLineに1ライン分のピクセルデータが格納されている
    // これを画像保存や処理に利用
}

#include <d3d9.h>
// 例：バックバッファを取得するコード
LPDIRECT3DSURFACE9 pBackBuffer = nullptr;
HRESULT hr = pDevice->GetRenderTarget(0, &pBackBuffer);
if (FAILED(hr))
{
    // 取得に失敗した場合のエラーハンドリング
    // 例：リソースの解放やエラーメッセージの出力
}

// 取得したサーフェイスのリファレンスカウントは増加しているため、使用後は必ず解放
if (pBackBuffer)
{
    pBackBuffer->Release();
}

// 例：リファレンスカウントの管理
LPDIRECT3DSURFACE9 pBackBuffer = nullptr;
HRESULT hr = pDevice->GetRenderTarget(0, &pBackBuffer);
if (SUCCEEDED(hr))
{
    // 取得したサーフェイスを使った処理
    // 例：画像保存やデータ取得
    // 使用後は必ず解放
    pBackBuffer->Release();
}

// 例：幅・高さ・フォーマットの設定
int width = 1920; // 例：画面の横幅
int height = 1080; // 例：画面の縦幅
D3DFORMAT format = D3DFMT_A8R8G8B8; // 32ビットARGBフォーマット

// 例：システムメモリ上にサーフェイスを作成
LPDIRECT3DSURFACE9 pSurface = nullptr;
HRESULT hr = pDevice->CreateOffscreenPlainSurface(
    width,
    height,
    format,
    D3DPOOL_SYSTEMMEM,
    &pSurface,
    nullptr
);

#include <wrl/client.h>
using namespace Microsoft::WRL;
void CreateAndUseSurface(IDirect3DDevice9* pDevice)
{
    ComPtr<IDirect3DSurface9> pSurface;
    HRESULT hr = pDevice->CreateOffscreenPlainSurface(
        1920,
        1080,
        D3DFMT_A8R8G8B8,
        D3DPOOL_SYSTEMMEM,
        &pSurface,
        nullptr
    );
    if (SUCCEEDED(hr))
    {
        // ここでpSurfaceを使った処理
        // 使用後は自動的に解放される
    }
}

#include <d3d9.h>
// 例：バックバッファの内容をシステムメモリにコピー
HRESULT hr = pDevice->GetRenderTargetData(pBackBuffer, pSystemMemorySurface);
if (FAILED(hr))
{
    // コピー失敗時のエラーハンドリング
}

#include <d3d9.h>
// 例：サーフェイスのロックとピクセルデータの取得
D3DLOCKED_RECT lockedRect;
HRESULT hr = pSurface->LockRect(&lockedRect, nullptr, D3DLOCK_READONLY);
if (SUCCEEDED(hr))
{
    // lockedRect.pBitsにピクセルデータが格納されている
    // ピッチはlockedRect.Pitchに格納されている
    // 例：画像の一行分のデータにアクセス
    BYTE* pPixelData = static_cast<BYTE*>(lockedRect.pBits);
    int lineSize = lockedRect.Pitch;
    // 例：画像の各行にアクセス
    for (int y = 0; y < height; ++y)
    {
        BYTE* pLine = pPixelData + y * lineSize;
        // pLineに1行分のピクセルデータが格納されている
        // ここで必要な処理を行う
    }
    pSurface->UnlockRect();
}

HRESULT hr = pSurface->LockRect(&lockedRect, nullptr, D3DLOCK_READONLY);

// 例：ピクセルデータの1行分の開始アドレス
BYTE* pLineStart = static_cast<BYTE*>(lockedRect.pBits) + y * lockedRect.Pitch;

// 例：画像の横幅と高さ
int width = 1920;
int height = 1080;
// ピクセルフォーマットに応じた1ピクセルあたりのバイト数
int bytesPerPixel = 4; // D3DFMT_A8R8G8B8の場合は4バイト
// 必要なバッファサイズ
size_t bufferSize = width * height * bytesPerPixel;
// メモリ確保
BYTE* pImageBuffer = new BYTE[bufferSize];

// 使用後の解放
delete[] pImageBuffer;

// 例：ロックしたピクセルデータ
BYTE* pSrc = static_cast<BYTE*>(lockedRect.pBits);
int srcPitch = lockedRect.Pitch;
// コピー先バッファ
BYTE* pDest = pImageBuffer;
int destPitch = width * bytesPerPixel; // 1行分のバイト数
// 1行ずつコピー
for (int y = 0; y < height; ++y)
{
    // ソースの行の開始アドレス
    BYTE* pSrcLine = pSrc + y * srcPitch;
    // デスティネーションの行の開始アドレス
    BYTE* pDestLine = pDest + y * destPitch;
    // 行ごとにmemcpyでコピー
    memcpy(pDestLine, pSrcLine, destPitch);
}

#include <fstream>
#include <cstdint>
// BMPヘッダー構造体
#pragma pack(push, 1)
struct BMPHeader
{
    uint16_t bfType;      // ファイルタイプ ('BM')
    uint32_t bfSize;      // ファイルサイズ
    uint16_t bfReserved1; // 予約領域(0)
    uint16_t bfReserved2; // 予約領域(0)
    uint32_t bfOffBits;   // ピクセルデータの開始位置
};
struct BMPInfoHeader
{
    uint32_t biSize;          // ヘッダーサイズ
    int32_t biWidth;          // 画像の横幅
    int32_t biHeight;         // 画像の縦幅
    uint16_t biPlanes;        // プレーン数(1)
    uint16_t biBitCount;      // 1ピクセルあたりのビット数
    uint32_t biCompression;   // 圧縮方式(0=非圧縮)
    uint32_t biSizeImage;     // ピクセルデータのサイズ
    int32_t biXPelsPerMeter;  // 横解像度
    int32_t biYPelsPerMeter;  // 縦解像度
    uint32_t biClrUsed;       // 使用色数
    uint32_t biClrImportant;  // 重要な色数
};
#pragma pack(pop)
void SaveBMP(const char* filename, BYTE* pPixelData, int width, int height)
{
    std::ofstream ofs(filename, std::ios::binary);
    if (!ofs)
        return;
    int bytesPerPixel = 4; // 例：D3DFMT_A8R8G8B8
    int rowSize = ((width * bytesPerPixel + 3) / 4) * 4; // 4バイトアラインメント
    int pixelDataSize = rowSize * height;
    BMPHeader header = {0};
    header.bfType = 0x4D42; // 'BM'
    header.bfSize = sizeof(BMPHeader) + sizeof(BMPInfoHeader) + pixelDataSize;
    header.bfOffBits = sizeof(BMPHeader) + sizeof(BMPInfoHeader);
    BMPInfoHeader infoHeader = {0};
    infoHeader.biSize = sizeof(BMPInfoHeader);
    infoHeader.biWidth = width;
    infoHeader.biHeight = -height; // 上下反転しないため負の値
    infoHeader.biPlanes = 1;
    infoHeader.biBitCount = 32;
    infoHeader.biCompression = 0;
    infoHeader.biSizeImage = pixelDataSize;
    // ヘッダーを書き込み
    ofs.write(reinterpret_cast<char*>(&header), sizeof(header));
    ofs.write(reinterpret_cast<char*>(&infoHeader), sizeof(infoHeader));
    // ピクセルデータを書き込み
    // BMPは下から上にピクセルを格納するため、逆順に書き出す必要がある
    for (int y = height - 1; y >= 0; --y)
    {
        BYTE* pLine = pPixelData + y * width * bytesPerPixel;
        ofs.write(reinterpret_cast<char*>(pLine), rowSize);
    }
}

#include <wincodec.h>
void SaveImageWithWIC(BYTE* pPixelData, int width, int height, GUID containerFormat, const wchar_t* filename)
{
    // COMの初期化
    CoInitialize(nullptr);
    IWICImagingFactory* pFactory = nullptr;
    CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pFactory));
    IWICBitmap* pBitmap = nullptr;
    pFactory->CreateBitmapFromMemory(
        width,
        height,
        GUID_WICPixelFormat32bppBGRA,
        width * 4,
        width * height * 4,
        pPixelData,
        &pBitmap
    );
    IWICBitmapEncoder* pEncoder = nullptr;
    pFactory->CreateEncoder(containerFormat, nullptr, &pEncoder);
    IWICStream* pStream = nullptr;
    CoCreateInstance(CLSID_WICStream, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pStream));
    pStream->InitializeFromFilename(filename, GENERIC_WRITE);
    pEncoder->Initialize(pStream, WICBitmapEncoderNoCache);
    IWICBitmapFrameEncode* pFrame = nullptr;
    pEncoder->CreateNewFrame(&pFrame, nullptr);
    pFrame->Initialize(nullptr);
    pFrame->SetSize(width, height);
    WICPixelFormatGUID formatGUID = GUID_WICPixelFormat32bppBGRA;
    pFrame->SetPixelFormat(&formatGUID);
    pFrame->WriteSource(pBitmap, nullptr);
    pFrame->Commit();
    pEncoder->Commit();
    // 解放
    pFrame->Release();
    pEncoder->Release();
    pStream->Release();
    pBitmap->Release();
    pFactory->Release();
    CoUninitialize();
}

#include <chrono>
#include <thread>
auto lastCaptureTime = std::chrono::steady_clock::now();
const std::chrono::milliseconds interval(100); // 100msごとにキャプチャ
while (running)
{
    auto now = std::chrono::steady_clock::now();
    if (now - lastCaptureTime >= interval)
    {
        // キャプチャ処理
        CaptureScreen();
        lastCaptureTime = now;
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
}

#include <thread>
#include <atomic>
#include <queue>
#include <mutex>
#include <condition_variable>
std::atomic<bool> isRunning(true);
std::queue<BYTE*> captureQueue;
std::mutex queueMutex;
std::condition_variable cv;
void CaptureThread()
{
    while (isRunning)
    {
        // キャプチャ処理
        BYTE* pData = new BYTE[width * height * 4]; // 例：ピクセルデータの確保
        CaptureScreen(pData); // 実装済みのキャプチャ関数
        // キューに追加
        {
            std::lock_guard<std::mutex> lock(queueMutex);
            captureQueue.push(pData);
        }
        cv.notify_one();
        // フレームレート制御
        std::this_thread::sleep_for(std::chrono::milliseconds(33)); // 約30fps
    }
}
void ProcessingThread()
{
    while (isRunning)
    {
        std::unique_lock<std::mutex> lock(queueMutex);
        cv.wait(lock, [] { return !captureQueue.empty() || !isRunning; });
        while (!captureQueue.empty())
        {
            BYTE* pData = captureQueue.front();
            captureQueue.pop();
            // 画像処理や保存
            SaveImage(pData);
            delete[] pData;
        }
    }
}

#include <windows.h>
#include <d3d9.h>
#include <iostream>
void CheckHRESULT(HRESULT hr, const char* context)
{
    if (FAILED(hr))
    {
        // HRESULTのエラーコードを16進数で出力
        std::cerr << "Error in " << context << ": HRESULT = 0x"
                  << std::hex << hr << std::dec << std::endl;
        // 追加のエラー情報取得(必要に応じて)
        // 例：FormatMessageを使ったエラーメッセージの取得
        LPVOID msgBuf;
        DWORD dwChars = FormatMessage(
            FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
            nullptr,
            hr,
            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
            (LPTSTR)&msgBuf,
            0,
            nullptr
        );
        if (dwChars)
        {
            std::wcout << L"Error message: " << (wchar_t*)msgBuf << std::endl;
            LocalFree(msgBuf);
        }
    }
}

#include <cassert>
void SafeCall(HRESULT hr, const char* context)
{
    if (FAILED(hr))
    {
        // ログ出力
        std::cerr << "Error in " << context << ": HRESULT = 0x"
                  << std::hex << hr << std::dec << std::endl;
        // アサーションで停止
        assert(false && "API呼び出し失敗");
    }
}

if (FAILED(hr))
{
    DebugBreak();
}

#include <fstream>
#include <chrono>
#include <ctime>
void LogError(const char* message, HRESULT hr)
{
    std::ofstream logFile("error.log", std::ios::app);
    auto now = std::chrono::system_clock::now();
    std::time_t now_c = std::chrono::system_clock::to_time_t(now);
    logFile << std::ctime(&now_c) << " - " << message << " HRESULT=0x"
            << std::hex << hr << std::dec << std::endl;
}

#include <d3d9.h>
#include <wrl/client.h>
class ScreenCaptureHelper
{
public:
    ScreenCaptureHelper(IDirect3DDevice9* device)
        : m_device(device)
    {
        // 初期化処理
        Initialize();
    }
    ~ScreenCaptureHelper()
    {
        // 解放処理
        ReleaseResources();
    }
    bool Initialize()
    {
        // 例：バックバッファの取得
        HRESULT hr = m_device->GetRenderTarget(0, &m_backBuffer);
        if (FAILED(hr))
            return false;
        // オフスクリーンサーフェイスの作成
        hr = m_device->CreateOffscreenPlainSurface(
            m_width, m_height, m_format, D3DPOOL_SYSTEMMEM, &m_offscreenSurface, nullptr);
        if (FAILED(hr))
            return false;
        return true;
    }
    void ReleaseResources()
    {
        if (m_backBuffer) { m_backBuffer->Release(); m_backBuffer = nullptr; }
        if (m_offscreenSurface) { m_offscreenSurface->Release(); m_offscreenSurface = nullptr; }
    }
private:
    IDirect3DDevice9* m_device;
    IDirect3DSurface9* m_backBuffer = nullptr;
    IDirect3DSurface9* m_offscreenSurface = nullptr;
    int m_width = 1920;  // 例：画面幅
    int m_height = 1080; // 例：画面高さ
    D3DFORMAT m_format = D3DFMT_A8R8G8B8; // 例：フォーマット
};

bool CaptureBackBuffer(IDirect3DDevice9* device, IDirect3DSurface9* backBuffer, IDirect3DSurface9* offscreenSurface)
{
    HRESULT hr = device->GetRenderTargetData(backBuffer, offscreenSurface);
    return SUCCEEDED(hr);
}
bool LockSurface(IDirect3DSurface9* surface, D3DLOCKED_RECT& lockedRect)
{
    return SUCCEEDED(surface->LockRect(&lockedRect, nullptr, D3DLOCK_READONLY));
}
void SavePixelData(BYTE* pData, int width, int height, int pitch)
{
    // 例：保存処理や画像変換
}

#include <wrl/client.h>
using namespace Microsoft::WRL;
class SafeCapture
{
public:
    void Capture()
    {
        ComPtr<IDirect3DSurface9> backBuffer;
        ComPtr<IDirect3DSurface9> offscreenSurface;
        // 初期化とエラーチェック
        // ...
        // キャプチャ処理
    }
};

// 例：FFmpegを用いたエンコードと送信の非同期処理
// キャプチャスレッドで取得したフレームをキューに格納し、エンコードスレッドで逐次処理

// 例：映像データのバッファリングとタイムスタンプ付与
struct FrameData
{
    BYTE* pPixels;
    uint64_t timestamp;
    int frameNumber;
};

// 例：動的解像度調整とエンコードキューの管理
// 高負荷時には解像度を下げ、エンコードキューを適切に管理