I've been running some crude benchmarks of the UAV::Pilot video timing. As I went over in my last post, I'm planning on having the video be read from the network in one process, and have it piped out to another process for decoding and display.
I added logging statements that show the exact time (using `Time::HiRes::gettimeofday()`) that a video packet comes in, and then another log for when we display it on the SDL window.
The first benchmark used the existing `uav_video_display` that's in the UAV::Pilot distribution, reading from the file `ardrone_video_stream_dump.bin`. This file is in the UAV::Pilot::ARDrone distribution and is a direct dump of the network stream from an AR.Drone's h.264 video port. It's primarily used to run some of the video parsing tests in that distro.
I found that on my laptop, there was a delay of 12.982ms between getting the video frame and actually displaying it. At 60fps, there is a delay of 16.667ms between each frame, so this seems quite acceptable. The AR.Drone only goes up to 30fps, anyway, but it's nice to know we have some leeway for future UAVs.
I then implemented a new script in the UAV::Pilot::ARDrone distro that read the same video frames from STDIN. I had planned on doing this with the same file noted above, like this:
cat ardrone_video_stream_dump.bin | ardrone_display_video.pl
But this ended up displaying only the last frame of video.
My theory on why this happens is that we use AnyEvent for everything, including reading IO and telling SDL when to display a new window. Using `cat` like that, there's always more data for the `AnyEvent->io` watcher to grab, so SDL never gets a chance until the pipe is out of data. At that point, it still has the last frame in memory, so that's what it displays.
I tried playing around with `dd` instead of `cat`, but got the same results.
So I broke down and connected to the actual AR.Drone with `nc`:
nc 192.168.1.1 5555 | ardrone_display_video.pl
Which did the trick. This does mean that the results are not directly comparable to each other. We can still run the numbers and make sure the delay remains insignificant, though.
And indeed it did. It averaged out to 13.025ms. That alleviates my concern that using a pipe would introduce a noticeable delay and things can go right ahead with this approach.