ZFX + Developia

Code: Alles auswählen

class VLC_ZFX
{
private:	
  const int video_width;
  const int video_height;
  TCriticalSection vlcMutex;
  std::vector<unsigned char> vlcBuffer;
  IDirect3DTexture9 vlcVideoTexture;
  IDirect3DTexture9 vlcMemoryTexture;
  pSprite: ID3DXSprite;
public:
	VLC_ZFX(void);
	~VLC_ZFX(void);

	void init();
	void deInit();

	// callbacks
	void* VLCLock(void* opaque, void* plane);
	void* VLCUnlock(void* opaque, void* picture, void* plane);
	void* VLCdisplay(void* opaque, void* picture);
	
	// starting callback
	void VideoPlay(const std::string& videofile);

	// Rendering
	void OnFrameRender();
};

Code: Alles auswählen

VLC_ZFX::VLC_ZFX(void)
: video_width(800),video_height(600)
{
	vlcBuffer.resize(video_width*video_height*4+32);
}

VLC_ZFX::~VLC_ZFX(void)
{
}

// Initialization
void VLC_ZFX::init()
{
	pd3dDevice.CreateTexture(video_width, video_height, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, vlcVideoTexture, NULL);
	pd3dDevice.CreateTexture(video_width, video_height, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, vlcMemoryTexture, NULL);
	D3DXCreateSprite(pd3dDevice, pSprite);
	vlcMutex = TCriticalSection.Create();
}

//Deinitialization
void VLC_ZFX::deInit()
{
	SAFE_RELEASE(vlcVideoTexture);
	SAFE_RELEASE(vlcMemoryTexture);
	SAFE_RELEASE(pSprite);
	vlcMutex.Free();
}

// ***********************************
//Callbacks
void* VLC_ZFX::VLCLock(void* opaque, void* plane)
{
	plane = &vclBuffer[0];
	vlcMutex.Enter();
	return NULL;
}

void* VLC_ZFX::VLCUnlock(void* opaque, void* picture, void* plane)
{
	vlcMutex.Leave();
	return NULL;
}

void* VLC_ZFX::VLCdisplay(void* opaque, void* picture)
{
	int i(0),j(0);
	D3DLOCKED_RECT prect;
	unsigned char* pTexBuffer(NULL);

  /// VLC outputs data in RGBA while we need to load data in BGRA into texture
  /// so, swap all Red and Blue values
	while (i<=(video_width*video_height-1)*4)
	{
		j = vlcBuffer[i];
		vlcBuffer[i] = vlcBuffer[i+2];
		vlcBuffer[i+2] = j;
		i += 4;
	}
  /// lock system memory texture and fill it with data
  if(vlcMemoryTexture.LockRect(0, prect, NULL, 0)== S_OK)
  {
    pTexBuffer = prect.pBits;
    for(i=0; i<video_height-1; ++i)
	{
      /// fill data into texture line by line
	// ******************** muss auch ne C-Version davon geben
      MoveMemory(pTexBuffer, vlcBuffer[i*video_width*4], video_width*4);
	// ******************** 
      /// and don't forget to offset by pitch, not by video_width*4
      pTexBuffer += prect.Pitch;
	}
    vlcMemoryTexture.UnlockRect(0);
  }
  return NULL;
}
// ***********************************

// Starting playback
void VLC_ZFX::VideoPlay(const std::string& videofile)
{
	void* pMedia(NULL);
	void* pMediaPlayer(NULL);

	pMedia = libvlc_media_new_path(vlc, videofile);
	pMediaPlayer = libvlc_media_player_new_from_media(pMedia);
	libvlc_media_release(pMedia);
	libvlc_video_set_callbacks(pMediaPlayer, VLCLock, VLCUnlock, VLCDisplay, NULL);
	libvlc_video_set_format(pMediaPlayer, "RGBA", video_width, video_height, video_width*4);
	libvlc_media_player_play(pMediaPlayer);
}

// Rendering
void VLC_ZFX::OnFrameRender()
{
	TD3DXMatrixA16 mat;
	TD3DXVector2 scale;

	//{ Prepare to render the scene here }

	// ************** Bin mir nicht ganz wegen dem 'or' sicher
	//pSprite._Begin(D3DXSPRITE_DONOTSAVESTATE or D3DXSPRITE_DO_NOT_ADDREF_TEXTURE);
	pSprite._Begin(D3DXSPRITE_DONOTSAVESTATE | D3DXSPRITE_DO_NOT_ADDREF_TEXTURE);
	// ***********************

	/// update video texture which we are going to render now, from system memory texture
	pd3dDevice.UpdateTexture(vlcMemoryTexture, vlcVideoTexture);

	/// stretch sprite so video texture will fit in window.
	/// window_width and window_height are window's dimensions
	scale.x = window_width/video_width;
	scale.y = window_height/video_height;
	D3DXMatrixTransformation2D(mat,  NULL, 0, scale, NULL, 0, NULL);
	pSprite.SetTransform(mat);

	/// finally, render it
	pSprite.Draw( vlcVideoTexture, NULL, NULL, NULL, 0xFFFFFFFF );
	pSprite._End();

	//{ End scene rendering here}
}

Code: Alles auswählen

nil oder :=
vlcMutex: TCriticalSection;
vlcBuffer: array [0 .. video_width*video_height*4+32] of byte;