估计需要mp3解码器的api
像卡拉ok般的歌词滚动，也是需要类似的api

请各位高手帮帮忙啊！

高手,请帮帮我啊!

楼主，搜一下关于在线播放的，网上有，你要的跟网络通信无关，但是也会有相应的播放内存流的东西,

Mark

联系我QQ:87770950

使用DirectShow, 
Delphi有DSPack包，

具体做法参见DSPACK234\Demos\D6-D7\Filters\Async
这是一个soure filter, 可以自己修改一下代码，从Stream中读取。

5.11日最后回复的帖子，竟然还出现在第1页~~~人气啊，简直就是气人

我贴给你吧
支持mp3,wma,wav等等...,没有对其它音频测试
引用了WMF9.pas单元,该单元可从 DSPack 或 DirectX的pas版 取得

Unit WMAudio;
{.$DEFINE TRIAL}

Interface

Uses
  SysUtils, Windows, Messages, Classes, WMF9, MMSystem, ActiveX

  {TWMTRackBar}
  {,Controls, ComCtrls};

Type
  WM_Status = (WM_ERROR, WM_OPENING, WM_OPENED, WM_STARTED, WM_PAUSED, WM_STOPED, WM_CLOSED,
    WM_BUFFERING_START, WM_BUFFERING_STOP, WM_END_OF_FILE, WM_END_OF_SEGMENT, WM_END_OF_STREAMING,
    WM_SAVEAS_START, WM_SAVEAS_STOP, WM_LOCATING, WM_CONNECTING, WM_NO_RIGHTS, WM_NO_RIGHTS_EX,
    WM_NEEDS_INDIVIDUALIZATION, WM_MISSING_CODEC, WM_ACQUIRE_LICENSE, WM_INDIVIDUALIZE,
    WM_NEW_METADATA, WM_NEW_SOURCEFLAGS, WM_SOURCE_SWITCH);
  TWM_Status = WM_Status;

Const
  WM_StatusText: Array[TWM_Status] Of String = (
    'An error occurred in reading the file.',
    'The file has been opening for reading.',
    'The file has been opened for reading.',
    'The reader has started reading the file.',
    'The reader has paused reading the file.',
    'The reader has stoped reading the file.',
    'The reader has closed the file.',
    'The reader has started buffering data.',
    'The reader has stoped buffering data.',
    'The reader has reached the end of the file.',
    'The end of a segment has been encountered.',
    'The file has finished streaming.',
    'The reader object has begun saving a file from a server.',
    'The reader has stopped saving a file from a server.',
    'The reader is locating a server.',
    'The reader is connecting to a server.',
    'The reader has tried to play back DRM version 1 content and the computer does not have an appropriate license to play it.',
    'The reader has tried to play back DRM version 7 content and the computer does not have an appropriate license to play it.',
    'The client needs a security update.',
    'The reader does not have the appropriate codec to decompress this file.',
    'The license acquisition process is complete.',
    'The individualization process is in progress or has completed.',
    'The metadata has changed for the current source.',
    'There has been a change to the settings for the current source.',
    'There has been a change in source file or stream.');

Type
  TOnPositionChange = Procedure(Sender: TObject; lPos, lLen: Int64; ElapsedText, RemainingText, DurationText: String) Of Object;
  TOnStatus = Procedure(Sender: TObject; Status: TWM_Status; StatusText: String) Of Object;

  TAudioHeaderAttribute = Class(TPersistent)
  Private
    FDuration: Int64;                   //文件总长度
    FTitle: String;                     //文件标题
    FAuthor: String;                    //艺术家
    FCopyright: String;                 //版权
    FDescription: String;               //注释
    FSeekable: Boolean;                 //是否允许快进
  Published
    Property Duration: Int64 Read FDuration;
    Property Title: String Read FTitle;
    Property Author: String Read FAuthor;
    Property Copyright: String Read FCopyright;
    Property Description: String Read FDescription;
    Property Seekable: Boolean Read FSeekable;
  End;

  TWMAudio = Class(TObject, IWMReaderCallback)
  Private
    FActive: Boolean;
    m_hAsyncEvent: THandle;
    m_hrAsync: HRESULT;
    m_pReader: IWMReader;
    m_pReader2: IWMReaderAdvanced2;
    m_pHeaderInfo: IWMHeaderInfo;
    m_hWaveOut: HWAVEOUT;
    m_pWfx: PWaveFormatEx;
    m_dwThreadID: DWORD;                //线程ID
    hThread: THandle;                   //线程句柄
    m_dwAudioOutputNum: LongWord;
    FStream: TMemoryStream;
    Ahattr: TAudioHeaderAttribute;

    FStatus: TWM_Status;                //当前状态
    FStatusText: String;
    FPosition: Int64;                   //当前播放位置

    FOnPositionChange: TOnPositionChange;
    FOnStatus: TOnStatus;
    Procedure SetActive(Value: Boolean);
    Procedure SetPosition(Value: Int64);

    Procedure SetStatus(Status: TWM_Status);
    Procedure OnWaveOutMsg;
    Procedure SetAsyncEvent(hrAsync: HRESULT);
    Procedure WaitForEvent(hEvent: THandle; Const msMaxWaitTime: DWORD = INFINITE);
    Function GetAudioOutput: Boolean;
    Procedure GetHeaderAttrs;
    Procedure GetHeaderAttribute(Name: WideString; Var Value: Pbyte);
    Function GetIStream(Stream: TStream): IStream;
    Procedure SetTime(TimeElapsed, FileDuration: Int64);
    Procedure Start(Const cnsStart: Int64 = 0);
  Protected
    FRefCount: Integer;
    //定义COM 接口中一个 IUnknown
    Function QueryInterface(Const IID: TGUID; Out Obj): Integer; Stdcall;
    Function _AddRef: Integer; Stdcall;
    Function _Release: Integer; Stdcall;
    Function OnSample(dwOutputNum: LongWord; cnsSampleTime, cnsSampleDuration: Int64;
      dwFlags: LongWord; pSample: INSSBuffer; pvContext: Pointer): HRESULT; Stdcall;
    Function OnStatus(Status: TWMTStatus; hr: HRESULT; dwType: TWMTAttrDataType;
      pValue: Pbyte; pvContext: Pointer): HRESULT; Stdcall;
  Public
    Constructor Create;
    Destructor Destroy; Override;
    Procedure LoadFromFile(FileName: String);
    Procedure LoadFromURL(URL: String);
    Procedure LoadFromStream(Stream: TStream);
    Procedure LoadFromResourceName(Instance: THandle; Const ResName: String; ResType: PChar);
    Procedure LoadFromResourceID(Instance: THandle; ResID: Integer; ResType: PChar);
    Procedure Open(FileName: String);
    Procedure Close;
    Procedure Play;
    Procedure Pause;
    Procedure Resume;
    Procedure Stop;
    Procedure AboutBox;
  Published

    Property Active: Boolean Read FActive Write SetActive;
    Property Status: TWM_Status Read FStatus;
    Property StatusText: String Read FStatusText;
    Property Position: Int64 Read FPosition Write SetPosition;
    Property AudioHeaderAttrib: TAudioHeaderAttribute Read Ahattr;

    Property OnPositionChange: TOnPositionChange Read FOnPositionChange Write FOnPositionChange;
    Property OnStatusInfo: TOnStatus Read FOnStatus Write FOnStatus;
  End;

Implementation

接着上

{$IFDEF TRIAL}
{$DEFINE BYCOPYRIGHT}
{$ENDIF}

{$IFDEF BYCOPYRIGHT}
Const
  ByCopyRight = 'BY WWW.SKYGZ.COM';
  {$ENDIF}

Function TWMAudio.QueryInterface(Const IID: TGUID;
  Out Obj): Integer;
Begin
  If GetInterface(IID, Obj) Then Result := S_OK
  Else Result := E_NOINTERFACE;
End;

Function TWMAudio._AddRef: Integer;
Begin
  Inc(FRefCount);
  Result := FRefCount;
End;

Function TWMAudio._Release: Integer;
Begin
  Dec(FRefCount);
  Result := FRefCount;
End;

Function TWMAudio.OnSample(dwOutputNum: LongWord; cnsSampleTime, cnsSampleDuration: Int64;
  dwFlags: LongWord; pSample: INSSBuffer; pvContext: Pointer): HRESULT;
Var
  hr: HRESULT;
  mmr: MMRESULT;
  cbData: LongWord;
  pData: Pbyte;
  m_pWh: PWaveHdr;
Begin
  If m_dwAudioOutputNum <> dwOutputNum Then
  Begin
    Result := S_OK;
    Exit;
  End;
  hr := S_OK;
  cbData := 0;
  pData := Nil;
  hr := pSample.GetBufferAndLength(pData, cbData);
  If Failed(hr) Then
  Begin
    Result := hr;
    Exit;
  End;
  GetMem(m_pWh, SizeOf(WAVEHDR) + cbData);
  GetMem(m_pWh^.lpData, cbData);
  m_pWh^.dwBufferLength := cbData;
  m_pWh^.dwBytesRecorded := cbData;
  m_pWh^.dwUser := cnsSampleTime;
  m_pWh^.dwLoops := 0;
  m_pWh^.dwFlags := 0;
  m_pWh^.lpNext := Nil;
  m_pWh^.reserved := 0;
  CopyMemory(m_pWh^.lpData, pData, cbData);

  While true Do
  Begin
    mmr := waveOutPrepareHeader(m_hWaveOut, m_pWh, SizeOf(WAVEHDR));
    If mmr <> MMSYSERR_NOERROR Then Break;
    hr := waveOutWrite(m_hWaveOut, m_pWh, SizeOf(WAVEHDR));
    If hr <> MMSYSERR_NOERROR Then Break;
    SetTime(cnsSampleTime, Ahattr.FDuration);
  End;

  pData := Nil;
  If mmr <> MMSYSERR_NOERROR Then
  Begin
    Try
      If m_pWh <> Nil Then
      Begin
        FreeMem(m_pWh^.lpData);
        FreeMem(m_pWh);
        m_pWh := Nil;
      End;
    Except
    End;
    Stop;
  End;
  Result := S_OK;
End;

Function TWMAudio.OnStatus(Status: TWMTStatus; hr: HRESULT; dwType: TWMTAttrDataType;
  pValue: Pbyte; pvContext: Pointer): HRESULT;
Begin
  Case Status Of
    WMT_ERROR:
      Begin
        SetStatus(WM_ERROR);
        SetAsyncEvent(hr);
      End;
    WMT_OPENED:                         {打开}
      Begin
        SetStatus(WM_OPENED);
        SetAsyncEvent(0);
      End;
    WMT_STARTED: SetStatus(WM_STARTED); {播放}
    WMT_CLOSED:                         {关闭}
      Begin
        SetStatus(WM_CLOSED);
        SetAsyncEvent(0);
      End;
    WMT_STOPPED:                        {停止}
      Begin
        SetStatus(WM_STOPED);
        SetAsyncEvent(0);
      End;

    WMT_ACQUIRE_LICENSE: SetStatus(WM_ACQUIRE_LICENSE);
    WMT_INDIVIDUALIZE: SetStatus(WM_INDIVIDUALIZE);
    WMT_SOURCE_SWITCH: SetStatus(WM_SOURCE_SWITCH);
    WMT_MISSING_CODEC: SetStatus(WM_MISSING_CODEC);
    WMT_BUFFERING_START: SetStatus(WM_BUFFERING_START);
    WMT_BUFFERING_STOP: SetStatus(WM_BUFFERING_STOP);
    WMT_SAVEAS_START: SetStatus(WM_SAVEAS_START);
    WMT_SAVEAS_STOP: SetStatus(WM_SAVEAS_STOP);
    WMT_LOCATING: SetStatus(WM_LOCATING);
    WMT_CONNECTING: SetStatus(WM_CONNECTING);
    WMT_END_OF_FILE:
      Begin
        SetStatus(WM_END_OF_FILE);
        SetAsyncEvent(0);
        Stop;
        SetTime(Ahattr.FDuration, Ahattr.Duration);
        SetStatus(WM_STOPED);
      End;
    WMT_END_OF_SEGMENT: SetStatus(WM_END_OF_SEGMENT);
    WMT_END_OF_STREAMING:
      Begin
        SetStatus(WM_END_OF_STREAMING);
        SetAsyncEvent(0);
      End;
    WMT_NEEDS_INDIVIDUALIZATION: SetStatus(WM_NEEDS_INDIVIDUALIZATION);
    WMT_NO_RIGHTS: SetStatus(WM_NO_RIGHTS);
    WMT_NO_RIGHTS_EX: SetStatus(WM_NO_RIGHTS_EX);
    WMT_NEW_METADATA: SetStatus(WM_NEW_METADATA);
    WMT_NEW_SOURCEFLAGS: SetStatus(WM_NEW_SOURCEFLAGS);
  End;
  Result := S_OK;
End;

Procedure TWMAudio.SetStatus(Status: TWM_Status);
Begin
  FStatus := Status;
  FStatusText := WM_StatusText[FStatus];
  If Not Assigned(FOnStatus) Then Exit;
  FOnStatus(Self, Status, FStatusText);
End;

Procedure WaveProc(hwo: HWAVEOUT; uMsg: Uint; DwInstance, DwParam1, DwParam2: DWORD); Stdcall;
Var
  P: Pointer;
Begin
  P := Pointer(DwInstance);
  PostThreadMessage(TWMAudio(P).m_dwThreadID, uMsg, DwParam1, DwParam2);
End;

Function OnWaveOutThread(lpParameter: Pointer): LongInt; Stdcall;
Begin
  TWMAudio(lpParameter).OnWaveOutMsg;
  Result := 0;
End;

Procedure TWMAudio.OnWaveOutMsg;
Var
  Msg: TMsg;
  pwh: PWaveHdr;
  mmr: MMRESULT;
Begin
  pwh := Nil;
  mmr := MMSYSERR_NOERROR;
  PeekMessage(Msg, 0, WM_USER, WM_USER, PM_NOREMOVE);
  While GetMessage(Msg, 0, 0, 0) Do
  Begin
    Case Msg.message Of
      MM_WOM_DONE:
        Begin
          pwh := PWaveHdr(Msg.wParam);
          mmr := waveOutUnprepareHeader(m_hWaveOut, pwh, SizeOf(TWaveHdr));
          Try
            FreeMem(pwh^.lpData);
            FreeMem(pwh);
            pwh := Nil;
          Except
          End;
          If mmr = MMSYSERR_NOERROR Then
          Else If mmr = WHDR_ENDLOOP Then
            SetEvent(m_hAsyncEvent)
              //Else If mmr = MMSYSERR_INVALHANDLE Then
//  SetEvent(m_hAsyncEvent)
//Else Stop;
        End;
      WOM_CLOSE: PostQuitMessage(0);
    End;
  End;
End;

Procedure TWMAudio.SetAsyncEvent(hrAsync: HRESULT);
Begin
  m_hrAsync := hrAsync;
  SetEvent(m_hAsyncEvent);
End;

Procedure TWMAudio.WaitForEvent(hEvent: THandle; Const msMaxWaitTime: DWORD);
Var
  i: DWORD;
  Msg: TMsg;
Begin
  i := 0;
  While i < msMaxWaitTime Do
  Begin
    If PeekMessage(Msg, 0, 0, 0, PM_REMOVE) Then
    Begin
      TranslateMessage(Msg);
      DispatchMessage(Msg);
    End;
    If WaitForSingleObject(hEvent, 10) <> WAIT_TIMEOUT Then Break;
    Inc(i, 10);
  End;
End;

Function TWMAudio.GetAudioOutput: Boolean;
Var
  cOutputs, cbType, i: LongWord;
  pMediaType: PWMMediaType;
  pProps: IWMOutputMediaProps;
Begin
  Result := false;
  cOutputs := 0;
  cbType := 0;
  pMediaType := Nil;
  If m_pReader = Nil Then Exit;
  If Failed(m_pReader.GetOutputCount(cOutputs)) Then
  Begin
    //'Could not get output count';
    Exit;
  End;

  For i := 0 To cOutputs - 1 Do
  Begin
    pProps := Nil;
    If pMediaType <> Nil Then
    Begin
      FreeMem(pMediaType);
      pMediaType := Nil;
    End;

    If Failed(m_pReader.GetOutputProps(i, pProps)) Then
    Begin
      //'Could not get output props';
      Exit;
    End;
    If Failed(pProps.GetMediaType(Nil, cbType)) Then
    Begin
      //'Could not query for the space needed for media type';
      pProps := Nil;
      Exit;
    End;
    GetMem(pMediaType, cbType);
    If Failed(pProps.GetMediaType(pMediaType, cbType)) Then
    Begin
      //'Could not get media type';
      pProps := Nil;
      Exit;
    End;
    If IsEqualGUID(pMediaType^.majortype, WMMEDIATYPE_Audio) Then
      Break;
  End;

  If cOutputs = i Then
  Begin
    //'Could not find an audio stream in the specified file';
    Exit;
  End;
  m_dwAudioOutputNum := i;
  If m_pWfx <> Nil Then
  Begin
    FreeMem(m_pWfx);
    m_pWfx := Nil;
  End;
  GetMem(m_pWfx, pMediaType^.cbFormat);
  CopyMemory(m_pWfx, pMediaType^.pbFormat, pMediaType^.cbFormat);

  If pMediaType <> Nil Then
  Begin
    FreeMem(pMediaType);
    pMediaType := Nil;
  End;
  pProps := Nil;
  Result := true;
End;