チュートリアル: WMContainer オブジェクトを使用した ASF ストリームのコピー

[アーティクル]
06/13/2023

ASF ファイルを作成する方法の 1 つは、既存のファイルから ASF ストリームをコピーすることです。これを行うには、ソースファイルからメディアデータを取得し、出力ファイルに書き込むことができます。ソースファイルが ASF ファイルの場合は、圧縮解除と再圧縮を行わずにストリームサンプルをコピーできます。

このチュートリアルでは、ASF オーディオビデオファイル (.wmv) から最初のオーディオストリームを抽出し、それを新しい ASF オーディオファイル (.wma) にコピーすることで、このシナリオを示します。このチュートリアルでは、入力ファイル名と出力ファイル名を引数として受け取るコンソールアプリケーションを作成します。アプリケーションは ASF スプリッターを使用して入力ストリームサンプルを解析し、ASF マルチプレクサーに送信してオーディオストリームの ASF データパケットを書き込みます。

このチュートリアルで実行する手順は次のとおりです。

前提条件
用語
1. プロジェクトを設定する
2. ヘルパー関数を宣言する
3. 入力 ASF ファイルを開く
4. 入力ファイルのオブジェクトを初期化する
5. オーディオプロファイルを作成する
6. 出力ファイルのオブジェクトを初期化する
7. 新しい ASF データパケットを生成する
8. ASF オブジェクトを新しいファイルに書き込む
9 Entry-Point関数を記述する
関連トピック

前提条件

このチュートリアルでは、次のことを前提としています。

ASF オブジェクトを操作するために Media Foundation によって提供される ASF ファイルの構造とコンポーネントに精通しています。これらのコンポーネントには、ContentInfo、splitter、マルチプレクサー、プロファイルオブジェクトが含まれます。詳細については、「 WMContainer ASF コンポーネント」を参照してください。
既存のファイルの ASF ヘッダーオブジェクトと ASF データパケットを解析し、スプリッターを使用して圧縮ストリームサンプルを生成するプロセスについて理解しています。詳細については、「チュートリアル: ASF ファイルの読み取り」を参照してください。
メディアバッファーとバイトストリームについてよく知っています。具体的には、バイトストリームを使用したファイル操作と、メディアバッファーの内容をバイトストリームに書き込む操作です。 ( 2 を参照してください。ヘルパー関数を宣言します。)

用語

このチュートリアルでは、次の用語を使用します。

ソースバイトストリーム: バイトストリームオブジェクトは、入力ファイルの内容を含む IMFByteStream インターフェイスを公開します。
Source ContentInfo オブジェクト: ContentInfo オブジェクトは、入力ファイルの ASF ヘッダーオブジェクトを表す IMFASFContentInfo インターフェイスを公開します。
オーディオプロファイル: プロファイルオブジェクトは、入力ファイルのオーディオストリームのみを含む IMFASFProfile インターフェイスを公開します。
ストリームサンプル:メディアサンプルは、スプリッターによって生成された IMFSample インターフェイスを公開し、圧縮状態の入力ファイルから取得された選択されたストリームのメディアデータを表します。
Output ContentInfo オブジェクト: ContentInfo オブジェクトは、出力ファイルの ASF ヘッダーオブジェクトを表す IMFASFContentInfo インターフェイスを公開します。
データバイトストリーム: バイトストリームオブジェクトは、出力ファイルの ASF データオブジェクト部分全体を表す IMFByteStream インターフェイスを公開します。
データパケット: メディアサンプルは、マルチプレクサーによって生成された IMFSample インターフェイスを公開し、データバイトストリームに書き込まれる ASF データパケットを表します。
出力バイトストリーム: バイトストリームオブジェクトは、出力ファイルの内容を含む IMFByteStream インターフェイスを公開します。

1. プロジェクトを設定する

ソースファイルに次のヘッダーを含めます。

#include <stdio.h>       // Standard I/O
#include <windows.h>     // Windows headers
#include <mfapi.h>       // Media Foundation platform
#include <wmcontainer.h> // ASF interfaces
#include <mferror.h>     // Media Foundation error codes

次のライブラリファイルにリンクします。

mfplat.lib
mf.lib
mfuuid.lib

SafeRelease 関数を宣言します。

template <class T> void SafeRelease(T **ppT)
{
    if (*ppT)
    {
        (*ppT)->Release();
        *ppT = NULL;
    }
}

2. ヘルパー関数を宣言する

このチュートリアルでは、次のヘルパー関数を使用して、バイトストリームの読み取りと書き込みを行います。

関数は AllocReadFromByteStream バイトストリームからデータを読み取り、データを保持する新しいメディアバッファーを割り当てます。詳細については、「 IMFByteStream::Read」を参照してください。

//-------------------------------------------------------------------
// AllocReadFromByteStream
//
// Reads data from a byte stream and returns a media buffer that
// contains the data.
//-------------------------------------------------------------------

HRESULT AllocReadFromByteStream(
    IMFByteStream *pStream,         // Pointer to the byte stream.
    DWORD cbToRead,                 // Number of bytes to read.
    IMFMediaBuffer **ppBuffer       // Receives a pointer to the media buffer. 
    )
{
    HRESULT hr = S_OK;
    BYTE *pData = NULL;
    DWORD cbRead = 0;   // Actual amount of data read.

    IMFMediaBuffer *pBuffer = NULL;

    // Create the media buffer. 
    // This function allocates the memory for the buffer.
    hr = MFCreateMemoryBuffer(cbToRead, &pBuffer);

    // Get a pointer to the memory buffer.
    if (SUCCEEDED(hr))
    {
        hr = pBuffer->Lock(&pData, NULL, NULL);
    }

    // Read the data from the byte stream.
    if (SUCCEEDED(hr))
    {
        hr = pStream->Read(pData, cbToRead, &cbRead);
    }

    // Update the size of the valid data in the buffer.
    if (SUCCEEDED(hr))
    {
        hr = pBuffer->SetCurrentLength(cbRead);
    }

    // Return the pointer to the caller.
    if (SUCCEEDED(hr))
    {
        *ppBuffer = pBuffer;
        (*ppBuffer)->AddRef();
    }

    if (pData)
    {
        pBuffer->Unlock();
    }
    SafeRelease(&pBuffer);
    return hr;
}

関数は WriteBufferToByteStream 、メディアバッファーからバイトストリームにデータを書き込みます。詳細については、「 IMFByteStream::Write」を参照してください。

//-------------------------------------------------------------------
// WriteBufferToByteStream
//
// Writes data from a media buffer to a byte stream.
//-------------------------------------------------------------------

HRESULT WriteBufferToByteStream(
    IMFByteStream *pStream,   // Pointer to the byte stream.
    IMFMediaBuffer *pBuffer,  // Pointer to the media buffer.
    DWORD *pcbWritten         // Receives the number of bytes written.
    )
{
    HRESULT hr = S_OK;
    DWORD cbData = 0;
    DWORD cbWritten = 0;
    BYTE *pMem = NULL;

    hr = pBuffer->Lock(&pMem, NULL, &cbData);

    if (SUCCEEDED(hr))
    {
        hr = pStream->Write(pMem, cbData, &cbWritten);
    }

    if (SUCCEEDED(hr))
    {
        if (pcbWritten)
        {
            *pcbWritten = cbWritten;
        }
    }

    if (pMem)
    {
        pBuffer->Unlock();
    }
    return hr;
}

関数は AppendToByteStream 、1 つのバイトストリームの内容を別のバイトストリームに追加します。

//-------------------------------------------------------------------
// AppendToByteStream
//
// Reads the contents of pSrc and writes them to pDest.
//-------------------------------------------------------------------

HRESULT AppendToByteStream(IMFByteStream *pSrc, IMFByteStream *pDest)
{
    HRESULT hr = S_OK;

    const DWORD READ_SIZE = 1024;

    BYTE buffer[READ_SIZE];

    while (1)
    {
        ULONG cbRead;

        hr = pSrc->Read(buffer, READ_SIZE, &cbRead);

        if (FAILED(hr)) { break; }

        if (cbRead == 0)
        {
            break;
        }

        hr = pDest->Write(buffer, cbRead, &cbRead);

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

    return hr;
}

3. 入力 ASF ファイルを開く

MFCreateFile 関数を呼び出して、入力ファイルを開きます。メソッドは、ファイルの内容を含むバイトストリームオブジェクトへのポインターを返します。ファイル名は、アプリケーションのコマンドライン引数を使用してユーザーによって指定されます。

次のコード例では、ファイル名を取得し、ファイルの読み取りに使用できるバイトストリームオブジェクトへのポインターを返します。

        // Open the file.
        hr = MFCreateFile(MF_ACCESSMODE_READ, MF_OPENMODE_FAIL_IF_NOT_EXIST, 
            MF_FILEFLAGS_NONE, pszFileName, &pStream);

4. 入力ファイルのオブジェクトを初期化する

次に、ソース ContentInfo オブジェクトとストリームサンプルを生成するためのスプリッターを作成して初期化します。

手順 2 で作成したこのソースバイトストリームは、ASF ヘッダーオブジェクトを解析し、ソース ContentInfo オブジェクトを設定するために使用されます。このオブジェクトは、入力ファイル内のオーディオストリームの ASF データパケットの解析を容易にするために、スプリッターを初期化するために使用されます。また、入力ファイル内の ASF データオブジェクトの長さと、ファイルの先頭からの最初の ASF データパケットへのオフセットも取得します。これらの属性は、オーディオストリームサンプルを生成するためにスプリッターによって使用されます。

入力ファイルの ASF コンポーネントを作成して初期化するには、

MFCreateASFContentInfo を呼び出して ContentInfo オブジェクトを作成します。この関数は、 IMFASFContentInfo インターフェイスへのポインターを返します。
IMFASFContentInfo::P arseHeader を呼び出して、ASF ヘッダーを解析します。この手順の詳細については、「既存のファイルの ASF ヘッダーオブジェクトの読み取り」を参照してください。
MFCreateASFSplitter を呼び出して、ASF スプリッターオブジェクトを作成します。この関数は、 IMFASFSplitter インターフェイスへのポインターを返します。
IMFASFSplitter::Initialize を呼び出し、IMFASFContentInfoポインターを渡します。この手順の詳細については、「 ASF Splitter オブジェクトの作成」を参照してください。
IMFASFContentInfo::GeneratePresentationDescriptor を呼び出して、ASF ファイルのプレゼンテーション記述子を取得します。
プレゼンテーション記述子から MF_PD_ASF_DATA_START_OFFSET 属性の値を取得します。この値は、ファイルの先頭からのバイトオフセットとして、ファイル内の ASF データオブジェクトの場所です。
プレゼンテーション記述子から MF_PD_ASF_DATA_LENGTH 属性の値を取得します。この値は、ASF データオブジェクトの合計サイズ (バイト単位) です。詳細については、「 ASF ヘッダーオブジェクトからの情報の取得」を参照してください。

次のコード例は、すべての手順を統合する関数を示しています。この関数は、ソースバイトストリームへのポインターを受け取り、ソース ContentInfo オブジェクトとスプリッターへのポインターを返します。また、ASF データオブジェクトの長さとオフセットを受け取ります。

//-------------------------------------------------------------------
// CreateSourceParsers
//
// Creates the ASF splitter and the ASF Content Info object for the 
// source file.
// 
// This function also calulates the offset and length of the ASF 
// Data Object.
//-------------------------------------------------------------------

HRESULT CreateSourceParsers(
    IMFByteStream *pSourceStream,
    IMFASFContentInfo **ppSourceContentInfo,
    IMFASFSplitter **ppSplitter,
    UINT64 *pcbDataOffset,
    UINT64 *pcbDataLength
    )
{
    const DWORD MIN_ASF_HEADER_SIZE = 30;

    IMFMediaBuffer *pBuffer = NULL;
    IMFPresentationDescriptor *pPD = NULL;
    IMFASFContentInfo *pSourceContentInfo = NULL;
    IMFASFSplitter *pSplitter = NULL;

    QWORD cbHeader = 0;

    /*------- Parse the ASF header. -------*/

    // Create the ASF ContentInfo object.
    HRESULT hr = MFCreateASFContentInfo(&pSourceContentInfo);
    
    // Read the first 30 bytes to find the total header size.
    if (SUCCEEDED(hr))
    {
        hr = AllocReadFromByteStream(
            pSourceStream, 
            MIN_ASF_HEADER_SIZE, 
            &pBuffer
            );
    }

    // Get the header size.
    if (SUCCEEDED(hr))
    {
        hr = pSourceContentInfo->GetHeaderSize(pBuffer, &cbHeader);
    }

    // Release the buffer; we will reuse it.
    SafeRelease(&pBuffer);
    
    // Read the entire header into a buffer.
    if (SUCCEEDED(hr))
    {
        hr = pSourceStream->SetCurrentPosition(0);
    }

    if (SUCCEEDED(hr))
    {
        hr = AllocReadFromByteStream(
            pSourceStream, 
            (DWORD)cbHeader, 
            &pBuffer
            );
    }

    // Parse the buffer and populate the header object.
    if (SUCCEEDED(hr))
    {
        hr = pSourceContentInfo->ParseHeader(pBuffer, 0);
    }

    /*------- Initialize the ASF splitter. -------*/

    // Create the splitter.
    if (SUCCEEDED(hr))
    {
        hr = MFCreateASFSplitter(&pSplitter);
    }
    
    // initialize the splitter with the ContentInfo object.
    if (SUCCEEDED(hr))
    {
        hr = pSplitter->Initialize(pSourceContentInfo);
    }


    /*------- Get the offset and size of the ASF Data Object. -------*/

    // Generate the presentation descriptor.
    if (SUCCEEDED(hr))
    {
        hr =  pSourceContentInfo->GeneratePresentationDescriptor(&pPD);
    }

    // Get the offset to the start of the Data Object.
    if (SUCCEEDED(hr))
    {
        hr = pPD->GetUINT64(MF_PD_ASF_DATA_START_OFFSET, pcbDataOffset);
    }

    // Get the length of the Data Object.
    if (SUCCEEDED(hr))
    {
        hr = pPD->GetUINT64(MF_PD_ASF_DATA_LENGTH, pcbDataLength);
    }

    // Return the pointers to the caller.
    if (SUCCEEDED(hr))
    {
        *ppSourceContentInfo = pSourceContentInfo;
        (*ppSourceContentInfo)->AddRef();

        *ppSplitter = pSplitter;
        (*ppSplitter)->AddRef();

    }

    SafeRelease(&pPD);
    SafeRelease(&pBuffer);
    SafeRelease(&pSourceContentInfo);
    SafeRelease(&pSplitter);

    return S_OK;
}

5. オーディオプロファイルを作成する

次に、ソース ContentInfo オブジェクトから取得して、入力ファイルのプロファイルオブジェクトを作成します。次に、入力ファイルのオーディオストリームのみが含まれるようにプロファイルを構成します。これを行うには、ストリームを列挙し、プロファイルからオーディオ以外のストリームを削除します。オーディオプロファイルオブジェクトは、このチュートリアルの後半で、出力 ContentInfo オブジェクトを初期化するために使用します。

オーディオプロファイルを作成するには

IMFASFContentInfo::GetProfile を呼び出して、ソース ContentInfo オブジェクトから入力ファイルのプロファイルオブジェクトを取得します。メソッドは、入力ファイル内のすべてのストリームを含むプロファイルオブジェクトへのポインターを返します。詳細については、「 ASF プロファイルの作成」を参照してください。
プロファイルから相互除外オブジェクトを削除します。この手順は、オーディオ以外のストリームがプロファイルから削除されるために必要です。これにより、相互除外オブジェクトが無効になる可能性があります。
次のように、プロファイルからすべての非オーディオストリームを削除します。
- IMFASFProfile::GetStreamCount を呼び出して、ストリームの数を取得します。
- ループで IMFASFProfile::GetStream を呼び出して、各ストリームをインデックスで取得します。
- IMFASFStreamConfig::GetStreamType を呼び出してストリームの種類を取得します。
- 非オーディオストリームの場合は、 IMFASFProfile::RemoveStream を呼び出してストリームを削除します。
最初のオーディオストリームのストリーム番号を格納します。これは、ストリームサンプルを生成するためにスプリッターで選択されます。ストリーム番号が 0 の場合、呼び出し元はオーディオストリームファイルがなかったと見なすことができます。

次のコードでは、これらの手順を実行します。

//-------------------------------------------------------------------
// GetAudioProfile
//
// Gets the ASF profile from the source file and removes any video
// streams from the profile.
//-------------------------------------------------------------------

HRESULT GetAudioProfile(
    IMFASFContentInfo *pSourceContentInfo, 
    IMFASFProfile **ppAudioProfile, 
    WORD *pwSelectStreamNumber
    )
{
    IMFASFStreamConfig *pStream = NULL;
    IMFASFProfile *pProfile = NULL;

    DWORD dwTotalStreams = 0;
    WORD  wStreamNumber = 0; 
    GUID guidMajorType = GUID_NULL;
    
    // Get the profile object from the source ContentInfo object.
    HRESULT hr = pSourceContentInfo->GetProfile(&pProfile);

    // Remove mutexes from the profile
    if (SUCCEEDED(hr))
    {
        hr = RemoveMutexes(pProfile);
    }

    // Get the total number of streams on the profile.
    if (SUCCEEDED(hr))
    {
        hr = pProfile->GetStreamCount(&dwTotalStreams);
    }

    // Enumerate the streams and remove the non-audio streams.
    if (SUCCEEDED(hr))
    {
        for (DWORD index = 0; index < dwTotalStreams; )
        {
            hr = pProfile->GetStream(index, &wStreamNumber, &pStream);

            if (FAILED(hr)) { break; }

            hr = pStream->GetStreamType(&guidMajorType);

            SafeRelease(&pStream);

            if (FAILED(hr)) { break; }

            if (guidMajorType != MFMediaType_Audio)
            {
                hr = pProfile->RemoveStream(wStreamNumber);
    
                if (FAILED(hr)) { break; }

                index = 0;
                dwTotalStreams--;
            }
            else
            {
                // Store the first audio stream number. 
                // This will be selected on the splitter.

                if (*pwSelectStreamNumber == 0)
                {
                    *pwSelectStreamNumber = wStreamNumber;
                }

                index++;
            }
        }
    }

    if (SUCCEEDED(hr))
    {
        *ppAudioProfile = pProfile;
        (*ppAudioProfile)->AddRef();
    }

    SafeRelease(&pStream);
    SafeRelease(&pProfile);

    return S_OK;
}

この関数は RemoveMutexes 、プロファイルから相互除外オブジェクトを削除します。

HRESULT RemoveMutexes(IMFASFProfile *pProfile)
{
    DWORD cMutex = 0;
    HRESULT hr = pProfile->GetMutualExclusionCount(&cMutex);

    if (SUCCEEDED(hr))
    {
        for (DWORD i = 0; i < cMutex; i++)
        {
            hr = pProfile->RemoveMutualExclusion(0);

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

    return hr;
}

6. 出力ファイルのオブジェクトを初期化する

次に、出力ファイルのデータパケットを生成するための出力 ContentInfo オブジェクトとマルチプレクサーを作成します。

手順 4 で作成したオーディオプロファイルを使用して、出力 ContentInfo オブジェクトを設定します。このオブジェクトには、グローバルファイル属性やストリームプロパティなどの情報が含まれます。出力 ContentInfo オブジェクトは、出力ファイルのデータパケットを生成するマルチプレクサーを初期化するために使用されます。データパケットが生成された後、新しい値を反映するように ContentInfo オブジェクトを更新する必要があります。

出力ファイルの ASF コンポーネントを作成して初期化するには

MFCreateASFContentInfo を呼び出して空の ContentInfo オブジェクトを作成し、IMFASFContentInfo::SetProfile を呼び出して手順 3 で作成したオーディオプロファイルの情報を設定します。詳細については、「新しい ASF ファイルの ContentInfo オブジェクトの初期化」を参照してください。
出力 ContentInfo オブジェクトを使用して、マルチプレクサーオブジェクトを作成して初期化します。詳細については、「マルチプレクサーオブジェクトの作成」を参照してください。

次のコード例は、手順を統合する関数を示しています。この関数は、プロファイルオブジェクトへのポインターを受け取り、出力 ContentInfo オブジェクトとマルチプレクサーへのポインターを返します。

//-------------------------------------------------------------------
// CreateOutputGenerators
//
// Creates the ASF mux and the ASF Content Info object for the 
// output file.
//-------------------------------------------------------------------

HRESULT CreateOutputGenerators(
    IMFASFProfile *pProfile, 
    IMFASFContentInfo **ppContentInfo, 
    IMFASFMultiplexer **ppMux
    )
{
    IMFASFContentInfo *pContentInfo = NULL;
    IMFASFMultiplexer *pMux = NULL;

    // Use the ASF profile to create the ContentInfo object.
    HRESULT hr = MFCreateASFContentInfo(&pContentInfo);

    if (SUCCEEDED(hr))
    {
        hr = pContentInfo->SetProfile(pProfile);
    }

    // Create the ASF Multiplexer object.
    if (SUCCEEDED(hr))
    {
        hr = MFCreateASFMultiplexer(&pMux);
    }
    
    // Initialize it using the new ContentInfo object.
    if (SUCCEEDED(hr))
    {
        hr = pMux->Initialize(pContentInfo);
    }

    // Return the pointers to the caller.
    if (SUCCEEDED(hr))
    {
        *ppContentInfo = pContentInfo;
        (*ppContentInfo)->AddRef();

        *ppMux = pMux;
        (*ppMux)->AddRef();
    }

    SafeRelease(&pContentInfo);
    SafeRelease(&pMux);

    return hr;
}

7. 新しい ASF データパケットを生成する

次に、スプリッターを使用してソースバイトストリームからオーディオストリームサンプルを生成し、それらをマルチプレクサーに送信して ASF データパケットを作成します。これらのデータパケットは、新しいファイルの最終的な ASF データオブジェクトを構成します。

オーディオストリームのサンプルを生成するには

IMFASFSplitter::SelectStreams を呼び出して、スプリッターの最初のオーディオストリームを選択します。
ソースバイトストリームからメディアバッファーにメディアデータの固定サイズブロックを読み取ります。
pdwStatusFlags パラメーターで ASF_STATUSFLAGS_INCOMPLETE フラグを受け取る限り、ループ内で IMFASFSplitter::GetNextSample を呼び出して、ストリームサンプルをスプリッターからメディアサンプルとして収集します。詳細については、「既存の ASF データオブジェクトからのストリームサンプルの生成」の「 ASF データパケットのサンプルの生成」を参照してください。
メディアサンプルごとに、 IMFASFMultiplexer::P rocessSample を呼び出して、メディアサンプルをマルチプレクサーに送信します。マルチプレクサは、ASF データオブジェクトのデータパケットを生成します。
マルチプレクサーによって生成されたデータパケットをデータバイトストリームに書き込みます。
すべてのデータパケットが生成されたら、 IMFASFMultiplexer::End を呼び出して、出力 ContentInfo オブジェクトを ASF データパケット生成中に収集された情報で更新します。

次のコード例では、ASF スプリッターからストリームサンプルを生成し、マルチプレクサーに送信します。マルチプレクサは ASF データパケットを生成し、ストリームに書き込みます。

//-------------------------------------------------------------------
// GenerateASFDataObject
// 
// Creates a byte stream that contains the ASF Data Object for the
// output file.
//-------------------------------------------------------------------

HRESULT GenerateASFDataObject(
    IMFByteStream *pSourceStream, 
    IMFASFSplitter *pSplitter, 
    IMFASFMultiplexer *pMux, 
    UINT64   cbDataOffset,
    UINT64   cbDataLength,
    IMFByteStream **ppDataStream
    )
{
    IMFMediaBuffer *pBuffer = NULL;
    IMFByteStream *pDataStream = NULL;
    
    const DWORD READ_SIZE = 1024 * 4;

    // Flush the splitter to remove any pending samples.
    HRESULT hr = pSplitter->Flush();

    if (SUCCEEDED(hr))
    {
        hr = MFCreateTempFile(
            MF_ACCESSMODE_READWRITE, 
            MF_OPENMODE_DELETE_IF_EXIST,
            MF_FILEFLAGS_NONE,
            &pDataStream
            );
    }

    if (SUCCEEDED(hr))
    {
        hr = pSourceStream->SetCurrentPosition(cbDataOffset);
    }

    if (SUCCEEDED(hr))
    {
        while (cbDataLength > 0)
        {
            DWORD cbRead = min(READ_SIZE, (DWORD)cbDataLength);

            hr = AllocReadFromByteStream(
                pSourceStream, 
                cbRead, 
                &pBuffer
                );

            if (FAILED(hr)) 
            { 
                break; 
            }

            cbDataLength -= cbRead;

            // Push data on the splitter.
            hr =  pSplitter->ParseData(pBuffer, 0, 0);

            if (FAILED(hr)) 
            { 
                break; 
            }

            // Get ASF packets from the splitter and feed them to the mux.
            hr = GetPacketsFromSplitter(pSplitter, pMux, pDataStream);

            if (FAILED(hr)) 
            { 
                break; 
            }

            SafeRelease(&pBuffer);
        }
    }

    // Flush the mux and generate any remaining samples.
    if (SUCCEEDED(hr))
    {
        hr = pMux->Flush();
    }

    if (SUCCEEDED(hr))
    {
        hr = GenerateASFDataPackets(pMux, pDataStream);
    }

     // Return the pointer to the caller.
    if (SUCCEEDED(hr))
    {
        *ppDataStream = pDataStream;
        (*ppDataStream)->AddRef();
    }

    SafeRelease(&pBuffer);
    SafeRelease(&pDataStream);
    return hr;
}

ASF スプリッターからパケットを取得するために、前のコードは関数を呼び出します。次に GetPacketsFromSplitter 示します。

//-------------------------------------------------------------------
// GetPacketsFromSplitter
//
// Gets samples from the ASF splitter.
//
// This function is called after calling IMFASFSplitter::ParseData.
//-------------------------------------------------------------------

HRESULT GetPacketsFromSplitter(
    IMFASFSplitter *pSplitter,
    IMFASFMultiplexer *pMux,
    IMFByteStream *pDataStream
    )
{
    HRESULT hr = S_OK;
    DWORD   dwStatus = ASF_STATUSFLAGS_INCOMPLETE;
    WORD    wStreamNum = 0;

    IMFSample *pSample = NULL;

    while (dwStatus & ASF_STATUSFLAGS_INCOMPLETE) 
    {
        hr = pSplitter->GetNextSample(&dwStatus, &wStreamNum, &pSample);

        if (FAILED(hr))
        {
            break;
        }

        if (pSample)
        {
            //Send to the multiplexer to convert it into ASF format
            hr = pMux->ProcessSample(wStreamNum, pSample, 0);

            if (FAILED(hr)) 
            { 
                break; 
            }

            hr = GenerateASFDataPackets(pMux, pDataStream);

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

        SafeRelease(&pSample);
    }

    SafeRelease(&pSample);
    return hr;
}

関数は GenerateDataPackets 、マルチプレクサーからデータパケットを取得します。詳細については、「 ASF データパケットの取得」を参照してください。

//-------------------------------------------------------------------
// GenerateASFDataPackets
// 
// Gets data packets from the mux. This function is called after 
// calling IMFASFMultiplexer::ProcessSample. 
//-------------------------------------------------------------------

HRESULT GenerateASFDataPackets( 
    IMFASFMultiplexer *pMux, 
    IMFByteStream *pDataStream
    )
{
    HRESULT hr = S_OK;

    IMFSample *pOutputSample = NULL;
    IMFMediaBuffer *pDataPacketBuffer = NULL;

    DWORD dwMuxStatus = ASF_STATUSFLAGS_INCOMPLETE;

    while (dwMuxStatus & ASF_STATUSFLAGS_INCOMPLETE)
    {
        hr = pMux->GetNextPacket(&dwMuxStatus, &pOutputSample);

        if (FAILED(hr))
        {
            break;
        }

        if (pOutputSample)
        {
            //Convert to contiguous buffer
            hr = pOutputSample->ConvertToContiguousBuffer(&pDataPacketBuffer);
            
            if (FAILED(hr))
            {
                break;
            }

            //Write buffer to byte stream
            hr = WriteBufferToByteStream(pDataStream, pDataPacketBuffer, NULL);

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

        SafeRelease(&pDataPacketBuffer);
        SafeRelease(&pOutputSample);
    }

    SafeRelease(&pOutputSample);
    SafeRelease(&pDataPacketBuffer);
    return hr;
}

8. 新しいファイルに ASF オブジェクトを書き込む

次に、 IMFASFContentInfo::GenerateHeader を呼び出して、出力 ContentInfo オブジェクトの内容をメディアバッファーに書き込みます。このメソッドは、ContentInfo オブジェクトに格納されているデータを ASF ヘッダーオブジェクト形式のバイナリデータに変換します。詳細については、「新しい ASF ヘッダーオブジェクトの生成」を参照してください。

新しい ASF ヘッダーオブジェクトが生成されたら、最初にヘルパー関数 WriteBufferToByteStream を呼び出して、手順 2 で作成した出力バイトストリームに Header オブジェクトを書き込んで、出力ファイルを書き込みます。データバイトストリームに含まれる Data オブジェクトを使用して、Header オブジェクトに従います。コード例は、データバイトストリームの内容を出力バイトストリームに転送する関数を示しています。

//-------------------------------------------------------------------
// WriteASFFile
//
// Writes the complete ASF file.
//-------------------------------------------------------------------

HRESULT WriteASFFile( 
    IMFASFContentInfo *pContentInfo, // ASF Content Info for the output file.
    IMFByteStream *pDataStream,      // Data stream.
    PCWSTR pszFile                   // Output file name.
    )
{
    
    IMFMediaBuffer *pHeaderBuffer = NULL;
    IMFByteStream *pWmaStream = NULL;

    DWORD cbHeaderSize = 0;
    DWORD cbWritten = 0;

    // Create output file.
    HRESULT hr = MFCreateFile(
        MF_ACCESSMODE_WRITE, 
        MF_OPENMODE_DELETE_IF_EXIST,
        MF_FILEFLAGS_NONE,
        pszFile,
        &pWmaStream
        );

    // Get the size of the ASF Header Object.
    if (SUCCEEDED(hr))
    {
        hr = pContentInfo->GenerateHeader(NULL, &cbHeaderSize);
    }

    // Create a media buffer.
    if (SUCCEEDED(hr))
    {
        hr = MFCreateMemoryBuffer(cbHeaderSize, &pHeaderBuffer);
    }

    // Populate the media buffer with the ASF Header Object.
    if (SUCCEEDED(hr))
    {
        hr = pContentInfo->GenerateHeader(pHeaderBuffer, &cbHeaderSize);
    }
 
    // Write the header contents to the byte stream for the output file.
    if (SUCCEEDED(hr))
    {
        hr = WriteBufferToByteStream(pWmaStream, pHeaderBuffer, &cbWritten);
    }

    if (SUCCEEDED(hr))
    {
        hr = pDataStream->SetCurrentPosition(0);
    }

    // Append the data stream to the file.

    if (SUCCEEDED(hr))
    {
        hr = AppendToByteStream(pDataStream, pWmaStream);
    }

    SafeRelease(&pHeaderBuffer);
    SafeRelease(&pWmaStream);

    return hr;
}

9 Entry-Point関数を記述する

これで、前の手順をまとめて完全なアプリケーションに配置できます。 Media Foundation オブジェクトのいずれかを使用する前に、 MFStartup を呼び出して Media Foundation プラットフォームを初期化します。完了したら、 MFShutdown を呼び出します。詳細については、「 Media Foundation の初期化」を参照してください。

次のコードは、コンソールアプリケーション全体を示しています。コマンドライン引数は、変換するファイルの名前と新しいオーディオファイルの名前を指定します。

int wmain(int argc, WCHAR* argv[])
{
    if (argc != 3)
    {
        wprintf_s(L"Usage: %s input.wmv, %s output.wma\n");
        return 0;
    }

    HRESULT hr = MFStartup(MF_VERSION);

    if (FAILED(hr))
    {
        wprintf_s(L"MFStartup failed: 0x%X\n", hr);
        return 0;
    }

    PCWSTR pszInputFile = argv[1];      
    PCWSTR pszOutputFile = argv[2];     
    
    IMFByteStream      *pSourceStream = NULL;       
    IMFASFContentInfo  *pSourceContentInfo = NULL;  
    IMFASFProfile      *pAudioProfile = NULL;       
    IMFASFContentInfo  *pOutputContentInfo = NULL;  
    IMFByteStream      *pDataStream = NULL;         
    IMFASFSplitter     *pSplitter = NULL;           
    IMFASFMultiplexer  *pMux = NULL;                

    UINT64  cbDataOffset = 0;           
    UINT64  cbDataLength = 0;           
    WORD    wSelectStreamNumber = 0;    

    // Open the input file.

    hr = OpenFile(pszInputFile, &pSourceStream);

    // Initialize the objects that will parse the source file.

    if (SUCCEEDED(hr))
    {
        hr = CreateSourceParsers(
            pSourceStream, 
            &pSourceContentInfo,    // ASF Header for the source file.
            &pSplitter,             // Generates audio samples.
            &cbDataOffset,          // Offset to the first data packet.
            &cbDataLength           // Length of the ASF Data Object.
            );
    }

    // Create a profile object for the audio streams in the source file.

    if (SUCCEEDED(hr))
    {
        hr = GetAudioProfile(
            pSourceContentInfo, 
            &pAudioProfile,         // ASF profile for the audio stream.
            &wSelectStreamNumber    // Stream number of the first audio stream.
            );
    }

    // Initialize the objects that will generate the output data.

    if (SUCCEEDED(hr))
    {
        hr = CreateOutputGenerators(
            pAudioProfile, 
            &pOutputContentInfo,    // ASF Header for the output file.
            &pMux                   // Generates ASF data packets.
            );
    }

    // Set up the splitter to generate samples for the first
    // audio stream in the source media.

    if (SUCCEEDED(hr))
    {
        hr = pSplitter->SelectStreams(&wSelectStreamNumber, 1);
    }
    
    // Generate ASF Data Packets and store them in a byte stream.

    if (SUCCEEDED(hr))
    {
        hr = GenerateASFDataObject(
               pSourceStream, 
               pSplitter, 
               pMux, 
               cbDataOffset, 
               cbDataLength, 
               &pDataStream    // Byte stream for the ASF data packets.    
               );
    }

    // Update the header with new information if any.

    if (SUCCEEDED(hr))
    {
        hr = pMux->End(pOutputContentInfo);
    }

    //Write the ASF objects to the output file
    if (SUCCEEDED(hr))
    {
        hr = WriteASFFile(pOutputContentInfo, pDataStream, pszOutputFile);
    }

    // Clean up.
    SafeRelease(&pMux);
    SafeRelease(&pSplitter);
    SafeRelease(&pDataStream);
    SafeRelease(&pOutputContentInfo);
    SafeRelease(&pAudioProfile);
    SafeRelease(&pSourceContentInfo);
    SafeRelease(&pSourceStream);

    MFShutdown();

    if (FAILED(hr))
    {
        wprintf_s(L"Could not create the audio file: 0x%X\n", hr);
    }

    return 0;
}

WMContainer ASF コンポーネント
Media Foundation での ASF サポート

次の方法で共有

チュートリアル: WMContainer オブジェクトを使用した ASF ストリームのコピー

前提条件

用語

1. プロジェクトを設定する

2. ヘルパー関数を宣言する

3. 入力 ASF ファイルを開く

4. 入力ファイルのオブジェクトを初期化する

5. オーディオプロファイルを作成する

6. 出力ファイルのオブジェクトを初期化する

7. 新しい ASF データパケットを生成する

8. 新しいファイルに ASF オブジェクトを書き込む

9 Entry-Point関数を記述する

フィードバック

その他のリソース

次の方法で共有

チュートリアル: WMContainer オブジェクトを使用した ASF ストリームのコピー

前提条件

用語

1. プロジェクトを設定する

2. ヘルパー関数を宣言する

3. 入力 ASF ファイルを開く

4. 入力ファイルのオブジェクトを初期化する

5. オーディオ プロファイルを作成する

6. 出力ファイルのオブジェクトを初期化する

7. 新しい ASF データ パケットを生成する

8. 新しいファイルに ASF オブジェクトを書き込む

9 Entry-Point関数を記述する

関連トピック

フィードバック

その他のリソース

5. オーディオプロファイルを作成する

7. 新しい ASF データパケットを生成する