As a follow-up to my previous article on FLAC and encoding uncompressed audio, I have further developed the Wav2Flac library and added FLAC decoding to the WAVE container. Some key points of this aspect of the WavFlacTest library are:

• Support for 16- and 24-bit audio streams
• Support for virtually all FLAC channel mappings: mono, stereo, 5.1, 7.1, etc.
• The resulting file is a bit-for-bit copy of the original audio stream

All source code and the compiled 32-bit FLAC library can be downloaded from here.

Known limitations

• Due to the wave format used being 32-bit, uncompressed files greater than 2GB in size might not play in full in some players.
• Even though FlacReader can receive metadata callbacks, the data is not interpreted. This can be further developed using the FLAC API documentation.

One thing that popped in my mind yesterday after having a conversation over twitter (admittedly, a service I had rarely used until recently), is that the more followers you have, the higher the odds you would have to use other languages in addition to a lingua franca. This ‘leaves out’ other friends who could have limited knowledge of foreign languages.

This is how the idea for the Tweet Balloon Translator was born. It’s a Greasemonkey script for Firefox, which uses the balloon/hover feature recently introduced in twitter plus the Google Translate service to translate tweets quickly and inline.

You can install the script from userscripts.org or the local copy here.

Development notes

The key phases I outlined for the script were as follows:

1. Establish a working translation block of code using the Google Translate JSON API
2. Research the possibilities of inserting a Translate link in such aspects of twitter as the profile page, direct messages, retweets. The Guest/logged out user scenario also had to be taken into account as twitter serves the pages in a different manner.
3. Figure out a way to use the twitter internal API for the HoverCard balloon feature. This was probably the hardest of all three because of the way these are created and populated.
4. Integrate 1 through 3 in a single script.

Needless to say, the script employs asynchronous requests to Google via the HTTPXMLRequest model so as to not break the UI thread, as well as exception handling.

Please feel free to try out, review, or contribute to the script at userscripts.org. I feel both international and English-speaking users could benefit from this by being able to communicate with more people on twitter, and understand international tweets.

What’s needed is for the window function to be overriden (WndProc) and pre-process the target window rectangle used by the WM_SIZING message.

The new destination rectangle is calculated by taking into account the resizing handle and the window chrome size (title height, border width, etc.).

protected override void WndProc(ref Message m)
{
    if (m.Msg == WM_SIZING)
    {
        RECT rc = (RECT)Marshal.PtrToStructure(m.LParam, typeof(RECT));

        int w = rc.Right - rc.Left - chromeWidth;
        int h = rc.Bottom - rc.Top - chromeHeight;

        switch (m.WParam.ToInt32()) // Resize handle
        {

           // …

        }

        Marshal.StructureToPtr(rc, m.LParam, true);
    }

    base.WndProc(ref m);
}

You can find the full C# source code here, including a test program. The aspect ratio and initial client size is set to 16:9.

Lossless audio is used on various media, including studio masters, CD, DVD-Audio (via MLP) and Blu-ray (via Dolby TrueHD, which is technically a rebrand of and an extension to MLP, and DTS-HD Master Audio). All of these, when decoded, will result in a pulse-code modulated signal identical to the source, unlike the popular MP3 format. MP3 performs a quality-file size trade-off by discarding or reducing frequencies less audible to human hearing.

PCM by design uses a constant bitrate, which is proportional to the sample rate, bit depth and number of audio channels, which results in very large file sizes with the increasing of each parameter, and/or duration of the audio track.

Solutions such as FLAC, TrueHD and DTS-HD MA are used to losslessly compress the source audio so that the rest of the medium (for example, a Blu-ray disc) can be used for more audio tracks, higher-bandwidth video or extras.

Out of the aforementioned, only FLAC is free to use—both TrueHD and DTS-HD MA encoders and decoders have to be licensed.

The first part of the series will explore the processing of uncompressed audio data with the FLAC API in C#. In case you prefer to use Visual Basic .NET, you can use this online converter.

Anatomy of a WAVE file

In order to process a digital audio signal, we have to know three key parameters:

• The frequency, at which the signal was sampled. Usual sample rates are 44,100 Hz; 48,000 Hz, 96,000 Hz and rarely 192,000 Hz.
• The “depth” of each sample, measured in bits. The FLAC encoder supports up to 24 bits. Our C# WAVE reader will support 16 and 24 bits of audio data.
• The number of channels, which the recording consists of. This is usually mono, stereo (CD), 5.1 (DVD-Audio, Blu-ray) or 7.1 (Blu-ray).

The most common container for PCM audio data is the WAVE file format. As noted above, PCM has a constant bitrate of

SampleRate * BitDepth * Channels,

which makes it very easy to predict the size of each block of audio samples—a single second of audio data would be Bitrate / 8 bytes (8 bits in a byte)—e.g. 176.4KB for a second of CD-quality audio.

We can create the initialization method of the WavReader class by starting with an input Stream object. We have to ensure that there is enough available data for the wave format header, and check that the file is indeed a RIFF/WAVE file to avoid unnecessary reading and processing.

uRiffHeader = reader.ReadInt32();
uRiffHeaderSize = reader.ReadInt32();
uWaveHeader = reader.ReadInt32();

if (uRiffHeader != 0×46464952 /* RIFF */ ||
    uWaveHeader != 0×45564157 /* WAVE */)
    throw new Exception(”Invalid WAVE header!”);

Right after the RIFF chunk there can be a number of JUNK (padding) chunks, which we can skip and data and fmt chunks, whose data we need.

// Read all WAVE chunks
while (reader.BaseStream.Position < reader.BaseStream.Length)
{
    int type = reader.ReadInt32();
    int size = reader.ReadInt32();

    long last = reader.BaseStream.Position;

    switch (type)
    {
        case 0×61746164: /* data */
            uDataHeader = type;
            nTotalAudioBytes = size;
            break;

        case 0×20746d66: /* fmt  */
            uFmtHeader = type;
            uFmtHeaderSize = size;

            format.wFormatTag = reader.ReadInt16();
            format.nChannels = reader.ReadInt16();
            format.nSamplesPerSec = reader.ReadInt32();
            format.nAvgBytesPerSec = reader.ReadInt32();
            format.nBlockAlign = reader.ReadInt16();
            format.wBitsPerSample = reader.ReadInt16();
            format.cbSize = reader.ReadInt16();
            break;
    }

    if (uDataHeader == 0) // Do not skip the ‘data’ chunk size
        reader.BaseStream.Position = last + size;
    else
        break;
}

Our WavReader class only supports 16 and 24-bit PCM samples, so we have to ensure that format format.wFormatTag is 1 (PCM) and format.wBitsPerSample ple is either 16 or 24. These limitations can be further removed by implementing sample rate conversion on-the-fly.

After all headers are read, nTotalAudioBytes will contain the total count of audio data bytes in the WAVE file. To determine the duration of the audio file, we can simply divide it by the block size (Bitrate / 8 bytes).

The input stream will now be at the start of the audio samples. Every 16th or 24th bit (respectively, 2nd or 3rd byte) will mark the beginning of each sample. All audio samples are interleaved so the stream consists of:

channel 0, sample 0

channel 1, sample 0

…

channel n, sample 0

channel 0, sample 1

…

Now that we have reached the audio samples, we can start feeding them to FLAC.

Free Lossless Audio Codec

The FLAC encoder is an open-source C/C++ project. In order to use it in a C# application we have to use PInvoke to call its application programming interface—LibFlac.dll. The latest version of LibFlac can be found at http://sourceforge.net/projects/flac/files/flac-win/.

1. Create a new encoder instance.
2. Set the three key parameters (sample rate, bits per sample,
3. number of channels).
4. Optionally set a compression level (default is 5).
5. Initialize the encoder by passing references to the callback functions (Write, Tell and Seek).
6. Pass all (desired) audio samples to the encoder, which will return their compressed counterpart.
7. Finalize and delete the encoder instance. This will release all memory allocated by FLAC.

// Callbacks
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
delegate int WriteCallback(IntPtr context, IntPtr buffer, int bytes, uint samples, uint current_frame, IntPtr userData);

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
delegate int SeekCallback(IntPtr context, long absoluteOffset, IntPtr userData);

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
delegate int TellCallback(IntPtr context, out long absoluteOffset, IntPtr userData);