[kinovea-dev] Re: Direct2D

  • From: Hugh <greatview@xxxxxxxxx>
  • To: <kinovea-dev@xxxxxxxxxxxxx>
  • Date: Thu, 28 Apr 2011 11:55:38 +1000

Having a quick look at the black flashing, it is not covering the entire 
content.  For example if I play a video which is very wide, it only goes part 
of the way across.  Maybe there is something clearing a set region or redrawing 
this section.



From: kinovea-dev-bounce@xxxxxxxxxxxxx 
[mailto:kinovea-dev-bounce@xxxxxxxxxxxxx] On Behalf Of joan@xxxxxxxxxxx
Sent: Saturday, 15 January 2011 12:43 AM
To: kinovea-dev@xxxxxxxxxxxxx
Subject: [kinovea-dev] Re: Direct2D


I wrote a page on the wiki to try to describe two possible architectures.



Feel free to modify it, add comments, opinion, pros/cons, etc.




On Thu, 13 Jan 2011 22:18:55 +0100, Joan wrote:


I have tried the Direct2D / SlimDX code you sent.

I wasn't too sure as to how exactly use the control, here is what I did:
- Added a Direct2DControl member to PlayerScreenUserInterface.
- In the PlayerScreenUserInterface constructor I call 
Direct2DControl.SetControl() passing in the center panel (to test on the back 
panel for now)
- immediately call Direct2DControl.Run() to trigger initializations.
- At each new frame, (in PlayerScreenUserInterface.ShowNextFrame), I call 
Direct2DControl.DrawVideoBitmap() passing in the decoded image,
- and Direct2DControl.Update() to actually draw on the panel.

Let me know if I did anything wrong. Did you also modify 
PlayerScreenUserInterface in this way for your tests ?

It seems to work pretty well.
I've tried to instrument and get some figures regarding speed, but it proved 
harder than I thought to really pinpoint the rendering time.
(Also I've recently changed machine and it's like everything is running super 
fast :-))

The part taking the most time (about 10 to 20ms each frame on my machine) would 
seem to be DrawVideoBitmap(). 
This function involves copying the whole GDI+ bitmap into a Direct2D bitmap for 
later use. This is a step we can probably avoid completely by decoding directly 
into a Direct2D bitmap from the FFMpeg code. 

This is maybe what you suggested in the forum thread... In the case of 
pre-extraction to memory, we can also probably keep an in-memory array of 
Direct2D bitmaps instead of an array of GDI+ bitmaps. I'm sure we'll find a way 
to avoid this extra copy.

About your concern to release resources, I don't think we need to use a 
separate form for rendering and react to the OnClose() event of it.
Screens must implement a BeforeClose() method (see AbstractScreen) which is 
triggered when the screen is closed (close button, changing screens 
configuration, etc.)
We should be able to use it to ask the PlayerScreen and the renderer to dispose 
any outstanding resources.

We'll probably need to transform and simplify the DirectXInterface class.
Also, I don't know if we need the other classes, (Direct3D10Context, etc.) ? If 
not, we might even merge the two for simplicity.

I haven't looked at the direct2D drawing primitives and how we might implement 
the drawing tools visuals. 
The architecture discussion will probably depend on how these can be abstracted 
between Direct2D and GDI+.

I will create a topic on the wiki to push some schematics of possible 
architectures so we are clearer about what we discuss.
Let me know of your experiments.


Le 10/01/2011 21:34, Joan a écrit : 


I am super sorry for the delay.
Unfortunately, I haven't had much time to look into this, but I will.
(I have some issues at work with the company wanting to close the local office, 
this has somewhat prevented proper focus on the project, but it's going to 
resolve one way or the other in the next few weeks.)


Le 05/01/2011 17:34, Hugh a écrit : 

Hey Jean,


Was just wondering how the Direct2D code was working for you?  Did you have any 
luck moving the drawing onto a new form?  Just didn’t see any recent changes in 
the code and was hoping it is working!






On Thu, 13 Jan 2011 22:18:55 +0100, Joan wrote: 

Other related posts: