Finally, I got lucky a few days ago. User thomasd of CivFanatics forum posted a Colonization image viewer written in Java here: http://forums.civfanatics.com/showthread.php?t=256665&page=2. This is in fact based on code from ScummVM. What’s the connection between Colonization and a program for playing old point-and-click adventure games? It turns out one of the adventure engines supported by ScummVM is MADS which is short for MicroProse Adventure Development System. And as Colonization is a MicroProse game, some code sharing between their games took place (at least the file compression method MADSPACK). So now if you want to write your own Colonization image extractor you can dig deep into history of ScummVM’s Git repository (as support for MADS engine seems to have been removed) or try your luck with Java decompiler

Colonization - Jamestown Conquered

Colonization - Fortress of Quebec

If you want to play Colonization today: DOS version runs ok even in Windows XP. For newer 64 bit Windows you have to use DOSBox or virtualize some old OS (not sure if it works in 32 bit version of Win7).

There is also Colonization for Windows from 1995, a port of the game for Windows 3.1 (Amiga and Mac version were also produced). It features slightly updated graphics (at least unit sprites are in higher resolution) but also not so nice user interface (some unskinned Windows controls etc.). Big difference between DOS and Windows version is that the later runs at the resolution of your desktop so you can see much larger part of the world map at once (maybe not so much in 1995). The downside is that as a 16 bit application it won’t run in 64 bit Windows OS.

Colonization for Windows

Game resources in Win version of Colonization are stored differently from DOS version. Sounds are just individual WAV files in game folder, music is CD audio, and spites & tiles are stored as resources in DLL libraries.

Some Links

Here’s the official Colonization trailer from 1994:

And some links to a few fan pages:

• http://www.colonization.biz
• http://www.colonizationfans.com/game-topics.html

Being a programmer, rather that searching for some program on the Internet, I wrote my own quick and dirty command line tool for this task (mostly hard-coded paths etc.) in mid 2010. This year, I added GUI (where all the settings can be adjusted), some more date & time functions, and basically made the whole thing usable. And finally, beta release of PhotoMixer is available.

Download

Please report any bugs and problems you encounter. Ideas for new features as well!

Overview

PhotoMixer takes photo sources as input and mixes/sorts them. Photo source is a folder with photos that have different properties than some other source. Most often, it’s from a different person and/or taken with different camera. PhotoMixer takes all the photos from all sources and puts them all in one output folder with file names that contain timestamps (so that the files appear in the same order regardless if you sort them by name, type, or date).

The most important this is: it can adjust date & time of photos from each source automatically. As the result, you now have a folder with all the photos from your trip in the right order even though they originally came from ten people with all of them having wrong date & time setting in their cameras. Where’s the catch? Well, there should be one photo that each of these people took at nearly the same time. These reference photos are then used by PhotoMixer to synchronize the sources.

Each source can be synchronized using reference photo or just by explicit time shift. Photo date and time is taken from embedded EXIF metadata that’s generated by digital camera and inserted in JPEG file. Only when, for some reason, EXIF is not present, file system date is used instead. When using reference photo synchronization one of the sources must be designated as main reference source. That is the source whose dates will not be modified and all other sources will be shifted in regard to date differences between their reference photo and that of the main source.

PhotoMixer also offers some useful tools for related tasks.

Usage Guide

PhotoMixer employs tabbed user interface where the first tab contains output settings and log. Additional tabs define photo sources. When you start the tool for the first time new source is created, and you can start setting it up and adding more sources. When you are done with sources, go to Settings tab, adjust output options, and finally click Run button.

Photo source options

For each source you can select folder with photos and type of synchronization. For sync by reference photo you must select this photo and for explicit shift you provide positive or negative time in seconds.

Settings and output tab

On Settings tab select the output folder, base name of the generated files (will be named “BaseName TimeStamp.jpg”), and main reference source used for synchronization.

All the options and source definitions can be saved for later usage and restored using the Save and Load actions in the Tools menu. There is also tool for clearing the output folder and two little more complex tools: Set Photo Date & Time and Set File Time from Photo Metadata.

"Set Photo Date & Time" tool

If you totally lost all date & time info about some photos and you want at least something (e.g. you use some photo organizer and want some filtering based on year & month to work) you can generate it using Set Photo Date & Time tool. Some base date & time is selected and each photo can have optional time increment (e.g. first photo has “base time”, second has “base time + 5 minutes”, another one has “base time + 10 minutes”, etc.).

Set File Time from Photo Metadata tool can be used to restore file system date & time according to metadata inside the photo.

Nice to have features for future version

Some are definitely going to be included, some are more like pipe dreams.

• Detect blurred photos that you just want to delete.
• Detect similar images – often more people take a photo of the same thing but you want to keep just one (the best looking one).
• Resampling of output photos to different resolution. Although this is a lossy operation, it has its uses.
• Create embedded JPEG thumbnails where missing (they’re embedded by cameras but some photo editing program could remove it).
• Lossless rotation of MJPEG videos from cameras (90/180/270 rotations).
• Strip junk data streams (e.g. after lossless rotation in Irfan the old data stream is kept in the file resulting in 2x bigger file).
• Linux and Mac OS X version (at least with CLI).
• Something to deal with camera orientation (when taking the photo). Some cameras have positioning sensor and store this information in metadata so the program could rotate them accordingly. For others, some GUI that allows simple and fast manual rotations would be nice. Probably redundant: probably just do it in Live Gallery/Picassa/whatever.

The End

Sorting of about 3000 photos too about 2 minutes on my desktop (nearly all of that time is spent reading EXIF metadata from the files). Here are some photos from the “last batch” (panoramas made in Microsoft ICE):

Daggerfall

Just a few days ago I’ve stumbled upon new attempt at bringing Daggerfall back to life. Ruins of Hill Deep is a total conversion mod (like quite a few for Morrowind and Oblivion). Author of the RoHD is Interkarma, well known person in Daggerfall fan community. He wrote quite a few tools for Daggerfall over the years and the new 3D engine is based on their code base. Well, good luck with the project and hopefully we’ll finally see some Daggerfall action again soon.

Another remake currently in works is DaggerXL (mentioned in Daggerfall for Free!). Unfortunately, after a really promising start its development slowed down so let’s hope it will pick up the pace again (the author is currently merging several of his engines for remakes, like Dark Forces and Blood, into one shared engine).

Last but not least, Daggerfall turned 15 this August. So let’s watch this official trailer:

Or a guy with shotgun wreaking havoc among Daggerfall’s popular town guards:

Arena

I tried running TES: Arena on Android phone recently. There’s a free DOSBox port for Android called aDOSBox. On my Nexus S (1Ghz ARM CPU) aDOSBox runs Arena at about 1 FPS. So it is far from playable speed but new phones could get usable frame rates maybe in a year or two (on Galaxy S II it’s already noticeably faster). Main problem is controlling the game since there are nearly no usable buttons/keys on the phone. Also Arena is quite “mouse heavy” as you need to move the mouse holding the right button to swing your weapon.

Apart from free a DOSBox, there is also paid AnDOSBox that is supposed to be faster. See this youtube video of Daggerfall running on HTC Desire (1GHz CPU as well) which seems to be faster than Arena in aDOSBox (confused by the similar name? They also have nearly identical icon!).  Do you know any other alternative for running Arena on smart phones?

Some city in Tamriel

Arena character overview

Game Resources

New tool for extracting and converting Arena files appeared on UESP site last year. It’s command line utility based on WinArena (mentioned in post HoMaM 2 and Arena remakes). You can get the source code in C at UESP Arena-Files.

I’ve been thinking about creating some GUI for Arena files browsing and extraction. Daggerfall has great tools created by community for fiddling with its assets but Arena not so much. File format decoding would have to be based on WinArena too, as it’s the known only tool (and stuff based on it) that can read more than just some textures or extract file archives. No file format documentation can be found on the net either (though there’s lot of info for Daggerfall formats). So WinArena’s code is basically the only documentation/reference available.

And finally, the official Arena trailer:

• Login to your shell service at SF.net (ssh to username,projectname@shell.sourceforge.net) and navigate to your project’s repository. You start in your home dir (for me that’s /home/users/g/ga/galfar) and your project’s repo dir might look like /home/scm_hg/i/im/imaginglib/imaginglib/.hg/.
• There you create a new file named hgrc (repository configuration) or edit the existing one.
• Append the following two lines to that config file:

  [web]
  allow_archive = gz zip

• Save the config and enjoy downloading zip and tar.gz archives! You’ll see new zip and gz items in the top menu of repo browser (e.g. summary | shortlog | changelog | graph | tags | branches | files | zip | gz) when viewing the revisions and also corresponding two icons in repository list that can be used to get the snapshot of top revision of each repository.

PS: You can convert whole repository to Mercurial with all the history and tags simply by using Convert extension. It takes quite a lot of time when you convert remote repository directly but the conversion continues where it left off when you get timeout or some network problem and run the conversion again.

Half floats first appeared in early 2000s as samples in images and textures. Floats provide higher dynamic range than what is available with regular 8bit or 16bit integer samples. On the other hand, commonly used single and double precision floats have much higher memory cost per pixel. Half floats have more reasonable memory requirements and their precision is adequate for many usages in imaging.

16bit float formats have been supported by ATI and NVidia GPUs for many years. I’m not sure about other IHVs but at least Direct3D 10 capable GPUs should all support it.

Read on if your interested how to convert between half and single precision floats (Object Pascal code).

Half/Single Conversion code

Finally, here’s the code for converting to half floats and back to single precision float. It’s based on C++ code from OpenEXR library (half class).

First some types and constants

Note that THalfFloat type is just an alias for Word.

type
  THalfFloat = type Word;

const
  HalfMin:     Single = 5.96046448e-08; // Smallest positive half
  HalfMinNorm: Single = 6.10351562e-05; // Smallest positive normalized half
  HalfMax:     Single = 65504.0;        // Largest positive half
  // Smallest positive e for which half (1.0 + e) != half (1.0)
  HalfEpsilon: Single = 0.00097656;
  HalfNaN:     THalfFloat = 65535;
  HalfPosInf:  THalfFloat = 31744;
  HalfNegInf:  THalfFloat = 64512;

Single precision float to half

function FloatToHalf(Float: Single): THalfFloat;
var
  Src: LongWord;
  Sign, Exp, Mantissa: LongInt;
begin
  Src := PLongWord(@Float)^;
  // Extract sign, exponent, and mantissa from Single number
  Sign := Src shr 31;
  Exp := LongInt((Src and $7F800000) shr 23) - 127 + 15;
  Mantissa := Src and $007FFFFF;

  if (Exp > 0) and (Exp < 30) then
  begin
    // Simple case - round the significand and combine it with the sign and exponent
    Result := (Sign shl 15) or (Exp shl 10) or ((Mantissa + $00001000) shr 13);
  end
  else if Src = 0 then
  begin
    // Input float is zero - return zero
    Result := 0;
  end
  else
  begin
    // Difficult case - lengthy conversion
    if Exp <= 0 then
    begin
      if Exp < -10 then
      begin
        // Input float's value is less than HalfMin, return zero
         Result := 0;
      end
      else
      begin
        // Float is a normalized Single whose magnitude is less than HalfNormMin.
        // We convert it to denormalized half.
        Mantissa := (Mantissa or $00800000) shr (1 - Exp);
        // Round to nearest
        if (Mantissa and $00001000) > 0 then
          Mantissa := Mantissa + $00002000;
        // Assemble Sign and Mantissa (Exp is zero to get denormalized number)
        Result := (Sign shl 15) or (Mantissa shr 13);
      end;
    end
    else if Exp = 255 - 127 + 15 then
    begin
      if Mantissa = 0 then
      begin
        // Input float is infinity, create infinity half with original sign
        Result := (Sign shl 15) or $7C00;
      end
      else
      begin
        // Input float is NaN, create half NaN with original sign and mantissa
        Result := (Sign shl 15) or $7C00 or (Mantissa shr 13);
      end;
    end
    else
    begin
      // Exp is > 0 so input float is normalized Single

      // Round to nearest
      if (Mantissa and $00001000) > 0 then
      begin
        Mantissa := Mantissa + $00002000;
        if (Mantissa and $00800000) > 0 then
        begin
          Mantissa := 0;
          Exp := Exp + 1;
        end;
      end;

      if Exp > 30 then
      begin
        // Exponent overflow - return infinity half
        Result := (Sign shl 15) or $7C00;
      end
      else
        // Assemble normalized half
        Result := (Sign shl 15) or (Exp shl 10) or (Mantissa shr 13);
    end;
  end;
end;

Half to single precision float

function HalfToFloat(Half: THalfFloat): Single;
var
  Dst, Sign, Mantissa: LongWord;
  Exp: LongInt;
begin
  // Extract sign, exponent, and mantissa from half number
  Sign := Half shr 15;
  Exp := (Half and $7C00) shr 10;
  Mantissa := Half and 1023;

  if (Exp > 0) and (Exp < 31) then
  begin
    // Common normalized number
    Exp := Exp + (127 - 15);
    Mantissa := Mantissa shl 13;
    Dst := (Sign shl 31) or (LongWord(Exp) shl 23) or Mantissa;
    // Result := Power(-1, Sign) * Power(2, Exp - 15) * (1 + Mantissa / 1024);
  end
  else if (Exp = 0) and (Mantissa = 0) then
  begin
    // Zero - preserve sign
    Dst := Sign shl 31;
  end
  else if (Exp = 0) and (Mantissa <> 0) then
  begin
    // Denormalized number - renormalize it
    while (Mantissa and $00000400) = 0 do
    begin
      Mantissa := Mantissa shl 1;
      Dec(Exp);
    end;
    Inc(Exp);
    Mantissa := Mantissa and not $00000400;
    // Now assemble normalized number
    Exp := Exp + (127 - 15);
    Mantissa := Mantissa shl 13;
    Dst := (Sign shl 31) or (LongWord(Exp) shl 23) or Mantissa;
    // Result := Power(-1, Sign) * Power(2, -14) * (Mantissa / 1024);
  end
  else if (Exp = 31) and (Mantissa = 0) then
  begin
    // +/- infinity
    Dst := (Sign shl 31) or $7F800000;
  end
  else //if (Exp = 31) and (Mantisa <> 0) then
  begin
    // Not a number - preserve sign and mantissa
    Dst := (Sign shl 31) or $7F800000 or (Mantissa shl 13);
  end;

  // Reinterpret LongWord as Single
  Result := PSingle(@Dst)^;
end;

Deskewing some smart paper

My approach is fairly common for this problem – rotation angle is first determined using Hough transform and then the image is rotated accordingly. Classical Hough transform is able identify lines in the image and it was later extended to allow detection of any arbitrary shapes.

Lines of text can be thought of as horizontal lines in the image. In a skewed scanned document all the lines will be rotated by some small angle. We can start with the equation of the line y = k · x + q. Since we’re interested in the angle, we can rewrite it as y = (sin(α) / cos(α)) · x + q. Finally, we can rearrange it as y · cos(α) − x · sin(α) = d. Now every point [x, y] in the image can have infinite number of lines going through it, where each is defined by two parameters: angle α and distance from the origin d.

We want to consider lines only for certain points of input image. Ideally, that would be the base lines on which the “text is sitting”. Simple way of determining these points is to check for black pixels which have white pixels just below them. Now for each of the classified points, we determine parameters α and d for all the lines that go through them. To get some finite number of lines, we calculate d for angles α from a certain range (I use angle step of 0.1 degrees). We want to find a line that intersects as many classified points as possible – an accumulator is used to store “votes” for each calculated line. For each point that is believed to be on the text base line, we add one vote for each line that intersects it. At the end, we find the top lines that have the most votes. Ideally, these are the base lines of all lines of text in the document. Finally, we get the rotation angle by averaging angle α of the top lines and rotate the whole image accordingly.

Important part is that one: “check for black pixels which have white pixels just below”. What’s black and white is determined by comparing value of the current pixel against some given threshold. For images where background is plain white and the text is black it’s easy just to use 0.5 as the threshold. But when the background/foreground distinction is not so sharp calculating the threshold adaptively based on the current image can be very useful. Deskew supports both adaptive threshold calculation as well as specifying constant threshold as command line parameter.

Deskewing some math exercise

Implementation is written in Object Pascal and uses Imaging library for reading and writing various image file formats. There are precompiled binaries for 32bit Windows and Linux, other platforms can be built from sources using Free Pascal compiler (you need Imaging library for compilation). Archive also contains few test images.

Much later, in 2008, I stumbled upon small Lego exhibition made by some local fans. There was a really huge M-Tron base and it got me thinking about buying few of those larger Space sets I wanted years ago. Well, after about two-month eBay shopping spree I had all M-Tron sets – together with about 60 others (and some individual parts orders from Bricklink). I became a nightmare for local post women with all these international packages coming nearly every other day. My best buy was probably Blacktron Message Intercept Base with original box for less than £20 from eBay UK.

These days I don’t have time for Lego anymore, but hopefully this will change some day. And some larger building space would be nice too!

My latest creation is Ice Planet’s Deep Freeze Defender rebuilt as a M-Tron ship. Unfortunately, it was quite damaged during moving to a different house so I’ll have to do some repairs.

Check out my Brickshelf gallery and current set collection.

New features of Jpeg 2000 for Pascal will be CMYK colorspace support and also indexed/palettized images support (yes, it’s possible to have image using palette in Jpeg 2000). These features as well as proper alpha channel definitions are patched into OpenJpeg library. Its team is not very active in incorporating larger patches into their code, so patches will probably always be additional step for people who want to recompile OpenJpeg themselves for use with PasJpeg2000.

You can follow the progress of the new version in SVN repository here: branch v120.

One way is to override DoDraw method of TImageList and change the code that draws disabled images. You can do regular RGB to grayscale conversion here or let  Windows draw it for you in grayscale with nearly no work on your part. You can do this by using ImageList_DrawIndirect with ILS_SATURATE parameter. Note that this works only on Windows XP and newer and for 32bit images only. For older targets or color depths doing your own RGB->grayscale conversion is an option (good idea would probably be to cache converted grayscale images somewhere so they won’t need to be converted on every draw call).

Here’s the code of DoDraw method using  ILS_SATURATE:

type
// Descendant of regular TImageList
TSIImageList = class(TImageList)
protected
  procedure DoDraw(Index: Integer; Canvas: TCanvas; X, Y: Integer;
    Style: Cardinal; Enabled: Boolean = True); override;
end;

procedure TSIImageList.DoDraw(Index: Integer; Canvas: TCanvas; X, Y: Integer;
  Style: Cardinal; Enabled: Boolean);
var
  Options: TImageListDrawParams;

  function GetRGBColor(Value: TColor): Cardinal;
  begin
    Result := ColorToRGB(Value);
    case Result of
      clNone: Result := CLR_NONE;
      clDefault: Result := CLR_DEFAULT;
    end;
  end;

begin
  if Enabled or (ColorDepth <> cd32Bit) then
    inherited
  else if HandleAllocated then
  begin
    FillChar(Options, SizeOf(Options), 0);
    Options.cbSize := SizeOf(Options);
    Options.himl := Self.Handle;
    Options.i := Index;
    Options.hdcDst := Canvas.Handle;
    Options.x := X;
    Options.y := Y;
    Options.cx := 0;
    Options.cy := 0;
    Options.xBitmap := 0;
    Options.yBitmap := 0;
    Options.rgbBk := GetRGBColor(BkColor);
    Options.rgbFg := GetRGBColor(BlendColor);
    Options.fStyle := Style;
    Options.fState := ILS_SATURATE; // Grayscale for 32bit images

    ImageList_DrawIndirect(@Options);
  end;
end;

Important note: For ILS_SATURATE to work correctly source image files must be 32bit with proper alpha channel data, setting color depth of TImageList to 32bit is not enough! If you don’t see any images drawn this is probably the cause: 8/24bit image is loaded from file and then inserted into 32bit TImageList. As there is no alpha channel data in source image it is drawn as fully transparent so you don’t see anything.

Today you can play original DOS version of  HoMaM 2 in DosBox. It wasn’t the case few years ago when DosBox wasn’t able to run SVGA games. There’s also Windows version of HoMaM 2 executables in Heroes Of Might And Magic 2 Gold (expansion disk included). However, neither of these two options take advantage of today’s high resolution monitors. Map view will always be stretched from it’s original 640×480 resolution.

Several years ago, I stumbled upon Free Heroes II project. It’s a GPL cross-platform (SDL based) implementation of Heroes of the Might and Magic II engine. It’s been steadily progressing over the years and fortunately hasn’t died like many other remakes of older games. Today, “standard game” mode is playable as well as hot seat multiplayer. Very nice feature of Free Heroes II is that map view is not stretched to higher resolutions. Instead, you can see larger portion of a map without the need for a lot of scrolling around. Let’s hope we’ll see version 1.0 in near future.

Another game I’d like to see remade is the first The Elder Scrolls game Arena. There hasn’t been any known attempt at remake Arena – unlike its sequel Daggerfall (though all past remakes failed the latest one, DaggerXL, remains very promising). No description of Arena file formats is available on the Internet either (with few exceptions of raw images or formats shared by more Bethesda games) – again unlike Daggerfall where almost everything is described in detail.

I was pleasantly surprised few months ago when I found out about WinArena. It was originally Arena resource extractor and converter (textures, maps, sounds, sprites, …) with 3D engine capable of  displaying Arena maps added later. Unfortunately there are only two versions you can find on the net and the latest is dated December 2005 – so it’s long since dead.

3D engine uses software rendering in 256 color mode like original Arena (it supports higher resolutions though). According to the author, many of the effects in the game are based on palette manipulation tricks so it wouldn’t be possible to get the exact Arena look using standard hardware accelerated 3D API like Direct3D or OpenGL.

What’s best on WinArena is that full source code is provided. And since it handles most if not all Arena file formats, getting their description is just a matter of going through the code. I’d also love the possibility to revisit all the main maps in the game so maybe I’ll modify it a little bit (WinArena currently starts at the beginning of actual Arena gameplay – in the prison like most TES games do).

You can get latest version of WinArena at TESNexus.

Just before publishing this post I also found Python port of Elder Scrolls: Arena which also seems inactive at the moment (there’s some resource extraction Python code in the project’s repository).

Downloads

Top download is JPEG 2000 for Pascal package with about 700 downloads. Second place goes to glSOAR terrain renderer with about 200 downloads. Third place is shared between Earth Under Fire shooter and venerable JPEG Ripper tool, both with meager 60 downloads.

Visitors

There have been around 4000 visitors since last March. 42% of them got here from referring sites,  35% used search engine, and 23% is direct traffic.

Referring Pages

Basically all of them are connected to Imaging Library or JPEG 2000 for Pascal (torry.net, delphiplus.org, imaginglib.sf.net, cc.embarcadero.com, etc.). For some reason there’s really a lot of referrals from images.google[.ru|.de|.fr|.com] pointing mostly to screenshots from Ufo: Extraterrestrials and Terrain Rendering stuff. Few links to Earth Under Fire from pascalgamedevelopment.com are in the stats too.

Browsers and OS

Firefox is in the lead with 40% share, IE is second with 25%, third is Opera with 22%, Chrome and Safari have 7% and 2% respectively. Windows is major OS here with 91%, Linux and Mac OS X have about 4% each. There’s also one visit from Wii and one from PS3.

Search Engine Keywords

Most common keywords refer to these topics: Terrain rendering, JPEG 2000 for Delphi and Pascal, Ufo: Extraterrestrials, DirectX 11 for Delphi, and Daggerfall. You can find more or less information about these topics at this site.

Some keywords were very common too even though I wouldn’t think they’d be so popular:

• APNG  (mostly coupled with Delphi) – As far as I know my Imaging is only library for Pascal and Delphi that can read and write APNG animated images. That’s probably why Google search for “apng delphi” puts this site at top.
• Delphi shr operator – Looks like there’s more people surprised that it treats negative values differently than shift right operator in C and some other languages. More on this in this post Shift Right: Delphi vs C.
• Daggerfall music (“daggerfall gstory music”, “eric heberling” daggerfall”, “robert hood daggerfall”) – Great music indeed, much better than what’s in Morrowind and Oblivion.
• SOAR terain rendering – here’s my Pascal implementation glSOAR.
• Modula-2 related (“modula-2 vs c++, vs pascal, vs freepascal, on mac ox, for 8051, …” )

And here are some uniques searches:

• “ancientlich” – My favorite monster in Daggerfall as well, checkout bestiary at UESP (top of the Undead section!).
• “UFO old programming language” – that must be COBOL!
• “ufo enemy ripped png picture” – anyone has these?
• “directx 11 radeon x1950″ – sadly no, otherwise I’d put it back in my PC right away.
• “mng vs apng” – basically MNG is much more capable but harder to implement, more VS info here.
• “john the ripper directx 11″ – is this some of kind of a game or what?
• “mac os 7.5 emulator” – check out Basilisk .
• “midi format daggerfall” – It’s HMI (Human machine interfaces MIDI music file), WinAmp can play and convert that (and other old game MIDI formats as well).
• “a price drop for gpu in 2010″ – there better be one.
• “earth on fire from space” – let’s hope not anytime soon.
• “gulfar vivek”, “how is galfar doing?”, “large galfar image” – ???

Few days ago I tried C++ Builder 2010 and was pleasantly surprised. It worked! I tried just the library core for now (ImagingTypes, Imaging, ImagingFormats, Pascal only file handlers, etc.) and it works without problems. I’m not sure which C++ Builder version is required for successful compile though. Versions 6 and 2006 stopped with internal error, 2010 worked, and there are 2 other versions between.

Anyway, I’ll try to check out most of the library until the 2010 trial expires for me. Hmm, I’m wondering how many people use C++ Builder for C++ development – I’ve never did something serious in it, basically just to get object files usable by Delphi – so I have no idea if it’s ok.

PS: Another C++ Builder related news – patch for OpenJpeg library to get it compiling in BCB is posted here.

So what can you expect in the next version of PasJpeg2000 library?
Higher GCC optimization levels should make it a lot faster when using Free Pascal (particularly in Mac OS X where O0 was used). Irreversible DWT transformation produces smaller lossy files than current PasJpeg2000 version and with optional MCT (multicomponent transform – basically RGB>YCbCr) you get even smaller ones. There’s now also a patch that enables OpenJpeg to get palettes from JP2 files so indexed JPEG 2000 images could be supported too. And finally, there are some bug fixes (wrong reconstruction of subsampled files, …).

It does in fact. SHR treats its first operand as unsigned value even though it is a variable of signed type whereas >> takes the sign bit into account. In the function I converted the operand for right shift was often negative and Delphi’s SHR just ignored the value of the sign bit.

A Bit of Code

int a, b1, b2;
a = -512;
b1 = a >> 1;
b2 = a / 2;

After running this C code both b1 and b2 have a value of -256.

var A, B1, B2: Integer;
A := -512;
B1 := A shr 1;
B2 := A div 2;

This Delphi code however yields different result: B2 is -256 as expected but B1 has a value of 2147483392.

A Bit of Assembler

Assembler output of C code:

Unit1.cpp.22: b1 = a >> 1;
mov eax,[ebp-$0c]
sar eax,1
mov [ebp-$10],eax
Unit1.cpp.23: b2 = a / 2;
mov edx,[ebp-$0c]
sar edx,1
jns $00401bb9
adc edx,$00
mov [ebp-$14],edx

Assembler output of Delphi code:

Unit1.pas.371: B1 := A shr 1;
mov eax,[ebp-$0c]
shr eax,1
mov [ebp-$1c],eax
Unit1.pas.373: B2 := A div 2;
mov eax,[ebp-$0c]
sar eax,1
jns $00565315
adc eax,$00
mov [ebp-$20],eax

As you can see, asm output of C and Delphi divisions is identical. What differs is asm for shift right operator. Delphi uses shr instruction whereas C uses sar instruction. The difference: shr does logical shift and sar does arithmetic one.

The SHR instruction clears the most significant bit (see Figure 6-7 in the Intel Architecture Software Developer’s Manual, Volume 1); the SAR instruction sets or clears the most significant bit to correspond to the sign (most significant bit) of the original value in the destination operand.

Quoted from: http://faydoc.tripod.com/cpu/shr.htm

More info and downloads at Imaging’s homepage.

I checked out Clootie graphics pages but no luck there. Unfortunately, it’s not so active anymore. After that I thought DX11 for Pascal wouldn’t appear in like several months at least. Surprise, I found it about 5 minutes later. John Bladen published his DX11 translation on DirectX for Delphi blog. Thanks John!

Now all that remains is buying a DX11 GPU. New Radeons should be released sometime during this week and I’m thinking of getting 5850 model in a few months. Rumours are that NVidia’s DX11 cards won’t be out before 2010, so probably no big price drops for 5800 Radeons are to be expected until then.

My pile of old graphic cards will get bigger once again. I don’t buy new CPU/motherboard/RAM too often (now it’s Core2 from 2007 and before that AthlonXP in 2002) and I usually manage to sell the old ones or put them on server duty somewhere. However, since GPU performance as well as requirements on it rise much more faster than that of CPU, I ended up with like 5 cards in last 8 years. I managed to sell Radeon 9000 and GeForce 6600 but I still have Riva TNT2 and Radeon X1950 in my closet somewhere (and S3 Trio!). Hopefully, I’ll find a buyer for my 1GB 4850 soon.

Lately, I’ve had bad luck buying some new stuff just before major price drop. Hopefully, this won’t happen with 5850. Not that I want it to remain expensive – just want to buy it after the drop, not  a little while before it.

Mainly for testing purposes during implementation of these new methods, I want to create extension for Imaging that compares two images (original and one reconstructed from compressed original) and measures PSNR and some other quality metrics.

I’m also thinking of implementing DXT5 based format using YCoCg colorspace and PVRTC (texture compression currently used in iPhone).

Few links if you’re interested:

• Brief DXTC overview: http://en.wikipedia.org/wiki/S3_Texture_Compression
• More technical details: http://www.opengl.org/registry/specs/EXT/texture_compression_s3tc.txt
• YCoCg-DXT related: http://developer.nvidia.com/object/real-time-ycocg-dxt-compression.html

Here’s some quick comparison of DXT compressors (click the image to see full size). Value in brackets is MSE (mean square error) – lesser number means compressed image is more similar to original.

There were a lot of attempts at remakes of Daggerfall but all failed so far. However, a new promising one appeared recently and it’s progressing at warp speed since then (one month from wrongly textured entrance of Privateer’s Hold dungeon to rendering city blocks). Check out development blog and downloads at the homepage of DaggerXL. You need original Daggerfall data files to run the demo – no problem now when you can get it free.

Daggerfall Workshop was recently reopened as well. It’s a home of tools that let you explore Daggerfall’s game assets (textures, models, maps, music, etc.). There’s also a new exploring tool in development that looks really good, with very interesting blog posts about various Dagger’s file formats, rendering techniques, and so on.

I did my small share of dabbling in Daggerfall’s file formats too. Image and texture loaders in Object Pascal are part of ElderImagery extension of Imaging library and I’ve got BSA archive handler somewhere too. I’m now thinking of adding SKY format (backdrop images used in game for skies and far away mountains) loader, just for fun I guess.

When writing about Daggerfall, one cannot forget mentioning its music which was really excellent. Much more atmospheric and fitting than the music in recent Elder Scrolls games (there was also a lot more tracks). Check out Robert Hood’s arrangements of Eric Heberling’s original music tracks.

There’s header translation working with both Delphi and FPC and original C library precompiled to object files (Delphi) and static libraries (FPC for Win32, Linux x86/x64, and Mac OS X).

I’ve written simple TBitmap descendant that loads and saves JPEG 2000 images. It’s only for Delphi now – can’t do LCL version with just few IFDEFS, there are lot more changes between VCL and LCL TBitmaps. I plan to write separate LCL version for one of upcoming releases (using TFPCustomImageWriter and TFPCustomImageReader classes).

You can get JPEG 2000 for Pascal library at it’s project page.

Now I’m gonna extend PNG saver to allow saving multi images to simple APNG files, much like MNG saving works now. There’s really not a good unified way how to pass some more information to image file savers in current library design – that’s one of TODOs for new Imaging architecture.

There is already PNG-like chunk based format for animations called MNG (already supported by Imaging – at least the basic features). However, MNG is quite complex format and its support among browsers and image viewers/editors is lacking. Code library supporting all MNG features is huge.

APNG on the other hand is just an extension of PNG and its implementation is not so complex. I’m going to load only the raw frames from files at first and see what will have to be done to support animating the frames next. Canvas class will have to be used here for alpha blending subsequent frames to previous ones. I’ll add option to turn the animating on/off just like it is available for animated GIF files.

More info about APNG: http://www.animatedpng.com and https://wiki.mozilla.org/APNG_Specification.

Current theme is just temporary, I’ll look for something more to my liking later (going away for a week in few hours) and probably do some modifications. I’ve tried quite a few themes already but there was always some glitch (no header margins, wrong image alignment, etc.).

First difference you may notice (compared to Pascal) is case sensitiveness of Modula-2, for instance all reserved words are upper cased. You don’t have to write so many begin-end statements though. Another C-like trait is importance of header files (definition modules) order during compiling – just change it a little bit in a large project and whole thing breaks down.

More info about Modula-2 if you’re interested: http://www.modula2.org/.

After not so straightforward installation of Mac OS X in VMWare I fixed the issue just by changing number “24” to “32” in the code (TRawImage.Description.Depth field, LCL raw image to TBitmap conversion). Apparently, Carbon created bitmap with 6 bits per color channel. Now I just need to check if 24->32 change doesn’t break anything when using other LCL widget sets (I’m sure there was a reason for 24bits since I vaguely remember 32bits were there few years ago) – so maybe conditional compilation will be needed here.

Another issue I noticed is that LCL Imager demo couldn’t load default image (Tigers.jpg) that is displayed when it is started without parameters. Demo uses relative path to the image but (from Demos/Bin to Demos/Data directory). Mac OS X application LCLImager.app is placed in Demos/Bin directory by Lazarus but it is not a simple single file. It’s a directory itself and actual demo executable is located somewhere inside. I’ve not really decided on solution yet. Maybe embed the image in the executable as resource?

See the difference?

I decided to remove Kylix support (CLX graphic classes, project files, build scripts, core library still compiles). It’s not working properly on many (all?) current Linux distros (so I can’t test) and it was abandoned by Borland/Codegear quite some time ago. It was nice to have DCC compiler in Linux and it also made Borland to make Delphi RTL crossplatform. There are rumors about crosscompiling features in upcoming Delphi releases (in 2010?)  so maybe we’ll see DCC in Linux again.

Instead of Kylix project files there are new ones for Delphi 2009. Imaging itself didn’t require many fixes to compile and work with Delphi 2009,  most of them were related to text-based file format loaders (XMP, PNM) and external libraries (JpegLib, ZLib).

More info and downloads at Imaging’s homepage.