1. Main window representing an audio file loaded

2. Custom FIR-filter dialog box representing equalizer

3. Custom IIR-filter design window and filter's frequency response

This project focuses on digital signal processing of audio data represented by discrete samples stored in a file (namely, Windows Audio WAV files). The project also involves digital filters design (implemented in software) and variable audio effects implementation. Explanatory note includes an extensive review of existing IIR- and FIR-filters design approaches. Applying various audio effects and their software implementation are considered as well. Fast Fourier Transform (FFT) and fast convolution algorithms are core algorithms of the project. Many DSP algorithms are also implemented in the project, such as IIR- and FIR- software filters; echo, chorus and reverberation audio effects; homomorphic signal processing, etc. The main audio signal can be represented in the following forms: sample values (linear and logarithmic scales), frequency histogram, and sound spectrogram. The main audio signal can be convolved with analytical defined function (such as “sin(x)/x”, etc.). There is also an original approach of visual IIR-filters design implemented in the program.

Project features:

• Representation of an audio signal as a set of sample values (linear or logarithmic scale), frequency histogram or sound spectrogram.
• Basic non-linear editing operations: selection of a part of the signal, copying, deletion and insertion of the selected part.
• Wav-file format conversion using the following parameters: sample rate, number of bits per sample, number of channels (mono or stereo).
• Audio signal playback using sound card.
• Low-, high- and band-pass signal filtering.
• Custom signal filtering using multiple band-pass filter.
• Signal filtering using user-designed IIR-filters.
• IIR-filters design using graphical representation of the complex z-domain plane.
• Custom signal convolution with user-defined analytical function.
• Homomorphic signal processing via taking the logarithm, discrete Fourier transform and FIR-filters.
• Audio effects implementation: echo, chorus, reverberation, noise, etc.
• Surround sound audio effect implementation using user-defined 3D-scene with sound-reflecting objects.

Input data:

• Digital audio signal from a wav-file.
• Filters settings files.
• Surround sound audio effect settings file.
• User keyboard and mouse input.

Output data:

• Digital audio signal saved to a wav-file.
• Filters settings files.
• Surround sound audio effect settings file.
• Visual audio signal representation.
• Sound card playback output.

Project summary:

• Operating system: 32-bit Windows
• Language: C++
• IDE: Microsoft Visual Studio 6.0
• GUI library used: MFC
• Status: university project, non-commercial
• Last build: March, 2002

For this project you can:

• Download source (382 Kb)
• Download binary (182 Kb)
• Download full documentation in Russian (4,7 Mb)

1. Main window including input signal representation child window, system's frequency response child window and filters' configuration child window

2. Filter system frequency response (band-pass filter in this case)

3. Sound spectrogram of an input signal (displayed in real-time)

This project is an extension of the Digital Audio Processing Program described above. The main difference between the two projects is that the Real-Time Digital Audio Signal Processing Program carries out all the DSP algorithms' calculations in real-time. So, for example, you can plug a microphone to the sound card's input and simultaneously listen to the processed audio signal from the speakers plugged to the sound card's output. Processing of audio signal includes FIR-filtering (low-, high-, band-pass and multiple band-pass filters), IIR-filtering, and digital audio effects (echo, chorus, reverberation, noise, amplitude modulation, synthesis). Moreover, it is possible to combine several filters and effect processors in a chain, so the output of one filter is attached to the input of another filter. All the filter settings can be altered on-the-fly  during signal processing. The input signal can be acquired from the sound card's input or from Windows Audio wav-file. The output can be either played to the sound card's output or written to a Windows Audio wav-file. The program can perform multiple-channel audio processing: you can either select the desired sound card for input and/or output, then select another one and begin separate signal processing, or select inputs from several sound cards and send the output to particular one. So, multiple sound cards are supported, either with or without full-duplex technology.

Project features:

• Audio signal source selection: sound card (if there are multiple sound cards, selection of particular sound card) or Windows Audio wav-file.
• Processed audio signal destination selection: sound card (if there are multiple sound cards, selection of particular sound card) or Windows Audio wav-file.
• Source audio signal sampling (if a sound card was selected) using the following parameters: sample rate, number of bits per sample, number of channels (mono or stereo).
• Possibility of real-time processing estimation for particular computer (the performance graph is displayed).
• Synchronous real-time audio signal acquisition, processing and playback.
• Representation of an audio signal as a set of sample values (linear scale), frequency histogram or sound spectrogram.
• Low-, high-, band-pass and multiple band-pass signal filtering.
• Signal filtering using user-designed IIR-filters.
• IIR-filters design using graphical representation of the complex z-domain plane.
• Audio effects implementation: echo, chorus, reverberation, noise, amplitude modulation, synthesis.
• Single filter or filter system frequency response representation in the form of graph with logarithmic scale.
• Filters can be sequentially combined to form filter system with multiplied transfer function.

Input data:

• Analog or digital audio signal from a sound card.
• Digital audio signal from a wav-file.
• Filters settings files.
• Effects settings files.
• User-defined filter order in filter system.
• User keyboard and mouse input.

Output data:

• Digital audio signal saved to wav-file.
• Sound card playback output.
• Filters settings file.
• Effects settings file.
• Visual audio signal representation.
• Graphical source signal representation.
• Graphical processed signal representation.
• Graphical frequency response representation for single filter or filter system.

Project summary:

• Operating system: 32-bit Windows
• Language: C++
• IDE: Borland C++Builder 6.0
• GUI library used: VCL
• Status: university project, non-commercial
• Last build: December, 2002

For this project you can:

• Download source (192 Kb)
• Download binary (474 Kb)
• Download full documentation in Russian (3,9 Mb)

1. Main window representing a file browser and selected files panel

2. Conversion settings dialog box

The main disadvantage of many existing audio processing programs is that they don't allow converting multiple wav-files from one format to another in batch mode. With VOX format being very common in computer telephony (for example, for Dialogic boards), the purpose was to write a program with simple intuitive interface and an ability to convert multiple wav-files either to another format or to VOX in batch mode. Apart from FIR filtering used to enhance audio conversion, the program also applies amplitude normalization for both loud and quiet files to be converted into amplitude-normalized files.

Project features:

• Multiple files selection from different directories and disks.
• Batch file format conversion.
• FIR-filtering and normalization.
• Dialogic VOX audio format support.
• Conversion performed using the following parameters: samplerate, number of bits per sample, number of channels (mono or stereo).

Input data:

• Multiple wav-files.
• User-defined conversion settings.

Output data:

• Converted wav- or VOX-files.
• INI-file with saved settings.

Project summary:

• Operating system: 32-bit Windows
• Language: C++
• IDE: Borland C++Builder 6.0
• GUI library used: VCL
• Status: commercial project for russian mobile operator BeeLine
• Last build: May, 2006

For this project you can:

• Download demo source (67 Kb)
• Download demo binary (415 Kb)

Main window representing ray tracing algorithm output

This program was developed to demonstrate the simplest ray tracing algorithm to students. This program uses hardcoded internal 3D-scene representation that cannot be changed. The programs uses simple Witted lighting model with some modifications for texture and fog support. The user can choose output image resolution and begin rendering process. The output image can be saved to a Windows bitmap (.bmp) file.

Project features:

• Rendering 3D-scene using ray tracing algorithm and simple Witted lighting model.
• Saving output image to a Windows bitmap file.

Input data:

• Hardcoded internal 3D-scene representation.
• User-defined output image resolution.

Output data:

• Rendered image.
• Windows bitmap file output.

Project summary:

• Operating system: 32-bit Windows
• Language: C++
• IDE: Microsoft Visual Studio 6.0
• GUI library used: Win32 API
• Status: educational, noncommercial project
• Last build: October, 2001

For this project you can:

• Download source (172 Kb)
• Download binary (71 Kb)

Main window representing an inverted image

This image editor uses some FIR-filters along with other operations. There are three types of filters: blur, sharpen and user-defined. Filter kernel is represented in matrix form, thus students can set individual coefficients according to different formulas and eventually see image, modified by the filter. Another set of operations includes brightness/contrast adjustment, color inversion, scale, rotate and mirror transforms. The main purpose of the program is to give the students fundamental basis in image processing, including FIR-filters. The format of image files used is 24-bit Windows bitmap files.

Project features:

• Loading and saving Windows bitmap files.
• Linear image processing: brightness and color adjustments.
• Non-linear image processing: color inversion.
• Geometric image transforms: scaling, rotating and mirroring.
• FIR-filtering using two-dimensional Fast Fourier Transform.

Input data:

• Windows bitmap file.
• User-defined filter kernel.
• User-defined transform settings.

Output data:

• Modified image.
• Windows bitmap file output.

Project summary:

• Operating system: 32-bit Windows
• Language: C++
• IDE: Borland C++Builder 6.0
• GUI library used: VCL
• Status: educational, noncommercial project
• Last build: June, 2006

For this project you can:

• Download source (16 Kb)
• Download binary (419 Kb)

Main window representing a loaded JPEG-image

This program is an implementation of the JPEG decoding algorithm (Huffman decompression, dequantization, discrete cosine transform and color space mapping). The main purpose of the project is to show students a practical implementation of a theoretical image lossy compression algorithm.

Project features:

• Loading and decoding JPEG-files, displaying the image.

Input data:

• JPEG image file .

Output data:

• Rendered image.

Project summary:

• Operating system: 32-bit Windows
• Language: C++
• IDE: Microsoft Visual Studio 6.0
• GUI library used: Win32 API
• Status: educational, noncommercial project
• Last build: August, 2002

For this project you can:

• Download source (31 Kb)
• Download binary (22 Kb)

Main window representing a list of OpenGL extensions

This program retrieves a list of video card's OpenGL extensions. This list is used to see which OpenGL extensions are supported by a video card. The main purpose of the project is to show students how to retrieve the list of OpenGL extensions.

Project features:

• Displaying a list of video card's OpenGL extensions.
• Saving extensions list to a text file.

Input data:

• OpenGL API calls.

Output data:

• Displayed list of video card's OpenGL extensions.
• Saved text file with the list .

Project summary:

• Operating system: 32-bit Windows
• Language: C++
• IDE: Borland C++Builder 6.0
• GUI library used: VCL
• Status: educational, noncommercial project
• Last build: February, 2003

For this project you can:

• Download source (14 Kb)
• Download binary (336 Kb)

Main window representing rendered fractal image.

This program uses L-system (or Lindenmayer system, a formal grammar) to build fractal images consisting of straight lines connected to each other. The user defines several rules, the number of iterations, rotation angle, and the program iterates through the system of rules to build a fractal image.

Project features:

• Rendering fractal image using L-system.

Input data:

• L-system axiom.
• L-system rules.
• Number of iterations (recursion count).
• Initial angle (denominator of Pi).
• Angle of line rotation (denominator of Pi).
• All the above data loaded from a file.

Output data:

• Rendered fractal image.
• Input data saved to a file.

Project summary:

• Operating system: 32-bit Windows
• Language: C++
• IDE: Microsoft Visual Studio 6.0
• GUI library used: MFC
• Status: educational, noncommercial project
• Last build: February, 2001

For this project you can:

• Download source (43 Kb)
• Download binary (104 Kb)

Main window representing rendered fractal image.

This program uses iterated functions system to build fractal images consisting of initial black square recursively transformed by affine transforms. The user defines up to six affine transforms, several rules, the number of iterations, and the program iterates through predefined affine transformas to build a fractal image.

Project features:

• Rendering fractal image using iterated functions system (IFS).
• Saving rendered fractal image to Windows bitmap file.

Input data:

• A set of affine transformas  coefficients.
• Number of iterations (recursion count).
• Rendered image dimensions.
• All the above data loaded from a file.

Output data:

• Rendered fractal image.
• Rendered fractal image saved to Windows bitmap file.
• Input data saved to a file.

Project summary:

• Operating system: 32-bit Windows
• Language: C++
• IDE: Microsoft Visual Studio 6.0
• GUI library used: MFC
• Status: educational, noncommercial project
• Last build: February, 2001

For this project you can:

• Download source (46 Kb)
• Download binary (109 Kb)

Game screenshot.

This is the first computer game I have written. It is a remake of a famous Mario game from a game console. With graphics taken from simplified PC-port, the world was extended in both width and height. The functionality isn’t implemented in full - for example, Mario doesn't interact with animals and there are no bonus bricks. But anyway the game is fun :)

Project summary:

• Operating system: DOS
• Language: Pascal
• IDE: Borland Pascal 7.0
• GUI library used: no
• Status: entertainment, noncommercial project
• Last build: July, 1999

For this project you can:

• Download source and binary (176 Kb)

Game screenshot.

This game is an implementation of Rubik's Cube puzzle. In this version you can select difficulty level (number of initial permutations). You can also save the game and continue playing later.

Project summary:

• Operating system: 32-bit Windows
• Language: C++
• IDE: Microsoft Visual Studio 6.0
• GUI library used: Win32 API
• Status: entertainment, noncommercial project
• Last build: May, 2002

For this project you can:

• Download source (162 Kb)
• Download binary (28 Kb)

This game is the most advanced of all I ever wrote - it is a first-person shooter. In the game you are in a shooting-gallery, and your mission is to shoot down the targets with "terrorist" faces painted on them. You dispose of limited ammo and time to complete the round. There are three rounds. The first one is fairly simple, the second more difficult (due to increased speed of target movements and fewer ammo). The best way to describe the last round is "failure is not an option" for there are 5 targets and the same number of shells; in addition, targets move fast and do not follow a straight line, while time limit is very short. In the last round you will face Darth Vader and Osama bin Laden amongst other targets :)

Music is borrowed from Doom2 and Duke Nukem 3D themes, textures - from Half-Life, "terrorist" faces - from Counter-Strike and other sites, everything else is hand-made.

Project summary:

• Operating system: 32-bit Windows
• Language: C++
• IDE: Microsoft Visual Studio 6.0
• GUI library used: Win32 API
• Status: entertainment, noncommercial project
• Last build: June, 2006

For this project you can:

• Download source (71 Kb)
• Download binary, including game data (2,29 Mb)

Fig. 1. Main window representing active script.

Fig. 2. Project tree window.

Fig. 3. COM objects window.

Fig. 4. Watch window.

Fig. 5. Debug log window.

Fig. 6. Context help.

Fig.
7. Context watch popup.

Fig. 8. Source code highlighting settings.

Fig. 9. "New file" window with wizard's icon.

Fig. 10. Compiler settings.

It was the biggest commercial project I took part in. IntelleScript 3 (IS3) is a powerful IVR (Interactive Voice Response) platform for developing modern voice and other telecommunication applications. It can be used in call-centers, voice conference applications, SMS processing applications, VoiceXML, CallControlXML and other hi-tech telecommunication applications. The core of IS3 is its message-oriented transport layer model and IntelleScript 3 Language. The language was developed and implemented by myself from scratch.

IS3 Language is a high-level procedural, event-driven language with built-in objects (string, array, map, etc.) and COM support. It is something like a mixture of Pascal, C and Basic. Here you can download an archive with sample scripts used in real world commercial applications. IS3 is rather powerful language. It has numerous built-in routines and COM-objects for data processing including mathematical, string, date/time, file, message-oriented and other services.

IS3 Language support for IS3 consists of several components:

• Integrated Development Environment - ScriptoGen - used for developing, compiling and debugging scripts (described below).
• Scripts translator - used to compile scripts in bytecode in order to execute them later in scripts engine.
• Scripts engine - used to execute scripts (like Java virtual machine).
• Scripts dispatcher - used to control scripts execution, translate messages into scripts and transfer from scripts to transport layer.
• Surrogate process - used to hold all instances of scripts engines. The main purpose of this module is to protect the rest of the system from possible scripts failure due to poor-written COM-objects executed in the same process as scripts engine.

All the mentioned language support modules were implemented by me on my own; implementation of others involved participation of me and other developers engaged in the project as well. Today IS3 brings a large profit to our company; it has been installed in several leading Russian telecommunications companies, e.g. BeeLine, Interregional Transit Telecom and others.

Below a description of ScriptoGen (GUI part of IS3 Language support) is provided. ScriptoGen is a powerful IDE for developing, compiling and debugging scripts. You can see program screenshots on the left. The major features on ScriptoGen are as follows:

• Syntax highlighting using different user-selected and user-defined color schemes (see fig. 1, 8).
• Project tree window – used to display scripts forming the project along with all scripts instances and messages in debug mode (see fig. 2).
• COM-objects window – used to display methods descriptions of selected COM-objects identified by ProgId (see fig. 3).
• Watch window – used to check the value of any selected variable. Scroll bars are provided for displaying complex variables’ values. When choosing a COM-object, all its actual properties will be displayed (see fig. 4).
• Logs - build log (used to display warning and error messages during compilation phase) and debug log (used to display all the messages generated by scripts engine) (see fig. 5).
• Context help for built-in and third-party COM-objects. When you type a '.' after the name of an object, you get context help providing a complete list of methods and properties of this object (see fig. 6).
• Context watch popup - pointing to a variable's name with mouse cursor in debug mode will result in displaying  its current value (see fig. 7).
• Conditional and unconditional break points. The number breakpoints in the script is unrestricted. Some of them can be conditional, i.e. they only "break" if a specified condition is true. For example, an "i == 10" condition is suitable for a loop of 100 iterations.
• Multi-script debugging – allows you to debug a number of scripts simultaneously.
• Offline and Online debug modes. In offline mode you debug a script on your local machine, using local COM objects and limited functionality. Online mode is more powerful and allows debugging scripts on a remote telephony server, for example, by making calls to a test number and watching your script's progress in real-time. This mode is particularly useful when debugging very complex voice applications involving numerous menus, conferences, etc.
• Wizards for creating projects and scripts (see fig. 9).
• Flexible compiler settings including popular warnings disabling (see fig. 10).

You can download and run offline version of ScriptoGen. The archive includes the following files:

• ScriptoGen.exe - IDE executive.
• Translator.dll - DLL compiler.
• Engine.dll - scripts engine COM-component; you need to register it using regsvr32.
• IO.dll - file IO COM-component.
• Service.dll - service routines for date/time and others.
• Test.prj - test project.
• Include directory - header files for all scripts.

Project summary:

• Operating system: Windows XP/2003
• Language: C++
• IDE: Microsoft Visual Studio 2005
• GUI library used: MFC
• Status: commercial project for russian mobile operator BeeLine and others.
• Last build: June, 2006

For this project you can:

• Download demo binary (2,85 Mb)

Fig. 1. Main window representing process list.

Fig. 2. Main window representing process tree.

Fig. 3. Main window representing performance graph.

Fig. 4. Main window representing extended OS counters.

Fig. 5. Main window representing processor's features.

Fig. 6. Process memory regions list.

Fig. 7. Process memory editor.

Fig. 8. Process thread list.

Fig. 9. Process privileges dialog box.

This task manager's implementation is rather powerful. Its distinctive feature is the ability to obtain process call stack for all threads, which makes the program  very convenient for developers when debugging different processes. This task manager was originally intended for developers. It also includes an extensive set of features which are not unique: for example, see Mark Russinovich's ProcessExplorer. Other task managers, being either simple or advanced, are short of many useful features available in Power Task Manager. Thus, for example, ProcessExplorer is lacking the ability to view and edit process memory or to set process privileges (SeDebugName, SeShutdownName, etc.).

Project features:

• Displaying a list of processes with the following attributes: image name, process ID, CPU usage (in percentage terms), CPU (user and kernel) time, time of creation, working set size, virtual memory size, base priority, thread counter, user objects count, GUI objects counter, handle counter, IO bytes read, IO bytes written, user name, image path (see fig. 1).
• Displaying process tree (see fig. 2).
• Terminating arbitrary process.
• Terminating process tree.
• Terminating several processes under the same name.
• Displaying system information: OS type, version, build number, service packs installed; user name, computer name, system folder, Windows folder, processor type, number of processors, system page size and user address range.
• Performance graph for CPU and virtual memory (see fig. 3).
• Various system counters, e.g. total number of open handles, total amount of memory, free physical memory, system cache size, kernel memory info, committed charges, page pool limits, etc. (see fig. 4).
• Processor info: vendor, type, family, stepping, model, serial number, processor features (commands extensions system, etc.), cache info, additional features (power control, address range size, etc.) (see fig. 5).
• Setting process base priority.
• Setting process privileges (see fig. 9).
• Modifying process ACLs (Access Control Lists).
• Displaying process startup info.
• Displaying process main module version info.
• Viewing and editing process memory (see fig. 6, 7).
• Modifying process working set size.
• Displaying process module list.
• Displaying process thread list (see fig. 8).
• Displaying process handle list.
• Displaying process "snapshot" - call stack of all threads .
• Searching loaded DLL modules by name.
• Saving the above lists to a text file.

Input data:

• WinAPI calls.

Output data:

• Lists, graphs and text data.
• Some of the above data saved to a text file.

Project summary:

• Operating system: 32-bit Windows
• Language: C++
• IDE: Borland C++Builder 6.0
• GUI library used: VCL
• Status: noncommercial project from "Debug tools" package
• Last build: March, 2006

For this project you can:

• Download source (520 Kb)
• Download binary (1,28 Mb)