VisClient/org/hfbk/vid/AVVideoThread.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.SWScaleLibrary;
import net.sf.ffmpeg_java.AVCodecLibrary.AVCodecContext;
import net.sf.ffmpeg_java.AVCodecLibrary.AVFrame;
import net.sf.ffmpeg_java.AVFormatLibrary.AVPacket;

import org.hfbk.util.Sleeper;
import org.hfbk.vis.Prefs;

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

class AVVideoThread extends AVStreamThread{
        
        final static int VIDEO_BUFFER=0x2FFFF;
        
        AVFrame frame, frameRGB; // original and rgb resampled framebuffer
        
        int width, height, frameBytes;
        
        final int pix_fmt = AVCodecLibrary.PIX_FMT_RGB24;
        
        int time;
        
        Pointer swscaler; //holds rgb conversion engine

        ByteBuffer out;
        
        public AVVideoThread(AVCodecContext ctx, int maxPixels) {
                super("AVVideoThread", ctx,VIDEO_BUFFER);
                
                setDaemon(true);
                setPriority(Thread.MIN_PRIORITY+2);
                
                width =  ctx.width;
                height = ctx.height;
                
                while (width*height>maxPixels){
                        width/=2; height/=2;
                }
                
                frame    = AV.CODEC.avcodec_alloc_frame(); // to hold one frame
                frameRGB = AV.CODEC.avcodec_alloc_frame(); // to hold rgb converted frame
                
                if (frame == null || frameRGB == null)
                        throw new RuntimeException("Could not allocate frames");

                // the frame buffer itself is created by the codec.
                // but we need to build a buffer for our RGB converted frame.
                frameBytes   = AV.CODEC.avpicture_get_size(pix_fmt, width, height);
                final Pointer buffer = AV.UTIL.av_malloc(frameBytes);
                if (buffer == null)
                        throw new RuntimeException("Could not allocate frame buffers");
                
                // assign buffer to frameRGB
                AV.CODEC.avpicture_fill(frameRGB, buffer, pix_fmt, width, height);      
        
                //build software scaler for rgb conversion
                synchronized(AV.SWSCALE){
                        swscaler = AV.SWSCALE.sws_getContext(ctx.width, ctx.height, 
                                                                         ctx.pix_fmt, width, height,
                                                                         pix_fmt, SWScaleLibrary.SWS_POINT, null, null, null);
                }
                if (swscaler==null)
                        throw new RuntimeException("Could not open swscaler.");
        }
        
        /* decode one video AVPacket */
        ByteBuffer decodeVideo(AVPacket packet){
                // a call-by-reference parameter from native code
                // just give us back one integer
                final IntByReference frameFinished = new IntByReference();

                AV.CODEC.avcodec_decode_video(ctx, frame, frameFinished, packet.data, packet.size);
                
                // one packet equals one frame but could take 
                // more than pne before they could be decoded.
                if (frameFinished.getValue() != 0) {
                        
                        // Convert the image from its native color format to RGB
                        convertToRGB(frame, frameRGB);
                                        
                        // return the frame RGB data
                        return frameRGB.data0.getByteBuffer(0, frameBytes);
                }
                return null;
        }

        
        /* decoding main loop. polls packets from the videoQueue
         * and decodes them to videoOut buffer. speed is limited
         * by the media time advanced via getFrame(). */
        public void run() {
                AVPacket packet;
                while(running){
                        
                        packet=null;
                        while (running && ( !playing || (packet=poll())==null && !finished) )                                           
                                Sleeper.sleep(2);
                        
                        if (packet==null) break;
                        //we are told to stop 
                        //or the stream is finished and the queue all used up.
                        
                        out=decodeVideo(packet);
                        
                        int dt=(int)packet.pts-time+40;
                        
                        tick((int)packet.pts); //fire a tick to synchronize others
                        
                        free(packet); //put packet to recycling                         
                        
                        if(dt>0) Sleeper.sleep(dt);
                }
                
                close();
        }
        
        protected void close(){
                if(Prefs.current.debug) System.out.println("AVVideo finished.");
                super.close();
                synchronized(AV.UTIL){
                        if(frameRGB.data0!=null)
                                AV.UTIL.av_free(frameRGB.data0);                                
                        AV.UTIL.av_free(frameRGB.getPointer());                 
                        AV.UTIL.av_free(frame.getPointer());
                }
                synchronized (AV.SWSCALE) {AV.SWSCALE.sws_freeContext(swscaler);}               
                if(Prefs.current.debug) System.out.println("AVVideo down!");
        }
        
        /* convert a frame from native to RGB color format 
         * via libav's swscale software scaler. this should be 
         * replaced by gpu shader if available. */
        int convertToRGB(AVFrame src, AVFrame dst) {
                Pointer[] id = src.getPointer().getPointerArray(0, 4);
                Pointer[] od = dst.getPointer().getPointerArray(0, 4);
                int[] src_linesize = src.getPointer().getIntArray(4*Pointer.SIZE, 4);
                int[] dst_linesize = dst.getPointer().getIntArray(4*Pointer.SIZE, 4);
                
                return  AV.SWSCALE.sws_scale(swscaler, id, src_linesize, 0, ctx.height, od, dst_linesize);
        }       
}

---