psx h4x0rz in teh wired

Replicate

2011-08-13T08:47:00.000-07:00

On a whim, I ran one of the unique identifiers in the Lain game through Google which led me to a couple interesting sites.

A very impressive Russian site is trying to recreate most of the game's content for browsing on the web. What impressed me even more is the creator managed to reverse-engineer some of the game's data types before I did. He kindly gave jPSXdec a shout out since it was used heavily to extract nearly everything on the site.

This very old Japanese site I've seen before, but did a good job of documenting the game's content as well.

Translation Hacking

2011-08-05T06:28:00.000-07:00

There's been a bit of activity with the translation lately, so I've been working more on the translation tools. Here's real video of the proof-of-concept I posted previously.

I figured it would be a bit rough to use this approach. Unfortunately, anything more than this would multiply the amount of work many times.

I've also discovered there are 34 images on the game discs that don't seem to ever appear in the game. They're not particularly interesting, however.

Decoding MPEG-like bitstreams

2011-06-01T22:45:00.000-07:00

While developing jPSXdec for the last 4 years, I've run across three different methods of decoding bitstreams. Of course, in the honored tradition of multimedia hacking, none of these approaches are documented anywhere. So I thought I'd break that unwritten rule and actually write about them.

If you'd like to learn more about what part this plays in MPEG and PlayStation .STR decoding, check out my thorough document on the subject: PlayStation_STR_format.txt

Approach 1: Brute force

This is the most obvious approach. For each code, peek the next n-bits until the bits match something.

Next17Bits = Peek17Bits()

For Each Possible Code

    If Next17Bits starts with code bits

        Skip bit code length

        If END_OF_BLOCK code

            return END_OF_BLOCK

        Else If ESCAPE_CODE

            ParseEscapeCode()

        Else

            return matching code

        End If

    End if

Next

In the worst case, this approach requires 111 conditional checks to identify a bit code. To be honest, I've never actually seen this implemented anywhere besides by me years ago when first learning about bitstream parsing.

Approach 2: Binary tree

I actually ran across this approach implemented in the Serial Experiments Lain PlayStation game. You have a tree of conditionals testing the value of each bit until a match is found.

If ReadNextBit() == '1'

    If ReadNextBit() == '0'

        return END_OF_BLOCK

    Else

        If ReadNextBit() == '0'

            return ('11+0'.ZeroRun, '11+0'.AC)

        Else

            return ('11+1'.ZeroRun, '11+1'.AC)

        End If

    End If

Else

    If ReadNextBit() == '1'

        If ReadNextBit() == '1'

            // '011s'

            ...

        Else

            // '010... and so on

        End If

    Else

        // '00... and so on

    End If

End If

The branching can be optimized a bit for most leaves: once the length of the bit code is clear, the remaining bits can be used as the index in several small lookup tables. The jPSXdec implementation only requires (in the worst case) 12 branches to determine the longest bit codes.

Approach 3: Array lookup

I believe this type of approach is used in ffmpeg and the Q-gears decoder. Thanks to the unspoken tradition of never documenting anything, I was unable to understand what it was doing. It wasn't until I reverse-engineered the .iki bitstream parsing that I finally saw how this approach works.

At least for MPEG-1 (and PSX STR), you can take advantage of its particular set of variable length bit codes. Only the first code ('11s') and the end-of-block code ('10') need special parsing. The rest of the codes fall under one of three groups. The group a code belongs to can be determined by looking at how many initial zeros it has.

Group one starts with between 1 and 4 zeros (this also includes the escape code 000001).
Group two starts with between 6 and 8 zeros.
Group three starts with between 9 and 11 zeros.

All codes in their groups:

    [Special handling]

    01 // end-of-block

    11s

    ---- [Group 1] ----

    0 11s

    0 100s

    0 101s

    0 0101s

    0 0110s

    0 0111s

    0 00100s

    0 00101s

    0 00110s

    0 00111s

    0 000100s

    0 000101s

    0 000110s

    0 000111s

    0 00001 // escape code

    0 0100000s

    0 0100001s

    0 0100010s

    0 0100011s

    0 0100100s

    0 0100101s

    0 0100110s

    0 0100111s

    ---- [Group 2] ----

    000000 1000s

    000000 1001s

    000000 1010s

    000000 1011s

    000000 1100s

    000000 1101s

    000000 1110s

    000000 1111s

    000000 010000s

    000000 010001s

    000000 010010s

    000000 010011s

    000000 010100s

    000000 010101s

    000000 010110s

    000000 010111s

    000000 011000s

    000000 011001s

    000000 011010s

    000000 011011s

    000000 011100s

    000000 011101s

    000000 011110s

    000000 011111s

    000000 0010000s

    000000 0010001s

    000000 0010010s

    000000 0010011s

    000000 0010100s

    000000 0010101s

    000000 0010110s

    000000 0010111s

    000000 0011000s

    000000 0011001s

    000000 0011010s

    000000 0011011s

    000000 0011100s

    000000 0011101s

    000000 0011110s

    000000 0011111s

    ---- [Group 3] ----

    000000000 10000s

    000000000 10001s

    000000000 10010s

    000000000 10011s

    000000000 10100s

    000000000 10101s

    000000000 10110s

    000000000 10111s

    000000000 11000s

    000000000 11001s

    000000000 11010s

    000000000 11011s

    000000000 11100s

    000000000 11101s

    000000000 11110s

    000000000 11111s

    000000000 010000s

    000000000 010001s

    000000000 010010s

    000000000 010011s

    000000000 010100s

    000000000 010101s

    000000000 010110s

    000000000 010111s

    000000000 011000s

    000000000 011001s

    000000000 011010s

    000000000 011011s

    000000000 011100s

    000000000 011101s

    000000000 011110s

    000000000 011111s

    000000000 0010000s

    000000000 0010001s

    000000000 0010010s

    000000000 0010011s

    000000000 0010100s

    000000000 0010101s

    000000000 0010110s

    000000000 0010111s

    000000000 0011000s

    000000000 0011001s

    000000000 0011010s

    000000000 0011011s

    000000000 0011100s

    000000000 0011101s

    000000000 0011110s

    000000000 0011111s

Each group has its own lookup table of 256 entries, and each code will be associated with one or more entries in the lookup table. After stripping off the minimum number of zeros in the group, no entry in the group will have more than 8 bits remaining in the bit code. For codes that have 8 bits remaining, its value identifies the associated table index. For the bit codes that have fewer than 8 bits remaining, you have to walk through every combination of the remaining bits to find all associated indexes.

Example:

Group 1 code: 00110s
Use 0 for sign bit for now: 001100
Strip off first leading 0: 01100
Find all combinations of remaining bits:

    01100+000 = 96 (table index)

    01100+001 = 97

    01100+010 = 98

    01100+011 = 99

    01100+100 = 100

    01100+101 = 101

    01100+110 = 102

    01100+111 = 103

Thus bit code 00110s will be associated with table indexes 96-103.

Now each table entry needs three values: the inverse discreet cosine transform (IDCT) run of zero-value alternating current (AC) coefficients, the non-zero AC coefficient value, and the length of the bitstream bits that should be skipped.

Once all three tables are constructed, the following pseudo code will parse your bitstream.

If ReadNextBit() == '1'

    If ReadNextBit() == '0'

        return END_OF_BLOCK

    Else

        If ReadNextBit() == '0'

            return ('11+0'.ZeroRun, '11+0'.AC)

        Else

            return ('11+1'.ZeroRun, '11+1'.AC)

        End If

    End If

Else

    Next16Bits = Peek16Bits()

    If NumberOfLeadingZeros(Next16Bits) <= 4

        Match = LookupTable1[(Next16Bits >> 8) & 0xff]

    Else If NumberOfLeadingZeros(Next16Bits) <= 8

        Match = LookupTable2[(Next16Bits >> 3) & 0xff]

    Else If NumberOfLeadingZeros(Next16Bits) <= 11

        Match = LookupTable3[Next16Bits & 0xff]

    Else

        // bitstream error

    End If

    If Match == ESCAPE_CODE

        SkipBits(ESCAPE_CODE.BitLength)

        ParseEscapeCode()

    Else

        SkipBits(Match.BitLength)

        return (Match.ZeroRun, Match.AC)

    End If

End If

Of course the implementation details can vary, but this gives the idea. The Approach 3 I implemented for jPSXdec requires about 8 conditionals to identify a bit code in the worst case. I've found it to be about 10%-15% faster than the Approach 2 I've been using.

PlayStation Video Decoders:The Final Showdown

2010-09-06T14:33:00.000-07:00

Updated from the previous comparison with the lastest versions, and three new decoders!

Most importantly, I finally captured what it ACTUALLY looks like on PlayStation hardware (in the dead center).

Those on top get it (more) correct, those on the bottom get it (more) wrong (and ffmpeg and Q-gears are just weird).

Naturally jPSXdec dominates in quality and accuracy. :)

The lineup:

PSXPlay
a fixed version of PCSX by Gabriele Gorla
jPSXdec
MAME
PsxMC
PSmplay
PsxTulz
reevengi
PCSX
ffmeg
Q-gears

See the download for all the jucy (and technical) details.

Immaculate Decoding

2010-08-19T12:39:00.000-07:00

Just writing a straight-forward PlayStation 1 video decoder has been a lot of work. However, for the absolute most impeccable quality, there is so much more that can be considered in the process.

Upsampling

When PlayStation videos are created, the pixels are broken up into luma (brightness) components and chroma (color) components. Like with JPEG and MPEG formats, 3/4 of the chroma information is thrown away because the human eye can't really tell (this is an example of lossy compression).

When decoding, that lost chroma information needs to be recreated somehow to convert the pixels back into RGB. Unfortunately there is no one 'right' way to do it, because there's really no way to get that lost information back. All you can do is 'guess' by filling in the blanks based on the information around the pixels using some kind of interpolation. Some of the most well known kinds of interpolation are: nearest neighbor, bilinear, bicubic, and lanczos. I've read about more advanced chroma upsampling approaches that also take into account the luma component. This works because there is often a lot of correlation between the luma and chroma components--when the luma changes, the chroma probably will also. I'd like to try to find the best one, but I haven't had much luck on finding many good resources about them all.

Now, because this is essentially just scaling of a 2D image, I've been worried about this article that points out a nasty little gremlin called gamma correction. It seems nearly everyone has been doing image scaling wrong since the popularization of the sRGB gamma corrected color space. I'm assuming video isn't immune to the same problem, yet I've never seen anyone mention it.

Deblocking

Assuming we find the upsampling method of choice, there are still ways the image can be improved. Most video codecs break the frames down into 'blocks', then encode each block separately--again losing information along the way. When everything is reconstructed, that lost information can often be seen as visible distortions between blocks. This problem has been addressed in more recent video codecs such as h.264, but is still a problem with the older MPEG2. I believe nearly all DVD players do some deblocking before showing the final frame.

Even though MPEG2 has been around a long time and deblocking is so common, I've had the darndest time trying to find much mention of what deblocking algorithms are in use today. UnBlock, and this page on JPEG Post-Processing are the best I've come by. I think I've read somewhere that some advanced deblockers can even make use of the original MPEG2 data to improve the deblocking.

I still consider myself a multimedia novice, so there are probably more post-processing methods that would really make the output shine. A big bummer among all research in that area is that if you can think it, you can pretty much count on it been patented.

Given how difficult all this stuff is, I really really wish I could just pass that problem off to the big players in the field, such as ffmpeg (i.e. libavcodec). I've even considered writing a PSX video to MPEG2 video translator so the MPEG2 video can be fed into ffmpeg. Unfortunately there are some big reasons why doing this still makes me uneasy.

IDCT

The PlayStation uses its own particular IDCT approach that I've never seen anywhere else. Given how important it is that the DCT used to encode the video matches the IDCT used to decode, there are no existing decoders that can do it (except jPSXdec of course).

Differences in YCbCr

Another worry is that a real good quality MPEG2 decoder will spatially position the chroma components in the proper location (vertically aligned with every other luma component) as opposed to how I believe PSX does it (the MPEG1 way: in-between luma components).

To make things a bit more complicated, MPEG2 uses the proper Rec.601 Y'CbCr color space with [16-235] luma, and [16-240] chroma range. PSX on the other hand, uses the full [0-255] range for color information. Many video converters don't handle that discrepancy very well. Related to that, pretty much all converters store the data as integers, so any fractional information is lost after every conversion. In contrast, jPSXdec maintains all that fractional information until the very end.

In general though, I have not been impressed with ffmpeg's quality, so I can't suggest people use it when looking for good quality.

One advantage that comes when incorporating all these enhancements in jPSXdec is it provides a much nicer user experience. No need to be hopping between multiple tools to get the best results.

So if I were to actually implement all these features, where would I get the information I lack? Perhaps the doom9.org forums could help. If any multimedia gurus happen to pass by this post, please, if you could, toss some wisdom my way.

YCbCr to RGB Conversion Showdown

2010-03-26T19:34:00.000-07:00

In trying to ensure pixel perfect accuracy in my color conversions, I wanted to compare how two popular video converters handle YCbCr to RGB conversion: ffmpeg* and VirtualDub v1.9.8.

The Rec.601 YCbCr to RGB equation is defined as such:

Given Y color range of [16, 235] and Cb,Cr color range of [16, 240].
[ 1.164   0       1.59  ]   [ Y  - 16  ]     [ r ]
[ 1.164  -0.391  -0.813 ] * [ Cb - 128 ]  =  [ g ]
[ 1.164   2.018   0     ]   [ Cr - 128 ]     [ b ]

You can generate a table of the YCbCr to RGB conversion using this bit of code. Values outside valid YCbCr ranges are simply mapped to white.


public class YCbCrAndRgb {
    public static void main(String[] args) {
        for (int y = 0; y < 256; y++) {
            for (int cb = 0; cb < 256; cb++) {
                for (int cr = 0; cr < 256; cr++) {
                    if (y >=  16 && cb >=  16 && cr >= 16 &&
                        y <= 235 && cb <= 240 && cr <= 240) 
                    {
                        int r = (int)Math.round( (y - 16) * 1.164                       + (cr - 128) *  1.596 );
                        int g = (int)Math.round( (y - 16) * 1.164 + (cb - 128) * -0.391 + (cr - 128) * -0.813 );
                        int b = (int)Math.round( (y - 16) * 1.164 + (cb - 128) *  2.018                       );
                        
                        if (r < 0) r = 0; else if (r > 255) r = 255;
                        if (g < 0) g = 0; else if (g > 255) g = 255;
                        if (b < 0) b = 0; else if (b > 255) b = 255;
                        
                        System.out.format("%02x%02x%02x\t%02x%02x%02x", y, cb, cr, r, g, b);
                        System.out.println();
                    } else {
                        System.out.format("%02x%02x%02x\tffffff", y, cb, cr);
                        System.out.println();
                    }
                }
            }
        }
    }
}

Using a pixel format without subsampling should let me convert pixels without blending interfering, however ffmpeg still adds blending even to 4:4:4, which would distort the results. So instead I generated several AVIs with small dimensions (8x8) with fourcc YV12 pixel format (4:2:0), each frame containing one solid color. That came out to 256 AVI files, each with 256*256 frames.

Those AVIs were fed through ffmpeg and VirtualDub and converted to uncompressed RGB AVIs. This ffmepg command converts YCbCr to RGB AVI.

ffmpeg -i inYCbCr.avi -vcodec rawvideo -pix_fmt bgr24 outRgb.avi

Under VirtualDub's Video->Color Depth menu you can set the output pixel format.

A little script walked through every AVI and pulled out the first RGB pixel of each frame and associated it with the original YCbCr color.

At that point I had a table with 256^3 rows and 4 columns:

Original YCbCr color
RGB generated with the standard equation and floating-point math
RGB generated with VirtualDub
RGB generated with ffmpeg

Here you can download 4096x4096 images of the resulting RGB values using the three conversion methods.

Floating-point
VirtualDub	ffmpeg

Now to analyze, starting with some visual comparisons. Diffing and autoleveling (normalizing) exposes what pixels are different.

Floating-point vs. VirtualDub

Floating-point vs. ffmpeg

Seems VirtualDub is far more accurate than ffmepg, but still doesn't match the floating-point version perfectly.

Now some numbers.

VirtualDub has 1795792 pixels (11%) different from the floating-point conversion.
ffmpeg has 10827725 pixels (65%) different from the floating-point conversion.

Differences broken down by color channel.

I'm disappointed but not surprised that there are so many 1-off values in general. But ffmpeg's variance is as much as -3?? Wow, I hope I'm doing something wrong because that's pretty bad.

In the rare case someone has over an hour and 10GB to spare, along with various strange prerequisites, you can download the scripts used to generate these details.

FFmpeg version SVN-r22107, Copyright (c) 2000-2010 the FFmpeg developers
  built on Feb 28 2010 06:11:15 with gcc 4.4.2
  configuration: --enable-memalign-hack --cross-prefix=i686-mingw32- --cc=ccache-i686-mingw32-gcc --
arch=i686 --target-os=mingw32 --enable-runtime-cpudetect --enable-avisynth --enable-gpl --enable-ver
sion3 --enable-bzlib --enable-libgsm --enable-libfaad --enable-pthreads --enable-libvorbis --enable-
libtheora --enable-libspeex --enable-libmp3lame --enable-libopenjpeg --enable-libxvid --enable-libsc
hroedinger --enable-libx264 --enable-libopencore_amrwb --enable-libopencore_amrnb
  libavutil     50. 9. 0 / 50. 9. 0
  libavcodec    52.55. 0 / 52.55. 0
  libavformat   52.54. 0 / 52.54. 0
  libavdevice   52. 2. 0 / 52. 2. 0
  libswscale     0.10. 0 /  0.10. 0

IDCT Demystified (a little)

2010-03-13T00:00:00.000-08:00

The inverse discrete cosine transform is a very mysterious and intimidating equation.

(apologies if I messed up the notation)

For the longest time I let the IDCT remain a black box. I found a handful of Java IDCT implementations, plugged them in, and cross my fingers.

I know what the 2D DCT does: it pushes all the image data to the top left corner of the block, while the IDCT undoes that magic. I'm not sure how it does this, but just knowing what it does is enough for me.

But recently I finally discovered that the IDCT is simply a couple of matrix multiplications.

idct_matrix^T . coefficients . idct_matrix

The IDCT equation doesn't really suggest that to the casual mathematician. Of course if you take a class or pay for a book on the subject, maybe this is old news to you.

For those uninformed like me, let's take a closer look at this IDCT matrix.

Theoretically we could throw a bunch of trigonometry identities at this matrix to simplify it, but it turns out to be so much easier to just calculate it and see which decimal values are the same. In the end, there turns out to only be 7 unique values (listed here in varying forms).

1/sqrt(8)       =  cos(  PI/ 4)/2
cos(1*PI/16)/2  =  cos(  PI/16)/2  =  sqrt(2+sqrt(2+sqrt(2)))/4
cos(2*PI/16)/2  =  cos(  PI/ 8)/2  =  sqrt(2+sqrt(2))/4
cos(3*PI/16)/2  =  cos(3*PI/16)/2  =  sqrt(2+sqrt(2-sqrt(2)))/4
cos(5*PI/16)/2  =  cos(5*PI/16)/2  =  sqrt(2-sqrt(2-sqrt(2)))/4
cos(6*PI/16)/2  =  cos(3*PI/ 8)/2  =  sqrt(2-sqrt(2))/4
cos(7*PI/16)/2  =  cos(7*PI/16)/2  =  sqrt(2-sqrt(2+sqrt(2)))/4

Now the IDCT matrix can be simplified to this:

Taking things a step further, let's multiply the two IDCT matrix multiplications out (Maxima is awesome). After a lot of trigonometric simplification, it turns into a massive matrix. This tiny portion below resembles what the entire matrix looks like.

You can download the full 30,000 pixel wide image if you dare.

All those additions/subtractions help to explain why fast IDCT implementations consist of so many sums and only occasional multiplications.

The bare math still makes it difficult to identify patterns, so I took things to the extreme and visualized it a bit.

Writing a Java-only Video Player

2010-02-07T21:52:00.000-08:00

Finally designed and put together a fully working implementation, involving a custom blocking queue and 6 threads. I’ve tested it on Windows XP, OS X, and old Kubuntu Hardy. Windows and Mac both look amazing and run perfectly smooth. Unfortunately on Linux the video playback stutters a lot. At first I thought it was due to the GC. After integrating an impressive object pool design, the cause actually turned out to be the Java audio api.

I use the audio playback position to determine when a frame should be displayed. Running a little test exposes how reliable this timer is.

import javax.sound.sampled.*;

public class AudioPositionTest {
    public static void main(String[] args) throws LineUnavailableException {
        AudioFormat audFmt = new AudioFormat(18900, 16, 2, true, true);
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, audFmt);
        SourceDataLine player = (SourceDataLine) AudioSystem.getLine(info);
        player.open(audFmt);
        player.start();

        byte[] abBuf = new byte[2 * 400];

        long lngTestLength = 20 * 1000; // 20 seconds
        long lngTestStart = System.currentTimeMillis();
        long lngTestEnd = lngTestStart + lngTestLength;

        System.out.println(System.getProperty("os.name") + "\tJava " +
                           System.getProperty("java.version"));
        StringBuilder sb = new StringBuilder(400);
        while (System.currentTimeMillis() < lngTestEnd) {
            player.write(abBuf, 0, abBuf.length);
            long lngTime = System.currentTimeMillis();
            long lngPos = player.getLongFramePosition();
            sb.append(lngTime - lngTestStart);
            sb.append('\t');
            sb.append(lngPos);
            System.out.println(sb);
            sb.setLength(0);
            Thread.yield();
        }

        player.stop();
        player.close();
    }
}

Graphing some of the output makes it pretty clear why Linux playback is choppy.

Since that isn’t going to work, my next test will involve registering a listener for start and stop events, and track playback time manually. Though I’m worried my time and the playback time are going to get out of sync.

PSX Video Converter Deathmatch

2009-10-24T09:50:00.001-07:00

UPDATE: This comparison has been superseeded by a newer one

I took 8 different video converters and lined them up for the showdown of the decade!
Ok, so it's not really that dramatic. Some points of interest:

PCSX shows the most amount of blocky artifacts, which is understandable because its converter was designed for speed over quality.
PsxMC, PSmplay, PsxTulz, and PCSX all show very similar coloring. PsxMC and PSmplay are especially similar; however, they are not pixel exact matches.
Q-gears seems to have the darkest and warmest colors of them all, while ffmpeg is the brightest.
jPSXdec seems to produce softer images than the others, and its colors are quite similar to PSXPlay.

The differences may not seem very apparent side-by-side, but if you align the images on top of each other (like layers) then toggle the top image's visibility, the differences really stand out.

Now which is the most accurate? That depends on your definition of accurate.

Do you want the exact values the PlayStation 1 hardware produces?
Do you want it to match how you see it on the television?
Do you want it to more closely resemble what the original designer created?
Do you want a more mathematically precise conversion?

I don't have modded PlayStation hardware, and I don't have any way to very accurately capture composite video output, so I can't investigate #1 or #2.

You need to have the official Sony PlayStation 1 movie converter tool to investigate #3. If some shifty soul wanted to convert this video to STR and send it to me, I could investigate further. ;)

I made my best effort to ensure jPSXdec is very mathematically accurate, so I can at least recommend jPSXdec if you want #4.

Download all the converted images, along with more details (including some source code) on how I did all the conversions.

25Oct2009: updated download with corrections and included convertible test STR.

23Nov2009: updated download with better PsxTulz screenshot (thanks T_chan!).

jPSXdec forever

2009-08-15T04:08:00.001-07:00

According to Ohloh, jPSXdec is worth at least $150,000, but that is for code from a year ago. It now has now swelled to over 28,000 lines of code in over 170 files, and will probably be past 30k LOC by next version's release.

I really wish I could work on jPSXdec non-stop until it's ready for prime time again. School, work, the economy, a seriously expensive family emergency, and some critical life changes have all conspired to make that impossible. In fact, I don't have much hope in seeing the next release available anytime this year.

Things completed so far:
* The complicated part of media playback (managing 6 simultaneous threads isn't easy)
* Much needed cleanup of the Tim decoder, XA ADPCM decoder, and serialization code
* Reorganized the arrangement of media streams verses more static types of media
* Fixed both bugs on the issue list.
* Fixed the Tim false-positive matching that happens fairly often
* Fixed FF7 frame-rate miscalculation
* Break things up by game (i.e. setup plugin system)
* ISO9660 file detection
* Improved detection of audio (including CD-i) and video media items
* More robust disc image detection

Still to do:
* Re-implement the saving process for the various media types
* Redo frame rate detection

Beyond the next release:
* Automatic error reporting
* Redo the GUI
* Append AVI writer to make it stricter so it can produce cleaner AVI files
* AVI PNG codec
* Yuv4mpeg2 writing and/or AVI YUV codec
* Real-time media playback/preview
* Searching for static demux and MDEC data
* Finding and uncompressing lhz data, often used in PSX games
* Raw direct CD reading from the disc drive (based on java-avm)
* CD-i video formats
* More game handling
* STR and XA re-encoders
* CD track audio handling

When hell freezes over:
A custom hex browser for jPSXdec. Other free and/or open source hex browsers are generally decent, but none do everything I really need. Some desired features:
* Viewing of very large files without loading the whole thing into memory (hundreds of MB)
* Quick viewing and editing values as big/little endian of varying bit sizes/signs/types
More specifically for PSX hacking
* Identifying and browsing by sector (much like CDmage and IsoBuster do)
* Highlighting of the sector headers and footers
* Viewing of continuous demuxed sector payloads
* Identification of known sector types, and the various fields in each
* An overview map of the entire CD, with quick identifying symbols/colors for every sector and its type
The closest thing I've seen to this is VirtualDub's hex viewer.

And the ultimate pièce de résistance:
* Real-time processing of the data as you mouse-over it, and showing how it results in the final output
* Allows you to take each bit of data in the disc and follow it through the entire decoding process, each step of the way
* Allow you to change anything in real-time, and see how it would turn out
I've repeatedly imagined a program like this for even just mpeg1 or 2 streams. Those streams are really complicated, and you never get to see the direct connection between the data and the output. It would be so neat to hover over a block or a macro block and be able to see exactly where it was going to end up on screen, how it will look, and everything around it. The whole motion detection as well. It would be an incredible tool to teach people how those streams work. In the almost impossible case you've seen the official Bluetooth development tools, that's exactly what I had in mind.

All these neat ideas could eventually turn jPSXdec into the ultimate PSX hacking utility.

The time frame for everything? A long...long time. Years probably. Which really makes me wonder: what will become of this project in, say, another decade? Should I start soliciting help?

In the next to impossible case someone would like to join in developing jPSXdec, his skills might hopefully include:
* Very usable knowledge of Java (no need for an expert because I don't think I am)
* Love and value for clear and well documented source code
* Some experience with reverse-engineering just about anything (media formats preferred)
Added bonus:
* General understanding of mpeg/jpeg-type image formats
* Awareness of cross-platform development issues, and/or experience with developing simple programs for multiple platforms (i.e. Windows, Linux, Mac)

Comparing Media Quality of Playstation 1 games

2009-05-08T05:23:00.000-07:00

I suppose very few people have ever looked as closely at Playstation 1 media as I have. Of those that have, I assume most worked for Sony, or developed games using the official SDK. Of the few that never got that approved proprietary insight, almost all are Japanese. Finally, of those even fewer remaining whose primary language is English, almost none care anymore at this late date. So I thought I'd take a moment and share some of what I've observed.

To my knowledge, only one game has actually used custom variable-length (i.e. huffman) codes in its video streams: Serial Experiments Lain. The infamous logo.iki sample may also use custom huffman codes (it sure doesn't use the standard ones), but until I find what game it's from I can't know for sure.

Now I assume S.E. Lain's use of custom variable-length codes means its video quality is higher than if the standard set was used, else why would they use it? Its custom decoding software also took full advantage of every last bit of space available to each frame. I've never seen games using the standard SDK decoder that pushed their buffer to the limit. And if that wasn't enough, it sacrificed as much audio quality as it could to increase space for video bandwidth.

I find this all terribly ironic because the quality of the game's artwork is downright awful.

So while S.E. Lain's video quality is pointlessly top-notch, its sound quality is not only bad, it is probably one of the worst. The audio was encoded very poorly, with many of the loud moments pointlessly sawed to half the dynamic range, creating excruciating distortions.

It's a crying shame, because even though everything about the game was different from the anime series, at least the audio contained more work by the original Lain voice actress, Kaori Shimizu.

Lain's video decoder also took a small speed hit because the data is stored as big-endian. This means that the little-endian Playstation platform has to take a moment to reverse every 32bit value read from memory. Who knows, maybe reversing it would have sped up the animation of Lain while drudgingly browsing all those media items.

The game that I've seen with the next best video quality trick is Alice In Cyber Land. It may be the only game that uses variable frame rates. During times with less video action, the frame rate could be dropped, giving the images more bandwidth for detail. When the action picked up again, the frame rate and quality could return to normal so the more rapid frame changes could be shown. I suspect any game's video could be modified to use this feature. In fact, it's really too bad that the official Sony SDK encoder didn't use this trick. So many game videos might have looked even nicer.

Meanwhile, on the good end of the audio quality spectrum, Square's (now SquareEnix) custom audio format provided the best audio experience of any games I've seen. Its unique format, used in several of their RPGs, produced almost twice the quality of the best standard SDK audio format. An entire sector was devoted to each left/right audio channel, and at intervals that resulted in nearly CD quality output.

Through the Digital Looking Glass

2009-04-11T04:33:00.000-07:00

While exhaustively reverse-engineering the Serial Experiments Lain game, always in the back of my mind was an article I read years ago. It describes some curious connections between Lain, and another game called Alice In Cyber Land.
http://www.cjas.org/~leng/alice.htm

So naturally, once the Lain game hacking was thoroughly complete, my attention quickly turned to finding the secrets Alice held.

The work to discover the unique ways the game stored its videos really paid off. The Alice videos were all well animated, and suggested a game that could be a lot of fun. But for now I must be content with its raw Japanese clips, all of which can now be viewed on Youtube.

The Alice In Cyber Land franchise didn't stop with the game. It also included a soundtrack, and short OVA. It seems at least episode 1 was fansubbed by a group called "Boot To Da Head" back in 1997. The first episode is now watchable in very low quality, raw Japanese.

While the connections between Lain and Alice are intriguing, you might be interested to know that they don't end there. Tucked away in a corner of the internet is a little account by one of the game's creators that extends the connections to one more series: Digimon Tamers.
http://www.konaka.com/alice6/tamers/characters/juri-e.html

CD-i

2009-04-06T21:42:00.000-07:00

I was pleasantly surprised when I found someone concocted a clever way of using jPSXdec to decode CD-i audio.

As explained in Jonathan Atkins's CDXA documentation, the Sony Playstation 1 and the Phillips CD-i both used the same audio format on their CDs. It never occurred to me that the CD-i likely has a retro community still following it, much like the Playstation 1 does.

This video describes a working solution to extracting CD-i audio with jPSXdec that will work with any game. However, after the extraction, you have to manually break up the audio clips and possibly adjust the speed of some.

Alternatively, you could do the job that jPSXdec can't yet do so the extracted audio clips don't need any extra editing.

If you let jPSXdec do its best to index the CD (or raw music file), it will find all the audio sectors, but fails to concatenate most of the contiguous streams. You're left with several thousand audio clips with a duration of 1 sector. It wouldn't be too difficult to write a script that checks the audio properties (channel, frequency, etc) and finds what sectors should be combined into a single audio clip. It even sounds like someone has already managed to make some headway with this.

Adding better CD-i audio handling to jPSXdec is quite easy, and will be included in the next release (whenever I can get this redesign finished). As for CD-i video, I can't say I have much motivation (or time) to figure it out. But if anyone wants to get their hands dirty and write some decoding code of their own, I'd be happy to support them however I can.

Java real-time video playback

2009-01-27T06:01:00.000-08:00

Much of the easy changes have already been made to jPSXdec. The biggest and hardest change left is implementing real-time playback. To do this in pure Java is tricky. I've spent a month looking at every kind of Java video player out there.

I want to keep jPSXdec as cross-platform and simple-to-use as possible (Just Work™). So while the JMF has Java-only implementations for playback, it needs a separate installation, has far more functionality that I need, and being closed source doesn't help. It's curious that even though the JMF has plenty of documented bugs, and hasn't been updated in years, it's still the de facto Java media standard. Meanwhile, the FMJ library is open source, but it's even bigger than JMF, and uses JNI to wield each platform's native playing capabilities. I've examined various other small libraries, but nothing met my needs: a simple synchronized audio and video player. So I'm stuck trying to figure out how to do it myself.

Initially I thought to duplicate the general design of JMF/FMJ since it seems to work for them. It would also help someone with greater familiarity with those libs to take the next step and properly integrate PSX decoding into them. However, after several days of tearing apart those massive libraries, and seeing I'd only scratched the surface, I dropped that idea.

Finally went back and took a closer look at SurePlayer. It plays mpeg1 movies great with very little processor use. It's fully cross-platform, and is a much more digestible library, so I'll be using that as a guide for implementation. With this clear direction, I can push forward with more jPSXdec development. Maybe in several years when Java 7 is ubiquitous, jPSXdec can be changed to utilize the new JMC.

Also during my searchings I serendipitously ran across a Java library to handle cross-platform raw CD reading! It's not quite as clean as I would like, but it's a pretty good foundation to build upon.

In other news, we've had a couple translators pop out of the woodwork recently. Will they be the salvation this project so desperately needs?

A man can dream.

We're back...sort of

2009-01-04T02:05:00.000-08:00

We welcome in the new year with http://psx.lain.pl coming back online after yet another "I thought it was just temporary" blackout (thanks again go to toruvinn for fixing and hosting the server). Unfortunately the 14% completion still haunts us, and hope for additional progress has not improved.

As for jPSXdec, I've been making some progress on the redesign, but it will be many months before it will be in shape for another release.

How to encode quality PlayStation 1 video

2008-09-24T11:31:00.000-07:00

Update: I have since discovered this technique may work, but videos would need to be encoded as mpeg2 due to PlayStation videos having 2 more bits of quality than mpeg1 can handle. Unfortunately that starts getting tricky as mpeg2 has a different chroma subsampling position. In short, this technique has a lot of subtle caveats that should be considered. A future post may be made to explore the issues.

Recently I've run across a couple of groups trying to replace the video of a PlayStation 1 game. As we have to do the same thing with S.E. Lain, I thought I would share some insight on how it might be done with the highest quality output.

Since there are many things that go into encoding mpeg type images (DCT + quantization being the least of it), that task is best left to programs that know how to do it well, such as ffmpeg. It also allows you to tweak those options, and use its advanced features to get the best results.

So here is how you could do it, broken down into 6 ridiculously complicated steps.

Convert your video into yuv4mpeg2 video (or perhaps an AVI with a YCbCr codec), but using the PSX specific rgb->YCbCr conversion.
Feed the YCbCr video into ffmpeg at a mpeg1 allowed fps and create a mpeg1 movie with only I-frames (-intra). This should be done at a variety of different quality levels (-qscale from 1 to n).
Parse the I-frames out of the movie, and parse each frame's macro-blocks
Convert the mpeg1 VLCs to PSX VLCs
Do this for every mpeg1 quality and pick the one that fits best within the amount of space available to each frame
Multiplex the frames and construct all the sectors, including the correct frame headers and the sectors' ECE/EDC codes

If the new video is mostly just the old video with some changes (e.g. subtitles) then quality can improved tremendously with this variation.

Use some method to determine which macro blocks to replace (manually picking them, or performing a diff on lossless video data, or a fuzzy diff on lossy video data)
Only replace those macro blocks with new ones of the same qscale
If the replaced data makes the frame too big, then either replace the entire frame with an ffmpeg created frame that will fit (qscale will probably be bigger), or remove some quality in the frame to make it smaller
Multiplex the frames and construct all the sectors

Alternatively have ffmpeg write an AVI using MJPG codec, then parse the JPEG frames and convert the JPEG VLCs to PSX VLCs (I'm not sure how to get ffmpeg to produce quality variations with the MJPG codec).

Encoding video by the steps above will likely have better results than if you used Sony's official PS1 SDK video encoder (and will also reduce the likelihood of serious legal trouble and C&D letters).

Here is a possible ffmpeg command-line for step 2 above.

ffmpeg -i source.y4m -vcodec mpeg1video -r 30 -qscale #  \
     -trellis 1 -intra -dc 10 -dct faan -debug dct_coeff \
     -vstats_file qscale#.log out-qscale#.m1v

-i source.y4m            : yuv4mpeg2 input file
-vcodec mpeg1video       : write mpeg1
-r 30                    : use 30 frames/sec 
                           (just to use something 
                            compatible with mpeg1)
-qscale #                : chosen qscale
-trellis 1               : trellis quantization
                           does this even apply?
-intra                   : only write I-frames
-dc 10                   : use 10 bits of precision 
                           for the DC values? 
                           (not sure if this is helpful)
-dct faan                : use a floating-point 
                           discrete-cosine-transform 
                           for best quality
-debug dct_coeff         : forgot what this does
-vstats_file qscale#.log : write a log of useful info
out-qscale#.m1v          : output file, video only

zOMG psx.lain.pl is down!

2008-07-14T20:18:00.000-07:00

And it has been for quite awhile. I thought it was just temporary, but finally learned yesterday that the good fellow that was nice enough to host the page has chosen to close the account. We are grateful for the time we could use the server.

Don't worry, we still have all data and work done so far. Unfortunately we're currently without a host, and the project is still stuck at around 14% completion.

I personally would like to thank everyone that has contributed thus far...

Hikari - Translated dialogs from video sequences to Polish.
phm - Extracted the media with jpsxdec and setup the wiki. Retranslated video sequences dialogs from Polish to English. Advertised for translators, and coordinated with their changes.
MercuryTW - Provided some translations from a translator of his own (Keigo). Edited/corrected translated files.
stalker-kun - Provided hosting for the wiki.
otakufish - Provided some translations.
toruvinn - Provided nice domain.
farhan - Ruthlessly proofread random translations, utilising his qualifications in the field of Applied Pedantry with Grammar Nazism.
fishy - Proofread translations, created the public project page.
arc - Provided some translations.
Jossos - Provided some translations.
utakata - corrected a Japanese transcription.
Najica - Provided some translations.
Quibbage - Created subtitle files for videos.

...and everyone else (sorry if I've missed your name here)--thank you all very much.

jPSXdec development has been pretty quiet as well. I should submit the bug that fails to decode some of the Lain videos, or just commit the fix. The next things to do with jPSXdec require some major changes, and things have been busy (my toon won't hit level 60 by itself ;). I'm still here and interested in the project and related topics. I don't plan on that changing anytime soon.

Sonic

2008-05-04T17:12:00.000-07:00

AVI
Fixed the obvious problems with AVI writing, but still problems persist.
* My Windows Quicktime install must be bad because it crashes from like everything (but Mac Quicktime plays fine)
* My Linux mplayer must be bad because it plays all movies stretched, one way or another
* All programs on my lappy crash from my movies except Windows Media Player
* My Linux Totem still plays it with green garbage

So I think I may be doing MJPG slightly wrong, but I'm not sure what. Plus I finally figured out why I could never find any documentation on the MJPG codec: "there is no document that defines a single exact format that is universally recognized as a complete specification of “Motion JPEG” for use in all contexts" Wikipedia

Native decoder
Got the native decoder working great on Windows, Linux and Mac. CMake has made cross-platform building a breeze :D It's really exciting to see the decoding plow through dozens of frames per second.

Indeed, native decoding is fast...

Java is faster
The heck?? Contrary to what I thought I saw in my initial tests, my swift Java decoding module is significantly faster than using the native decoder. How? Not sure, but I suspect it's due to all the overhead needed when calling a JNI function (such as changing big-endian to little-endian). It already melts through 150 sectors/second like a hot knife through butter--but since it spends half its time with garbage collection, could it be faster with some object pooling?

v0.34

2008-04-22T22:12:00.000-07:00

I just needed to get something for a public release. It was the re-implementation of the command-line that kept hanging me up (it was boring and I wanted to work on other things ;). I admit in my rush to just get something released, I sorta skimped on the code commenting. :P

Testing

Before releasing, I randomly tested jpsxdec on the dozen or so games that my friends let me borrow. As a result I threw in some last-minute changes to handle a couple new movie types. 'Last minute' means these may not even work right (I look forward to finding a way to save variable frame rate movies ^^).

I ran some quick tests on my Linux Mint machine. Compiz was often rendering the progress window without controls, so there was no way to close the program! And there's an annoying JFileChooser 'All Files' filter bug... :P (just wrote a work-around a moment ago).

My tests on a Mac were a little more promising. Rendering was slick--even looked better than Windows rendering.

After seeing how jpsxdec worked on Linux, I was worried about the quality of jpsxdec--then I saw iTunes for Windows and was feeling pretty good again.

AVI writing is faulty

Seems my AVI writer is getting something wrong because it is crashing or otherwise playing poorly on Linux by VLC ('this avi is broken'), mplayer (plays upside-down, stretched, or just crashes), Totem player (green gunk on the screen). On Windows and Mac, Quicktime is having problems (plays video too slowly or crashes). Real Player also crashes the good crash.

Speed

Since much of the core decoding work for jpsxdec is finished, I started looking for something a little more exciting to work on. So, following MrVacBob's suggestion, I began writing a crazy fast Java decoder. After doing everything I could think of, and examining the work of previous coders, I came to the conclusion that a real-time PSX Java decoder may be possible, but the resulting code would be so ugly, long, and annoying, it just isn't worth it. I hope to complete a faster Java decoder that'll cut the decoding time by maybe half, but also make a small, cross-platform native library will be fast enough for real-time playback.

My friends keep dropping games on me--more than I can keep up with. It takes so long to rip games that I went ahead and threw together raw cd reading on Windows. It's pretty buggy, and I'm sure I'm doing something wrong, but it mostly worked. If ever I can get it more stable, I'll include it. For my Linux coding friends, the JNI Java class is in the source if you feel like writing a Linux version of the lib :)

Licenses

The LGPL of the Swing libraries included with jpsxdec don't require that I distribute the source code of the libraries (I haven't changed them, and I am linking them separately). But since jpsxdec is GPL, does that require me to include the LGPL sources with the distribution? I really didn't want the hassle of it, but just to be safe I included the source with the pre-combiled binaries together in the zip files.

Incoming

2008-03-13T19:49:00.000-07:00

Been wanting to get some stats on jpsxdec code for a long time (Google code doesn't have such features), finally ran across StatSVN and took a quick look at the results.

Now running over 20,000 lines of code, and almost 100 files. Compared to Oct 21, 2007's 7,000 lines, that's 13,000 LOC over 144 days, for a measly 90 lines per day.

Anyway, I'm guesstimating next week will be the next jpsxdec release. It will have some exciting features:

~~Saving to AVI, both uncompressed and MJPG compressed~~ your mileage may vary
~~A very nice dialog box providing the many decoding options available~~ it's arrite
~~Final Fantasy 9 finally working properly~~ done!
~~Chrono Cross is also working!~~ mostly done!
~~Cleaned up command-line~~ done!
and lots of delicious code documentation :)

lain? lain!

2008-02-25T13:59:00.000-08:00

The Serial Experiments Lain PSX Game Translation Project is really coming along. A few more wonderful translators have generously offered some help. We have roughly 7% of the game translated already.

Here are some exciting fruits of everyone's efforts so far (actual screenshots).

nihongo niban

2008-02-17T22:08:00.001-08:00

Much awesomeness has transpired recently. But first, the dull ramblings of jpsxdec status.

Looked up how to encode uncompressed (RGB) AVI files. It's not too complicated--Microsoft and other sites have usable documentation. Even found a Java class to get me started. But I got really excited when the hidden art of MJPG encoding was uncovered. It is so ridiculously easy, I can understand why no one ever describes how to do it.* Of course if we're gonna write AVI files, we need to know the frame-rate. Just a simple 400 lines of code is all that took.* Needed to also change the overall code design to a 'push' architecture with listeners. This had the additional bonus of pulling the actual file writing to the top-level interface--right where it belongs. :D

* /sarcasm

But overall things are looking pretty good. For the next release I want to add a new popup window showing the many decoding options.

Also in the future I want to allow for piping out uncompressed AVI to a program like ffmpeg or mencoder. For Windows I'll also include the infamous Video for Windows. Still need to add raw cd reading.

But while merrily carrying on with all this, out of nowhere came a fishy fellow with the powers of language transformation! He generously offered to spend some time with the S.E. Lain game. Sooo... efforts on jpsxdec are delayed as the Serial Experiments Lain PSX Game Translation Project commences (SELPGTP?).

But with 5.5 hours of audio, he has his work cut out for him. Do you share the powers of language transformation? We could really use your help.

On the technical side, we are working on adding the eventual translation into the game. And I present to you an actual screen shot based on an earlier idea.

Amalgamation

2008-02-02T10:28:00.000-08:00

Been busy with a bunch of different aspects of jpsxdec. Only the GUI and Code Design will be in the next release (v0.31 today!). The rest will show up in releases after that.

GUI
Even though it's a pretty lame GUI now, I hope it will drop the bar of entry a little.

Code Design
I had difficulty deciding on highest-level interface between the GUI/CLI and the logic. So I set it aside and worked on other things.

PSX YUV->yuv4mpeg2 conversion matrix
This will allow jpsxdec to output more accurate .yuv image sequences.

Frame Rate Calculation
I thought it was a good idea to guess the exact FF7 frame rate algorithm via trial-and-error. 8 hours later I finally saw that FF7 frame lengths do actually follow a pattern, but a ridiculous one. I hoped it would come to a frame rate of exactly 15/100.1% (half the rate of NTSC). That is close, but there was no way I could guess the underlying algorithm of this...


    if (iMovieType == WACKED_NTSC1 && iThisFrame == 101)
        iThisFrameLength = 11;
    if (iMovieType == WACKED_NTSC2 && iThisFrame == 100)
        iThisFrameLength = 11;
    else if (iThisFrame == 200)
        iThisFrameLength = 11;
    else if (iThisFrame >= 203 && iThisFrame <= 298) {
        if (((iThisFrame - 203) % 4) == 0)
            iThisFrameLength = 11;
        else if (((iThisFrame - 203) % 4) == 1)
            iThisFrameLength = 9;
        else
            iThisFrameLength = 10;
    }
    else if (iThisFrame == 299)
        iThisFrameLength = 11;
    else if (iThisFrame >= 303 && iThisFrame <= 398) {
        if (((iThisFrame - 303) % 4) == 0)
            iThisFrameLength = 11;
        else if (((iThisFrame - 303) % 4) == 1)
            iThisFrameLength = 9;
        else
            iThisFrameLength = 10;
    } 
    else if (iThisFrame == 399)
        iThisFrameLength = 11;
    else if (iThisFrame >= 402 && iThisFrame < 497) {
        if (((iThisFrame - 402) % 4) == 0)
            iThisFrameLength = 11;
        else if (((iThisFrame - 402) % 4) == 2)
            iThisFrameLength = 9;
        else
            iThisFrameLength = 10;
    }
    else if (iThisFrame == 498)
        iThisFrameLength = 11;
    else if (iThisFrame == 501)
        iThisFrameLength = 11;
    else if (iThisFrame >= 504 && iThisFrame <= 600) {
        if (((iThisFrame - 504) % 4) == 0)
            iThisFrameLength = 9;
        else if (((iThisFrame - 504) % 4) == 2)
            iThisFrameLength = 11;
        else
            iThisFrameLength = 10;
    } 
    else
        iThisFrameLength = 10;

Raw CD reading (Windows)
Made a native program to read raw CD sectors via DeviceIoControl. It's a simple interactive prompt that accepts commands to open/close a CD and read sectors. I even setup a Java program to communicate with the native program via stdin/out. Unfortunately it was slow, and was very vulnerable to deadlock while reading from stdin. I also started adding ASPI for raw CD reading, but there seems to be a lot more to using that API.

Encoding via VFW (Video for Windows)
I worked out a little program to convert a series of raw image and audio data into an AVI, using the oh-so-familiar Video for Windows popup. I wonder if it can handle accepting all the audio at once, then all the video at once....

JNI
Even though I said it would be a pain in the butt, I guess it's really not so bad. It's kinda like translating VB6 COM code into C++. This will likely speed up raw CD reading, and save me from communicating via stdin/out.

Code Design
Finally got back to this again. Since no solution was particularly attractive, I went with the simplest one. This will only use one optional ~~callback~~ listener (for progress status).

However, I have begun to think that the 'pull' architecture is not the best approach to begin with. A 'push' architecture is more applicable to this situation: as sectors are read from the disc, they need to be 'pushed' into the appropriate streams. Listeners can be added to collect the streams of interest. If jpsxdec was to ever play media in real time (not likely), this would be the necessary design. In any case, the 'push' approach would make decoding a little faster because there is less seek time.

PSX YCbCr to yuv4mpeg2

2008-01-20T19:47:00.000-08:00

PSX YCbCr

Given Y, Cb, and Cr color range of [-128, 127].

                              PSX
[ 1   0        1.402  ]   [ Y + 128 ]    [ r ]
[ 1  -0.3437  -0.7143 ] * [ Cb      ] =  [ g ]
[ 1   1.772    0      ]   [ Cr      ]    [ b ]

yuv4mpeg2 (i.e. Rec.601) YCbCr

Given Y color range of [16, 235] and Cb,Cr color range of [16, 240].

                              Rec.601
[ 1.164   0       1.59  ]   [ Y  - 16  ]     [ r ]
[ 1.164  -0.391  -0.813 ] * [ Cb - 128 ]  =  [ g ]
[ 1.164   2.018   0     ]   [ Cr - 128 ]     [ b ]

To convert a PSX YCbCr color to a Rec.601 YCbCr color:


[ 1  -3415973/13224846875  1242172/13224846875 ]
[ 0   105814197/105798775      -5608/105798775 ]
[ 0       19492/105798775  105791687/105798775 ]

Answer:  yuv4mpeg2^-1 * PSX =
[ 1  3415973/13225888625  -1242172/13225888625 ]
[ 0  105791687/105807109        5608/105807109 ]
[ 0     -19492/105807109   105814197/105807109 ]

Rec601_YCbCr = 
                                     PSX
                                     [Y + 128]   [ 16]
     Rec601_Matrix^-1 * PSX_Matrix * [Cb     ] + [128]
                                     [Cr     ]   [128]

Where

Rec601_Matrix^-1 * PSX_Matrix =

     [250/291 -488509/2660418030 -82738/1330209015]
     [0          4014411/4571165       164/4571165]
     [0            3673/27426990   8031459/9142330]

Thanks to toruvinn for refreshing me on matrix math, and this site and Maxima for saving me from lots of raw calculations.

Update 27Feb2010: Fixed.
Update 23Mar2010: Really fixed.

HATSUHINODE

2008-01-06T12:00:00.000-08:00

Hope all had a pleasant new year. As we enter 2008, it is interesting to note that this year marks the 10th anniversary of the Serial Experiments Lain anime series, along with the Playstation game.

Now that holidays are over, I finally managed to release the latest compiled executable on the download page. No changes to the program interface (same wonderful command-line that you're used to ;), but it has all the latest internal goodness that I hope actually works--most notable is it now [edit] mostly supports FF8 (it would help to fully test it before making such calims :P).

Happy Winter Solstice

2007-12-14T13:12:00.000-08:00

This time of year brings, among other things, demands that defy the known laws of time and space. So further updates for jPSXdec and the STR file format will have to wait until after the holidays.

In the works:

~~Full FF8 support~~ done!
~~GUI~~ well, it's something
~~Removing dependence on Java 1.6, down to 1.5~~ done!
~~FF9 video support~~ video yes, audio no
~~TIM image searching and converting~~ need to include more comprehensive TIM searching

So until then, may you have a pleasant season, and take a moment to ponder upon whatever higher power you may believe in (*cough*lain*cough*).

Games tested with jPSXdec

2007-11-29T08:15:00.000-08:00

PLEASE LEAVE A COMMENT ABOUT ANY GAME YOU USED WITH JPSXDEC

Alundra 2 - works
Valkyrie Profile - works
Xenogears - works
Final Fantasy Chronicles - works (video at 30 fps)
Saiyuki: Journey West - works
Intelligent Qube - works
Power Puff Girls - works
Simpsons Wrestling - works
Super Puzzle Fighter 2 Turbo - works
Lethal Enforcers 1 and 2 - works
Battle Arena Toshinden - works
Metal Gear Solid - works
Silent Hill - works
Tekken 3 - works
Xeno Gears - works
Motorhead - works
Oddworld Abes Oddysee - works
Spyro - works
Worms World Party - works
Soul Blade - works
R4 Ridge Racer Type 4 - works

Samples from ffmpeg examples
abc000.str - works (video at 30 fps)
descent_descent-e.str.bz2 - works
finalfantasyVII_movie-gold4.mov.bz2 - works
jumpingflash2_music2.xai.bz2 - works
jumpingflash2_movie-01.str.bz2 - works
lain.str - works
lunar2.str - works (video just under 20 fps)
river1.str - works (video at 12.5 fps)
st3.xa - works
logo.iki - works (from game "UmJammer Lammy")

Games requiring special handling
Serial Experiments Lain - works
FF7 - works
FF8 - works
FF9 - works
Chrono Cross - works
Alice in Cyberland - works
Sonic Wings Special - last movie seems like filler data, but can be converted if it is first copied off the disc normally
Ace Combat 3 - works
Legend of Mana

Gran Turismo?
G-Generation?
Ko'hloons Gate?
Maborosi (まぼろし月夜) Moonlit Night?
Formula 1?
Lunar 2?
BeatMania 4?

"Huve Fun With Family Movie"

2007-11-09T20:05:00.000-08:00

...with out warranty of any kid.

#lain

2007-11-06T08:02:00.000-08:00

Through a lucky course of events, the folks over at a Lain IRC channel ran across my page. As farhan put it, "i suppose lain favours your blog". The people were friendly, and I met an excellent tester that helped with the jPSXdec development (thanks phm!).

If you love Lain, and know how to get around IRC (or can fake it, like I do ;), then feel free to join us at IRCnet (open.ircnet.net or maybe irc.ircnet.com) #lain.

nihongo

2007-11-04T20:52:00.000-08:00

Since I began the task of decoding the Serial Experiments Lain Playstation movies years ago, I've hoped some friendly multi-lingual folks might someday translate all the audio and movies into English. I've always assumed the translated media would be downloadable, separate from the game itself, until I met a fellow who had the lofty desire to put the translated media back into the game.

I wondered what he was going to do about the 2 hours of audio. Dubbing seems the only option. But while finally playing through the whole game the other night, I found there are many sound-effects and characters in the audio portions. I would hate to lose all that to dubbing (not to mention my preference for sub-titles).

However, I also noticed the pictures shown in the background as you listen to audio, and I started thinking...

Not an actual screen-shot (you can tell by the pixels), but I have the ability to make it so. This isn't a perfect solution, but could be an alternative to dubbing (and it's probably easier too).

Close the world, Open the nExt.

2007-10-27T16:36:00.000-07:00

After watching and enjoying the Serial Experiments Lain anime series, my interest was piqued by something I saw on the disc extras.

A Lain Playstation game.

And I had to own it.

With the help of my Japanese co-worker during my trip to Japan, I managed to acquire a copy all of my own.

Jen's site was accurate when it said there was very little info about the game. Following her lead, I wanted to change that. I wanted to decode the video for all to see. The audio could be ripped just fine, but the video refused to decode. Endless Googles later and I was still left wanting.

While toying with the game in an emulator, it dawned on me that if I couldn't decode the video off the disc, maybe I could let the game do it for me. I got the open source P.E.Op.S. GPU plug-in and went to work grabbing the video frames before anything was drawn over them. Soon I had nearly all the media from disc 1 sitting on my hard drive.

However, I ran into a snag. The decoded audio from the disc wasn't lining up with the video frames I had captured.

I had big plans, but was burning out and couldn't ever find a reason for this discrepancy. The project was abandoned for another day.

Two years later...

Finding myself still stumped over the audio/video mismatching, I veered a different direction. Could I possibly learn how to decode PSX videos myself?

Another endless bout of Googles later and I learned about JPEG and MPEG encoding. Soon I had my own I-frame decoder. It was the Q-gears source code that finally pushed the decoder into aligning with PSX data. It was done. I was seeing video frames from games I'd never seen before, and without ever touching someone else's decoder.

I could do what existing decoders could do, but what of Lain? What is with all this video data? It doesn't add up to anything sensible. Again I hit a snag. The only way to know what the data means is to see what the game is doing, and how could I do that?

I was just about ready to settle with my mis-matched audio and video frames, but I couldn't leave well enough alone. I ran across the pSX emulator that provides debugging capabilities. So over a three day weekend I swam through a sea of R3051 assembly code. By the end I knew how it is all done.

Outraged at the lack of information and source code about the PSX, I decided to take my little decoder to the big time and share everything I have learned over the last few months.

And thus is the jPSXdec.

Open Sauce

2007-10-21T03:13:00.000-07:00

As mentioned in the project goals, the code will be open source. And I want to make sure this source code stays open and free (unlike so many hacking tools before this one). As such, I plan on releasing jPSXdec under ~~GPL v3~~ GPL v2 (for better compatibility).

Initially, I thought simply providing the source compressed in an archive on this site would be sufficient. I've mentioned a few ways people could help with the development if they were interested. I kept these very modular, so incorporating them would be fairly easy. I also didn't think the source code would be very large.

But there has been a request to setup a code repository instead. I've also realized the size of the source code is already non-trivial (almost 7000 lines of code), and will only grow larger (especially if a GUI is added).

I'm all for setting up a code repository, however, I don't know anything about existing hosting sites (except SF), nor do I have any experience setting up or maintaining such a site. I wish I could list some criteria, but I'm not even sure what I'll need. If anyone has any thoughts/info/suggestions/insight, I'd be interested in hearing them.

Update: After carefully weighing the different options, I found that Google Code was the best choice after all (thanks phm).

I will also be releasing two tidbits of documentation:

documentation about the code, describing how the different classes are organized and used.
a lengthy text file describing the STR file format and decoding process (nearly complete).

While I'm somewhat familiar with the GPL license, I've never had any experience with licensing documentation. It seems there are two recommended options: GNU FDL and FreeBSD Documentation License. After reading a little about them, I'm not sure which to choose. Again, if anyone has any thoughts, please share.

Update: Went with MIT license.

Thanks!

Links

2007-10-18T11:14:00.001-07:00

Numerous links were followed during the development of this program. All of these were valid at the time I followed them. I'm just throwing these in here for now. I'll clean it up later.

PSX Tools
http://hitmen.c02.at/html/psx_tools.html
http://members.fortunecity.com/zlasher/files/toolz.html
http://www.psxforum.com/utilities.php
http://www.geocities.com/anapan8/cv/

Decoding links
http://jcatki.no-ip.org/cdxa/
http://www.momentaryfascinations.com/technology/the.spyro.soundtracks.html
http://forums.qhimm.com/index.php?topic=6473.0
http://forums.qhimm.com/index.php?topic=6140.0
http://q-gears.svn.sourceforge.net/viewvc/q-gears/trunk/src/common/movie/decoders/
http://wiki.multimedia.cx/index.php?title=PlayStation_Motion_Decoder
http://osdir.com/ml/video.xine.devel/2003-02/msg00179.html
http://osdir.com/ml/video.xine.devel/2003-02/msg00186.html
http://samples.mplayerhq.hu/game-formats/psx-str/
http://www.koders.com/c/fidF23C1EAFCEAF84CA539927A01093D37D9695722A.aspx

MPEG1 links
http://bmrc.berkeley.edu/research/mpeg/faq/mpeggeneral.html
http://www.chiariglione.org/ride/inside_MPEG-1/inside_MPEG-1.htm
http://www.andrewduncan.ws/MPEG/MPEG-1_Picts.html
http://www.geocities.com/xhelmboyx/quicktime/formats/mpeg-layout.txt
http://www.faqs.org/faqs/mpeg-faq/
http://www.wotsit.org/list.asp?search=mpeg
http://guru.multimedia.cx/the-mpeg124-and-h26123-idct/
http://www.uow.edu.au/~nabg/MPEG/IDCT.html

Other Info
http://forum.digital-digest.com/showthread.php?t=17898
http://www.greenspun.com/bboard/q-and-a-fetch-msg.tcl?msg_id=000tS4
http://groups.google.com/group/alt.games.sony-playstation/browse_thread/thread/3bb9cc7ce10bbb58/02098464ed19f81a?hl=ened19f81a
http://www.megagames.com/psx/psx_copy_patch_linux.shtml
http://rpgd.emulationworld.com/klarth/

Goals and Roadmap

2007-10-16T20:41:00.000-07:00

I have some simple goals for this project.

Cross-platform
Open source
Very well documented
Very clear, direct, non-obfuscated, and well documented source code (specifically the video decoding portion)
More stable than existing decoders
Capable of decoding all types of audio and video that existing decoders can, plus more
Highest decoding quality possible

The program is written in Java because it helps meet many of these goals.

Unfortunately, the goals to make the source code as clear as possible, and highest decoding quality, have the side effect of making the decoder rather slow. Right now it decodes between 0.5-4 frames per second on my 2.8Ghz machine. The only way I plan on improving the speed is by using a disgustingly obfuscated IDCT. Since that is by far the slowest part of the decoder, it could help a lot.

The first version will simply be a command-line tool. It will decode video into a series of images, and the audio into a wav file. It will handle standard STR files, plus a few special formats: Final Fantasy VII, ~~Final Fantasy VIII~~ (delayed to 2nd version), and Serial Experiments Lain.

The next version I plan to include raw CD reading (for Windows), fix bugs, and maybe add some more special game handling. I think I also want to add raw file copying off CDs.

Following that, I hope to add a GUI to the program. I'm thinking of duplicating much of PsxMC's interface.

I'm not sure what to do about encoding the movies into another movie format. Trying to use Video for Windows in Java would be a pain in the butt (read JNI), and it also wouldn't be cross platform. My current thought is to do what jMencode does: provide a GUI for open-source encoding programs. It appears mencoder can encode using the computer's Video for Windows codecs. But I know how much everyone likes, and is familiar with how Video for Windows works. So currently I don't have a clear plan of what to do.

Want to help? Come up with a GUI, an encoding method, or raw CD reading for Linux/Mac!

teh h4x0rz

2007-10-14T11:53:00.001-07:00

0xyyuu0038rrrr0000
yy = Luminance quantization scale
uu = Chrominance quantization scale
rrrr = number of run length codes in frame

v3 DC Coefficients style
11s                     (0, 1)
011s                    (0, 2)
0100 s                  (1, 1)
0101 s                  (0, 3)
0010 1s                 (0, 4)
0011 0s                 (2, 1)
0011 1s                 (0, 5)
0001 00s                (0, 6)
0001 01s                (3, 1)
0001 10s                (1, 2)
0001 11s                (0, 7)
0000 100s               (0, 8)
0000 101s               (4, 1)
0000 110s               (0, 9)
0000 111s               (5, 1)
0010 0000 s             (0, 10)
0010 0001 s             (0, 11)
0010 0010 s             (1, 3)
0010 0011 s             (6, 1)
0010 0100 s             (0, 12)
0010 0101 s             (0, 13)
0010 0110 s             (7, 1)
0010 0111 s             (0, 14)
0000 0010 00s           (0, 15)
0000 0010 01s           (2, 2)
0000 0010 10s           (8, 1)
0000 0010 11s           (1, 4)
0000 0011 00s           (0, 16)
0000 0011 01s           (0, 17)
0000 0011 10s           (9, 1)
0000 0011 11s           (0, 18)
0000 0001 0000 s        (0, 19)
0000 0001 0001 s        (1, 5)
0000 0001 0010 s        (0, 20)
0000 0001 0011 s        (10, 1)
0000 0001 0100 s        (0, 21)
0000 0001 0101 s        (3, 2)
0000 0001 0110 s        (12, 1)
0000 0001 0111 s        (0, 23)
0000 0001 1000 s        (0, 22)
0000 0001 1001 s        (11, 1)
0000 0001 1010 s        (0, 24)
0000 0001 1011 s        (0, 28)
0000 0001 1100 s        (0, 25)
0000 0001 1101 s        (1, 6)
0000 0001 1110 s        (2, 3)
0000 0001 1111 s        (0, 27)
0000 0000 1000 0s       (0, 26)
0000 0000 1000 1s       (13, 1)
0000 0000 1001 0s       (0, 29)
0000 0000 1001 1s       (1, 7)
0000 0000 1010 0s       (4, 2)
0000 0000 1010 1s       (0, 31)
0000 0000 1011 0s       (0, 30)
0000 0000 1011 1s       (14, 1)
0000 0000 1100 0s       (0, 32)
0000 0000 1100 1s       (0, 33)
0000 0000 1101 0s       (1, 8)
0000 0000 1101 1s       (0, 35)
0000 0000 1110 0s       (0, 34)
0000 0000 1110 1s       (5, 2)
0000 0000 1111 0s       (0, 36)
0000 0000 1111 1s       (0, 37)
0000 0000 0100 00s      (2, 4)
0000 0000 0100 01s      (1, 9)
0000 0000 0100 10s      (1, 24)
0000 0000 0100 11s      (0, 38)
0000 0000 0101 00s      (15, 1)
0000 0000 0101 01s      (0, 39)
0000 0000 0101 10s      (3, 3)
0000 0000 0101 11s      (7, 3)
0000 0000 0110 00s      (0, 40)
0000 0000 0110 01s      (0, 41)
0000 0000 0110 10s      (0, 42)
0000 0000 0110 11s      (0, 43)
0000 0000 0111 00s      (1, 10)
0000 0000 0111 01s      (0, 44)
0000 0000 0111 10s      (6, 2)
0000 0000 0111 11s      (0, 45)
0000 0000 0010 000s     (0, 47)
0000 0000 0010 001s     (0, 46)
0000 0000 0010 010s     (16, 1)
0000 0000 0010 011s     (2, 5)
0000 0000 0010 100s     (0, 48)
0000 0000 0010 101s     (1, 11)
0000 0000 0010 110s     (0, 49)
0000 0000 0010 111s     (0, 51)
0000 0000 0011 000s     (0, 50)
0000 0000 0011 001s     (7, 2)
0000 0000 0011 010s     (0, 52)
0000 0000 0011 011s     (4, 3)
0000 0000 0011 100s     (0, 53)
0000 0000 0011 101s     (17, 1)
0000 0000 0011 110s     (1, 12)
0000 0000 0011 111s     (0, 55)
0000 0000 0001 0000 s   (0, 54)
0000 0000 0001 0001 s   (0, 56)
0000 0000 0001 0010 s   (0, 57)
0000 0000 0001 0011 s   (21, 1)
0000 0000 0001 0100 s   (0, 58)
0000 0000 0001 0101 s   (3, 4)
0000 0000 0001 0110 s   (1, 13)
0000 0000 0001 0111 s   (23, 1)
0000 0000 0001 1000 s   (8, 2)
0000 0000 0001 1001 s   (0, 59)
0000 0000 0001 1010 s   (2, 6)
0000 0000 0001 1011 s   (19, 1)
0000 0000 0001 1100 s   (0, 60)
0000 0000 0001 1101 s   (9, 2)
0000 0000 0001 1110 s   (24, 1)
0000 0000 0001 1111 s   (18, 1)
0000 01                 MPEG1 escape style
10                      EOB