• How to open swf from the memory?
• Source of ShockwaveEx.pas
• Simple playing

How to open swf from the memory?

Unfortunately, the "standard" TShockwaveFlash does not contain any methods to play SWF from stream. Besides, a player does not load swf if its name is the same as a previous opened swf. So, quite often we have to use the following code:

var
  blankSWF, realSWF: string;
...
// create a blank temp file
  blankSWF := tempDir + '\' + {randomize name};
 
// create a real movie
  realSWF := tempDir + '\' + {randomize name};
 
  Player.Movie := blankSWF;
  Player.Movie := realSWF;

How to avoid that and open swf from the memory?
The property TShockwaveFlash.EmbedMovie was an incitement to me. If it is set to true then the file TShockwaveFlash.Movie is included to DFM as resource. DFM analyzing shows that swf is stored in the ControlData "section" together with other properties: Movie, ScaleMode, Quality, etc.

The first try was TStream.WriteComponent and TStream.ReadComponent using. After WriteComponent calling the saved data was analyzed and the swf was wrote to a required place. Unfortunately, ReadComponent calling did not give an expect result and the data relevant to ControlData was not updated. For example:

  player: TShockwaveFlash;
 
  mem: TMemoryStream;
...
  player.ScaleMode := 2; // exact fit
  mem.WriteComponent(Player); 
 
  player.ScaleMode := 0; // show all
  mem.Position := 0;
  mem.ReadComponent(player);
  mem.Free;
 
  ShowMessage('Scale mode is ' + IntToStr(player.ScaleMode));  // show 0,  not 2 !!!

Partly, it was fixed with the player control removing but it was not the best solution, because at least there was flickering.

  player: TShockwaveFlash;
 
  mem: TMemoryStream;
  OldParent: TWinControl;
...
  player.ScaleMode := 2; // exact fit
  mem.WriteComponent(Player); 
  OldParent := Player.Parent;
  Player.Free;
 
  mem.Position := 0;
  RegisterClass (TShockwaveFlash);
  Player := TShockwaveFlash (mem.ReadComponent(nil));
  Player.Parent := OldParent;
  Mem.Free;
  UnRegisterClass (TShockwaveFlash);
 
  ShowMessage('Scale mode is ' + IntToStr(player.ScaleMode));  // show 2, ok!

Analyzing the source TOleControl I came to a conclusion that after a control is created the ControlData is read but the value is not applied. To fix that the access to the field FObjectData is required but it is impossible because it is a private member. To avoid all these troubles I had to realize own method LoadMovieFromStream for an alternate way of data uploading.

Source ShockwaveEx.pas

Also, you can free download FlashAX with ShockwaveEx.pas.

//*******************************************************//
//                                                       //
//                      DelphiFlash.com                  //
//         Copyright (c) 2004-2007 FeatherySoft, Inc.    //
//                    info@delphiflash.com               //
//                                                       //
//*******************************************************//
 
//  Description: Extended ShockwaveFlash visual control
//  update: 20 July 2006 by Cga - added ShiftState
//  update: 23 oct 2006
//  Last date update: 2 may 2007 - added LoadMovieFromStream
 
unit ShockwaveEx;
 
interface
 
uses
  Windows, SysUtils, Classes, Controls, OleCtrls, ShockwaveFlashObjects_TLB,
  Messages{$IFNDEF VER130}, Types{$ENDIF}, Forms, ActiveX;
 
type
  TShockwaveFlashEx = class(TShockwaveFlash)
  private
    FOnMouseDown: TMouseEvent;
    FOnMouseUp: TMouseEvent;
    FOnMouseMove: TMouseMoveEvent;
    FOnClick: TNotifyEvent;
    fLockMouseClick: boolean;
    WasDown: boolean;
    FOleObject: IOleObject;
  protected
    procedure WndProc(var Message:TMessage); override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
    procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
    procedure Click; override;
    procedure InitControlInterface(const Obj: IUnknown); override;
  public
    Procedure CreateWnd; override;
    procedure LoadMovieFromStream(Src: TStream);
  published
    property OnMouseDown: TMouseEvent read FOnMouseDown write FOnMouseDown;
    property OnMouseUp: TMouseEvent read FOnMouseUp write FOnMouseUp;
    property OnMouseMove: TMouseMoveEvent read FOnMouseMove write FOnMouseMove;
    property OnClick: TNotifyEvent read FOnClick write FOnClick;
    property LockMouseClick: boolean read fLockMouseClick write fLockMouseClick default false;
  end;
 
procedure Register;
 
implementation
 
Uses
  ZLib;
 
Procedure TShockwaveFlashEx.CreateWnd;
begin
  inherited;
end;
 
procedure TShockwaveFlashEx.InitControlInterface(const Obj: IUnknown);
begin
  FOleObject := Obj as IOleObject;
end;
 
procedure TShockwaveFlashEx.LoadMovieFromStream(Src: TStream);
 var
   unCompress: TStream;
   Mem, Mem2: TMemoryStream;
   SRCSize: longint;
   PersistStream: IPersistStreamInit;
   SAdapt: TStreamAdapter;
   ISize: int64;
   B: byte;
   ASign: array [0..2] of char;
   isCompress: boolean;
   ZStream: TDeCompressionStream;
 
begin
  // prepare src movie
  Src.Read(ASign, 3);
  isCompress := ASign = 'CWS';
  if isCompress then
    begin
      unCompress := TMemoryStream.Create;
      ASign := 'FWS';
      unCompress.Write(ASign, 3);
      unCompress.CopyFrom(Src, 1); // version
      SRC.Read(SRCSize, 4);
      unCompress.Write(SRCSize, 4);
      ZStream := TDeCompressionStream.Create(Src);
      try
        unCompress.CopyFrom(ZStream, SRCSize - 8);
      finally
        ZStream.free;
      end;
      unCompress.Position := 0;
    end else
    begin
      Src.Position := Src.Position - 3;
      SRCSize := Src.Size - Src.Position;
      unCompress := Src;
    end;
 
  // store "template"
  EmbedMovie := false;
  FOleObject.QueryInterface(IPersistStreamInit, PersistStream);
  PersistStream.GetSizeMax(ISize);
  Mem := TMemoryStream.Create;
  Mem.SetSize(ISize);
  SAdapt := TStreamAdapter.Create(Mem);
  PersistStream.Save(SAdapt, true);
  SAdapt.Free;
 
  // insetr movie to "template"
  Mem.Position := 1;
  Mem2 := TMemoryStream.Create;
  B := $66; // magic flag: "f" - embed swf; "g" - without swf;
  Mem2.Write(B, 1);
  Mem2.CopyFrom(Mem, 3);
  Mem2.Write(SRCSize, 4);
  Mem2.CopyFrom(unCompress, SRCSize);
  Mem2.CopyFrom(Mem, Mem.Size - Mem.Position);
 
  // load activeX data
  Mem2.Position := 0;
  SAdapt := TStreamAdapter.Create(Mem2);
  PersistStream.Load(SAdapt);
  SAdapt.Free;
 
  // free all
  Mem2.Free;
  Mem.Free;
  PersistStream := nil;
  if isCompress then unCompress.Free;
end;
 
procedure TShockwaveFlashEx.WndProc(var Message: TMessage);
Var x,y: integer;
    xy: TPoint;
    ShiftState: TShiftState;//cga
begin
  if (Message.Msg >= WM_MOUSEFIRST) and (Message.Msg <= WM_MOUSELAST) then//cga
    if not (csDesigning in ComponentState) then begin
      ShiftState:=KeysToShiftState(TWMMouse(Message).Keys);//cga
      x:=TSmallPoint(Message.LParam).x;
      y:=TSmallPoint(Message.LParam).y;
      case Message.Msg of
        CM_MOUSELEAVE: WasDown:=false;
        WM_LBUTTONDOWN:
        begin
          MouseDown(mbLeft,ShiftState,x,y);
          WasDown:=true;
        end;
        WM_RBUTTONDOWN: WasDown:=true;
        WM_RBUTTONUP:
        if (PopupMenu<>nil) and (WasDown) then begin
          WasDown:=false;
          xy.X:=x;
          xy.Y:=y;
          xy:=ClientToScreen(xy);
          PopupMenu.Popup(xy.X,xy.Y);
        end;
        WM_LBUTTONUP:
        begin
          MouseUp(mbLeft,ShiftState,x,y);
          WasDown:=false;
        end;
        WM_MOUSEMOVE: MouseMove(ShiftState,x,y);
      end;
      //
      if (((Message.Msg=WM_RBUTTONDOWN) or (Message.Msg=WM_RBUTTONDOWN)) and (not Menu)) or
         (((Message.Msg=WM_RBUTTONUP) or (Message.Msg=WM_LBUTTONUP) or (Message.Msg=WM_LBUTTONDOWN)
          or (Message.Msg=WM_LBUTTONDBLCLK))
          and fLockMouseClick)
      then
        Message.Result := 0
      else
        inherited WndProc(Message);
      Exit;
    end;
  inherited WndProc(Message);
end;
 
procedure TShockwaveFlashEx.MouseDown(Button: TMouseButton; Shift:
TShiftState; X, Y: Integer);
begin
  if Assigned(FOnMouseDown) then
    begin
      FOnMouseDown(Self, Button, Shift, X, Y);
    end;
end;
 
procedure TShockwaveFlashEx.MouseUp(Button: TMouseButton; Shift:
TShiftState; X, Y: Integer);
begin
  if Assigned(FOnMouseUp) then
    begin
      FOnMouseUp(Self, Button, Shift, X, Y);
    end;
  if WasDown Then Click;
end;
 
procedure TShockwaveFlashEx.MouseMove(Shift: TShiftState; X, Y: Integer);
begin
  if Assigned(FOnMouseMove) then FOnMouseMove(Self, Shift, X, Y);
end;
 
procedure TShockwaveFlashEx.Click;
begin
  if Assigned(FOnClick) then FOnClick(Self);
end;
 
procedure Register;
begin
  RegisterComponents('Flash', [TShockwaveFlashEx]);
end;
 
initialization
  RegisterClass(TShockwaveFlashEx);
 
finalization
  UnRegisterClass(TShockwaveFlashEx);
 
end.
 

I would like to notice that ControlData must contain an uncompressed movie. Please take account of that to avoid unnecessary Compress/UnCompress actions.

Sample of use

procedure TmDemo.bLoadClick(Sender: TObject);
var 
  mem: TMemoryStream;
begin
  with TOpenDialog.Create(self) do
  begin
    Filter := 'SWF|*.swf';
    if Execute then
    begin
      mem := TMemoryStream.Create;
      mem.LoadFromFile(FileName);
      mem.Position := 0; 
      Player.LoadMovieFromStream(mem);
      mem.Free;
    end;
    Free;
  end;
end;

to top