Quadcap Embeddable Server

com/quadcap/http/client/Mp3FrameStream.java

Go to the documentation of this file.

package com.quadcap.http.client;

import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

import com.quadcap.util.Debug;

import com.quadcap.io.IO;

/*
 * Copyright 2004 by Stan Bailes and Quadcap Software.
 *
 **/
public class Mp3FrameStream extends OutputStream {
    ByteArrayOutputStream               frame = new ByteArrayOutputStream();
    OutputStream                        frameData;
    OutputStream                        nonFrameData;
    int                                 state = 0;

    int                                 id = 0;
    int                                 layer = 0;
    int                                 protection = 0;
    int                                 bitrateEnc = 0;
    int                                 frequency = 0;
    int                                 pad = 0;
    int                                 priv = 0;
    int                                 mode = 0;
    int                                 modeExt = 0;
    int                                 copy = 0;
    int                                 home = 0;
    int                                 emph = 0;

    double                              bitrate = 0;
    double                              samplerate = 0;
    int                                 framesize = 0;
    int                                 count = 0;

    int                                 totalBytes = 0;
    int                                 nonFrameCount = 0;

    boolean                             started = false;
    int                                 bitrateEncStart = 0;
    int                                 frequencyStart = 0;
    
    public Mp3FrameStream() {}

    public void init(OutputStream frameData, OutputStream nonFrameData) {
        this.frameData = frameData;
        this.nonFrameData = nonFrameData;
        started = false;
    }

    public void write(int b) throws IOException {
        totalBytes++;
        if (false && (totalBytes % 100000) == 99999) {
            msg("totalBytes: " + totalBytes + ", state: " + state +
                ", count: " + count + ", framesize: " + framesize);
        }
                                                 
        b &= 0xff;
        switch (state) {
        case 0:
            if (b == 0xff) {
                state = 1;
            } else {
                nonFrameData.write(b);
                nonFrameCount++;
            }
            break;
        case 1:
            if ((b & 0xe0) == 0xe0) {
                if (nonFrameCount > 0) {
                    msg("" + nonFrameCount + " non frame bytes @ " +
                        totalBytes);
                }
                nonFrameCount = 0;
                //msg("Frame starts at byte " + ((totalBytes) - 2));
                frame.reset();
                frame.write(0xff);
                frame.write(b);
                id = (b & 0x8) >> 3;
                layer = (b & 0x6) >> 1;
                protection = (b & 0x1);
                state = 2;
            } else {
                nonFrameData.write(0xff);
                nonFrameData.write(b);
                nonFrameCount++;
                state = 0;
            }
            break;
        case 2:
            frame.write(b);
            bitrateEnc = (b & 0xf0) >> 4;
            frequency = (b & 0xc) >> 2;
            pad = (b & 0x2) >> 1;
            priv = (b & 0x1);
            state = 3;
            break;
        case 3:
            frame.write(b);
            mode = (b & 0xc0) >> 6;
            modeExt = (b & 0x3) >> 4;
            copy = (b & 0x8) >> 3;
            home = (b & 0x4) >> 2;
            emph = (b & 0x3);
            bitrate = bitrates[bitrateEnc][(id << 2) | layer] * 1000;
            samplerate = samplerates[(id << 2) | frequency];
            if (samplerate == 0) {
                state = 0;
                nonFrameData.write(frame.toByteArray());
                nonFrameCount += 4;
            } else if (started && bitrateEnc != bitrateEncStart ||
                       frequency != frequencyStart) {
                nonFrameData.write(frame.toByteArray());
                nonFrameCount += 4;
                state = 0;
            } else {
                framesize = (int) (144 * (bitrate / samplerate) + pad);
                if (!started) {
                    msg("bitrate: " + bitrate + ", samplerate: " + samplerate +
                        ", framesize: " + framesize + " brEnc: " + bitrateEnc +
                        " id: " + id + " layer: " + layer + " freq: " +
                        frequency);
                    started = true;
                }
                bitrateEncStart = bitrateEnc;
                frequencyStart = frequency;
                count = 4;
                state = 4;
            }
            break;
        case 4:
            frame.write(b);
            if (++count >= framesize) {
                byte[] data = frame.toByteArray();
                frameData.write(data);
                state = 0;
            }
            break;
        }
    }

    int[] samplerates = {
        22050, 24000, 16000, 0,         // MPEG-2
        44100, 48000, 32000, 0          // MPEG-1
    };
    
    int[][] bitrates = {
        // MPEG-2           MPEG-1
        //   layer              layer
        //   I    II  III       I    II  III
        {0,   8,  32,  32,  0,  32,  32,  32},  // 0
        {0,   8,  32,  32,  0,  32,  32,  32},  // 1
        {0,  16,  48,  64,  0,  40,  48,  64},  // 2
        {0,  24,  56,  96,  0,  48,  56,  96},  // 3
        {0,  32,  64, 128,  0,  56,  64, 128},  // 4
        {0,  64,  80, 160,  0,  64,  80, 160},  // 5
        {0,  80,  96, 192,  0,  80,  96, 192},  // 6
        {0,  96, 112, 224,  0,  96, 112, 224},  // 7
        {0, 112, 128, 256,  0, 112, 128, 256},  // 8
        {0, 128, 160, 288,  0, 128, 160, 288},  // 9
        {0, 160, 192, 320,  0, 160, 192, 320},  // 10
        {0, 112, 224, 352,  0, 192, 224, 352},  // 11
        {0, 128, 256, 384,  0, 224, 256, 384},  // 12
        {0, 256, 320, 416,  0, 256, 320, 416},  // 13
        {0, 320, 384, 448,  0, 320, 384, 448},  // 14
        {0, 320, 384, 448,  0, 320, 384, 448}   // 15
    };

    void msg(String s) {
        Debug.println(s);
    }

    public static void main(String[] args) {
        Mp3FrameStream mp = new Mp3FrameStream();
        for (int i = 0; i < args.length; i++) {
            String s = args[i];
            try {
                if (false) {
                    FileInputStream fi = new FileInputStream(s);
                    int b;
                    int state = 0;
                    int count = 0;
                    while ((b = fi.read()) >= 0) {
                        count++;
                        switch (state) {
                        case 0:
                            if (b == 0xff) {
                                state = 1;
                            }
                            break;
                        case 1:
                            if (b == 251) {
                                state = 2;
                            } else if (b != 0xff) {
                                state = 0;
                            }
                            break;
                        case 2:
                            if (b == 146) {
                                mp.msg("Sync at " + (count-3));
                            }
                            state = 0;
                            break;
                        }
                    }
                    fi.close();
                }
                FileInputStream fis = new FileInputStream(s);
                try {
                    FileOutputStream raw = new FileOutputStream(s + ".out");
                    FileOutputStream skp = new FileOutputStream(s + ".skp");
                    mp.init(raw, skp);
                    try {
                        IO.copyStream(fis, mp);
                    } finally {
                        mp.close();
                    }
                } finally {
                    fis.close();
                }
            } catch (Throwable t) {
                Debug.print(t);
            }
        }
    }

    public void close() throws IOException {
        Debug.println("close()");
        frameData.close();
        nonFrameData.close();
        if (nonFrameCount > 0) {
            Debug.println("" + nonFrameCount + " trailing bytes no sync");
        }
    }
}