VisClient/org/hfbk/vid/AVAudioThread.java

Go to the documentation of this file.

package org.hfbk.vid;

import java.nio.ByteBuffer;

import net.sf.ffmpeg_java.AVCodecLibrary;
import net.sf.ffmpeg_java.AVCodecLibrary.AVCodecContext;
import net.sf.ffmpeg_java.AVFormatLibrary.AVPacket;

import org.dronus.al.ALAudioThread;
import org.hfbk.vis.Prefs;

import com.sun.jna.Pointer;
import com.sun.jna.ptr.IntByReference;

public class AVAudioThread extends AVStreamThread {

        final static int AUDIO_BUFFER=0xFFFF;
        // our OpenAl audio engine
        // it is NOT started as a thread on its own, 
        // but run from this one!
        ALAudioThread alThread; 

        final int SAMPLES=AVCodecLibrary.AVCODEC_MAX_AUDIO_FRAME_SIZE;
        Pointer decoded;
        
        int time;
        
        public AVAudioThread(AVCodecContext ctx) {
                super("AVAudioThread", ctx,AUDIO_BUFFER);
                
                setPriority(Thread.MAX_PRIORITY-1);
                
                int s=ctx.sample_rate;
                int b=ctx.bits_per_coded_sample;
                int c=ctx.channels; 
                if (b==0) b=16;
                
                alThread=new ALAudioThread(s, b, c){
                        protected ByteBuffer poll(){
                                AVPacket p=AVAudioThread.this.poll();
                                if(p!=null){
                                        tick((int)p.pts);
                                        return decodeAudio(p);
                                }
                                // if the stream is finished
                // and the queue already used up
                                else if (AVAudioThread.this.finished) 
                                        running=false;
                                
                                return null;                            
                        }
                        
                        public void tick(int time) {
                                AVAudioThread.this.tick(time);
                                AVAudioThread.this.time=time;
                        }
                };
        
                synchronized(AV.UTIL){
                        decoded=AV.UTIL.av_malloc(SAMPLES); 
                }
        }

        void setPlaying(boolean playing){
                super.setPlaying(playing);
                alThread.playing=playing;
        };
        
        public void run() {
                alThread.run();
                close();                
        }
        
        void setRunning(boolean running) {
                super.setRunning(running);
                alThread.running=running;
        }

        protected void close(){
                if(Prefs.current.debug) System.out.println("AVAudio finished.");
                super.close();
                synchronized(AV.UTIL){ 
                        AV.UTIL.av_free(decoded); 
                }               
                if(Prefs.current.debug) System.out.println("AVAudio down!");
        }
        
        /* decode one audio AVPacket */
        ByteBuffer decodeAudio(AVPacket packet){
                final IntByReference bufferSize = new IntByReference(SAMPLES);
        
                AV.CODEC.avcodec_decode_audio2(ctx, decoded,
                                bufferSize, packet.data, packet.size);
                free(packet);
                
                return decoded.getByteBuffer(0, bufferSize.getValue());
        }       
}

---