VisClient/org/hfbk/vid/AVStreamThread.java

Go to the documentation of this file.

package org.hfbk.vid;

import java.util.LinkedList;
import java.util.List;

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

import org.hfbk.util.Sleeper;

import com.sun.jna.Native;

public abstract class AVStreamThread extends Thread {

        protected boolean running=true;
        protected boolean playing=true;

        boolean finished=false;
        
        AVCodecContext ctx;
        
        int bytes, limit;

        private List<AVPacket> queue=new LinkedList<AVPacket>();
        private List<AVPacket> free=new LinkedList<AVPacket>();
        
        public AVStreamThread(String name, AVCodecContext ctx, int bufferlimit) {
                super(name);
                setDaemon(true);
                setPriority(Thread.MIN_PRIORITY + 3);
                
                this.limit=bufferlimit;
                this.ctx=ctx;
                
                String codecName=Native.toString(ctx.codec_name);
                if (ctx.codec_id == 0){                  
                        throw new RuntimeException("Codec not available.");
                }
                synchronized(AV.CODEC){
                        // Find matching decoder
                        AVCodec codec = AV.CODEC.avcodec_find_decoder(ctx.codec_id);
                        
                        // open decoder
                        if (AV.CODEC.avcodec_open(ctx, codec) < 0)
                                throw new RuntimeException("Could not open codec.");
                }
        }
        
        void setPlaying(boolean playing){this.playing=playing;}
        void setRunning(boolean running){this.running=running;}
        
        protected void close() {
                flush();
                synchronized(AV.CODEC){
                        AV.CODEC.avcodec_close(ctx);
                }
        }

        void tick(int time){}
        
        
        
        void add(AVPacket p) {
                while(bytes>limit) Sleeper.sleep(2);
                synchronized(this){
                        bytes+=p.size;
                        AV.FORMAT.av_dup_packet(p);
                        //System.out.println(p.getPointer()+" "+p.data);
                        queue.add(p);
                }
        }
        
        synchronized AVPacket poll() {
                if (queue.size()>0){
                        AVPacket e=queue.get(0);
                        queue.remove(0);
                        bytes-=e.size;
                        return e; 
                }
                return null;
        }
        
        void free(AVPacket p){
                p.destruct.callback(p);
                synchronized(free){
                        free.add(p);
                }
        }
        
        synchronized AVPacket getFree(){
                synchronized(free){                     
                        if (free.size()>0){
                                AVPacket e=free.get(0);
                                free.remove(0);
                                return e;
                        }else{
                                return new AVPacket();
                        }
                }
        }
        
        synchronized void flush() {
                AVPacket packet;
                while ((packet=poll())!=null)
                        packet.destruct.callback(packet);                       
        }
}

---