+ *

+ *

+ *

+ *

+

+ GL(0), KHRImage(1);

+

+ }

+

+

+

+ public final long getImage() { return image; }

+

+ @Override

+ return "EGLTextureFrame[pts " + pts + " ms, l " + duration + " ms, texID "+ texture.getTextureObject() + ", img "+ image + ", sync "+ sync+", clientBuffer "+clientBuffer+"]";

+

+ protected TextureSequence.TextureFrame createTexImage(GL gl, int texName) {

+ final Texture texture = super.createTexImageImpl(gl, texName, width, height);

+ final boolean eglUsage = TextureType.KHRImage == texType || useKHRSync ;

+

+ eglDrawable = (EGLDrawable) eglCtx.getGLDrawable();

+

+ image = eglExt.eglCreateImageKHR( eglDrawable.getNativeSurface().getDisplayHandle(), eglCtx.getHandle(),

+ throw new RuntimeException("EGLImage creation failed: "+EGL.eglGetError()+", ctx "+eglCtx+", tex "+texName+", err "+toHexString(EGL.eglGetError()));

+ IntBuffer tmp = Buffers.newDirectIntBuffer(1);

+ tmp.put(0, EGL.EGL_NONE);

+ sync = eglExt.eglCreateSyncKHR(eglDrawable.getNativeSurface().getDisplayHandle(), EGLExt.EGL_SYNC_FENCE_KHR, tmp);

+

+ protected void destroyTexFrame(GL gl, TextureSequence.TextureFrame frame) {

+ final boolean eglUsage = TextureType.KHRImage == texType || useKHRSync ;

+

+ eglDrawable = (EGLDrawable) eglCtx.getGLDrawable();

+ final EGLTextureFrame eglTex = (EGLTextureFrame) frame;

+

+ eglExt.eglDestroyImageKHR(eglDrawable.getNativeSurface().getDisplayHandle(), eglTex.getImage());

+ eglExt.eglDestroySyncKHR(eglDrawable.getNativeSurface().getDisplayHandle(), eglTex.getSync());

+ super.destroyTexFrame(gl, frame);

+ *

+ *

+ *

+ *

+import java.net.URI;

+import java.util.Map;

+import javax.media.nativewindow.AbstractGraphicsDevice;

+import javax.media.opengl.GLContext;

+import javax.media.opengl.GLDrawable;

+import javax.media.opengl.GLDrawableFactory;

+import javax.media.opengl.GLProfile;

+

+import jogamp.opengl.Debug;

+import com.jogamp.common.net.URIQueryProps;

+import com.jogamp.common.os.Platform;

+import com.jogamp.common.util.LFRingbuffer;

+import com.jogamp.common.util.Ringbuffer;

+import com.jogamp.opengl.GLExtensions;

+import com.jogamp.opengl.util.TimeFrameI;

+import com.jogamp.opengl.util.av.AudioSink;

+import com.jogamp.opengl.util.glsl.ShaderCode;

+import com.jogamp.opengl.util.texture.TextureSequence.TextureFrame;

+ * <li>{@link #setDesTextureCount(int)}</li>

+ *

+ private static final int STREAM_WORKER_DELAY = Debug.getIntProperty("jogl.debug.GLMediaPlayer.StreamWorker.delay", false, 0);

+ protected volatile State state;

+ private final Object stateLock = new Object();

+

+ protected int textureInternalFormat;

+

+

+

+ /** User requested URI stream location. */

+ protected URI streamLoc = null;

+ /**

+ * In case {@link #streamLoc} is a {@link GLMediaPlayer#CameraInputScheme},

+ * {@link #cameraPath} holds the URI's path portion

+ * as parsed in {@link #initStream(URI, int, int, int)}.

+ * @see #cameraProps

+ */

+ protected String cameraPath = null;

+ /** Optional camera properties, see {@link #cameraPath}. */

+ protected Map<String, String> cameraProps = null;

+

+ protected volatile float playSpeed = 1.0f;

+ protected float audioVolume = 1.0f;

+

+ /** Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+ protected int vid = GLMediaPlayer.STREAM_ID_AUTO;

+ /** Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+ protected int aid = GLMediaPlayer.STREAM_ID_AUTO;

+ /** Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+ /** Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+ /** Video avg. fps. Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+ /** Video avg. frame duration in ms. Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+ protected float frame_duration = 0f;

+ /** Stream bps. Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+ /** Video bps. Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+ /** Audio bps. Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+ /** In frames. Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+ protected int videoFrames = 0;

+ /** In frames. Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+ protected int audioFrames = 0;

+ /** In ms. Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+ /** Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+ /** Shall be set by the {@link #initStreamImpl(int, int)} method implementation. */

+

+ protected volatile int decodedFrameCount = 0;

+ protected int presentedFrameCount = 0;

+ protected int displayedFrameCount = 0;

+ protected volatile int video_pts_last = 0;

+

+ /**

+ * Help detect EOS, limit is {@link #MAX_FRAMELESS_MS_UNTIL_EOS}.

+ * To be used either by getNextTexture(..) or StreamWorker for audio-only.

+ */

+ private int nullFrameCount = 0;

+ private int maxNullFrameCountUntilEOS = 0;

+ /**

+ * Help detect EOS, limit {@value} milliseconds without a valid frame.

+ */

+ private static final int MAX_FRAMELESS_MS_UNTIL_EOS = 5000;

+ private static final int MAX_FRAMELESS_UNTIL_EOS_DEFAULT = MAX_FRAMELESS_MS_UNTIL_EOS / 30; // default value assuming 30fps

+

+ /** See {@link #getAudioSink()}. Set by implementation if used from within {@link #initStreamImpl(int, int)}! */

+ protected AudioSink audioSink = null;

+ protected boolean audioSinkPlaySpeedSet = false;

+

+ /** System Clock Reference (SCR) of first audio PTS at start time. */

+ private long audio_scr_t0 = 0;

+ private boolean audioSCR_reset = true;

+

+ /** System Clock Reference (SCR) of first video frame at start time. */

+ private long video_scr_t0 = 0;

+ /** System Clock Reference (SCR) PTS offset, i.e. first video PTS at start time. */

+ private int video_scr_pts = 0;

+ /** Cumulative video pts diff. */

+ private float video_dpts_cum = 0;

+ /** Cumulative video frames. */

+ private int video_dpts_count = 0;

+ /** Number of min frame count required for video cumulative sync. */

+ private static final int VIDEO_DPTS_NUM = 20;

+ /** Cumulative coefficient, value {@value}. */

+ private static final float VIDEO_DPTS_COEFF = 0.7943282f; // (float) Math.exp(Math.log(0.01) / VIDEO_DPTS_NUM);

+ /** Maximum valid video pts diff. */

+ private static final int VIDEO_DPTS_MAX = 5000; // 5s max diff

+ /** Trigger video PTS reset with given cause as bitfield. */

+ private boolean videoSCR_reset = false;

+

+ protected TextureFrame[] videoFramesOrig = null;

+ protected Ringbuffer<TextureFrame> videoFramesFree = null;

+ protected Ringbuffer<TextureFrame> videoFramesDecoded = null;

+ protected volatile TextureFrame lastFrame = null;

+ /**

+ * @see #isGLOriented()

+ */

+ protected boolean isInGLOrientation = false;

+

+ private final ArrayList<GLMediaEventListener> eventListeners = new ArrayList<GLMediaEventListener>();

+ this.textureCount=0;

+ this.textureInternalFormat = GL.GL_RGBA;

+ this.textureType = GL.GL_UNSIGNED_BYTE;

+ public final void setTextureUnit(int u) { texUnit = u; }

+

+ public final int getTextureUnit() { return texUnit; }

+

+ @Override

+ public final int getTextureTarget() { return textureTarget; }

+

+

+ protected final void setTextureFormat(int internalFormat, int format) {

+ textureInternalFormat=internalFormat;

+ textureFormat=format;

+ }

+ @Override

+ @Override

+ public final void setTextureWrapST(int[] wrapST) { texWrapST[0] = wrapST[0]; texWrapST[1] = wrapST[1];}

+ public final int[] getTextureWrapST() { return texWrapST; }

+

+ private final void checkGLInit() {

+ if(State.Uninitialized == state || State.Initialized == state ) {

+ throw new IllegalStateException("GL not initialized: "+this);

+

+ checkGLInit();

+ return ShaderCode.createExtensionDirective(GLExtensions.OES_EGL_image_external, ShaderCode.ENABLE);

+

+ checkGLInit();

+ case GL2.GL_TEXTURE_RECTANGLE:

+ throw new GLException("Unsuported texture target: "+toHexString(textureTarget));

+

+ *

+ checkGLInit();

+

+ *

+ * This implementation simply returns an empty string since it's using

+ checkGLInit();

+ return "";

+

+ public final int getDecodedFrameCount() { return decodedFrameCount; }

+

+ public final int getPresentedFrameCount() { return presentedFrameCount; }

+

+ @Override

+ public final int getVideoPTS() { return video_pts_last; }

+

+ @Override

+ public final int getAudioPTS() {

+ if( State.Uninitialized != state ) {

+ return getAudioPTSImpl();

+ return 0;

+ /** Override if not using audioSink! */

+ protected int getAudioPTSImpl() {

+ if( null != audioSink ) {

+ return audioSink.getPTS();

+ } else {

+ return 0;

+

+ @Override

+ public final State getState() { return state; }

+

+ @Override

+ public final State play() {

+ synchronized( stateLock ) {

+ final State preState = state;

+ switch( state ) {

+ case Paused:

+ if( playImpl() ) {

+ resetAVPTS();

+ if( null != audioSink ) {

+ audioSink.play(); // cont. w/ new data

+ }

+ if( null != streamWorker ) {

+ streamWorker.doResume();

+ }

+ changeState(0, State.Playing);

+ }

+ default:

+ }

+ if(DEBUG) { System.err.println("Play: "+preState+" -> "+state+", "+toString()); }

+ return state;

+ protected abstract boolean playImpl();

+

+ @Override

+ public final State pause(boolean flush) {

+ return pauseImpl(flush, 0);

+ }

+ private final State pauseImpl(boolean flush, int event_mask) {

+ synchronized( stateLock ) {

+ final State preState = state;

+ if( State.Playing == state ) {

+ event_mask = addStateEventMask(event_mask, GLMediaPlayer.State.Paused);

+ state = State.Paused;

+ if( null != streamWorker ) {

+ streamWorker.doPause();

+ }

+ if( flush ) {

+ resetAVPTSAndFlush();

+ } else if( null != audioSink ) {

+ audioSink.pause();

+ attributesUpdated( event_mask );

+ if( !pauseImpl() ) {

+ play();

+ }

+ }

+ if(DEBUG) { System.err.println("Pause: "+preState+" -> "+state+", "+toString()); }

+ return state;

+ protected abstract boolean pauseImpl();

+

+ public final State destroy(GL gl) {

+ return destroyImpl(gl, 0);

+ }

+ private final State destroyImpl(GL gl, int event_mask) {

+ synchronized( stateLock ) {

+ if( null != streamWorker ) {

+ streamWorker.doStop();

+ streamWorker = null;

+ }

+ destroyImpl(gl);

+ removeAllTextureFrames(gl);

+ textureCount=0;

+ changeState(event_mask, State.Uninitialized);

+ attachedObjects.clear();

+ return state;

+ protected abstract void destroyImpl(GL gl);

+

+ @Override

+ synchronized( stateLock ) {

+ final State preState = state;

+ final int pts1;

+ switch(state) {

+ case Playing:

+ case Paused:

+ final State _state = state;

+ state = State.Paused;

+ if( null != streamWorker ) {

+ streamWorker.doPause();

+ }

+ // Adjust target ..

+ if( msec >= duration ) {

+ msec = duration - (int)Math.floor(frame_duration);

+ } else if( msec < 0 ) {

+ msec = 0;

+ }

+ pts1 = seekImpl(msec);

+ resetAVPTSAndFlush();

+ if( null != audioSink && State.Playing == _state ) {

+ audioSink.play(); // cont. w/ new data

+ }

+ if(DEBUG) {

+ System.err.println("Seek("+msec+"): "+getPerfString());

+ }

+ if( null != streamWorker ) {

+ streamWorker.doResume();

+ }

+ state = _state;

+ break;

+ default:

+ pts1 = 0;

+ }

+ if(DEBUG) { System.err.println("Seek("+msec+"): "+preState+" -> "+state+", "+toString()); }

+ return pts1;

+

+ @Override

+ public final float getPlaySpeed() {

+ return playSpeed;

+ }

+

+ @Override

+ public final boolean setPlaySpeed(float rate) {

+ synchronized( stateLock ) {

+ final float preSpeed = playSpeed;

+ boolean res = false;

+ if(State.Uninitialized != state ) {

+ if( rate > 0.01f ) {

+ if( Math.abs(1.0f - rate) < 0.01f ) {

+ rate = 1.0f;

+ if( setPlaySpeedImpl(rate) ) {

+ resetAVPTS();

+ playSpeed = rate;

+ res = true;

+ if(DEBUG) { System.err.println("setPlaySpeed("+rate+"): "+state+", "+preSpeed+" -> "+playSpeed+", "+toString()); }

+ return res;

+ }

+ }

+ /**

+ * Override if not using AudioSink, or AudioSink's {@link AudioSink#setPlaySpeed(float)} is not sufficient!

+ * <p>

+ * AudioSink shall respect <code>!audioSinkPlaySpeedSet</code> to determine data_size

+ * at {@link AudioSink#enqueueData(com.jogamp.opengl.util.av.AudioSink.AudioFrame)}.

+ * </p>

+ */

+ protected boolean setPlaySpeedImpl(float rate) {

+ if( null != audioSink ) {

+ audioSinkPlaySpeedSet = audioSink.setPlaySpeed(rate);

+ }

+ // still true, even if audioSink rejects command since we deal w/ video sync

+ // and AudioSink w/ audioSinkPlaySpeedSet at enqueueData(..).

+ return true;

+ }

+

+ @Override

+ public final float getAudioVolume() {

+ getAudioVolumeImpl();

+ return audioVolume;

+ }

+ /**

+ * Override if not using AudioSink, or AudioSink's {@link AudioSink#getVolume()} is not sufficient!

+ */

+ protected void getAudioVolumeImpl() {

+ if( null != audioSink ) {

+ audioVolume = audioSink.getVolume();

+ }

+ }

+

+ @Override

+ public boolean setAudioVolume(float v) {

+ synchronized( stateLock ) {

+ final float preVolume = audioVolume;

+ boolean res = false;

+ if(State.Uninitialized != state ) {

+ if( Math.abs(v) < 0.01f ) {

+ v = 0.0f;

+ } else if( Math.abs(1.0f - v) < 0.01f ) {

+ v = 1.0f;

+ }

+ if( setAudioVolumeImpl(v) ) {

+ audioVolume = v;

+ res = true;

+ }

+ }

+ if(DEBUG) { System.err.println("setAudioVolume("+v+"): "+state+", "+preVolume+" -> "+audioVolume+", "+toString()); }

+ return res;

+ * Override if not using AudioSink, or AudioSink's {@link AudioSink#setVolume(float)} is not sufficient!

+ */

+ protected boolean setAudioVolumeImpl(float v) {

+ if( null != audioSink ) {

+ return audioSink.setVolume(v);

+ }

+ // still true, even if audioSink rejects command ..

+ return true;

+ }

+

+ @Override

+ public final void initStream(URI streamLoc, final int vid, final int aid, int reqTextureCount) throws IllegalStateException, IllegalArgumentException {

+ synchronized( stateLock ) {

+ if(State.Uninitialized != state) {

+ throw new IllegalStateException("Instance not in state unintialized: "+this);

+ }

+ if(null == streamLoc) {

+ throw new IllegalArgumentException("streamLock is null");

+ }

+ if( STREAM_ID_NONE != vid ) {

+ textureCount = validateTextureCount(reqTextureCount);

+ if( textureCount < TEXTURE_COUNT_MIN ) {

+ throw new InternalError("Validated texture count < "+TEXTURE_COUNT_MIN+": "+textureCount);

+ }

+ } else {

+ textureCount = 0;

+ }

+ decodedFrameCount = 0;

+ presentedFrameCount = 0;

+ displayedFrameCount = 0;

+ nullFrameCount = 0;

+ maxNullFrameCountUntilEOS = MAX_FRAMELESS_UNTIL_EOS_DEFAULT;

+ this.streamLoc = streamLoc;

+

+ // Pre-parse for camera-input scheme

+ cameraPath = null;

+ cameraProps = null;

+ final String streamLocScheme = streamLoc.getScheme();

+ if( null != streamLocScheme && streamLocScheme.equals(CameraInputScheme) ) {

+ final String rawPath = streamLoc.getRawPath();

+ if( null != rawPath && rawPath.length() > 0 ) {

+ // cut-off root fwd-slash

+ cameraPath = rawPath.substring(1);

+ final URIQueryProps props = URIQueryProps.create(streamLoc, ';');

+ cameraProps = props.getProperties();

+ } else {

+ throw new IllegalArgumentException("Camera path is empty: "+streamLoc.toString());

+ }

+ }

+

+ this.vid = vid;

+ this.aid = aid;

+ if ( this.streamLoc != null ) {

+ new Thread() {

+ public void run() {

+ try {

+ // StreamWorker may be used, see API-doc of StreamWorker

+ initStreamImpl(vid, aid);

+ } catch (Throwable t) {

+ streamErr = new StreamException(t.getClass().getSimpleName()+" while initializing: "+GLMediaPlayerImpl.this.toString(), t);

+ changeState(GLMediaEventListener.EVENT_CHANGE_ERR, GLMediaPlayer.State.Uninitialized);

+ } // also initializes width, height, .. etc

+ }

+ }.start();

+ }

+ }

+ }

+ /**

+ * Implementation shall set the following set of data here

+ * @see #vid

+ * @see #aid

+ * @see #videoFrames

+ * @see #audioFrames

+ protected abstract void initStreamImpl(int vid, int aid) throws Exception;

+

+ @Override

+ public final StreamException getStreamException() {

+ final StreamException e;

+ synchronized( stateLock ) {

+ e = streamErr;

+ streamErr = null;

+ }

+ return e;

+

+ @Override

+ public final void initGL(GL gl) throws IllegalStateException, StreamException, GLException {

+ synchronized( stateLock ) {

+ if(State.Initialized != state ) {

+ throw new IllegalStateException("Stream not in state initialized: "+this);

+ }

+ if( null != streamWorker ) {

+ final StreamException streamInitErr = getStreamException();

+ if( null != streamInitErr ) {

+ streamWorker = null; // already terminated!

+ destroy(null);

+ throw streamInitErr;

+ }

+ }

+ try {

+ if( STREAM_ID_NONE != vid ) {

+ removeAllTextureFrames(gl);

+ initGLImpl(gl);

+ if(DEBUG) {

+ System.err.println("initGLImpl.X "+this);

+ }

+ videoFramesOrig = createTexFrames(gl, textureCount);

+ if( TEXTURE_COUNT_MIN == textureCount ) {

+ videoFramesFree = null;

+ videoFramesDecoded = null;

+ lastFrame = videoFramesOrig[0];

+ } else {

+ videoFramesFree = new LFRingbuffer<TextureFrame>(videoFramesOrig);

+ videoFramesDecoded = new LFRingbuffer<TextureFrame>(TextureFrame[].class, textureCount);

+ lastFrame = videoFramesFree.getBlocking( );

+ }

+ if( null != streamWorker ) {

+ streamWorker.initGL(gl);

+ }

+ } else {

+ removeAllTextureFrames(null);

+ initGLImpl(null);

+ setTextureFormat(-1, -1);

+ setTextureType(-1);

+ videoFramesOrig = null;

+ videoFramesFree = null;

+ videoFramesDecoded = null;

+ lastFrame = null;

+ }

+ changeState(0, State.Paused);

+ } catch (Throwable t) {

+ destroyImpl(gl, GLMediaEventListener.EVENT_CHANGE_ERR); // -> GLMediaPlayer.State.Uninitialized

+ throw new GLException("Error initializing GL resources", t);

+ }

+ }

+ }

+ /**

+ * Shall initialize all GL related resources, if not audio-only.

+ * <p>

+ * Shall also take care of {@link AudioSink} initialization if appropriate.

+ * </p>

+ * @param gl null for audio-only, otherwise a valid and current GL object.

+ * @throws IOException

+ * @throws GLException

+ */

+ protected abstract void initGLImpl(GL gl) throws IOException, GLException;

+

+ /**

+ * Returns the validated number of textures to be handled.

+ * <p>

+ * Default is {@link #TEXTURE_COUNT_DEFAULT} minimum textures, if <code>desiredTextureCount</code>

+ * is < {@link #TEXTURE_COUNT_MIN}, {@link #TEXTURE_COUNT_MIN} is returned.

+ * </p>

+ * <p>

+ * Implementation must at least return a texture count of {@link #TEXTURE_COUNT_MIN}, <i>two</i>, the last texture and the decoding texture.

+ * </p>

+ */

+ protected int validateTextureCount(int desiredTextureCount) {

+ return desiredTextureCount < TEXTURE_COUNT_MIN ? TEXTURE_COUNT_MIN : desiredTextureCount;

+ }

+

+ protected TextureFrame[] createTexFrames(GL gl, final int count) {

+ final int[] texNames = new int[count];

+ gl.glGenTextures(count, texNames, 0);

+ final int err = gl.glGetError();

+ if( GL.GL_NO_ERROR != err ) {

+ throw new RuntimeException("TextureNames creation failed (num: "+count+"): err "+toHexString(err));

+ }

+ final TextureFrame[] texFrames = new TextureFrame[count];

+ for(int i=0; i<count; i++) {

+ texFrames[i] = createTexImage(gl, texNames[i]);

+ }

+ return texFrames;

+ }

+ protected abstract TextureFrame createTexImage(GL gl, int texName);

+

+ protected final Texture createTexImageImpl(GL gl, int texName, int tWidth, int tHeight) {

+ if( 0 > texName ) {

+ throw new RuntimeException("TextureName "+toHexString(texName)+" invalid.");

+ gl.glBindTexture(textureTarget, texName);

+ throw new RuntimeException("Couldn't bind textureName "+toHexString(texName)+" to 2D target, err "+toHexString(err));

+ textureInternalFormat, // internal format

+ tWidth, // width

+ tHeight, // height

+ throw new RuntimeException("Couldn't create TexImage2D RGBA "+tWidth+"x"+tHeight+", target "+toHexString(textureTarget)+

+ ", ifmt "+toHexString(textureInternalFormat)+", fmt "+toHexString(textureFormat)+", type "+toHexString(textureType)+

+ ", err "+toHexString(err));

+ ", ifmt "+toHexString(textureInternalFormat)+", fmt "+toHexString(textureFormat)+", type "+toHexString(textureType));

+ gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_MAG_FILTER, texMinMagFilter[1]);

+

+ return com.jogamp.opengl.util.texture.TextureIO.newTexture(

+ texName, textureTarget,

+ !isInGLOrientation);

+ }

+

+ protected void destroyTexFrame(GL gl, TextureFrame frame) {

+ frame.getTexture().destroy(gl);

+ }

+

+ @Override

+ public final TextureFrame getLastTexture() throws IllegalStateException {

+ if( State.Paused != state && State.Playing != state ) {

+ throw new IllegalStateException("Instance not paused or playing: "+this);

+ }

+ return lastFrame;

+ }

+

+ private final void removeAllTextureFrames(GL gl) {

+ final TextureFrame[] texFrames = videoFramesOrig;

+ videoFramesOrig = null;

+ videoFramesFree = null;

+ videoFramesDecoded = null;

+ lastFrame = null;

+ if( null != texFrames ) {

+ for(int i=0; i<texFrames.length; i++) {

+ final TextureFrame frame = texFrames[i];

+ if(null != frame) {

+ if( null != gl ) {

+ destroyTexFrame(gl, frame);

+ }

+ if( DEBUG ) {

+ System.err.println(Thread.currentThread().getName()+"> Clear TexFrame["+i+"]: "+frame+" -> null");

+ }

+ }

+ }

+ }

+

+ protected TextureFrame cachedFrame = null;

+ protected long lastTimeMillis = 0;

+

+ private final boolean[] stGotVFrame = { false };

+

+ @Override

+ public final TextureFrame getNextTexture(GL gl) throws IllegalStateException {

+ synchronized( stateLock ) {

+ if( State.Paused != state && State.Playing != state ) {

+ throw new IllegalStateException("Instance not paused or playing: "+this);

+ }

+ if(State.Playing == state) {

+ boolean dropFrame = false;

+ try {

+ do {

+ final boolean droppedFrame;

+ if( dropFrame ) {

+ presentedFrameCount--;

+ dropFrame = false;

+ droppedFrame = true;

+ } else {

+ droppedFrame = false;

+ }

+ final boolean playCached = null != cachedFrame;

+ final int video_pts;

+ final boolean hasVideoFrame;

+ TextureFrame nextFrame;

+ if( playCached ) {

+ nextFrame = cachedFrame;

+ cachedFrame = null;

+ presentedFrameCount--;

+ video_pts = nextFrame.getPTS();

+ hasVideoFrame = true;

+ } else {

+ if( null != videoFramesDecoded ) {

+ // multi-threaded and video available

+ nextFrame = videoFramesDecoded.get();

+ if( null != nextFrame ) {

+ video_pts = nextFrame.getPTS();

+ hasVideoFrame = true;

+ } else {

+ video_pts = TimeFrameI.INVALID_PTS;

+ hasVideoFrame = false;

+ }

+ } else {

+ // single-threaded or audio-only

+ video_pts = getNextSingleThreaded(gl, lastFrame, stGotVFrame);

+ nextFrame = lastFrame;

+ hasVideoFrame = stGotVFrame[0];

+ }

+ }

+ final long currentTimeMillis = Platform.currentTimeMillis();

+

+ if( TimeFrameI.END_OF_STREAM_PTS == video_pts ||

+ ( duration > 0 && duration <= video_pts ) || maxNullFrameCountUntilEOS <= nullFrameCount )

+ {

+ // EOS

+ if( DEBUG ) {

+ System.err.println( "AV-EOS (getNextTexture): EOS_PTS "+(TimeFrameI.END_OF_STREAM_PTS == video_pts)+", "+this);

+ }

+ pauseImpl(true, GLMediaEventListener.EVENT_CHANGE_EOS);

+

+ } else if( TimeFrameI.INVALID_PTS == video_pts ) { // no audio or video frame

+ if( null == videoFramesDecoded || !videoFramesDecoded.isEmpty() ) {

+ nullFrameCount++;

+ }

+ if( DEBUG ) {

+ final int audio_pts = getAudioPTSImpl();

+ final int audio_scr = (int) ( ( currentTimeMillis - audio_scr_t0 ) * playSpeed );

+ final int d_apts;

+ if( audio_pts != TimeFrameI.INVALID_PTS ) {

+ d_apts = audio_pts - audio_scr;

+ } else {

+ d_apts = 0;

+ }

+ final int video_scr = video_scr_pts + (int) ( ( currentTimeMillis - video_scr_t0 ) * playSpeed );

+ final int d_vpts = video_pts - video_scr;

+ System.err.println( "AV~: dT "+(currentTimeMillis-lastTimeMillis)+", nullFrames "+nullFrameCount+

+ getPerfStringImpl( video_scr, video_pts, d_vpts, audio_scr, audio_pts, d_apts, 0 ) + ", droppedFrame "+droppedFrame);

+ }

+ } else { // valid pts: has audio or video frame

+ nullFrameCount=0;

+

+ if( hasVideoFrame ) { // has video frame

+ presentedFrameCount++;

+

+ final int audio_pts = getAudioPTSImpl();

+ final int audio_scr = (int) ( ( currentTimeMillis - audio_scr_t0 ) * playSpeed );

+ final int d_apts;

+ if( audio_pts != TimeFrameI.INVALID_PTS ) {

+ d_apts = audio_pts - audio_scr;

+ } else {

+ d_apts = 0;

+ }

+

+ final int frame_period_last = video_pts - video_pts_last; // rendering loop interrupted ?

+ if( videoSCR_reset || frame_period_last > frame_duration*10 ) {

+ videoSCR_reset = false;

+ video_scr_t0 = currentTimeMillis;

+ video_scr_pts = video_pts;

+ }

+ final int video_scr = video_scr_pts + (int) ( ( currentTimeMillis - video_scr_t0 ) * playSpeed );

+ final int d_vpts = video_pts - video_scr;

+ // final int d_avpts = d_vpts - d_apts;

+ if( -VIDEO_DPTS_MAX > d_vpts || d_vpts > VIDEO_DPTS_MAX ) {

+ // if( -VIDEO_DPTS_MAX > d_avpts || d_avpts > VIDEO_DPTS_MAX ) {

+ if( DEBUG ) {

+ System.err.println( "AV*: dT "+(currentTimeMillis-lastTimeMillis)+", "+

+ getPerfStringImpl( video_scr, video_pts, d_vpts, audio_scr, audio_pts, d_apts, 0 ) + ", "+nextFrame+", playCached " + playCached+ ", dropFrame "+dropFrame);

+ }

+ } else {

+ final int dpy_den = displayedFrameCount > 0 ? displayedFrameCount : 1;

+ final int avg_dpy_duration = ( (int) ( currentTimeMillis - video_scr_t0 ) ) / dpy_den ; // ms/f

+ final int maxVideoDelay = Math.min(avg_dpy_duration, MAXIMUM_VIDEO_ASYNC);

+ video_dpts_count++;

+ // video_dpts_cum = d_avpts + VIDEO_DPTS_COEFF * video_dpts_cum;

+ video_dpts_cum = d_vpts + VIDEO_DPTS_COEFF * video_dpts_cum;

+ final int video_dpts_avg_diff = video_dpts_count >= VIDEO_DPTS_NUM ? getVideoDPTSAvg() : 0;

+ final int dt = (int) ( video_dpts_avg_diff / playSpeed + 0.5f );

+ // final int dt = (int) ( d_vpts / playSpeed + 0.5f );

+ // final int dt = (int) ( d_avpts / playSpeed + 0.5f );

+ final TextureFrame _nextFrame = nextFrame;

+ if( dt > maxVideoDelay ) {

+ cachedFrame = nextFrame;

+ nextFrame = null;

+ } else if ( !droppedFrame && dt < -maxVideoDelay && null != videoFramesDecoded && videoFramesDecoded.size() > 0 ) {

+ // only drop if prev. frame has not been dropped and

+ // frame is too late and one decoded frame is already available.

+ dropFrame = true;

+ }

+ video_pts_last = video_pts;

+ if( DEBUG ) {

+ System.err.println( "AV_: dT "+(currentTimeMillis-lastTimeMillis)+", "+

+ getPerfStringImpl( video_scr, video_pts, d_vpts,

+ audio_scr, audio_pts, d_apts,

+ video_dpts_avg_diff ) +

+ ", avg dpy-fps "+avg_dpy_duration+" ms/f, maxD "+maxVideoDelay+" ms, "+_nextFrame+", playCached " + playCached + ", dropFrame "+dropFrame);

+ }

+ }

+ } // has video frame

+ } // has audio or video frame

+

+ if( null != videoFramesFree && null != nextFrame ) {

+ // Had frame and not single threaded ? (TEXTURE_COUNT_MIN < textureCount)

+ final TextureFrame _lastFrame = lastFrame;

+ lastFrame = nextFrame;

+ if( null != _lastFrame ) {

+ videoFramesFree.putBlocking(_lastFrame);

+ }

+ }

+ lastTimeMillis = currentTimeMillis;

+ } while( dropFrame );

+ } catch (InterruptedException e) {

+ e.printStackTrace();

+ }

+ }

+ displayedFrameCount++;

+ return lastFrame;

+ }

+ }

+ protected void preNextTextureImpl(GL gl) {}

+ protected void postNextTextureImpl(GL gl) {}

+ /**

+ * Process stream until the next video frame, i.e. {@link TextureFrame}, has been reached.

+ * Audio frames, i.e. {@link AudioSink.AudioFrame}, shall be handled in the process.

+ * <p>

+ * Video frames shall be ignored, if {@link #getVID()} is {@link #STREAM_ID_NONE}.

+ * </p>

+ * <p>

+ * Audio frames shall be ignored, if {@link #getAID()} is {@link #STREAM_ID_NONE}.

+ * </p>

+ * <p>

+ * Method may be invoked on the <a href="#streamworker"><i>StreamWorker</i> decoding thread</a>.

+ * </p>

+ * <p>

+ * Implementation shall care of OpenGL synchronization as required, e.g. glFinish()/glFlush()!

+ * </p>

+ * @param gl valid and current GL instance, shall be <code>null</code> for audio only.

+ * @param nextFrame the {@link TextureFrame} to store the video PTS and texture data,

+ * shall be <code>null</code> for audio only.

+ * @return the last processed video PTS value, maybe {@link TimeFrameI#INVALID_PTS} if video frame is invalid or n/a.

+ * Will be {@link TimeFrameI#END_OF_STREAM_PTS} if end of stream reached.

+ */

+ protected abstract int getNextTextureImpl(GL gl, TextureFrame nextFrame);

+

+ protected final int getNextSingleThreaded(final GL gl, final TextureFrame nextFrame, boolean[] gotVFrame) throws InterruptedException {

+ final int pts;

+ if( STREAM_ID_NONE != vid ) {

+ preNextTextureImpl(gl);

+ pts = getNextTextureImpl(gl, nextFrame);

+ postNextTextureImpl(gl);

+ if( TimeFrameI.INVALID_PTS != pts ) {

+ newFrameAvailable(nextFrame, Platform.currentTimeMillis());

+ gotVFrame[0] = true;

+ } else {

+ gotVFrame[0] = false;

+ }

+ } else {

+ // audio only

+ pts = getNextTextureImpl(null, null);

+ gotVFrame[0] = false;

+ }

+ return pts;

+ }

+

+

+ /**

+ * {@inheritDoc}

+ * <p>

+ * Note: All {@link AudioSink} operations are performed from {@link GLMediaPlayerImpl},

+ * i.e. {@link #play()}, {@link #pause(boolean)}, {@link #seek(int)}, {@link #setPlaySpeed(float)}, {@link #getAudioPTS()}.

+ * </p>

+ * <p>

+ * Implementations using an {@link AudioSink} shall write it's instance to {@link #audioSink}

+ * from within their {@link #initStreamImpl(int, int)} implementation.

+ * </p>

+ */

+ @Override

+ public final AudioSink getAudioSink() { return audioSink; }

+

+ /**

+ * To be called from implementation at 1st PTS after start

+ * w/ current pts value in milliseconds.

+ * @param audio_scr_t0

+ */

+ protected void setFirstAudioPTS2SCR(int pts) {

+ if( audioSCR_reset ) {

+ audio_scr_t0 = Platform.currentTimeMillis() - pts;

+ audioSCR_reset = false;

+ }

+ }

+ private void flushAllVideoFrames() {

+ if( null != videoFramesFree ) {

+ videoFramesFree.resetFull(videoFramesOrig);

+ lastFrame = videoFramesFree.get();

+ if( null == lastFrame ) { throw new InternalError("XXX"); }

+ videoFramesDecoded.clear();

+ }

+ cachedFrame = null;

+ }

+ private void resetAVPTSAndFlush() {

+ video_dpts_cum = 0;

+ video_dpts_count = 0;

+ resetAVPTS();

+ flushAllVideoFrames();

+ if( null != audioSink ) {

+ audioSink.flush();

+ }

+ }

+ private void resetAVPTS() {

+ nullFrameCount = 0;

+ presentedFrameCount = 0;

+ displayedFrameCount = 0;

+ decodedFrameCount = 0;

+ audioSCR_reset = true;

+ videoSCR_reset = true;

+ }

+ private final int getVideoDPTSAvg() {

+ return (int) ( video_dpts_cum * (1.0f - VIDEO_DPTS_COEFF) + 0.5f );

+ }

+

+ private final void newFrameAvailable(TextureFrame frame, long currentTimeMillis) {

+ decodedFrameCount++;

+ if( 0 == frame.getDuration() ) { // patch frame duration if not set already

+ frame.setDuration( (int) frame_duration );

+ }

+ synchronized(eventListenersLock) {

+ for(Iterator<GLMediaEventListener> i = eventListeners.iterator(); i.hasNext(); ) {

+ i.next().newFrameAvailable(this, frame, currentTimeMillis);

+ }

+ }

+ }

+

+ /**

+ * After {@link GLMediaPlayerImpl#initStreamImpl(int, int) initStreamImpl(..)} is completed via

+ * {@link GLMediaPlayerImpl#updateAttributes(int, int, int, int, int, int, int, float, int, int, int, String, String) updateAttributes(..)},

+ * the latter decides whether StreamWorker is being used.

+ */

+ class StreamWorker extends Thread {

+ private volatile boolean isRunning = false;

+ private volatile boolean isActive = false;

+ private volatile boolean isBlocked = false;

+

+ private volatile boolean shallPause = true;

+ private volatile boolean shallStop = false;

+

+ private volatile GLContext sharedGLCtx = null;

+ private boolean sharedGLCtxCurrent = false;

+ private GLDrawable dummyDrawable = null;

+

+ /**

+ * Starts this daemon thread,

+ * <p>

+ * This thread pauses after it's started!

+ * </p>

+ **/

+ StreamWorker() {

+ setDaemon(true);

+ synchronized(this) {

+ start();

+ while( !isRunning ) {

+ this.notifyAll(); // wake-up startup-block

+ try {

+ this.wait(); // wait until started

+ } catch (InterruptedException e) {

+ e.printStackTrace();

+ }

+ }

+ }

+ }

+

+ private void makeCurrent(GLContext ctx) {

+ if( GLContext.CONTEXT_NOT_CURRENT >= ctx.makeCurrent() ) {

+ throw new GLException("Couldn't make ctx current: "+ctx);

+ }

+ }

+

+ private void destroySharedGL() {

+ if( null != sharedGLCtx ) {

+ if( sharedGLCtx.isCreated() ) {

+ // Catch dispose GLExceptions by GLEventListener, just 'print' them

+ // so we can continue with the destruction.

+ try {

+ sharedGLCtx.destroy();

+ } catch (GLException gle) {

+ gle.printStackTrace();

+ }

+ }

+ sharedGLCtx = null;

+ }

+ if( null != dummyDrawable ) {

+ final AbstractGraphicsDevice device = dummyDrawable.getNativeSurface().getGraphicsConfiguration().getScreen().getDevice();

+ dummyDrawable.setRealized(false);

+ dummyDrawable = null;

+ device.close();

+ }

+ }

+

+ public final synchronized void initGL(GL gl) {

+ final GLContext glCtx = gl.getContext();

+ final boolean glCtxCurrent = glCtx.isCurrent();

+ final GLProfile glp = gl.getGLProfile();

+ final GLDrawableFactory factory = GLDrawableFactory.getFactory(glp);

+ final AbstractGraphicsDevice device = glCtx.getGLDrawable().getNativeSurface().getGraphicsConfiguration().getScreen().getDevice();

+ dummyDrawable = factory.createDummyDrawable(device, true, glCtx.getGLDrawable().getChosenGLCapabilities(), null); // own device!

+ dummyDrawable.setRealized(true);

+ sharedGLCtx = dummyDrawable.createContext(glCtx);

+ makeCurrent(sharedGLCtx);

+ if( glCtxCurrent ) {

+ makeCurrent(glCtx);

+ } else {

+ sharedGLCtx.release();

+ }

+ }

+ public final synchronized void doPause() {

+ if( isActive ) {

+ shallPause = true;

+ if( Thread.currentThread() != this ) {

+ if( isBlocked && isActive ) {

+ this.interrupt();

+ }

+ while( isActive ) {

+ try {

+ this.wait(); // wait until paused

+ } catch (InterruptedException e) {

+ e.printStackTrace();

+ }

+ }

+ }

+ }

+ }

+ public final synchronized void doResume() {

+ if( isRunning && !isActive ) {

+ shallPause = false;

+ if( Thread.currentThread() != this ) {

+ while( !isActive ) {

+ this.notifyAll(); // wake-up pause-block

+ try {

+ this.wait(); // wait until resumed

+ } catch (InterruptedException e) {

+ e.printStackTrace();

+ }

+ }

+ }

+ }

+ }

+ public final synchronized void doStop() {

+ if( isRunning ) {

+ shallStop = true;

+ if( Thread.currentThread() != this ) {

+ if( isBlocked && isRunning ) {

+ this.interrupt();

+ }

+ while( isRunning ) {

+ this.notifyAll(); // wake-up pause-block (opt)

+ try {

+ this.wait(); // wait until stopped

+ } catch (InterruptedException e) {

+ e.printStackTrace();

+ }

+ }

+ }

+ }

+ }

+ public final boolean isRunning() { return isRunning; }

+ public final boolean isActive() { return isActive; }

+

+ @Override

+ public final void run() {

+ setName(getName()+"-StreamWorker_"+StreamWorkerInstanceId);

+ StreamWorkerInstanceId++;

+

+ synchronized ( this ) {

+ isRunning = true;

+ this.notifyAll(); // wake-up ctor()

+ }

+

+ while( !shallStop ){

+ if( shallPause ) {

+ synchronized ( this ) {

+ if( sharedGLCtxCurrent ) {

+ postNextTextureImpl(sharedGLCtx.getGL());

+ sharedGLCtx.release();

+ }

+ while( shallPause && !shallStop ) {

+ isActive = false;

+ this.notifyAll(); // wake-up doPause()

+ try {

+ this.wait(); // wait until resumed

+ } catch (InterruptedException e) {

+ if( !shallPause ) {

+ e.printStackTrace();

+ }

+ }

+ }

+ if( sharedGLCtxCurrent ) {

+ makeCurrent(sharedGLCtx);

+ preNextTextureImpl(sharedGLCtx.getGL());

+ }

+ isActive = true;

+ this.notifyAll(); // wake-up doResume()

+ }

+ }

+ if( !sharedGLCtxCurrent && null != sharedGLCtx ) {

+ synchronized ( this ) {

+ if( null != sharedGLCtx ) {

+ makeCurrent( sharedGLCtx );

+ preNextTextureImpl(sharedGLCtx.getGL());

+ sharedGLCtxCurrent = true;

+ }

+ if( null == videoFramesFree ) {

+ throw new InternalError("XXX videoFramesFree is null");

+ }

+ }

+ }

+

+ if( !shallStop ) {

+ TextureFrame nextFrame = null;

+ try {

+ isBlocked = true;

+ final GL gl;

+ if( STREAM_ID_NONE != vid ) {

+ nextFrame = videoFramesFree.getBlocking();

+ nextFrame.setPTS( TimeFrameI.INVALID_PTS ); // mark invalid until processed!

+ gl = sharedGLCtx.getGL();

+ } else {

+ gl = null;

+ }

+ isBlocked = false;

+ final int vPTS = getNextTextureImpl(gl, nextFrame);

+ boolean audioEOS = false;

+ if( TimeFrameI.INVALID_PTS != vPTS ) {

+ if( null != nextFrame ) {

+ if( STREAM_WORKER_DELAY > 0 ) {

+ Thread.sleep(STREAM_WORKER_DELAY);

+ }

+ if( !videoFramesDecoded.put(nextFrame) ) {

+ throw new InternalError("XXX: free "+videoFramesFree+", decoded "+videoFramesDecoded+", "+GLMediaPlayerImpl.this);

+ }

+ newFrameAvailable(nextFrame, Platform.currentTimeMillis());

+ nextFrame = null;

+ } else {

+ // audio only

+ if( TimeFrameI.END_OF_STREAM_PTS == vPTS || ( duration > 0 && duration < vPTS ) ) {

+ audioEOS = true;

+ } else {

+ nullFrameCount = 0;

+ }

+ }

+ } else if( null == nextFrame ) {

+ // audio only

+ audioEOS = maxNullFrameCountUntilEOS <= nullFrameCount;

+ if( null == audioSink || 0 == audioSink.getEnqueuedFrameCount() ) {

+ nullFrameCount++;

+ }

+ }

+ if( audioEOS ) {

+ // state transition incl. notification

+ synchronized ( this ) {

+ shallPause = true;

+ isActive = false;

+ this.notifyAll(); // wake-up potential do*()

+ }

+ if( DEBUG ) {

+ System.err.println( "AV-EOS (StreamWorker): EOS_PTS "+(TimeFrameI.END_OF_STREAM_PTS == vPTS)+", "+GLMediaPlayerImpl.this);

+ }

+ pauseImpl(true, GLMediaEventListener.EVENT_CHANGE_EOS);

+ }

+ } catch (InterruptedException e) {

+ isBlocked = false;

+ if( !shallStop && !shallPause ) {

+ streamErr = new StreamException("InterruptedException while decoding: "+GLMediaPlayerImpl.this.toString(), e);

+ }

+ } catch (Throwable t) {

+ streamErr = new StreamException(t.getClass().getSimpleName()+" while decoding: "+GLMediaPlayerImpl.this.toString(), t);

+ } finally {

+ if( null != nextFrame ) { // put back

+ videoFramesFree.put(nextFrame);

+ }

+ if( null != streamErr ) {

+ if( DEBUG ) {

+ final Throwable t = null != streamErr.getCause() ? streamErr.getCause() : streamErr;

+ System.err.println("Caught StreamException: "+t.getMessage());

+ t.printStackTrace();

+ }

+ // state transition incl. notification

+ synchronized ( this ) {

+ shallPause = true;

+ isActive = false;

+ this.notifyAll(); // wake-up potential do*()

+ }

+ pauseImpl(true, GLMediaEventListener.EVENT_CHANGE_ERR);

+ }

+ }

+ }

+ }

+ synchronized ( this ) {

+ if( sharedGLCtxCurrent ) {

+ postNextTextureImpl(sharedGLCtx.getGL());

+ }

+ destroySharedGL();

+ isRunning = false;

+ isActive = false;

+ this.notifyAll(); // wake-up doStop()

+ }

+ }

+ }

+ static int StreamWorkerInstanceId = 0;

+ private volatile StreamWorker streamWorker = null;

+ private volatile StreamException streamErr = null;

+

+ protected final int addStateEventMask(int event_mask, State newState) {

+ if( state != newState ) {

+ switch( newState ) {

+ case Uninitialized:

+ event_mask |= GLMediaEventListener.EVENT_CHANGE_UNINIT;

+ break;

+ case Initialized:

+ event_mask |= GLMediaEventListener.EVENT_CHANGE_INIT;

+ break;

+ case Playing:

+ event_mask |= GLMediaEventListener.EVENT_CHANGE_PLAY;

+ break;

+ case Paused:

+ event_mask |= GLMediaEventListener.EVENT_CHANGE_PAUSE;

+ break;

+ }

+ }

+ return event_mask;

+ }

+

+ protected final void attributesUpdated(int event_mask) {

+ if( 0 != event_mask ) {

+ final long now = Platform.currentTimeMillis();

+ synchronized(eventListenersLock) {

+ for(Iterator<GLMediaEventListener> i = eventListeners.iterator(); i.hasNext(); ) {

+ i.next().attributesChanged(this, event_mask, now);

+ }

+ protected final void changeState(int event_mask, State newState) {

+ event_mask = addStateEventMask(event_mask, newState);

+ if( 0 != event_mask ) {

+ state = newState;

+ attributesUpdated( event_mask );

+ }

+ }

+

+ protected final void updateAttributes(int vid, int aid, int width, int height, int bps_stream,

+ int bps_video, int bps_audio, float fps,

+ int videoFrames, int audioFrames, int duration, String vcodec, String acodec) {

+ final boolean wasUninitialized = state == State.Uninitialized;

+

+ if( wasUninitialized ) {

+ event_mask |= GLMediaEventListener.EVENT_CHANGE_INIT;

+ state = State.Initialized;

+ }

+ if( STREAM_ID_AUTO == vid ) {

+ vid = STREAM_ID_NONE;

+ }

+ if( this.vid != vid ) {

+ event_mask |= GLMediaEventListener.EVENT_CHANGE_VID;

+ this.vid = vid;

+ }

+ if( STREAM_ID_AUTO == vid ) {

+ vid = STREAM_ID_NONE;

+ }

+ if( this.aid != aid ) {

+ event_mask |= GLMediaEventListener.EVENT_CHANGE_AID;

+ this.aid = aid;

+ }

+ }

+ if( 0 != fps ) {

+ this.frame_duration = 1000f / fps;

+ this.maxNullFrameCountUntilEOS = MAX_FRAMELESS_MS_UNTIL_EOS / (int)this.frame_duration;

+ } else {

+ this.frame_duration = 0;

+ this.maxNullFrameCountUntilEOS = MAX_FRAMELESS_UNTIL_EOS_DEFAULT;

+ }

+ if( this.videoFrames != videoFrames || this.audioFrames != audioFrames || this.duration != duration ) {

+ this.videoFrames = videoFrames;

+ this.audioFrames = audioFrames;

+ if( (null!=acodec && acodec.length()>0 && !this.acodec.equals(acodec)) ) {

+ if( wasUninitialized ) {

+ if( null != streamWorker ) {

+ throw new InternalError("XXX: StreamWorker not null - "+this);

+ }

+ if( TEXTURE_COUNT_MIN < textureCount || STREAM_ID_NONE == vid ) { // Enable StreamWorker for 'audio only' as well (Bug 918).

+ streamWorker = new StreamWorker();

+ }

+ if( DEBUG ) {

+ System.err.println("XXX Initialize @ updateAttributes: "+this);

+ attributesUpdated(event_mask);

+

+ protected void setIsGLOriented(boolean isGLOriented) {

+ if( isInGLOrientation != isGLOriented ) {

+ if( DEBUG ) {

+ System.err.println("XXX gl-orient "+isInGLOrientation+" -> "+isGLOriented);

+ isInGLOrientation = isGLOriented;

+ for(int i=0; i<videoFramesOrig.length; i++) {

+ videoFramesOrig[i].getTexture().setMustFlipVertically(!isGLOriented);

+ }

+ attributesUpdated(GLMediaEventListener.EVENT_CHANGE_SIZE);

+

+ public final URI getURI() {

+ return streamLoc;

+ public final int getVID() { return vid; }

+

+ @Override

+ public final int getAID() { return aid; }

+ public final String getVideoCodec() {

+ public final String getAudioCodec() {

+ public final int getVideoFrames() {

+ return videoFrames;

+ }

+

+ @Override

+ public final int getAudioFrames() {

+ return audioFrames;

+ public final int getDuration() {

+

+ public final long getStreamBitrate() {

+ public final int getVideoBitrate() {

+

+ public final int getAudioBitrate() {

+

+ public final float getFramerate() {

+ public final boolean isGLOriented() {

+ return isInGLOrientation;

+ }

+

+ @Override

+ public final int getWidth() {

+ public final int getHeight() {

+ public final String toString() {

+ final float tt = getDuration() / 1000.0f;

+ final String loc = ( null != streamLoc ) ? streamLoc.toString() : "<undefined stream>" ;

+ final int freeVideoFrames = null != videoFramesFree ? videoFramesFree.size() : 0;

+ final int decVideoFrames = null != videoFramesDecoded ? videoFramesDecoded.size() : 0;

+ final int video_scr = video_scr_pts + (int) ( ( Platform.currentTimeMillis() - video_scr_t0 ) * playSpeed );

+ final String camPath = null != cameraPath ? ", camera: "+cameraPath : "";

+ return "GLMediaPlayer["+state+", vSCR "+video_scr+", frames[p "+presentedFrameCount+", d "+decodedFrameCount+", t "+videoFrames+" ("+tt+" s), z "+nullFrameCount+" / "+maxNullFrameCountUntilEOS+"], "+

+ "speed "+playSpeed+", "+bps_stream+" bps, hasSW "+(null!=streamWorker)+

+ ", Texture[count "+textureCount+", free "+freeVideoFrames+", dec "+decVideoFrames+", tagt "+toHexString(textureTarget)+", ifmt "+toHexString(textureInternalFormat)+", fmt "+toHexString(textureFormat)+", type "+toHexString(textureType)+"], "+

+ "Video[id "+vid+", <"+vcodec+">, "+width+"x"+height+", glOrient "+isInGLOrientation+", "+fps+" fps, "+frame_duration+" fdur, "+bps_video+" bps], "+

+ "Audio[id "+aid+", <"+acodec+">, "+bps_audio+" bps, "+audioFrames+" frames], uri "+loc+camPath+"]";

+ }

+

+ @Override

+ public final String getPerfString() {

+ final long currentTimeMillis = Platform.currentTimeMillis();

+ final int video_scr = video_scr_pts + (int) ( ( currentTimeMillis - video_scr_t0 ) * playSpeed );

+ final int d_vpts = video_pts_last - video_scr;

+ final int audio_scr = (int) ( ( currentTimeMillis - audio_scr_t0 ) * playSpeed );

+ final int audio_pts = getAudioPTSImpl();

+ final int d_apts = audio_pts - audio_scr;

+ return getPerfStringImpl( video_scr, video_pts_last, d_vpts, audio_scr, audio_pts, d_apts, getVideoDPTSAvg() );

+ }

+ private final String getPerfStringImpl(final int video_scr, final int video_pts, final int d_vpts,

+ final int audio_scr, final int audio_pts, final int d_apts,

+ final int video_dpts_avg_diff) {

+ final float tt = getDuration() / 1000.0f;

+ final String audioSinkInfo;

+ final AudioSink audioSink = getAudioSink();

+ if( null != audioSink ) {

+ audioSinkInfo = "AudioSink[frames [p "+audioSink.getEnqueuedFrameCount()+", q "+audioSink.getQueuedFrameCount()+", f "+audioSink.getFreeFrameCount()+", c "+audioSink.getFrameCount()+"], time "+audioSink.getQueuedTime()+", bytes "+audioSink.getQueuedByteCount()+"]";

+ } else {

+ audioSinkInfo = "";

+ }

+ final int freeVideoFrames, decVideoFrames;

+ if( null != videoFramesFree ) {

+ freeVideoFrames = videoFramesFree.size();

+ decVideoFrames = videoFramesDecoded.size();

+ } else {

+ freeVideoFrames = 0;

+ decVideoFrames = 0;

+ }

+ return state+", frames[(p "+presentedFrameCount+", d "+decodedFrameCount+") / "+videoFrames+", "+tt+" s, z "+nullFrameCount+" / "+maxNullFrameCountUntilEOS+"], "+

+ "speed " + playSpeed+", dAV "+( d_vpts - d_apts )+", vSCR "+video_scr+", vpts "+video_pts+", dSCR["+d_vpts+", avrg "+video_dpts_avg_diff+"], "+

+ "aSCR "+audio_scr+", apts "+audio_pts+" ( "+d_apts+" ), "+audioSinkInfo+

+ ", Texture[count "+textureCount+", free "+freeVideoFrames+", dec "+decVideoFrames+"]";

+ public final GLMediaEventListener[] getEventListeners() {

+ private final Object eventListenersLock = new Object();

+

+ @Override

+ public final Object getAttachedObject(String name) {

+ return attachedObjects.get(name);

+ }

+

+ @Override

+ public final Object attachObject(String name, Object obj) {

+ return attachedObjects.put(name, obj);

+ }

+

+ @Override

+ public final Object detachObject(String name) {

+ return attachedObjects.remove(name);

+ }

+

+ private final HashMap<String, Object> attachedObjects = new HashMap<String, Object>();

+ protected static final int getPropIntVal(Map<String, String> props, String key) {

+ final String val = props.get(key);

+ try {

+ return Integer.valueOf(val).intValue();

+ } catch (NumberFormatException nfe) {

+ if(DEBUG) {

+ System.err.println("Not a valid integer for <"+key+">: <"+val+">");

+ }

+ }

+ return 0;

+ }

+}

+package jogamp.opengl.util.av;

+

+import java.nio.ByteBuffer;

+import java.util.Arrays;

+

+import javax.sound.sampled.AudioSystem;

+import javax.sound.sampled.DataLine;

+import javax.sound.sampled.SourceDataLine;

+

+import com.jogamp.opengl.util.av.AudioSink;

+

+/***

+ * JavaSound Audio Sink

+ * <p>

+ * FIXME: Parameterize .. all configs .. best via an init-method, passing requested

+ * audio capabilities

+ * </p>

+ */

+public class JavaSoundAudioSink implements AudioSink {

+

+ // Chunk of audio processed at one time

+ public static final int BUFFER_SIZE = 1000;

+ public static final int SAMPLES_PER_BUFFER = BUFFER_SIZE / 2;

+ private static final boolean staticAvailable;

+

+ // Sample time values

+ // public static final double SAMPLE_TIME_IN_SECS = 1.0 / DEFAULT_SAMPLE_RATE;

+ // public static final double BUFFER_TIME_IN_SECS = SAMPLE_TIME_IN_SECS * SAMPLES_PER_BUFFER;

+

+ private javax.sound.sampled.AudioFormat format;

+ private DataLine.Info info;

+ private SourceDataLine auline;

+ private int bufferCount;

+ private byte [] sampleData = new byte[BUFFER_SIZE];

+ private boolean initialized = false;

+ private AudioSink.AudioFormat chosenFormat = null;

+

+ private volatile boolean playRequested = false;

+ private float volume = 1.0f;

+

+ static {

+ boolean ok = false;

+ try {

+ AudioSystem.getAudioFileTypes();

+ ok = true;

+ } catch (Throwable t) {

+

+ }

+ staticAvailable=ok;

+ }

+

+ @Override

+ public String toString() {

+ return "JavaSoundSink[init "+initialized+", dataLine "+info+", source "+auline+", bufferCount "+bufferCount+

+ ", chosen "+chosenFormat+", jsFormat "+format;

+ }

+

+ @Override

+ public final float getPlaySpeed() { return 1.0f; } // FIXME

+

+ @Override

+ public final boolean setPlaySpeed(float rate) {

+ return false; // FIXME

+ }

+

+ @Override

+ public final float getVolume() {

+ // FIXME

+ return volume;

+ }

+

+ @Override

+ public final boolean setVolume(float v) {

+ // FIXME

+ volume = v;

+ return true;

+ }

+

+ @Override

+ public AudioSink.AudioFormat getPreferredFormat() {

+ return DefaultFormat;

+ }

+

+ @Override

+ public final int getMaxSupportedChannels() {

+ return 2;

+ }

+

+ @Override

+ public final boolean isSupported(AudioSink.AudioFormat format) {

+ return true;

+ }

+

+ @Override

+ public boolean init(AudioSink.AudioFormat requestedFormat, float frameDuration, int initialQueueSize, int queueGrowAmount, int queueLimit) {

+ if( !staticAvailable ) {

+ return false;

+ }

+ // Create the audio format we wish to use

+ format = new javax.sound.sampled.AudioFormat(requestedFormat.sampleRate, requestedFormat.sampleSize, requestedFormat.channelCount, requestedFormat.signed, !requestedFormat.littleEndian);

+

+ // Create dataline info object describing line format

+ info = new DataLine.Info(SourceDataLine.class, format);

+

+ // Clear buffer initially

+ Arrays.fill(sampleData, (byte) 0);

+ try{

+ // Get line to write data to

+ auline = (SourceDataLine) AudioSystem.getLine(info);

+ auline.open(format);

+ auline.start();

+ System.out.println("JavaSound audio sink");

+ initialized=true;

+ chosenFormat = requestedFormat;

+ } catch (Exception e) {

+ initialized=false;

+ }

+ return true;

+ }

+

+ @Override

+ public boolean isPlaying() {

+ return playRequested && auline.isRunning();

+ }

+

+ @Override

+ public void play() {

+ if( null != auline ) {

+ playRequested = true;

+ playImpl();

+ }

+ }

+ private void playImpl() {

+ if( playRequested && !auline.isRunning() ) {

+ auline.start();

+ }

+ }

+

+ @Override

+ public void pause() {

+ if( null != auline ) {

+ playRequested = false;

+ auline.stop();

+ }

+ }

+

+ @Override

+ public void flush() {

+ if( null != auline ) {

+ playRequested = false;

+ auline.stop();

+ auline.flush();

+ }

+ }

+

+ @Override

+ public final int getEnqueuedFrameCount() {

+ return 0; // FIXME

+ }

+

+ @Override

+ public int getFrameCount() {

+ return 1;

+ }

+

+ @Override

+ public int getQueuedFrameCount() {

+ return 0;

+ }

+

+ @Override

+ public boolean isInitialized() {

+ return initialized;

+ }

+

+ @Override

+ public void destroy() {

+ initialized = false;

+ chosenFormat = null;

+ // FIXEM: complete code!

+ }

+

+ @Override

+ public AudioFrame enqueueData(AudioDataFrame audioDataFrame) {

+ int byteSize = audioDataFrame.getByteSize();

+ final ByteBuffer byteBuffer = audioDataFrame.getData();

+ final byte[] bytes = new byte[byteSize];

+ final int p = byteBuffer.position();

+ byteBuffer.get(bytes, 0, byteSize);

+ byteBuffer.position(p);

+

+ int written = 0;

+ int len;

+ while (byteSize > 0) {

+ len = auline.write(bytes, written, byteSize);

+ byteSize -= len;

+ written += len;

+ }

+ playImpl();

+ return audioDataFrame;

+ }

+

+ @Override

+ public AudioFrame enqueueData(int pts, ByteBuffer bytes, int byteCount) {

+ return enqueueData(new AudioDataFrame(pts, chosenFormat.getBytesDuration(byteCount), bytes, byteCount));

+ }

+

+ @Override

+ public int getQueuedByteCount() {

+ return auline.getBufferSize() - auline.available();

+ }

+

+ @Override

+ public int getFreeFrameCount() {

+ return auline.available();

+ }

+

+ @Override

+ public int getQueuedTime() {

+ return getQueuedTimeImpl( getQueuedByteCount() );

+ }

+ private final int getQueuedTimeImpl(int byteCount) {

+ final int bytesPerSample = chosenFormat.sampleSize >>> 3; // /8

+ return byteCount / ( chosenFormat.channelCount * bytesPerSample * ( chosenFormat.sampleRate / 1000 ) );

+ }

+

+ @Override

+ public final int getPTS() { return 0; } // FIXME

+}

+package jogamp.opengl.util.av;

+

+

+import java.nio.ByteBuffer;

+

+import com.jogamp.opengl.util.av.AudioSink;

+

+public class NullAudioSink implements AudioSink {

+

+ @Override

+ public boolean isInitialized() {

+ return true;

+ }

+

+ private volatile float playSpeed = 1.0f;

+ private volatile boolean playRequested = false;

+ private float volume = 1.0f;

+

+ @Override

+ public final float getPlaySpeed() { return playSpeed; }

+

+ @Override

+ public final boolean setPlaySpeed(float rate) {

+ if( Math.abs(1.0f - rate) < 0.01f ) {

+ rate = 1.0f;

+ }

+ playSpeed = rate;

+ return true;

+ }

+

+ @Override

+ public final float getVolume() {

+ // FIXME

+ return volume;

+ }

+

+ @Override

+ public final boolean setVolume(float v) {

+ // FIXME

+ volume = v;

+ return true;

+ }

+

+ @Override

+ public AudioFormat getPreferredFormat() {

+ return DefaultFormat;

+ }

+

+ @Override

+ public final int getMaxSupportedChannels() {

+ return 8;

+ }

+

+ @Override

+ public final boolean isSupported(AudioFormat format) {

+ return true;

+ }

+

+ @Override

+ public boolean init(AudioFormat requestedFormat, float frameDuration, int initialQueueSize, int queueGrowAmount, int queueLimit) {

+ return true;

+ }

+

+ @Override

+ public boolean isPlaying() {

+ return playRequested;

+ }

+

+ @Override

+ public void play() {

+ playRequested = true;

+ }

+

+ @Override

+ public void pause() {

+ playRequested = false;

+ }

+

+ @Override

+ public void flush() {

+ }

+

+ @Override

+ public void destroy() {

+ }

+

+ @Override

+ public final int getEnqueuedFrameCount() {

+ return 0;

+ }

+

+ @Override

+ public int getFrameCount() {

+ return 0;

+ }

+

+ @Override

+ public int getQueuedFrameCount() {

+ return 0;

+ }

+

+ @Override

+ public int getQueuedByteCount() {

+ return 0;

+ }

+

+ @Override

+ public int getQueuedTime() {

+ return 0;

+ }

+

+ @Override

+ public final int getPTS() { return 0; }

+

+ @Override

+ public int getFreeFrameCount() {

+ return 1;

+ }

+

+ @Override

+ public AudioFrame enqueueData(AudioDataFrame audioDataFrame) {

+ return null;

+ }

+

+ @Override

+ public AudioFrame enqueueData(int pts, ByteBuffer bytes, int byteCount) {

+ return null;

+ }

+}

+ *

+ *

+ *

+ *

+import javax.media.opengl.GLException;

+import com.jogamp.common.os.Platform;

+import com.jogamp.opengl.util.av.GLMediaPlayer;

+ private long pos_start = 0;

+

+

+ protected final boolean setPlaySpeedImpl(float rate) {

+ protected final boolean playImpl() {

+ pos_start = Platform.currentTimeMillis();

+ protected final boolean pauseImpl() {

+ protected final int seekImpl(int msec) {

+ protected final int getNextTextureImpl(GL gl, TextureFrame nextFrame) {

+ final int pts = getAudioPTSImpl();

+ nextFrame.setPTS( pts );

+ return pts;

+

+ protected final int getAudioPTSImpl() {

+ pos_ms = (int) ( Platform.currentTimeMillis() - pos_start );

+ protected final void destroyImpl(GL gl) {

+ if(null != texData) {

+ texData.destroy();

+ texData = null;

+ }

+

+ public final static TextureData createTestTextureData() {

+ TextureData res = null;

+ URLConnection urlConn = IOUtil.getResource("jogl/util/data/av/test-ntsc01-57x32.png", NullGLMediaPlayer.class.getClassLoader());

+ res = TextureIO.newTextureData(GLProfile.getGL2ES2(), urlConn.getInputStream(), false, TextureIO.PNG);

+ if(null == res) {

+ final int w = 160;

+ final int h = 90;

+ ByteBuffer buffer = Buffers.newDirectByteBuffer(w*h*4);

+ res = new TextureData(GLProfile.getGL2ES2(),

+ GL.GL_RGBA, w, h, 0,

+ GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, false,

+ return res;

+ }

+

+ @Override

+ protected final void initStreamImpl(int vid, int aid) throws IOException {

+ texData = createTestTextureData();

+ final float _fps = 24f;

+ final int _duration = 10*60*1000; // msec

+ final int _totalFrames = (int) ( (_duration/1000)*_fps );

+ updateAttributes(0 /* fake */, GLMediaPlayer.STREAM_ID_NONE,

+ texData.getWidth(), texData.getHeight(), 0,

+ 0, 0, _fps,

+ _totalFrames, 0, _duration, "png-static", null);

+ }

+ @Override

+ protected final void initGLImpl(GL gl) throws IOException, GLException {

+ isInGLOrientation = true;

+ }

+

+ /**

+ * {@inheritDoc}

+ * <p>

+ * Returns {@link GLMediaPlayer#TEXTURE_COUNT_MIN}.

+ * </p>

+ */

+ @Override

+ protected int validateTextureCount(int desiredTextureCount) {

+ return TEXTURE_COUNT_MIN;

+

+ protected final TextureSequence.TextureFrame createTexImage(GL gl, int texName) {

+ final Texture texture = super.createTexImageImpl(gl, texName, width, height);

+ }

+ return new TextureSequence.TextureFrame( texture );

+

+ protected final void destroyTexFrame(GL gl, TextureSequence.TextureFrame frame) {

+ super.destroyTexFrame(gl, frame);

+

+ *

+ *

+ *

+ *

+

+import java.security.AccessController;

+import java.security.PrivilegedAction;

+import com.jogamp.common.util.VersionNumber;

+ * See {@link FFMPEGMediaPlayer#compatibility}.

+ private static final boolean DEBUG = FFMPEGMediaPlayer.DEBUG || DynamicLibraryBundleInfo.DEBUG;

+

+ private static final List<String> glueLibNames = new ArrayList<String>(); // none

+

+ private static final int symbolCount = 65;

+ private static final String[] symbolNames = {

+ "avutil_version",

+ "avcodec_version",

+ "avresample_version",

+/* 5 */ "swresample_version",

+

+ "avcodec_register_all",

+ "avcodec_close",

+ "avcodec_string",

+ "avcodec_find_decoder",

+ "avcodec_open2", // 53.6.0 (opt)

+ "avcodec_alloc_frame",

+ "avcodec_get_frame_defaults",

+ "avcodec_free_frame", // 54.28.0 (opt)

+ "avcodec_default_get_buffer", // <= 54 (opt), else sp_avcodec_default_get_buffer2

+ "avcodec_default_release_buffer", // <= 54 (opt), else sp_av_frame_unref

+ "avcodec_default_get_buffer2", // 55 (opt)

+ "avcodec_get_edge_width",

+ "av_image_fill_linesizes",

+ "avcodec_align_dimensions",

+ "avcodec_align_dimensions2",

+ "avcodec_flush_buffers",

+ "av_init_packet",

+ "av_new_packet",

+ "av_destruct_packet",

+ "av_free_packet",

+/* 27 */ "avcodec_decode_video2", // 52.23.0

+

+ "av_pix_fmt_descriptors",

+ "av_frame_unref", // 55.0.0 (opt)

+ "av_realloc",

+ "av_free",

+ "av_get_bits_per_pixel",

+ "av_samples_get_buffer_size",

+ "av_get_bytes_per_sample", // 51.4.0

+ "av_opt_set_int", // 51.12.0

+ "av_dict_get",

+ "av_dict_count", // 54.* (opt)

+ "av_dict_set",

+/* 28 */ "av_dict_free",

+

+ "av_register_all",

+ "av_find_input_format",

+ "avformat_open_input",

+ "av_dump_format",

+ "avformat_seek_file", // ??? (opt)

+ "av_read_play",

+ "av_read_pause",

+/* 54 */ "avformat_find_stream_info", // 53.3.0 (opt)

+

+ // libavdevice

+/* 55 */ "avdevice_register_all", // ???

+

+ // libavresample

+ "avresample_alloc_context", // 1.0.1

+ "avresample_open",

+ "avresample_close",

+ "avresample_free",

+/* 60 */ "avresample_convert",

+

+ // libavresample

+ "av_opt_set_sample_fmt", // actually lavu .. but exist only w/ swresample!

+ "swr_alloc",

+ "swr_init",

+ "swr_free",

+/* 65 */ "swr_convert",

+

+

+ private static final String[] optionalSymbolNames = {

+ "avformat_seek_file", // ??? (opt)

+ "avcodec_free_frame", // 54.28.0 (opt)

+ "av_frame_unref", // 55.0.0 (opt)

+ "av_dict_count", // 54.* (opt)

+ "avcodec_default_get_buffer", // <= 54 (opt), else sp_avcodec_default_get_buffer2

+ "avcodec_default_release_buffer", // <= 54 (opt), else sp_av_frame_unref

+ "avcodec_default_get_buffer2", // 55 (opt)

+

+ // libavdevice

+ "avdevice_register_all", // 53.0.0 (opt)

+

+ // libavresample

+ "avresample_version", // 1.0.1

+ "avresample_alloc_context", // 1.0.1

+ "avresample_open",

+ "avresample_close",

+ "avresample_free",

+ "avresample_convert",

+

+ // libavresample

+ "av_opt_set_sample_fmt", // actually lavu .. but exist only w/ swresample!

+ "swresample_version", // 0

+ "swr_alloc",

+ "swr_init",

+ "swr_free",

+ "swr_convert",

+

+ private static final long[] symbolAddr = new long[symbolCount];

+ private static final boolean libsUFCLoaded;

+ private static final boolean avresampleLoaded; // optional

+ private static final boolean swresampleLoaded; // optional

+ private static final boolean avdeviceLoaded; // optional

+ static final VersionNumber avCodecVersion;

+ static final VersionNumber avFormatVersion;

+ static final VersionNumber avUtilVersion;

+ static final VersionNumber avResampleVersion;

+ static final VersionNumber swResampleVersion;

+ private static final FFMPEGNatives natives;

+

+ private static final int LIB_IDX_UTI = 0;

+ private static final int LIB_IDX_FMT = 1;

+ private static final int LIB_IDX_COD = 2;

+ private static final int LIB_IDX_DEV = 3;

+ private static final int LIB_IDX_AVR = 4;

+ private static final int LIB_IDX_SWR = 5;

+

+ // native ffmpeg media player implementation is included in jogl_desktop and jogl_mobile

+ /** util, format, codec, device, avresample, swresample */

+ boolean[] _loaded= new boolean[6];

+ /** util, format, codec, avresample, swresample */

+ VersionNumber[] _versions = new VersionNumber[5];

+ _ready = initSymbols(_loaded, _versions);

+ libsUFCLoaded = _loaded[LIB_IDX_UTI] && _loaded[LIB_IDX_FMT] && _loaded[LIB_IDX_COD];

+ avdeviceLoaded = _loaded[LIB_IDX_DEV];

+ avresampleLoaded = _loaded[LIB_IDX_AVR];

+ swresampleLoaded = _loaded[LIB_IDX_SWR];

+ avUtilVersion = _versions[0];

+ avFormatVersion = _versions[1];

+ avCodecVersion = _versions[2];

+ avResampleVersion = _versions[3];

+ swResampleVersion = _versions[4];

+ if(!libsUFCLoaded) {

+ System.err.println("LIB_AV Not Available: lavu, lavc, lavu");

+ natives = null;

+ ready = false;

+ } else if(!_ready) {

+ System.err.println("LIB_AV Not Matching");

+ natives = null;

+ ready = false;

+ } else {

+ if( avCodecVersion.getMajor() == 53 && avFormatVersion.getMajor() == 53 && avUtilVersion.getMajor() == 51 ) {

+ // lavc53.lavf53.lavu51

+ natives = new FFMPEGv08Natives();

+ } else if( avCodecVersion.getMajor() == 54 && avFormatVersion.getMajor() == 54 && avUtilVersion.getMajor() == 52 ) {

+ // lavc54.lavf54.lavu52.lavr01

+ natives = new FFMPEGv09Natives();

+ } else if( avCodecVersion.getMajor() == 55 && avFormatVersion.getMajor() == 55 && avUtilVersion.getMajor() == 52 ) {

+ // lavc55.lavf55.lavu52.lavr01

+ natives = new FFMPEGv10Natives();

+ } else {

+ System.err.println("LIB_AV No Version/Native-Impl Match");

+ natives = null;

+ }

+ if( null != natives && FFMPEGStaticNatives.initIDs0() ) {

+ ready = natives.initSymbols0(symbolAddr, symbolCount);

+ } else {

+ ready = false;

+ }

+

+ static boolean libsLoaded() { return libsUFCLoaded; }

+ static boolean avDeviceLoaded() { return avdeviceLoaded; }

+ static boolean avResampleLoaded() { return avresampleLoaded; }

+ static boolean swResampleLoaded() { return swresampleLoaded; }

+ static FFMPEGNatives getNatives() { return natives; }

+

+ /**

+ * @param loaded 6: util, format, codec, device, avresample, swresample

+ * @param versions 5: util, format, codec, avresample, swresample

+ * @return

+ */

+ private static final boolean initSymbols(boolean[] loaded, VersionNumber[] versions) {

+ for(int i=0; i<6; i++) {

+ loaded[i] = false;

+ }

+ final DynamicLibraryBundle dl = AccessController.doPrivileged(new PrivilegedAction<DynamicLibraryBundle>() {

+ @Override

+ public DynamicLibraryBundle run() {

+ return new DynamicLibraryBundle(new FFMPEGDynamicLibraryBundleInfo());

+ } } );

+ dl.toString();

+ for(int i=0; i<6; i++) {

+ loaded[i] = dl.isToolLibLoaded(i);

+ }

+ if( !loaded[LIB_IDX_UTI] || !loaded[LIB_IDX_FMT] || !loaded[LIB_IDX_COD] ) {

+ throw new RuntimeException("FFMPEG Tool library incomplete: [ avutil "+loaded[LIB_IDX_UTI]+", avformat "+loaded[LIB_IDX_FMT]+", avcodec "+loaded[LIB_IDX_COD]+"]");

+

+

+ AccessController.doPrivileged(new PrivilegedAction<Object>() {

+ @Override

+ public Object run() {

+ for(int i = 0; i<symbolCount; i++) {

+ symbolAddr[i] = dl.dynamicLookupFunction(symbolNames[i]);

+ }

+ return null;

+ } } );

+

+ boolean res = true;

+ System.err.println("Fail: Could not resolve symbol <"+symbolNames[i]+">: not optional, no alternatives.");

+ res = false;

+ } else if(DEBUG) {

+ versions[0] = FFMPEGStaticNatives.getAVVersion(FFMPEGStaticNatives.getAvVersion0(symbolAddr[0]));

+ versions[1] = FFMPEGStaticNatives.getAVVersion(FFMPEGStaticNatives.getAvVersion0(symbolAddr[1]));

+ versions[2] = FFMPEGStaticNatives.getAVVersion(FFMPEGStaticNatives.getAvVersion0(symbolAddr[2]));

+ versions[3] = FFMPEGStaticNatives.getAVVersion(FFMPEGStaticNatives.getAvVersion0(symbolAddr[3]));

+ versions[4] = FFMPEGStaticNatives.getAVVersion(FFMPEGStaticNatives.getAvVersion0(symbolAddr[4]));

+

+ return res;

+

+ public final boolean shallLinkGlobal() { return true; }

+ /**

+ * {@inheritDoc}

+ * <p>

+ * Returns <code>true</code>.

+ * </p>

+ */

+ public final boolean shallLookupGlobal() {

+ return true;

+ }

+

+ public final List<List<String>> getToolLibNames() {

+ // 6: util, format, codec, device, avresample, swresample

+

+

+ avutil.add("libavutil.so.53"); // dummy future proof

+ avutil.add("libavutil.so.52"); // ffmpeg 1.2 + 2 / libav 9 + 10

+ avutil.add("libavutil.so.51"); // 0.8

+ avutil.add("libavutil.so.50"); // 0.7

+

+ avutil.add("avutil-53"); // dummy future proof

+ avutil.add("avutil-52"); // ffmpeg 1.2 + 2 / libav 9 + 10

+

+

+ avformat.add("libavformat.so.56"); // dummy future proof

+ avformat.add("libavformat.so.55"); // ffmpeg 2 / libav 10

+ avformat.add("libavformat.so.54"); // ffmpeg 1.2 / libav 9

+ avformat.add("libavformat.so.53"); // 0.8

+ avformat.add("libavformat.so.52"); // 0.7

+

+ avformat.add("avformat-56"); // dummy future proof

+ avformat.add("avformat-55"); // ffmpeg 2 / libav 10

+ avformat.add("avformat-54"); // ffmpeg 1.2 / libav 9

+

+

+ avcodec.add("libavcodec.so.56"); // dummy future proof

+ avcodec.add("libavcodec.so.55"); // ffmpeg 2/ libav 10

+ avcodec.add("libavcodec.so.54"); // ffmpeg 1.2 / libav 9

+ avcodec.add("libavcodec.so.53"); // 0.8

+ avcodec.add("libavcodec.so.52"); // 0.7

+

+ avcodec.add("avcodec-56"); // dummy future proof

+ avcodec.add("avcodec-55"); // ffmpeg 2/ libav 10

+ avcodec.add("avcodec-54"); // ffmpeg 1.2 / libav 9

+

+ final List<String> avdevice = new ArrayList<String>();

+ avdevice.add("avdevice"); // default

+

+ avdevice.add("libavdevice.so.56"); // dummy future proof

+ avdevice.add("libavdevice.so.55"); // ffmpeg 2

+ avdevice.add("libavdevice.so.54"); // ffmpeg 1.2 / libav 10

+ avdevice.add("libavdevice.so.53"); // 0.8 && libav 9

+

+ avdevice.add("avdevice-56"); // dummy future proof

+ avdevice.add("avdevice-55"); // ffmpeg 2

+ avdevice.add("avdevice-54"); // ffmpeg 1.2 / libav 10

+ avdevice.add("avdevice-53"); // 0.8 && libav 9

+ libsList.add(avdevice);

+

+ final List<String> avresample = new ArrayList<String>();

+ avresample.add("avresample"); // default

+

+ avresample.add("libavresample.so.2"); // dummy future proof

+ avresample.add("libavresample.so.1"); // libav 9 + 10

+

+ avresample.add("avresample-2"); // dummy future proof

+ avresample.add("avresample-1"); // libav 9 + 10

+ libsList.add(avresample);

+

+ final List<String> swresample = new ArrayList<String>();

+ swresample.add("swresample"); // default

+

+ swresample.add("libswresample.so.1"); // dummy future proof

+ swresample.add("libswresample.so.0"); // ffmpeg 1.2 + 2.x

+

+ swresample.add("swresample-1"); // dummy future proof

+ swresample.add("swresample-0"); // ffmpeg 1.2 + 2.x

+ libsList.add(swresample);

+

+ public final boolean useToolGetProcAdressFirst(String funcName) {

+ public final RunnableExecutor getLibLoaderExecutor() {

+ }

+ *

+ *

+ *

+ *

+import java.security.AccessController;

+import java.security.PrivilegedAction;

+import com.jogamp.common.os.Platform;

+import com.jogamp.common.util.IOUtil;

+import com.jogamp.opengl.util.TimeFrameI;

+import com.jogamp.opengl.util.av.AudioSink;

+import com.jogamp.opengl.util.av.AudioSink.AudioFormat;

+import com.jogamp.opengl.util.av.AudioSinkFactory;

+import com.jogamp.opengl.util.av.GLMediaPlayer;

+import jogamp.opengl.util.av.GLMediaPlayerImpl;

+import jogamp.opengl.util.av.impl.FFMPEGNatives.PixelFormat;

+import jogamp.opengl.util.av.impl.FFMPEGNatives.SampleFormat;

+ * or <a href="http://ffmpeg.org/">FFmpeg</a> which are ubiquitous

+ * available and usually pre-installed on Unix platforms.

+ * <p>

+ * Due to legal reasons we cannot deploy binaries of it, which contains patented codecs.

+ * </p>

+ * <p>

+ * precompiled binaries can be found at the

+ * <a href="#libavavail">listed location below</a>.

+ * </p>

+ *

+ * <a name="implspecifics"><h5>Implementation specifics</h5></a>

+ * The decoded video frame is written directly into an OpenGL texture

+ * on the GPU in it's native format. A custom fragment shader converts

+ * the native pixelformat to a usable <i>RGB</i> format if required.

+ * Hence only 1 copy is required before bloating the picture

+ * from <i>YUV*</i> to <i>RGB</i>, for example.

+ * </p>

+ * Implements pixel format conversion to <i>RGB</i> via

+ * fragment shader texture-lookup functions:

+ * <ul>

+ * <li>{@link PixelFormat#YUV420P}</li>

+ * <li>{@link PixelFormat#YUVJ420P}</li>

+ * <li>{@link PixelFormat#YUV422P}</li>

+ * <li>{@link PixelFormat#YUVJ422P}</li>

+ * <li>{@link PixelFormat#YUYV422}</li>

+ * <li>{@link PixelFormat#BGR24}</li>

+ * </ul>

+ * </p>

+ * <p>

+ *

+ * <a name="libavspecifics"><h5>Libav Specifics</h5></a>

+ * <p>

+ * Utilizes a slim dynamic and native binding to the Lib_av

+ * <li>libavformat</li>

+ * <li>libavutil</li>

+ * <li>libavresample (opt)</li>

+ * <li>libavdevice (opt)</li>

+ * </ul>

+ * </p>

+ *

+ * <a name="compatibility"><h5>LibAV Compatibility</h5></a>

+ * <p>

+ * Currently we are binary compatible w/:

+ * <table border="1">

+ * <tr><th>libav / ffmpeg</th><th>lavc</th><th>lavf</th><th>lavu</th><th>lavr</th> <th>FFMPEG* class</th></tr>

+ * <tr><td>0.8</td> <td>53</td> <td>53</td> <td>51</td> <td></td> <td>FFMPEGv08</td></tr>

+ * <tr><td>9.0 / 1.2</td> <td>54</td> <td>54</td> <td>52</td> <td>01/00</td> <td>FFMPEGv09</td></tr>

+ * <tr><td>10 / 2</td> <td>55</td> <td>55</td> <td>52</td> <td>01/00</td> <td>FFMPEGv10</td></tr>

+ * </table>

+ * See http://upstream-tracker.org/versions/libav.html

+ * <p>

+ * Check tag 'FIXME: Add more planar formats !'

+ * <code>jogl/src/jogl/native/libav/ffmpeg_impl_template.c</code>

+ *

+ *

+ * <a name="todo"><h5>TODO:</h5></a>

+ * <li>better audio synchronization handling? (video is synchronized)</li>

+ * </ul>

+ *

+ * <a name="libavavail"><h5>FFMPEG / LibAV Availability</h5></a>

+ * <p>

+ * <li>GNU/Linux: ffmpeg or libav are deployed in most distributions.</li>

+ * <li>Windows:

+ * <ul>

+ * <li>http://ffmpeg.zeranoe.com/builds/ (ffmpeg) <i>recommended, works w/ dshow</i></li>

+ * <li>http://win32.libav.org/releases/ (libav)</li>

+ * </ul></li>

+ * <li>MacOSX: http://ffmpegmac.net/</li>

+ * </ul>

+ * </p>

+public class FFMPEGMediaPlayer extends GLMediaPlayerImpl {

+

+ /** POSIX ENOSYS {@value}: Function not implemented. FIXME: Move to GlueGen ?!*/

+ private static final int ENOSYS = 38;

+

+ // Instance data

+ private static final FFMPEGNatives natives;

+ private static final int avUtilMajorVersionCC;

+ private static final int avFormatMajorVersionCC;

+ private static final int avCodecMajorVersionCC;

+ private static final int avResampleMajorVersionCC;

+ private static final int swResampleMajorVersionCC;

+ private static final boolean available;

+

+ final boolean libAVGood = FFMPEGDynamicLibraryBundleInfo.initSingleton();

+ final boolean libAVVersionGood;

+ if( FFMPEGDynamicLibraryBundleInfo.libsLoaded() ) {

+ natives = FFMPEGDynamicLibraryBundleInfo.getNatives();

+ if( null != natives ) {

+ avCodecMajorVersionCC = natives.getAvCodecMajorVersionCC0();

+ avFormatMajorVersionCC = natives.getAvFormatMajorVersionCC0();

+ avUtilMajorVersionCC = natives.getAvUtilMajorVersionCC0();

+ avResampleMajorVersionCC = natives.getAvResampleMajorVersionCC0();

+ swResampleMajorVersionCC = natives.getSwResampleMajorVersionCC0();

+ } else {

+ avUtilMajorVersionCC = 0;

+ avFormatMajorVersionCC = 0;

+ avCodecMajorVersionCC = 0;

+ avResampleMajorVersionCC = 0;

+ swResampleMajorVersionCC = 0;

+ }

+ final VersionNumber avCodecVersion = FFMPEGDynamicLibraryBundleInfo.avCodecVersion;

+ final VersionNumber avFormatVersion = FFMPEGDynamicLibraryBundleInfo.avFormatVersion;

+ final VersionNumber avUtilVersion = FFMPEGDynamicLibraryBundleInfo.avUtilVersion;

+ final VersionNumber avResampleVersion = FFMPEGDynamicLibraryBundleInfo.avResampleVersion;

+ final boolean avResampleLoaded = FFMPEGDynamicLibraryBundleInfo.avResampleLoaded();

+ final VersionNumber swResampleVersion = FFMPEGDynamicLibraryBundleInfo.swResampleVersion;

+ final boolean swResampleLoaded = FFMPEGDynamicLibraryBundleInfo.swResampleLoaded();

+ if( DEBUG ) {

+ System.err.println("LIB_AV Codec : "+avCodecVersion+" [cc "+avCodecMajorVersionCC+"]");

+ System.err.println("LIB_AV Format : "+avFormatVersion+" [cc "+avFormatMajorVersionCC+"]");

+ System.err.println("LIB_AV Util : "+avUtilVersion+" [cc "+avUtilMajorVersionCC+"]");

+ System.err.println("LIB_AV Resample: "+avResampleVersion+" [cc "+avResampleMajorVersionCC+", loaded "+avResampleLoaded+"]");

+ System.err.println("LIB_SW Resample: "+swResampleVersion+" [cc "+swResampleMajorVersionCC+", loaded "+swResampleLoaded+"]");

+ System.err.println("LIB_AV Device : [loaded "+FFMPEGDynamicLibraryBundleInfo.avDeviceLoaded()+"]");

+ System.err.println("LIB_AV Class : "+(null!= natives ? natives.getClass().getSimpleName() : "n/a"));

+ }

+ libAVVersionGood = avCodecMajorVersionCC == avCodecVersion.getMajor() &&

+ avFormatMajorVersionCC == avFormatVersion.getMajor() &&

+ avUtilMajorVersionCC == avUtilVersion.getMajor() &&

+ ( !avResampleLoaded || avResampleMajorVersionCC < 0 || avResampleMajorVersionCC == avResampleVersion.getMajor() ) &&

+ ( !swResampleLoaded || swResampleMajorVersionCC < 0 || swResampleMajorVersionCC == swResampleVersion.getMajor() ) ;

+ if( !libAVVersionGood ) {

+ System.err.println("LIB_AV Not Matching Compile-Time / Runtime Major-Version");

+ }

+ natives = null;

+ avUtilMajorVersionCC = 0;

+ avFormatMajorVersionCC = 0;

+ avCodecMajorVersionCC = 0;

+ avResampleMajorVersionCC = 0;

+ swResampleMajorVersionCC = 0;

+ libAVVersionGood = false;

+ available = libAVGood && libAVVersionGood && null != natives;

+

+ //

+ // General

+ //

+

+ private long moviePtr = 0;

+

+ //

+ // Video

+ //

+

+ private String texLookupFuncName = "ffmpegTexture2D";

+ private boolean usesTexLookupShader = false;

+ private PixelFormat vPixelFmt = null;

+ private int vPlanes = 0;

+ private int vBitsPerPixel = 0;

+ private int vBytesPerPixelPerPlane = 0;

+ private int texWidth, texHeight; // overall (stuffing planes in one texture)

+ private String singleTexComp = "r";

+ private final GLPixelStorageModes psm;

+

+ //

+ // Audio

+ //

+

+ private AudioSink.AudioFormat avChosenAudioFormat;

+ private int audioSamplesPerFrameAndChannel = 0;

+ moviePtr = natives.createInstance0(this, DEBUG_NATIVE);

+ audioSink = null;

+

+ protected final void destroyImpl(GL gl) {

+ if (moviePtr != 0) {

+ natives.destroyInstance0(moviePtr);

+ moviePtr = 0;

+ destroyAudioSink();

+ private final void destroyAudioSink() {

+ final AudioSink _audioSink = audioSink;

+ if( null != _audioSink ) {

+ audioSink = null;

+ _audioSink.destroy();

+ }

+

+ public static final String dev_video_linux = "/dev/video";

+

+ protected final void initStreamImpl(int vid, int aid) throws IOException {

+ if(0==moviePtr) {

+ throw new GLException("FFMPEG native instance null");

+ if(DEBUG) {

+ System.err.println("initStream: p1 "+this);

+ }

+

+ final String streamLocS = IOUtil.decodeURIIfFilePath(streamLoc);

+ destroyAudioSink();

+ if( GLMediaPlayer.STREAM_ID_NONE == aid ) {

+ audioSink = AudioSinkFactory.createNull();

+ } else {

+ audioSink = AudioSinkFactory.createDefault();

+ }

+ final AudioFormat preferredAudioFormat = audioSink.getPreferredFormat();

+ if(DEBUG) {

+ System.err.println("initStream: p2 preferred "+preferredAudioFormat+", "+this);

+ }

+

+ final boolean isCameraInput = null != cameraPath;

+ final String resStreamLocS;

+ // int rw=640, rh=480, rr=15;

+ int rw=-1, rh=-1, rr=-1;

+ String sizes = null;

+ if( isCameraInput ) {

+ switch(Platform.OS_TYPE) {

+ case ANDROID:

+ // ??

+ case FREEBSD:

+ case HPUX:

+ case LINUX:

+ case SUNOS:

+ resStreamLocS = dev_video_linux + cameraPath;

+ break;

+ case WINDOWS:

+ resStreamLocS = cameraPath;

+ break;

+ case MACOS:

+ case OPENKODE:

+ default:

+ resStreamLocS = streamLocS; // FIXME: ??

+ break;

+ }

+ if( null != cameraProps ) {

+ sizes = cameraProps.get(CameraPropSizeS);

+ int v = getPropIntVal(cameraProps, CameraPropWidth);

+ if( v > 0 ) { rw = v; }

+ v = getPropIntVal(cameraProps, CameraPropHeight);

+ if( v > 0 ) { rh = v; }

+ v = getPropIntVal(cameraProps, CameraPropRate);

+ if( v > 0 ) { rr = v; }

+ }

+ } else {

+ resStreamLocS = streamLocS;

+ }

+ final int aMaxChannelCount = audioSink.getMaxSupportedChannels();

+ final int aPrefSampleRate = preferredAudioFormat.sampleRate;

+ // setStream(..) issues updateAttributes*(..), and defines avChosenAudioFormat, vid, aid, .. etc

+ if(DEBUG) {

+ System.err.println("initStream: p3 cameraPath "+cameraPath+", isCameraInput "+isCameraInput);

+ System.err.println("initStream: p3 stream "+streamLoc+" -> "+streamLocS+" -> "+resStreamLocS);

+ System.err.println("initStream: p3 vid "+vid+", sizes "+sizes+", reqVideo "+rw+"x"+rh+"@"+rr+", aid "+aid+", aMaxChannelCount "+aMaxChannelCount+", aPrefSampleRate "+aPrefSampleRate);

+ }

+ natives.setStream0(moviePtr, resStreamLocS, isCameraInput, vid, sizes, rw, rh, rr, aid, aMaxChannelCount, aPrefSampleRate);

+

+ protected final void initGLImpl(GL gl) throws IOException, GLException {

+ if(null == audioSink) {

+ throw new GLException("AudioSink null");

+ }

+ final int audioQueueLimit;

+ if( null != gl && STREAM_ID_NONE != vid ) {

+ final GLContextImpl ctx = (GLContextImpl)gl.getContext();

+ AccessController.doPrivileged(new PrivilegedAction<Object>() {

+ @Override

+ public Object run() {

+ final ProcAddressTable pt = ctx.getGLProcAddressTable();

+ final long procAddrGLTexSubImage2D = pt.getAddressFor("glTexSubImage2D");

+ final long procAddrGLGetError = pt.getAddressFor("glGetError");

+ final long procAddrGLFlush = pt.getAddressFor("glFlush");

+ final long procAddrGLFinish = pt.getAddressFor("glFinish");

+ natives.setGLFuncs0(moviePtr, procAddrGLTexSubImage2D, procAddrGLGetError, procAddrGLFlush, procAddrGLFinish);

+ return null;

+ } } );

+ audioQueueLimit = AudioSink.DefaultQueueLimitWithVideo;

+ } else {

+ audioQueueLimit = AudioSink.DefaultQueueLimitAudioOnly;

+ }

+ if(DEBUG) {

+ System.err.println("initGL: p3 avChosen "+avChosenAudioFormat);

+ }

+

+ if( STREAM_ID_NONE == aid ) {

+ audioSink.destroy();

+ audioSink = AudioSinkFactory.createNull();

+ audioSink.init(AudioSink.DefaultFormat, 0, AudioSink.DefaultInitialQueueSize, AudioSink.DefaultQueueGrowAmount, audioQueueLimit);

+ final float frameDuration;

+ if( audioSamplesPerFrameAndChannel > 0 ) {

+ frameDuration= avChosenAudioFormat.getSamplesDuration(audioSamplesPerFrameAndChannel);

+ } else {

+ frameDuration = AudioSink.DefaultFrameDuration;

+ }

+ final boolean audioSinkOK = audioSink.init(avChosenAudioFormat, frameDuration, AudioSink.DefaultInitialQueueSize, AudioSink.DefaultQueueGrowAmount, audioQueueLimit);

+ if( !audioSinkOK ) {

+ System.err.println("AudioSink "+audioSink.getClass().getName()+" does not support "+avChosenAudioFormat+", using Null");

+ audioSink.destroy();

+ audioSink = AudioSinkFactory.createNull();

+ audioSink.init(avChosenAudioFormat, 0, AudioSink.DefaultInitialQueueSize, AudioSink.DefaultQueueGrowAmount, audioQueueLimit);

+ }

+ }

+ if(DEBUG) {

+ System.err.println("initGL: p4 chosen "+avChosenAudioFormat);

+ System.err.println("initGL: p4 chosen "+audioSink);

+ }

+

+ if( null != gl && STREAM_ID_NONE != vid ) {

+ int tf, tif=GL.GL_RGBA; // texture format and internal format

+ int tt = GL.GL_UNSIGNED_BYTE;

+ switch(vBytesPerPixelPerPlane) {

+ case 1:

+ if( gl.isGL3ES3() ) {

+ // RED is supported on ES3 and >= GL3 [core]; ALPHA is deprecated on core

+ tf = GL2ES2.GL_RED; tif=GL2ES2.GL_RED; singleTexComp = "r";

+ } else {

+ // ALPHA is supported on ES2 and GL2, i.e. <= GL3 [core] or compatibility

+ tf = GL2ES2.GL_ALPHA; tif=GL2ES2.GL_ALPHA; singleTexComp = "a";

+ }

+ break;

+

+ case 2: if( vPixelFmt == PixelFormat.YUYV422 ) {

+ // YUYV422: // < packed YUV 4:2:2, 2x 16bpp, Y0 Cb Y1 Cr

+ // Stuffed into RGBA half width texture

+ tf = GL2ES2.GL_RGBA; tif=GL2ES2.GL_RGBA; break;

+ } else {

+ tf = GL2ES2.GL_RG; tif=GL2ES2.GL_RG; break;

+ }

+ case 3: tf = GL2ES2.GL_RGB; tif=GL.GL_RGB; break;

+ case 4: if( vPixelFmt == PixelFormat.BGRA ) {

+ tf = GL2ES2.GL_BGRA; tif=GL.GL_RGBA; break;

+ } else {

+ tf = GL2ES2.GL_RGBA; tif=GL.GL_RGBA; break;

+ }

+ default: throw new RuntimeException("Unsupported bytes-per-pixel / plane "+vBytesPerPixelPerPlane);

+ }

+ setTextureFormat(tif, tf);

+ setTextureType(tt);

+ if(DEBUG) {

+ System.err.println("initGL: p5: video "+vPixelFmt+", planes "+vPlanes+", bpp "+vBitsPerPixel+"/"+vBytesPerPixelPerPlane+

+ ", tex "+texWidth+"x"+texHeight+", usesTexLookupShader "+usesTexLookupShader);

+ }

+ @Override

+ protected final TextureFrame createTexImage(GL gl, int texName) {

+ return new TextureFrame( createTexImageImpl(gl, texName, texWidth, texHeight) );

+ }

+

+ /**

+ * @param sampleRate sample rate in Hz (1/s)

+ * @param sampleSize sample size in bits

+ * @param channelCount number of channels

+ * @param signed true if signed number, false for unsigned

+ * @param fixedP true for fixed point value, false for unsigned floating point value with a sampleSize of 32 (float) or 64 (double)

+ * @param planar true for planar data package (each channel in own data buffer), false for packed data channels interleaved in one buffer.

+ * @param littleEndian true for little-endian, false for big endian

+ * @return

+ */

+

+ /**

+ * Native callback

+ * Converts the given libav/ffmpeg values to {@link AudioFormat} and returns {@link AudioSink#isSupported(AudioFormat)}.

+ * @param audioSampleFmt ffmpeg/libav audio-sample-format, see {@link SampleFormat}.

+ * @param audioSampleRate sample rate in Hz (1/s)

+ * @param audioChannels number of channels

+ */

+ final boolean isAudioFormatSupported(int audioSampleFmt, int audioSampleRate, int audioChannels) {

+ final SampleFormat avFmt = SampleFormat.valueOf(audioSampleFmt);

+ final AudioFormat audioFormat = avAudioFormat2Local(avFmt, audioSampleRate, audioChannels);

+ final boolean res = audioSink.isSupported(audioFormat);

+ if( DEBUG ) {

+ System.err.println("AudioSink.isSupported: "+res+": av[fmt "+avFmt+", rate "+audioSampleRate+", chan "+audioChannels+"] -> "+audioFormat);

+ }

+ return res;

+ }

+

+ /**

+ * Returns {@link AudioFormat} as converted from the given libav/ffmpeg values.

+ * @param audioSampleFmt ffmpeg/libav audio-sample-format, see {@link SampleFormat}.

+ * @param audioSampleRate sample rate in Hz (1/s)

+ * @param audioChannels number of channels

+ */

+ private final AudioFormat avAudioFormat2Local(SampleFormat audioSampleFmt, int audioSampleRate, int audioChannels) {

+ final int sampleSize;

+ boolean planar = true;

+ boolean fixedP = true;

+ final boolean signed;

+ switch( audioSampleFmt ) {

+ case S32:

+ planar = false;

+ case S32P:

+ sampleSize = 32;

+ signed = true;

+ break;

+ case S16:

+ planar = false;

+ case S16P:

+ sampleSize = 16;

+ signed = true;

+ break;

+ case U8:

+ planar = false;

+ case U8P:

+ sampleSize = 8;

+ signed = false;

+ break;

+ case DBL:

+ planar = false;

+ case DBLP:

+ sampleSize = 64;

+ signed = true;

+ fixedP = false;

+ case FLT:

+ planar = false;

+ case FLTP:

+ sampleSize = 32;

+ signed = true;

+ fixedP = false;

+ default: // FIXME: Add more formats !

+ throw new IllegalArgumentException("Unsupported sampleformat: "+audioSampleFmt);

+ }

+ return new AudioFormat(audioSampleRate, sampleSize, audioChannels, signed, fixedP, planar, true /* littleEndian */);

+ }

+

+ /**

+ * Native callback

+ * @param vid

+ * @param pixFmt

+ * @param planes

+ * @param bitsPerPixel

+ * @param bytesPerPixelPerPlane

+ * @param tWd0

+ * @param tWd1

+ * @param tWd2

+ * @param aid

+ * @param audioSampleFmt

+ * @param audioSampleRate

+ * @param audioChannels

+ * @param audioSamplesPerFrameAndChannel in audio samples per frame and channel

+ */

+ void setupFFAttributes(int vid, int pixFmt, int planes, int bitsPerPixel, int bytesPerPixelPerPlane,

+ int tWd0, int tWd1, int tWd2, int vW, int vH,

+ int aid, int audioSampleFmt, int audioSampleRate,

+ int audioChannels, int audioSamplesPerFrameAndChannel) {

+ // defaults ..

+ vPixelFmt = null;

+ vPlanes = 0;

+ vBitsPerPixel = 0;

+ vBytesPerPixelPerPlane = 0;

+ usesTexLookupShader = false;

+ texWidth = 0; texHeight = 0;

+

+ final int[] vTexWidth = { 0, 0, 0 }; // per plane

+

+ if( STREAM_ID_NONE != vid ) {

+ vPixelFmt = PixelFormat.valueOf(pixFmt);

+ vPlanes = planes;

+ vBitsPerPixel = bitsPerPixel;

+ vBytesPerPixelPerPlane = bytesPerPixelPerPlane;

+ vTexWidth[0] = tWd0; vTexWidth[1] = tWd1; vTexWidth[2] = tWd2;

+

+ switch(vPixelFmt) {

+ case YUVJ420P:

+ case YUV420P: // < planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

+ usesTexLookupShader = true;

+ // YUV420P: Adding U+V on right side of fixed height texture,

+ // since width is already aligned by decoder.

+ // Splitting texture to 4 quadrants:

+ // Y covers left top/low quadrant

+ // U on top-right quadrant.

+ // V on low-right quadrant.

+ // Y=w*h, U=w/2*h/2, V=w/2*h/2

+ // w*h + 2 ( w/2 * h/2 )

+ // w*h + w*h/2

+ texWidth = vTexWidth[0] + vTexWidth[1]; texHeight = vH;

+ break;

+ case YUVJ422P:

+ case YUV422P:

+ usesTexLookupShader = true;

+ // YUV422P: Adding U+V on right side of fixed height texture,

+ // since width is already aligned by decoder.

+ // Splitting texture to 4 columns

+ // Y covers columns 1+2

+ // U covers columns 3

+ // V covers columns 4

+ texWidth = vTexWidth[0] + vTexWidth[1] + vTexWidth[2]; texHeight = vH;

+ break;

+ case YUYV422: // < packed YUV 4:2:2, 2x 16bpp, Y0 Cb Y1 Cr - stuffed into RGBA half width texture

+ case BGR24:

+ usesTexLookupShader = true;

+ texWidth = vTexWidth[0]; texHeight = vH;

+ break;

+

+ case RGB24:

+ case ARGB:

+ case RGBA:

+ case ABGR:

+ case BGRA:

+ usesTexLookupShader = false;

+ texWidth = vTexWidth[0]; texHeight = vH;

+ break;

+ default: // FIXME: Add more formats !

+ throw new RuntimeException("Unsupported pixelformat: "+vPixelFmt);

+ }

+

+ // defaults ..

+ final SampleFormat aSampleFmt;

+ avChosenAudioFormat = null;;

+ this.audioSamplesPerFrameAndChannel = 0;

+

+ if( STREAM_ID_NONE != aid ) {

+ aSampleFmt = SampleFormat.valueOf(audioSampleFmt);

+ avChosenAudioFormat = avAudioFormat2Local(aSampleFmt, audioSampleRate, audioChannels);

+ this.audioSamplesPerFrameAndChannel = audioSamplesPerFrameAndChannel;

+ } else {

+ aSampleFmt = null;

+ }

+

+ System.err.println("audio: id "+aid+", fmt "+aSampleFmt+", "+avChosenAudioFormat+", aFrameSize/fc "+audioSamplesPerFrameAndChannel);

+ System.err.println("video: id "+vid+", fmt "+vW+"x"+vH+", "+vPixelFmt+", planes "+vPlanes+", bpp "+vBitsPerPixel+"/"+vBytesPerPixelPerPlane+", usesTexLookupShader "+usesTexLookupShader);

+ System.err.println("video: p["+i+"]: "+vTexWidth[i]);

+ System.err.println("video: total tex "+texWidth+"x"+texHeight);

+ System.err.println(this.toString());

+

+ /**

+ * Native callback

+ * @param isInGLOrientation

+ * @param pixFmt

+ * @param planes

+ * @param bitsPerPixel

+ * @param bytesPerPixelPerPlane

+ * @param tWd0

+ * @param tWd1

+ * @param tWd2

+ */

+ void updateVidAttributes(boolean isInGLOrientation, int pixFmt, int planes, int bitsPerPixel, int bytesPerPixelPerPlane,

+ int tWd0, int tWd1, int tWd2, int vW, int vH) {

+ }

+

+ *

+ public final String getTextureLookupFunctionName(String desiredFuncName) throws IllegalStateException {

+ if( usesTexLookupShader ) {

+ texLookupFuncName = desiredFuncName;

+ return texLookupFuncName;

+ return super.getTextureLookupFunctionName(desiredFuncName);

+

+ *

+ * e.g. YUV420P to RGB. Otherwise the call is delegated to it's super class.

+ */

+ public final String getTextureLookupFragmentShaderImpl() throws IllegalStateException {

+ if( !usesTexLookupShader ) {

+ return super.getTextureLookupFragmentShaderImpl();

+ }

+ case YUVJ420P:

+ case YUV420P: // < planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

+ return

+ "vec4 "+texLookupFuncName+"(in "+getTextureSampler2DType()+" image, in vec2 texCoord) {\n"+

+ " y = texture2D(image, texCoord)."+singleTexComp+";\n"+

+ " u = texture2D(image, u_off+tc_half)."+singleTexComp+";\n"+

+ " v = texture2D(image, v_off+tc_half)."+singleTexComp+";\n"+

+ " b = y+2.017*u;\n"+

+ ;

+ case YUVJ422P:

+ case YUV422P: ///< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)

+ return

+ "vec4 "+texLookupFuncName+"(in "+getTextureSampler2DType()+" image, in vec2 texCoord) {\n"+

+ " vec2 u_off = vec2("+tc_w_1+" , 0.0);\n"+

+ " vec2 v_off = vec2("+tc_w_1+" * 1.5, 0.0);\n"+

+ " vec2 tc_halfw = vec2(texCoord.x*0.5, texCoord.y);\n"+

+ " float y,u,v,r,g,b;\n"+

+ " y = texture2D(image, texCoord)."+singleTexComp+";\n"+

+ " u = texture2D(image, u_off+tc_halfw)."+singleTexComp+";\n"+

+ " v = texture2D(image, v_off+tc_halfw)."+singleTexComp+";\n"+

+ " y = 1.1643*(y-0.0625);\n"+

+ " u = u-0.5;\n"+

+ " v = v-0.5;\n"+

+ " r = y+1.5958*v;\n"+

+ " g = y-0.39173*u-0.81290*v;\n"+

+ " b = y+2.017*u;\n"+

+ " return vec4(r, g, b, 1);\n"+

+ "}\n"

+ ;

+

+ case YUYV422: // < packed YUV 4:2:2, 2 x 16bpp, [Y0 Cb] [Y1 Cr]

+ // Stuffed into RGBA half width texture

+ return

+ "vec4 "+texLookupFuncName+"(in "+getTextureSampler2DType()+" image, in vec2 texCoord) {\n"+

+ " "+

+ " float y1,u,y2,v,y,r,g,b;\n"+

+ " vec2 tc_halfw = vec2(texCoord.x*0.5, texCoord.y);\n"+

+ " vec4 yuyv = texture2D(image, tc_halfw).rgba;\n"+

+ " y1 = yuyv.r;\n"+

+ " u = yuyv.g;\n"+

+ " y2 = yuyv.b;\n"+

+ " v = yuyv.a;\n"+

+ " y = mix( y1, y2, mod(gl_FragCoord.x, 2) ); /* avoid branching! */\n"+

+ " y = 1.1643*(y-0.0625);\n"+

+ " u = u-0.5;\n"+

+ " v = v-0.5;\n"+

+ " r = y+1.5958*v;\n"+

+ " g = y-0.39173*u-0.81290*v;\n"+

+ " b = y+2.017*u;\n"+

+ " return vec4(r, g, b, 1);\n"+

+ "}\n"

+ ;

+ case BGR24:

+ return

+ "vec4 "+texLookupFuncName+"(in "+getTextureSampler2DType()+" image, in vec2 texCoord) {\n"+

+ " "+

+ " vec3 bgr = texture2D(image, texCoord).rgb;\n"+

+ " return vec4(bgr.b, bgr.g, bgr.r, 1);\n"+ /* just swizzle */

+ "}\n"

+ ;

+

+ default: // FIXME: Add more formats !

+ throw new InternalError("Add proper mapping of: vPixelFmt "+vPixelFmt+", usesTexLookupShader "+usesTexLookupShader);

+ }

+ public final boolean playImpl() {

+ final int errno = natives.play0(moviePtr);

+ if( DEBUG_NATIVE && errno != 0 && errno != -ENOSYS) {

+ System.err.println("libav play err: "+errno);

+ }

+ public final boolean pauseImpl() {

+ final int errno = natives.pause0(moviePtr);

+ if( DEBUG_NATIVE && errno != 0 && errno != -ENOSYS) {

+ System.err.println("libav pause err: "+errno);

+ }

+ protected final synchronized int seekImpl(int msec) {

+ throw new GLException("FFMPEG native instance null");

+ return natives.seek0(moviePtr, msec);

+ protected void preNextTextureImpl(GL gl) {

+ psm.setUnpackAlignment(gl, 1); // RGBA ? 4 : 1

+ gl.glActiveTexture(GL.GL_TEXTURE0+getTextureUnit());

+ protected void postNextTextureImpl(GL gl) {

+ psm.restore(gl);

+

+ protected final int getNextTextureImpl(GL gl, TextureFrame nextFrame) {

+ int vPTS = TimeFrameI.INVALID_PTS;

+ if( null != gl ) {

+ final Texture tex = nextFrame.getTexture();

+ tex.enable(gl);

+ tex.bind(gl);

+ }

+

+ /** Try decode up to 10 packets to find one containing video. */

+ for(int i=0; TimeFrameI.INVALID_PTS == vPTS && 10 > i; i++) {

+ vPTS = natives.readNextPacket0(moviePtr, textureTarget, textureFormat, textureType);

+ }

+ if( null != nextFrame ) {

+ nextFrame.setPTS(vPTS);

+ }

+ return vPTS;

+

+ final void pushSound(ByteBuffer sampleData, int data_size, int audio_pts) {

+ setFirstAudioPTS2SCR( audio_pts );

+ if( 1.0f == playSpeed || audioSinkPlaySpeedSet ) {

+ audioSink.enqueueData( audio_pts, sampleData, data_size);

+/**

+ * Copyright 2013 JogAmp Community. All rights reserved.

+ *

+ * Redistribution and use in source and binary forms, with or without modification, are

+ * permitted provided that the following conditions are met:

+ *

+ * 1. Redistributions of source code must retain the above copyright notice, this list of

+ * conditions and the following disclaimer.

+ *

+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list

+ * of conditions and the following disclaimer in the documentation and/or other materials

+ * provided with the distribution.

+ *

+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED

+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR

+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ *

+ * The views and conclusions contained in the software and documentation are those of the

+ * authors and should not be interpreted as representing official policies, either expressed

+ * or implied, of JogAmp Community.

+ */

+package jogamp.opengl.util.av.impl;

+

+import com.jogamp.opengl.util.texture.TextureSequence.TextureFrame;

+

+/* pp */ abstract class FFMPEGNatives {

+

+ private static final Object mutex_avcodec_openclose_jni = new Object();

+

+ final boolean initSymbols0(long[] symbols, int count) {

+ return initSymbols0(mutex_avcodec_openclose_jni, symbols, count);

+ }

+ abstract boolean initSymbols0(Object mutex_avcodec_openclose, long[] symbols, int count);

+ abstract int getAvUtilMajorVersionCC0();

+ abstract int getAvFormatMajorVersionCC0();

+ abstract int getAvCodecMajorVersionCC0();

+ abstract int getAvResampleMajorVersionCC0();

+ abstract int getSwResampleMajorVersionCC0();

+

+ abstract long createInstance0(FFMPEGMediaPlayer upstream, boolean verbose);

+ abstract void destroyInstance0(long moviePtr);

+

+ /**

+ * Issues {@link #updateAttributes(int, int, int, int, int, int, int, float, int, int, String, String)}

+ * and {@link #updateAttributes2(int, int, int, int, int, int, int, int, int, int)}.

+ *

+ * @param moviePtr

+ * @param url

+ * @param vid

+ * @param sizes requested video size as string, i.e. 'hd720'. May be null to favor vWidth and vHeight.

+ * @param vWidth requested video width (for camera mode)

+ * @param vHeight requested video width (for camera mode)

+ * @param vRate requested video framerate (for camera mode)

+ * @param aid

+ * @param aPrefSampleRate

+ * @param aPrefChannelCount

+ */

+ abstract void setStream0(long moviePtr, String url, boolean isCameraInput,

+ int vid, String sizes, int vWidth, int vHeight,

+ int vRate, int aid, int aMaxChannelCount, int aPrefSampleRate);

+

+ abstract void setGLFuncs0(long moviePtr, long procAddrGLTexSubImage2D, long procAddrGLGetError, long procAddrGLFlush, long procAddrGLFinish);

+

+ abstract int getVideoPTS0(long moviePtr);

+

+ abstract int getAudioPTS0(long moviePtr);

+

+ /**

+ * @return resulting current video PTS, or {@link TextureFrame#INVALID_PTS}

+ */

+ abstract int readNextPacket0(long moviePtr, int texTarget, int texFmt, int texType);

+

+ abstract int play0(long moviePtr);

+ abstract int pause0(long moviePtr);

+ abstract int seek0(long moviePtr, int position);

+

+ /** FFMPEG/libAV Audio Sample Format */

+ public static enum SampleFormat {

+ // NONE = -1,

+ U8, ///< unsigned 8 bits

+ S16, ///< signed 16 bits

+ S32, ///< signed 32 bits

+ FLT, ///< float

+ DBL, ///< double

+

+ U8P, ///< unsigned 8 bits, planar

+ S16P, ///< signed 16 bits, planar

+ S32P, ///< signed 32 bits, planar

+ FLTP, ///< float, planar

+ DBLP, ///< double, planar

+

+ COUNT; ///< Number of sample formats.

+

+ /**

+ * Returns the matching SampleFormat value corresponding to the given SampleFormat's integer ordinal.

+ * <pre>

+ * given:

+ * ordinal = enumValue.ordinal()

+ * reverse:

+ * enumValue = EnumClass.values()[ordinal]

+ * </pre>

+ * @throws IllegalArgumentException if the given ordinal is out of range, i.e. not within [ 0 .. SampleFormat.values().length-1 ]

+ */

+ public static SampleFormat valueOf(int ordinal) throws IllegalArgumentException {

+ final SampleFormat[] all = SampleFormat.values();

+ if( 0 <= ordinal && ordinal < all.length ) {

+ return all[ordinal];

+ }

+ throw new IllegalArgumentException("Ordinal "+ordinal+" out of range of SampleFormat.values()[0.."+(all.length-1)+"]");

+ }

+ };

+

+ /** FFMPEG/libAV Pixel Format */

+ public static enum PixelFormat {

+ // NONE= -1,

+ /** planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples) */

+ YUV420P,

+ /** packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr ( sharing Cb and Cr w/ 2 pixels )*/

+ YUYV422,

+ /** packed RGB 8:8:8, 24bpp, RGBRGB... */

+ RGB24,

+ /** packed RGB 8:8:8, 24bpp, BGRBGR... */

+ BGR24,

+ /** planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples) */

+ YUV422P,

+ /** planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples) */

+ YUV444P,

+ /** planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples) */

+ YUV410P,

+ /** planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) */

+ YUV411P,

+ /** Y, 8bpp */

+ GRAY8,

+ /** Y, 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb */

+ MONOWHITE,

+ /** Y, 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb */

+ MONOBLACK,

+ /** 8 bit with RGB32 palette */

+ PAL8,

+ /** planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of YUV420P and setting color_range */

+ YUVJ420P,

+ /** planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of YUV422P and setting color_range */

+ YUVJ422P,

+ /** planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of YUV444P and setting color_range */

+ YUVJ444P,

+ /** XVideo Motion Acceleration via common packet passing */

+ XVMC_MPEG2_MC,

+ /** */

+ XVMC_MPEG2_IDCT,

+ /** packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1 */

+ UYVY422,

+ /** packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3 */

+ UYYVYY411,

+ /** packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb) */

+ BGR8,

+ /** packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits */

+ BGR4,

+ /** packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb) */

+ BGR4_BYTE,

+ /** packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb) */

+ RGB8,

+ /** packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits */

+ RGB4,

+ /** packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb) */

+ RGB4_BYTE,

+ /** planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V) */

+ NV12,

+ /** as above, but U and V bytes are swapped */

+ NV21,

+

+ /** packed ARGB 8:8:8:8, 32bpp, ARGBARGB... */

+ ARGB,

+ /** packed RGBA 8:8:8:8, 32bpp, RGBARGBA... */

+ RGBA,

+ /** packed ABGR 8:8:8:8, 32bpp, ABGRABGR... */

+ ABGR,

+ /** packed BGRA 8:8:8:8, 32bpp, BGRABGRA... */

+ BGRA,

+

+ /** Y, 16bpp, big-endian */

+ GRAY16BE,

+ /** Y , 16bpp, little-endian */

+ GRAY16LE,

+ /** planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples) */

+ YUV440P,

+ /** planar YUV 4:4:0 full scale (JPEG), deprecated in favor of YUV440P and setting color_range */

+ YUVJ440P,

+ /** planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples) */

+ YUVA420P,

+ /** H.264 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers */

+ VDPAU_H264,

+ /** MPEG-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers */

+ VDPAU_MPEG1,

+ /** MPEG-2 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers */

+ VDPAU_MPEG2,

+ /** WMV3 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers */

+ VDPAU_WMV3,

+ /** VC-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers */

+ VDPAU_VC1,

+ /** packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian */

+ RGB48BE,

+ /** packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian */

+ RGB48LE,

+

+ RGB565BE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian

+ RGB565LE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian

+ RGB555BE, ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), big-endian, most significant bit to 0

+ RGB555LE, ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), little-endian, most significant bit to 0

+

+ BGR565BE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian

+ BGR565LE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian

+ BGR555BE, ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), big-endian, most significant bit to 1

+ BGR555LE, ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), little-endian, most significant bit to 1

+

+ VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers

+ VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers

+ VAAPI_VLD, ///< HW decoding through VA API, Picture.data[3] contains a vaapi_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers

+

+ YUV420P16LE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian

+ YUV420P16BE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian

+ YUV422P16LE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian

+ YUV422P16BE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian

+ YUV444P16LE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian

+ YUV444P16BE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian

+ VDPAU_MPEG4, ///< MPEG4 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers

+ DXVA2_VLD, ///< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer

+

+ RGB444LE, ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), little-endian, most significant bits to 0

+ RGB444BE, ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), big-endian, most significant bits to 0

+ BGR444LE, ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), little-endian, most significant bits to 1

+ BGR444BE, ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), big-endian, most significant bits to 1

+ Y400A, ///< 8bit gray, 8bit alpha

+ BGR48BE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian

+ BGR48LE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian

+ YUV420P9BE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian

+ YUV420P9LE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian

+ YUV420P10BE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian

+ YUV420P10LE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian

+ YUV422P10BE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian

+ YUV422P10LE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian

+ YUV444P9BE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian

+ YUV444P9LE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian

+ YUV444P10BE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian

+ YUV444P10LE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian

+ YUV422P9BE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian

+ YUV422P9LE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian

+ VDA_VLD, ///< hardware decoding through VDA

+ GBRP, ///< planar GBR 4:4:4 24bpp

+ GBRP9BE, ///< planar GBR 4:4:4 27bpp, big endian

+ GBRP9LE, ///< planar GBR 4:4:4 27bpp, little endian

+ GBRP10BE, ///< planar GBR 4:4:4 30bpp, big endian

+ GBRP10LE, ///< planar GBR 4:4:4 30bpp, little endian

+ GBRP16BE, ///< planar GBR 4:4:4 48bpp, big endian

+ GBRP16LE, ///< planar GBR 4:4:4 48bpp, little endian

+ COUNT ///< number of pixel formats in this list

+ ;

+ /**

+ * Returns the matching PixelFormat value corresponding to the given PixelFormat's integer ordinal.

+ * <pre>

+ * given:

+ * ordinal = enumValue.ordinal()

+ * reverse:

+ * enumValue = EnumClass.values()[ordinal]

+ * </pre>

+ * @throws IllegalArgumentException if the given ordinal is out of range, i.e. not within [ 0 .. PixelFormat.values().length-1 ]

+ */

+ public static PixelFormat valueOf(int ordinal) throws IllegalArgumentException {

+ final PixelFormat[] all = PixelFormat.values();

+ if( 0 <= ordinal && ordinal < all.length ) {

+ return all[ordinal];

+ }

+ throw new IllegalArgumentException("Ordinal "+ordinal+" out of range of PixelFormat.values()[0.."+(all.length-1)+"]");

+ }

+ }

+} \ No newline at end of file

+/**

+ * Copyright 2013 JogAmp Community. All rights reserved.

+ *

+ * Redistribution and use in source and binary forms, with or without modification, are

+ * permitted provided that the following conditions are met:

+ *

+ * 1. Redistributions of source code must retain the above copyright notice, this list of

+ * conditions and the following disclaimer.

+ *

+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list

+ * of conditions and the following disclaimer in the documentation and/or other materials

+ * provided with the distribution.

+ *

+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED

+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR

+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ *

+ * The views and conclusions contained in the software and documentation are those of the

+ * authors and should not be interpreted as representing official policies, either expressed

+ * or implied, of JogAmp Community.

+ */

+package jogamp.opengl.util.av.impl;

+

+import com.jogamp.common.util.VersionNumber;

+

+class FFMPEGStaticNatives {

+ static VersionNumber getAVVersion(int vers) {

+ return new VersionNumber( ( vers >> 16 ) & 0xFF,

+ ( vers >> 8 ) & 0xFF,

+ ( vers >> 0 ) & 0xFF );

+ }

+ static native boolean initIDs0();

+

+ static native int getAvVersion0(long func);

+}

+/**

+ * Copyright 2013 JogAmp Community. All rights reserved.

+ *

+ * Redistribution and use in source and binary forms, with or without modification, are

+ * permitted provided that the following conditions are met:

+ *

+ * 1. Redistributions of source code must retain the above copyright notice, this list of

+ * conditions and the following disclaimer.

+ *

+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list

+ * of conditions and the following disclaimer in the documentation and/or other materials

+ * provided with the distribution.

+ *

+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED

+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR

+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ *

+ * The views and conclusions contained in the software and documentation are those of the

+ * authors and should not be interpreted as representing official policies, either expressed

+ * or implied, of JogAmp Community.

+ */

+package jogamp.opengl.util.av.impl;

+

+class FFMPEGv08Natives extends FFMPEGNatives {

+ @Override

+ native boolean initSymbols0(Object mutex_avcodec_openclose, long[] symbols, int count);

+

+ @Override

+ native int getAvUtilMajorVersionCC0();

+

+ @Override

+ native int getAvFormatMajorVersionCC0();

+

+ @Override

+ native int getAvCodecMajorVersionCC0();

+

+ @Override

+ native int getAvResampleMajorVersionCC0();

+

+ @Override

+ native int getSwResampleMajorVersionCC0();

+

+ @Override

+ native long createInstance0(FFMPEGMediaPlayer upstream, boolean verbose);

+

+ @Override

+ native void destroyInstance0(long moviePtr);

+

+ @Override

+ native void setStream0(long moviePtr, String url, boolean isCameraInput, int vid, String sizes, int vWidth, int vHeight, int vRate, int aid, int aMaxChannelCount, int aPrefSampleRate);

+

+ @Override

+ native void setGLFuncs0(long moviePtr, long procAddrGLTexSubImage2D, long procAddrGLGetError, long procAddrGLFlush, long procAddrGLFinish);

+

+ @Override

+ native int getVideoPTS0(long moviePtr);

+

+ @Override

+ native int getAudioPTS0(long moviePtr);

+

+ @Override

+ native int readNextPacket0(long moviePtr, int texTarget, int texFmt, int texType);

+

+ @Override

+ native int play0(long moviePtr);

+

+ @Override

+ native int pause0(long moviePtr);

+

+ @Override

+ native int seek0(long moviePtr, int position);

+}

+/**

+ * Copyright 2013 JogAmp Community. All rights reserved.

+ *

+ * Redistribution and use in source and binary forms, with or without modification, are

+ * permitted provided that the following conditions are met:

+ *

+ * 1. Redistributions of source code must retain the above copyright notice, this list of

+ * conditions and the following disclaimer.

+ *

+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list

+ * of conditions and the following disclaimer in the documentation and/or other materials

+ * provided with the distribution.

+ *

+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED

+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR

+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ *

+ * The views and conclusions contained in the software and documentation are those of the

+ * authors and should not be interpreted as representing official policies, either expressed

+ * or implied, of JogAmp Community.

+ */

+package jogamp.opengl.util.av.impl;

+

+class FFMPEGv09Natives extends FFMPEGNatives {

+ @Override

+ native boolean initSymbols0(Object mutex_avcodec_openclose, long[] symbols, int count);

+

+ @Override

+ native int getAvUtilMajorVersionCC0();

+

+ @Override

+ native int getAvFormatMajorVersionCC0();

+

+ @Override

+ native int getAvCodecMajorVersionCC0();

+

+ @Override

+ native int getAvResampleMajorVersionCC0();

+

+ @Override

+ native int getSwResampleMajorVersionCC0();

+

+ @Override

+ native long createInstance0(FFMPEGMediaPlayer upstream, boolean verbose);

+

+ @Override

+ native void destroyInstance0(long moviePtr);

+

+ @Override

+ native void setStream0(long moviePtr, String url, boolean isCameraInput, int vid, String sizes, int vWidth, int vHeight, int vRate, int aid, int aMaxChannelCount, int aPrefSampleRate);

+

+ @Override

+ native void setGLFuncs0(long moviePtr, long procAddrGLTexSubImage2D, long procAddrGLGetError, long procAddrGLFlush, long procAddrGLFinish);

+

+ @Override

+ native int getVideoPTS0(long moviePtr);

+

+ @Override

+ native int getAudioPTS0(long moviePtr);

+

+ @Override

+ native int readNextPacket0(long moviePtr, int texTarget, int texFmt, int texType);

+

+ @Override

+ native int play0(long moviePtr);

+

+ @Override

+ native int pause0(long moviePtr);

+

+ @Override

+ native int seek0(long moviePtr, int position);

+}

+/**

+ * Copyright 2013 JogAmp Community. All rights reserved.

+ *

+ * Redistribution and use in source and binary forms, with or without modification, are

+ * permitted provided that the following conditions are met:

+ *

+ * 1. Redistributions of source code must retain the above copyright notice, this list of

+ * conditions and the following disclaimer.

+ *

+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list

+ * of conditions and the following disclaimer in the documentation and/or other materials

+ * provided with the distribution.

+ *

+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED

+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR

+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ *

+ * The views and conclusions contained in the software and documentation are those of the

+ * authors and should not be interpreted as representing official policies, either expressed

+ * or implied, of JogAmp Community.

+ */

+package jogamp.opengl.util.av.impl;

+

+class FFMPEGv10Natives extends FFMPEGNatives {

+ @Override

+ native boolean initSymbols0(Object mutex_avcodec_openclose, long[] symbols, int count);

+

+ @Override

+ native int getAvUtilMajorVersionCC0();

+

+ @Override

+ native int getAvFormatMajorVersionCC0();

+

+ @Override

+ native int getAvCodecMajorVersionCC0();

+

+ @Override

+ native int getAvResampleMajorVersionCC0();

+

+ @Override

+ native int getSwResampleMajorVersionCC0();

+

+ @Override

+ native long createInstance0(FFMPEGMediaPlayer upstream, boolean verbose);

+

+ @Override

+ native void destroyInstance0(long moviePtr);

+

+ @Override

+ native void setStream0(long moviePtr, String url, boolean isCameraInput, int vid, String sizes, int vWidth, int vHeight, int vRate, int aid, int aMaxChannelCount, int aPrefSampleRate);

+

+ @Override

+ native void setGLFuncs0(long moviePtr, long procAddrGLTexSubImage2D, long procAddrGLGetError, long procAddrGLFlush, long procAddrGLFinish);

+

+ @Override

+ native int getVideoPTS0(long moviePtr);

+

+ @Override

+ native int getAudioPTS0(long moviePtr);

+

+ @Override

+ native int readNextPacket0(long moviePtr, int texTarget, int texFmt, int texType);

+

+ @Override

+ native int play0(long moviePtr);

+

+ @Override

+ native int pause0(long moviePtr);

+

+ @Override

+ native int seek0(long moviePtr, int position);

+}

+ *

+ *

+ *

+ *

+

+ available = false;

+ /** FIXME!

+ // OMX binding is included in jogl_desktop and jogl_mobile

+ available = initIDs0(); */

+

+

+ }

+

+ protected TextureSequence.TextureFrame createTexImage(GL gl, int texName) {

+ final EGLTextureFrame eglTex = (EGLTextureFrame) super.createTexImage(gl, texName);

+ _setStreamEGLImageTexture2D(moviePtr, texName, eglTex.getImage(), eglTex.getSync());

+

+ protected void destroyTexFrame(GL gl, TextureSequence.TextureFrame imgTex) {

+ super.destroyTexFrame(gl, imgTex);

+

+ _stop(moviePtr);

+ _detachVideoRenderer(moviePtr);

+

+ protected void initStreamImpl(int vid, int aid) throws IOException {

+ if(!streamLoc.getScheme().equals("file")) {

+ throw new IOException("Only file schemes are allowed: "+streamLoc);

+ }

+ final String path=streamLoc.getPath();

+ if(DEBUG) {

+ System.out.println("initGLStream: clean path "+path);

+ }

+

+ if(DEBUG) {

+ System.out.println("initGLStream: p1 "+this);

+ if(DEBUG) {

+ System.out.println("initGLStream: p2 "+this);

+ }

+ protected final void initGLImpl(GL gl) throws IOException, GLException {

+ // NOP

+ isInGLOrientation = true;

+ }

+

+ @Override

+ protected int getAudioPTSImpl() {

+ public synchronized boolean playImpl() {

+ protected int getNextTextureImpl(GL gl, TextureFrame nextFrame) {

+ final int nextTex = _getNextTextureID(moviePtr, true);

+ // FIXME set pts !

+ /* FIXME

+ final TextureSequence.TextureFrame eglImgTex =

+ texFrameMap.get(new Integer(_getNextTextureID(moviePtr, blocking)));

+ } */

+ return 0; // FIXME: return pts

+

+ StringBuilder dest = new StringBuilder();

+ dest.append(orig.substring(i, j));

+ dest.append(repl);

+ return dest.append(orig.substring(i, orig.length())).toString();

+ private native long _createInstance();

+

+

+ private native void _setStreamEGLImageTexture2D(long moviePtr, int tex, long image, long sync);