glitchdrone

experiment with raw video codecs and synth track

prefast code analyze

Visual C++ has a static code analyzer called PREfast that ist now ditributes in the new-ish Windows SDK v6.1. PREfast analyze used to be distributed in the DDK, and it used in part by the Microsoft Secure Development Lifecycle (SDL). The analysis basically catches stuff you forget when you're dealing with a lot of code

- Checking for NULL pointers or parameters in your functions
- Out of bounds indexing or buffer overflows for example in array indexes in 'for' loops
- Local variable scope masking other scopes

To make code analyze work with visual studio, for example VS2005, I set up this batch file

; devenv-prefast.bat
call "C:\Program Files\Windows SDK\v6.1\vcvars32.bat"
start "C:\Program Files\Microsoft Visual Studio 8.0\VC\Common7\IDE\devenv.exe" /UseEnv

This uses the PATH, INCLUDES, and LIBS from vcvars32.bat, and uses them in the Visual Studio environment. Then, you add /analyze to the Project -> C/C++ Command line options and it does the static code analysis

dotfiles

Everyone knows linux stuff is totally customizable -- but what I figured out was that a lot of the configuration options are in hidden 'dotfiles'! I wanted to give cygwin a dark theme, so here's the most basic dark theme for vim and xterm

vim using .vimrc

" Example .vimrc here http://www.vi-improved.org/vimrc.php
" Vim colorschemes generator http://inspiration.sweyla.com/code/
" {
set background=dark " we plan to use a dark background
colorscheme inspiration907827
syntax on " syntax highlighting on
" }

xterm using .Xdefaults

XTerm*Background: black
XTerm*Foreground: grey
XTerm*utf8: 1

-- check out http://dotfiles.org/ for more of this stuff

opengl post processing

I figured out how to use OpenGL for post processing ... finally -- sort of used it as an excuse for valentines day to make something that would run on a Mac



Uses this pixel shader to make the big pixel convolution - http://www.lighthouse3d.com/opengl/ledshader/

wtl for the poor

I've always liked WTL. I learned programming by exploring Windows programming and C++ -- For me, just using the "Win32 API" was a good exercise (was it really though?). As I got better, I was constantly using C++ in weird ways, but when WTL came out, I knew that that it was actually good C++ for the Windows programming


WTL project circa 2006 - http://zxcvbn.googlecode.com/svn/trunk/wtltrip/

Recently though, Microsoft made WTL not so free, by taking rid of the MFC/ATL in the "Platform SDK" (which is now called the "Microsoft SDK").

The SDK does not have ATL base classes anymore, and it does not come with the Visual Studio Express Editions either. Free open source web browser Google Chrome uses WTL on Windows, and has some extensive workarounds for the issues


I found that I could get the ATL base classes if I register with MSDN and download the WDK here ...wait what? the device driver development kit? Microsoft acknowledges this in the WDK release notes : Windows Driver Kit (WDK) Version 7.0.0 Release Notes

[August 2009] ATL Best Practice - Use the Visual Studio release

ATL is included in the WDK as a convenience for driver developers who need to create Windows applets for their drivers. ATL should not be used for software development beyond this scope. The ATL that is available through Visual Studio provides a more complete and current set of libraries and should be used for development of software and web applications. Visual C++ Express Edition is available for free from MSDN.

So there aren't any good free sources for the MFC/ATL base, so the WTL is no longer a free software platform like it should be.

sources:
http://www.caloni.com.br/blog/archives/como-usar-wtl-com-o-atl-do-ddk

========== Build: 1 succeeded, 0 failed, 1 up-to-date, 0 skipped ==========

last.fm 2009

Last.fm has a cool API that let's you gewt almost any sort of data from them just using a web request in XML or JSON format. During their countdown for the top artists of 2009 they encouraged people to use the API, and I used the Last.fm API to show how many plays you scrobbled from each artist in the top 40.

http://zxcvbn.t35.com/lastfm-2009.html

Features:

• Uses Last.fm API to get JSON data for number of songs listened to
  
• Dynamic page effect using JavaScript to organize page elements
  
• Uses last.fm javascript client API
  

The program is pretty simple, it uses the Library.getTracks API method to retrieve your listening data. I create a last.fm object. you need an 'API key' and 'API secret', which you 'apply' for on their API page http://www.last.fm/api. Then, you can call any of the methods of the API you like

Using my program as an example

/* Create last.fm object */
var lastfm = new LastFM(
{
apiKey: 'Apply for key at http://www.last.fm/api',
apiSecret: 'Apply for API code at http://www.last.fm/api',
cache: cache
});

/* Success function parses JSON data. note: stringify JSON data before parsing */
function success(json_data) {
var json_string = JSON.stringify(json_data);
var json_parse = JSON.parse(json_string);
var tracks = json_parse.tracks;
}

/* Failure function parses error codes */
function failure(code, message) {
alert(code + ': ' + message);
}

/* Call the api function with JSON format API parameters */
lastfm.library.getTracks({ user: "LastFM Username", artist: "Britney Spears" },
success_function_callback, failure_function_callback);

Update:
I made it so you can find out how many songs you've listened to by any artist you type in. It's not very easy to find out if the artist isn't in your top charts

http://zxcvbn.t35.com/lastfm-2009.html

cpu post processing

Out of curiosity, I tried to replicate the post processing effect using the CPU instead of using shaders on the GPU. This is complicated because we're not supposed to access the graphics data directly, but uh-hmm -- whatever

To get the rendered graphics data, I use GetRenderTextureData which uses the system memory pool. But MSDN says that : "system memory is not typically accessible by the Direct3D device". So we must wait on a lock to copy from the system memory to default memory. This is a really costly operation and basically is the failure of my experiment. Running in exclusive (fullscreen) mode, takes about ~50ms to run, and the framerate is killed to <20fps

// Texture surfaces with given CreateTexture parameters
// renderTexture is D3DUSAGE_RENDERTARGET, D3DPOOL_DEFAULT
// systemMemTexture is D3DUSAGE_DYNAMIC, D3DPOOL_SYSTEMMEM
// defaultMemTexture is D3DUSAGE_DYNAMIC, D3DPOOL_DEFAULT

pd3dDevice->GetRenderTargetData(renderTextureSurface, systemMemSurface);
systemMemSurface->LockRect(&source, NULL, 0);
defaultMemSurface->LockRect(&dest, NULL, 0);
copy(source.pBits, dest.pBits);
systemMemSurface->UnlockRect();
defaultMemSurface->UnlockRect();

Apparently, GPGPU programming is enabled by hardware and the software. For example in nVidia CUDA it let's programmers control shared memory for hardware the graphics that enables programmer control (see Toms's Hardware: CUDA from the Hardware Point of View )



From the GPGPU FAQ it says about the shared memory

"Texture read operations are routed through a cache structure to allow efficient exploitation of reference locality. Read operations also factor into shader thread scheduling as read operations that miss the cache will block the thread and cause other ready threads to run while waiting for the read to memory to complete. Writes are routed through different logic that does some amount of buffering to maximize the efficieny of writes."