source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/include/mmstream.idl@ 33252

/*
 * Copyright 2004 Christian Costa
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

/*
 * Sun LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
 * other than GPL or LGPL is available it will apply instead, Sun elects to use only
 * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
 * a choice of LGPL license versions is made available with the language indicating
 * that LGPLv2 or any later version may be used, or where a choice of which version
 * of the LGPL is applied is otherwise unspecified.
 */

import "unknwn.idl";

cpp_quote("#define MS_ERROR_CODE(x)                  MAKE_HRESULT(1, FACILITY_ITF, (x) + 0x400)")
cpp_quote("#define MS_SUCCESS_CODE(x)                MAKE_HRESULT(0, FACILITY_ITF, x)")
cpp_quote("#define MS_S_PENDING                      MS_SUCCESS_CODE(1)")
cpp_quote("#define MS_S_NOUPDATE                     MS_SUCCESS_CODE(2)")
cpp_quote("#define MS_S_ENDOFSTREAM                  MS_SUCCESS_CODE(3)")

cpp_quote("#define MS_E_SAMPLEALLOC                  MS_ERROR_CODE(1)")
cpp_quote("#define MS_E_PURPOSEID                    MS_ERROR_CODE(2)")
cpp_quote("#define MS_E_NOSTREAM                     MS_ERROR_CODE(3)")
cpp_quote("#define MS_E_NOSEEKING                    MS_ERROR_CODE(4)")
cpp_quote("#define MS_E_INCOMPATIBLE                 MS_ERROR_CODE(5)")
cpp_quote("#define MS_E_BUSY                         MS_ERROR_CODE(6)")
cpp_quote("#define MS_E_NOTINIT                      MS_ERROR_CODE(7)")
cpp_quote("#define MS_E_SOURCEALREADYDEFINED         MS_ERROR_CODE(8)")
cpp_quote("#define MS_E_INVALIDSTREAMTYPE            MS_ERROR_CODE(9)")
cpp_quote("#define MS_E_NOTRUNNING                   MS_ERROR_CODE(10)")

cpp_quote("DEFINE_GUID(MSPID_PrimaryVideo,  0xa35ff56a, 0x9fda, 0x11d0, 0x8f, 0xdf, 0x0, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);")
cpp_quote("DEFINE_GUID(MSPID_PrimaryAudio,  0xa35ff56b, 0x9fda, 0x11d0, 0x8f, 0xdf, 0x0, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);")

cpp_quote("#if 0")
typedef void* PAPCFUNC;
cpp_quote("#endif")

typedef LONGLONG STREAM_TIME;

typedef GUID MSPID;
typedef REFGUID REFMSPID;

typedef enum {
        STREAMTYPE_READ         = 0,
        STREAMTYPE_WRITE        = 1,
        STREAMTYPE_TRANSFORM    = 2
} STREAM_TYPE;

typedef enum {
        STREAMSTATE_STOP        = 0,
        STREAMSTATE_RUN         = 1
} STREAM_STATE;


typedef enum {
        COMPSTAT_NOUPDATEOK                             = 0x00000001,
        COMPSTAT_WAIT                                   = 0x00000002,
        COMPSTAT_ABORT                                  = 0x00000004
} COMPLETION_STATUS_FLAGS;

enum {
        MMSSF_HASCLOCK                                  = 0x00000001,
        MMSSF_SUPPORTSEEK                               = 0x00000002,
        MMSSF_ASYNCHRONOUS                              = 0x00000004
};

enum {
        SSUPDATE_ASYNC                                  = 0x00000001,
        SSUPDATE_CONTINUOUS                             = 0x00000002
};

interface IMultiMediaStream;
interface IMediaStream;
interface IStreamSample;


[
object,
local,
uuid(B502D1BC-9A57-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IMultiMediaStream : IUnknown {

        HRESULT GetInformation(
                [out, optional] DWORD *pdwFlags,
                [out, optional] STREAM_TYPE *pStreamType);

        HRESULT GetMediaStream(
                [in] REFMSPID idPurpose,
                [out] IMediaStream **ppMediaStream);

        HRESULT EnumMediaStreams(
                [in] long Index,
                [out] IMediaStream **ppMediaStream);

        HRESULT GetState(
                [out] STREAM_STATE *pCurrentState);

        HRESULT SetState(
                [in] STREAM_STATE NewState);

        HRESULT GetTime(
                [out] STREAM_TIME *pCurrentTime);

        HRESULT GetDuration(
                [out] STREAM_TIME *pDuration);

        HRESULT Seek(
                [in] STREAM_TIME SeekTime);

        HRESULT GetEndOfStreamEventHandle(
                [out] HANDLE *phEOS);
}


[
object,
uuid(B502D1BD-9A57-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IMediaStream : IUnknown {
        
        HRESULT GetMultiMediaStream(
                [out] IMultiMediaStream **ppMultiMediaStream);

        HRESULT GetInformation(
                [out, optional] MSPID *pPurposeId,
                [out, optional] STREAM_TYPE *pType);

        HRESULT SetSameFormat(
                [in] IMediaStream *pStreamThatHasDesiredFormat,
                [in] DWORD dwFlags);

        HRESULT AllocateSample(
                [in]  DWORD dwFlags,
                [out] IStreamSample **ppSample);

        HRESULT CreateSharedSample(
                [in]  IStreamSample *pExistingSample,
                [in]  DWORD dwFlags,
                [out] IStreamSample **ppNewSample);

        HRESULT SendEndOfStream(DWORD dwFlags);
}


[
object,
local,
uuid(B502D1BE-9A57-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IStreamSample : IUnknown {
        
        HRESULT GetMediaStream(
                [in] IMediaStream **ppMediaStream);

        HRESULT GetSampleTimes(
                [out, optional] STREAM_TIME * pStartTime,
                [out, optional] STREAM_TIME * pEndTime,
                [out, optional] STREAM_TIME * pCurrentTime);

        HRESULT SetSampleTimes(
                [in, optional] const STREAM_TIME *pStartTime,
                [in, optional] const STREAM_TIME *pEndTime);

        HRESULT Update(
                [in] DWORD dwFlags,
                [in, optional] HANDLE hEvent,
                [in, optional] PAPCFUNC pfnAPC,
                [in, optional] DWORD dwAPCData);

        HRESULT CompletionStatus(
                [in] DWORD dwFlags,
                [in, optional] DWORD dwMilliseconds);
}