package org.musicontroller.streaming;
   
   import java.io.FilterOutputStream;
   import java.io.IOException;
   import java.io.OutputStream;
   
   import org.apache.log4j.Logger;
   import org.farng.mp3.InvalidTagException;
   import org.farng.mp3.MP3File;
  import org.farng.mp3.TagNotFoundException;
  
  import edu.emory.mathcs.backport.java.util.Arrays;
  
  /**
   * An MpegOutputStream filters all (meta)data from a stream, so that a clean
   * stream of Mpeg-frames remains. This class tries to achieve this by detecting
   * and decoding mp3-frame-headers in the stream. Correct headers and the
   * subsequent data are let through, whereas incorrect data is filtered. This
   * method has a downside: metadata in a mp3-file could in theory contain data
   * which looks like a valid mp3-frame-header too.
   * The solution is to not only read mp3-frame-headers, but metadata-headers as
   * well. If we encounter an ID3-header, we just skip the following data.
   * <ul>
   * <li>For ID3v1: after "TAG", 125 bytes of metadata follow.</li>
   * <li>For ID3v2: after "ID3xyfssss", 4*ssss bytes of metadata follow.</li>
   * </ul>
  
   * @author Varienaja
   */
  public class MpegOutputStream extends FilterOutputStream {
  	
  	private static final Logger log = Logger.getLogger(MpegOutputStream.class);
  	
  	private final static int BUFFERSIZE = 4096;
  	/**
  	 * The amount of milliseconds the stream should be inspected to detect
  	 * possible bandwidth-problems.
  	 */
  	private final static int LOWBANDWIDTHDETECTIONLENGTH = 10000;
  	/**
  	 * The amount of samples to take to detect possible bandwidth-problems.
  	 */
  	private final static int LOWBANDWIDTHSAMPLEDEPTH = 10;
  	
  	/**
  	 * The interval, after which we have to take a sample. An Mpeg frame contains
  	 * 26 ms of sound.
  	 */
  	private final static int FRAMEINTERVAL = LOWBANDWIDTHDETECTIONLENGTH / 26 / LOWBANDWIDTHSAMPLEDEPTH;
  	
  	/**
  	 * The amount of lag (in ms) we must experience in order to go into
  	 * 'panic-mode'. Use negative values!
  	 */
  	private final static int MAXLAG = -5000;
  	
  	private int count;
  
  	/**
  	 * When we found sync, we use this buffer to store a temporary copy of the
  	 * mpeg frame. This buffer contains at most one mpeg frame. 
  	 */
  	private byte[] testframe;
  	private State state;
  	private int[] framelength;
  	private byte second;
  	private byte third;
  	private byte fourth;
  	private int totalskip;
  	private int _todiscard;
  	private byte vMajor;
  	private byte vMinor;
  	private byte flags;
  	private byte[] metadatasize;
  	/**
  	 * Holds an integer-bytecount per bitrate. This can be used to calculate
  	 * the length of the bytes that were streamed; The bitrates that are held
  	 * are: 32,40,48,56,64,80,96,112,128,160,192,224,256,320kbs.
  	 */
  	private int[] _bitratesStreamed;
  	private long _byteswritten;
  	
  	private long _probeTime;
  	private int _probeLength;
  	/**
  	 * The amount of MPEG frames that have been flushed during a certain period
  	 * of time. A frame contains 26ms of sound.
  	 */
  	private int frameCounter;
  	
  	/**
  	 * A cyclic Array, containing the differences between time-streamed (length
  	 * of the streamed content) and stream-time (time used to stream the said
  	 * content).
  	 */
  	private int _streamDeltas[];
  	/**
  	 * Index to the _streamDeltas array.
  	 */
 	private int _streamDeltaIndex;
 
 	/**
 	 * All states we can encounter while trying to sync on a MP3 frame-header.
 	 */
 	private enum State {
 		WAITING_FOR_SYNC,
 		FIRST_SYNC_BYTE_FOUND,
 		SECOND_SYNC_BYTE_FOUND,
 		THIRD_SYNC_BYTE_FOUND,
 		SYNCHRONIZED,
 		
 		ID3_I,
 		ID3_D,
 		ID3_3,
 		ID3_vMajor,
 		ID3_vMinor,
 		ID3_flags,
 		ID3_s1,
 		ID3_s2,
 		ID3_s3,
 		ID3_s4,
 		
 		TAG_T,
 		TAG_A,
 		TAG_G,
 		
 		DISCARDING;
 	}
 	
 	/**
 	 * Creates a new MpegOutputStream.
 	 * @param out The OutputStream to filter.
 	 */
 	public MpegOutputStream(OutputStream out) {
 		super(out);
 		//The maximum theoretical length of such a frame is 1440 bytes(?).
 		//To be sure, I use a few extra bytes here.
 		testframe = new byte[BUFFERSIZE];
 		metadatasize = new byte[4];
 		reset();
 		log.debug("New MpegOutputStream created");
 	}
 	
 	/**
 	 * <p>Resets the internal state of the MpegOutputStream. This is
 	 * particularly useful when skipping songs. In the case of skipping, the
 	 * stream is cut off at an arbitrary position, causing the mpeg-stream to
 	 * become distorted.</p>
 	 * <p>This method also sets the seconds-counter back to 0.</p>
 	 * <p>When this class is busy copying an mpeg-frame which is only partly
 	 * handed over, the output can still contain pops. The new frame would come
 	 * too early, causing bogus-data to be played as music. A call to this reset
 	 * method invalidates the current mpeg frame, and therefore rules out
 	 * another source of nasty popping sounds.</p>
 	 */
 	public synchronized void reset() {
 		if (count>0) {
 			log.debug("Incomplete mpeg frame, skipped " + count + " bytes.");
 			count = 0;
 		}
 		totalskip = 0;
 		_bitratesStreamed = new int[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 		_streamDeltas = new int[LOWBANDWIDTHSAMPLEDEPTH];
 		_streamDeltaIndex = 0;
 		state = State.WAITING_FOR_SYNC;
 		_byteswritten = 0L;
 		_probeTime = System.currentTimeMillis();
 		_probeLength = 0;
 		frameCounter = 0;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see java.io.FilterOutputStream#write(int)
 	 */
 	public synchronized void write(int b) throws IOException {
 		byte[] buf = new byte[1];
 		buf[0] = (byte) b;
 		write(buf,0,1);
 	}
 	/**
 	 * Disregards bytes until a valid Mpeg-header is found. Calculates the expected frame-length.
 	 * When the full header + frame is received, the full frame is handed over
 	 * to the delegating OutputStream. Only correct MP3-frames are written, all other information
 	 * is disregarded.
 	 */
 	public synchronized void write(byte[] b, int off, int len) throws IOException {
 		if (len==0) return;
 		int endbyte = len+off;
 		
 		if (state==State.WAITING_FOR_SYNC) { //disregard bytes until 0xFF, 'I' or 'T' found
 			int skip=0;
 			while (b[off+skip]!=(byte) 0xFF && b[off+skip]!='I' && b[off+skip]!='T' && skip<len-1) {
 				skip++;
 			}
 
 			totalskip+=skip;
 			off+=skip;
 			len-=skip; //new situation
 			if (b[off]==(byte) 0xFF) {
 				state = State.FIRST_SYNC_BYTE_FOUND;
 				len--;
 				off++;
 			} else if (b[off]=='T') {
 				state = State.TAG_T;
 				len--;
 				off++;
 			} else if (b[off]=='I') {
 				state = State.ID3_I;
 				len--;
 				off++;
 			}
 		}
 		
 		if (state==State.TAG_T) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				if (b[off]=='A') {
 					state = State.TAG_A;
 					len--;
 					off++;
 				} else {
 					state = State.WAITING_FOR_SYNC;
 					totalskip+=2; //the last two bytes had to be skipped after all.
 					write(b,off,len); //try to sync again...
 					return;
 				}
 			}
 		}
 		if (state==State.TAG_A) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				if (b[off]=='G') {
 					log.debug("ID3v1 tag found, skipping 128 bytes.");
 					state = State.DISCARDING;
 					len--;
 					off++;
 					_todiscard = 125;
 				} else {
 					state = State.WAITING_FOR_SYNC;
 					totalskip+=3; //the last two bytes had to be skipped after all.
 					write(b,off,len); //try to sync again...
 					return;
 				}
 			}
 		}
 		
 		if (state==State.ID3_I) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				if (b[off]=='D') {
 					state = State.ID3_D;
 					len--;
 					off++;
 				} else {
 					state = State.WAITING_FOR_SYNC;
 					totalskip+=2; //the last two bytes had to be skipped after all.
 					write(b,off,len); //try to sync again...
 					return;
 				}
 			}
 		}
 		if (state==State.ID3_D) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				if (b[off]=='3') {
 					state = State.ID3_3;
 					len--;
 					off++;
 				} else {
 					state = State.WAITING_FOR_SYNC;
 					totalskip+=3; //the last two bytes had to be skipped after all.
 					write(b,off,len); //try to sync again...
 					return;
 				}
 			}
 		}
 		if (state==State.ID3_3) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				vMajor = b[off];
 				state = State.ID3_vMajor;
 				len--;
 				off++;
 			}
 		}
 		if (state==State.ID3_vMajor) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				vMinor = b[off];
 				state = State.ID3_vMinor;
 				len--;
 				off++;
 			}
 		}
 		if (state==State.ID3_vMinor) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				flags = b[off];
 				state = State.ID3_flags;
 				len--;
 				off++;
 			}
 		}
 		if (state==State.ID3_flags) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				metadatasize[0] = b[off];
 				state = State.ID3_s1;
 				len--;
 				off++;
 			}
 		}
 		if (state==State.ID3_s1) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				metadatasize[1] = b[off];
 				state = State.ID3_s2;
 				len--;
 				off++;
 			}
 		}
 		if (state==State.ID3_s2) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				metadatasize[2] = b[off];
 				state = State.ID3_s3;
 				len--;
 				off++;
 			}
 		}
 		if (state==State.ID3_s3) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				metadatasize[3] = b[off];
 				state = State.DISCARDING;
 				len--;
 				off++;
 				_todiscard = decodeSyncsafeInteger(metadatasize);
 				if (footerBitSet(flags)) {
 					_todiscard+=10;
 				}
 				log.debug("ID3v2."+vMajor+"."+vMinor+" tag found, skipping " + _todiscard + " bytes.");
 			}
 		}
 		if (state==State.DISCARDING) {
 			while (endbyte-off>0 && _todiscard>0) { //If there are bytes to read in the buffer b
 				len--;
 				off++;
 				_todiscard--;
 			}
 			if (_todiscard==0) {
 				state = State.WAITING_FOR_SYNC;
 				write(b,off,len); //try to sync again...
 				return;
 			}
 		}
 		
 		if (state==State.FIRST_SYNC_BYTE_FOUND) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				if ((b[off] & (byte) 0xE0) == (byte) 0xE0) {
 					second = b[off];
 					state = State.SECOND_SYNC_BYTE_FOUND;
 					len--;
 					off++;
 				} else {
 					state = State.WAITING_FOR_SYNC;
 					totalskip+=2; //the last two bytes had to be skipped after all.
 					write(b,off,len); //try to sync again...
 					return;
 				}
 			}
 		}
 		if (state==State.SECOND_SYNC_BYTE_FOUND) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				third = b[off];
 				state = State.THIRD_SYNC_BYTE_FOUND;
 				len--;
 				off++;
 			}
 		}
 		if (state==State.THIRD_SYNC_BYTE_FOUND) {
 			if (endbyte-off>0) { //If there are bytes to read in the buffer b
 				fourth = b[off];
 				state = State.SYNCHRONIZED;
 				len--;
 				off++;
 				
 				testframe[0] = (byte) 0xFF;
 				testframe[1] = second;
 				testframe[2] = third;
 				testframe[3] = fourth;
 				count=4;
 				try {
 					framelength = MP3File.readFrameHeaderCalcLength(testframe);
 					if (framelength[0]==0) {
 						state=State.WAITING_FOR_SYNC;
 						write(b,off,len);
 						return;
 			        }
 			        updateBitrateArray();
 				} catch (InvalidTagException e) { //We did not have a sync after all, start seeking again.
 					state=State.WAITING_FOR_SYNC;
 					totalskip+=4; //the last four bytes had to be skipped after all.
 					write(b,off,len);
 					return;
 				} catch (TagNotFoundException e) {
 					state=State.WAITING_FOR_SYNC;
 					totalskip+=4; //the last two bytes had to be skipped after all.
 					write(b,off,len);
 					return;
 				}
 			}
 		}
 		
 		if (state==State.SYNCHRONIZED) { //accept framelength bytes, flush and go to WAITING_FOR_SYNC again
 			//Now that we finally know that we're synced again, log how many bytes we skipped:
 			if (totalskip>0) {
 				log.debug("Skipped "+totalskip+" bytes of non-Mpeg information.");
 				totalskip=0;
 			}
 			if (len>framelength[0]-count) {
 				System.arraycopy(b,off,testframe,count,framelength[0]-count);
 				int c = framelength[0]-count;
 				count=framelength[0];
 				flushBuffer();
 				state = State.WAITING_FOR_SYNC;
 				//frame is completely written, waiting for new one
 				write(b,off+c,len-c);
 				return;
 			} else {
 				System.arraycopy(b,off,testframe,count,len);
 				count+=len;
 				//partial frame written, catch rest of frame in the next call of write()
 			}
 		}
 	}
 
 	/**
 	 * Updates the bitrate array. The last-read frame is used to update the
 	 * contents of the array.
 	 */
 	private void updateBitrateArray() {
 		switch (framelength[1]) {
 		case (32) : _bitratesStreamed[0]+=framelength[0]; break;
 		case (40) : _bitratesStreamed[1]+=framelength[0]; break;
 		case (48) : _bitratesStreamed[2]+=framelength[0]; break;
 		case (56) : _bitratesStreamed[3]+=framelength[0]; break;
 		case (64) : _bitratesStreamed[4]+=framelength[0]; break;
 		case (80) : _bitratesStreamed[5]+=framelength[0]; break;
 		case (96) : _bitratesStreamed[6]+=framelength[0]; break;
 		case (112) : _bitratesStreamed[7]+=framelength[0]; break;
 		case (128) : _bitratesStreamed[8]+=framelength[0]; break;
 		case (160) : _bitratesStreamed[9]+=framelength[0]; break;
 		case (192) : _bitratesStreamed[10]+=framelength[0]; break;
 		case (224) : _bitratesStreamed[11]+=framelength[0]; break;
 		case (256) : _bitratesStreamed[12]+=framelength[0]; break;
 		case (320) : _bitratesStreamed[13]+=framelength[0]; break;
 		}
 	}
 	
 	/**
 	 * Checks whether byte 4 is set in the flags.
 	 * @param flags2 The flags
 	 * @return True, when byte 4 is set.
 	 */
 	private boolean footerBitSet(byte flags) {
 		return (flags & (byte) 0x10) == 0x10;
 	}
 
 	/**
 	 * Decodes 4 bytes, containing a syncsafe integer. (See 
 	 * http://www.id3.org/id3v2.4.0-structure section 6.2)
 	 * NOTE: This method does no checking on the size of the array! Make sure
 	 * you pass 4 bytes, or you'll get an ArrayOutOfBoundsException.
 	 * @param buffer The bytearray, holding the syncsafe integer.
 	 * @return The value as a normal int value.
 	 */
 	private int decodeSyncsafeInteger(byte[] buffer) {
 		return (buffer[0] << 21) + (buffer[1] << 14) + (buffer[2] << 7) + buffer[3];
 	}
 
 	/*
 	 * Flushes all buffered data, but makes sure only complete Mpeg frames are
 	 * flushed.
 	 * (non-Javadoc)
 	 * @see java.io.FilterOutputStream#flush()
 	 */
 	public synchronized void flush() throws IOException {
 		flushBuffer();
 		out.flush();
 	}
 	
 	/**
 	 * Writes the contents of the internal buffer to the OutputStream. This
 	 * method only has effect when there is a complete Mpeg frame in the buffer.
 	 * @throws IOException if an I/O error occurs.
 	 */
 	private void flushBuffer() throws IOException {
 		if (count==framelength[0]) { //Only flush complete frames!
 			out.write(testframe,0,framelength[0]);
 			_byteswritten += count;
 			count = 0;
 			
 			frameCounter++;
 			if (frameCounter>FRAMEINTERVAL) {
 				frameCounter = 0;
 				int streamed = getStreamedLengthInMillis();
 				int deltaTimeStreamed = streamed - _probeLength;
 				
 				long curr = System.currentTimeMillis();
 				long deltaTime = curr - _probeTime;
 				if (log.isDebugEnabled()) {
 					log.debug("Streamed "+ deltaTimeStreamed + "ms of mpeg in " + deltaTime + "ms (" + 8*_byteswritten/deltaTimeStreamed + "kbs)");
 				}
 				
 				int difference = deltaTimeStreamed - (int) deltaTime;
 				if (difference < -30000) { 
 					//More than 30 seconds difference: the client probably has
 					//paused the stream. ignore this measurement
 					log.info("Huge difference in stream-time vs time streamed: " + difference + "ms. Stream was probably paused.");
 				} else {
 					int oldsum = 0;
 					for (int i : _streamDeltas) {
 						oldsum += i;
 					}
 					int newsum = oldsum - _streamDeltas[_streamDeltaIndex] + difference;
 					_streamDeltas[_streamDeltaIndex] = difference;
 					if (++_streamDeltaIndex >= _streamDeltas.length) {
 						_streamDeltaIndex = 0;
 					}
 					if ((oldsum > newsum) && (newsum < MAXLAG)) { 
 						//We're experiencing more lag than before AND more than our maximum.
 						//Enter panic mode.
 						log.info("Low bandwidth! Lagging " +newsum+ "ms. " + Arrays.toString(_streamDeltas) + " Transcode to lower bitrate?");
 					} else {
 						//Leave panic mode.
 					}
 				}
 				
 				_probeTime = curr;
 				_probeLength = streamed;
 				_byteswritten = 0;
 			}
 		}
 	}
 	
 	/**
 	 * Gets the playtime.
 	 * @return The amount of milliseconds that were transported through this object
 	 * since the last reset.
 	 */
 	public int getStreamedLengthInMillis() {
 		int length = 0;
 		
 		length+=_bitratesStreamed[0]/4; // 32kbit/s --> 2 bytes/ms
 		length+=_bitratesStreamed[1]/5; // 40kbit
 		length+=_bitratesStreamed[2]/5; // 48kbit
 		length+=_bitratesStreamed[3]/7; // 56kbit
 		length+=_bitratesStreamed[4]/8; // 64kbit
 		length+=_bitratesStreamed[5]/10; // 80kbit
 		length+=_bitratesStreamed[6]/12; // 96kbit
 		length+=_bitratesStreamed[7]/14; // 112kbit
 		length+=_bitratesStreamed[8]/16; // 128kbit
 		length+=_bitratesStreamed[9]/20; // 160kbit
 		length+=_bitratesStreamed[10]/24; // 192kbit
 		length+=_bitratesStreamed[11]/28; // 224 kbit
 		length+=_bitratesStreamed[12]/32; // 256 kbit
 		length+=_bitratesStreamed[13]/40; // 320 kbit;
 
 		return length;
 	}
 	
 	/**
 	 * Gets the number of bytes streamed.
 	 * @return The number of bytes streamed since the last reset.
 	 */
 	public long getBytesStreamed() {
 		return _byteswritten;
 	}
 	
 }