/*

 * Copyright (C) 2013-2014 Zhang Rui <bbcallen@gmail.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package tv.danmaku.ijk.media.player;

public class MediaInfo {

    public String mMediaPlayerName;

    public String mVideoDecoder;

    public String mVideoDecoderImpl;

    public String mAudioDecoder;

    public String mAudioDecoderImpl;

    public IjkMediaMeta mMeta;

}

/*

 * Copyright (C) 2015 Zhang Rui <bbcallen@gmail.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package tv.danmaku.ijk.media.player;

import android.annotation.TargetApi;

import android.content.Context;

import android.net.Uri;

import android.os.Build;

import android.view.Surface;

import android.view.SurfaceHolder;

import java.io.FileDescriptor;

import java.io.IOException;

import java.util.Map;

import tv.danmaku.ijk.media.player.misc.IMediaDataSource;

import tv.danmaku.ijk.media.player.misc.ITrackInfo;

public class MediaPlayerProxy implements IMediaPlayer {

    protected final IMediaPlayer mBackEndMediaPlayer;

    public MediaPlayerProxy(IMediaPlayer backEndMediaPlayer) {

        mBackEndMediaPlayer = backEndMediaPlayer;

    }

    public IMediaPlayer getInternalMediaPlayer() {

        return mBackEndMediaPlayer;

    }

    @Override

    public void setDisplay(SurfaceHolder sh) {

        mBackEndMediaPlayer.setDisplay(sh);

    }

    @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)

    @Override

    public void setSurface(Surface surface) {

        mBackEndMediaPlayer.setSurface(surface);

    }

    @Override

    public void setDataSource(Context context, Uri uri)

            throws IOException, IllegalArgumentException, SecurityException, IllegalStateException {

        mBackEndMediaPlayer.setDataSource(context, uri);

    }

    @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)

    @Override

    public void setDataSource(Context context, Uri uri, Map<String, String> headers)

            throws IOException, IllegalArgumentException, SecurityException, IllegalStateException {

        mBackEndMediaPlayer.setDataSource(context, uri, headers);

    }

    @Override

    public void setDataSource(FileDescriptor fd)

            throws IOException, IllegalArgumentException, IllegalStateException {

        mBackEndMediaPlayer.setDataSource(fd);

    }

    @Override

    public void setDataSource(String path) throws IOException, IllegalArgumentException, SecurityException, IllegalStateException {

        mBackEndMediaPlayer.setDataSource(path);

    }

    @Override

    public void setDataSource(IMediaDataSource mediaDataSource)  {

        mBackEndMediaPlayer.setDataSource(mediaDataSource);

    }

    @Override

    public String getDataSource() {

        return mBackEndMediaPlayer.getDataSource();

    }

    @Override

    public void prepareAsync() throws IllegalStateException {

        mBackEndMediaPlayer.prepareAsync();

    }

    @Override

    public void start() throws IllegalStateException {

        mBackEndMediaPlayer.start();

    }

    @Override

    public void stop() throws IllegalStateException {

        mBackEndMediaPlayer.stop();

    }

    @Override

    public void pause() throws IllegalStateException {

        mBackEndMediaPlayer.pause();

    }

    @Override

    public void setScreenOnWhilePlaying(boolean screenOn) {

        mBackEndMediaPlayer.setScreenOnWhilePlaying(screenOn);

    }

    @Override

    public int getVideoWidth() {

        return mBackEndMediaPlayer.getVideoWidth();

    }

    @Override

    public int getVideoHeight() {

        return mBackEndMediaPlayer.getVideoHeight();

    }

    @Override

    public boolean isPlaying() {

        return mBackEndMediaPlayer.isPlaying();

    }

    @Override

    public void seekTo(long msec) throws IllegalStateException {

        mBackEndMediaPlayer.seekTo(msec);

    }

    @Override

    public long getCurrentPosition() {

        return mBackEndMediaPlayer.getCurrentPosition();

    }

    @Override

    public long getDuration() {

        return mBackEndMediaPlayer.getDuration();

    }

    @Override

    public void release() {

        mBackEndMediaPlayer.release();

    }

    @Override

    public void reset() {

        mBackEndMediaPlayer.reset();

    }

    @Override

    public void setVolume(float leftVolume, float rightVolume) {

        mBackEndMediaPlayer.setVolume(leftVolume, rightVolume);

    }

    @Override

    public int getAudioSessionId() {

        return mBackEndMediaPlayer.getAudioSessionId();

    }

    @Override

    public MediaInfo getMediaInfo() {

        return mBackEndMediaPlayer.getMediaInfo();

    }

    @Override

    public void setLogEnabled(boolean enable) {

    }

    @Override

    public boolean isPlayable() {

        return false;

    }

    @Override

    public void setOnPreparedListener(OnPreparedListener listener) {

        if (listener != null) {

            final OnPreparedListener finalListener = listener;

            mBackEndMediaPlayer.setOnPreparedListener(new OnPreparedListener() {

                @Override

                public void onPrepared(IMediaPlayer mp) {

                    finalListener.onPrepared(MediaPlayerProxy.this);

                }

            });

        } else {

            mBackEndMediaPlayer.setOnPreparedListener(null);

        }

    }

    @Override

    public void setOnCompletionListener(OnCompletionListener listener) {

        if (listener != null) {

            final OnCompletionListener finalListener = listener;

            mBackEndMediaPlayer.setOnCompletionListener(new OnCompletionListener() {

                @Override

                public void onCompletion(IMediaPlayer mp) {

                    finalListener.onCompletion(MediaPlayerProxy.this);

                }

            });

        } else {

            mBackEndMediaPlayer.setOnCompletionListener(null);

        }

    }

    @Override

    public void setOnBufferingUpdateListener(OnBufferingUpdateListener listener) {

        if (listener != null) {

            final OnBufferingUpdateListener finalListener = listener;

            mBackEndMediaPlayer.setOnBufferingUpdateListener(new OnBufferingUpdateListener() {

                @Override

                public void onBufferingUpdate(IMediaPlayer mp, int percent) {

                    finalListener.onBufferingUpdate(MediaPlayerProxy.this, percent);

                }

            });

        } else {

            mBackEndMediaPlayer.setOnBufferingUpdateListener(null);

        }

    }

    @Override

    public void setOnSeekCompleteListener(OnSeekCompleteListener listener) {

        if (listener != null) {

            final OnSeekCompleteListener finalListener = listener;

            mBackEndMediaPlayer.setOnSeekCompleteListener(new OnSeekCompleteListener() {

                @Override

                public void onSeekComplete(IMediaPlayer mp) {

                    finalListener.onSeekComplete(MediaPlayerProxy.this);

                }

            });

        } else {

            mBackEndMediaPlayer.setOnSeekCompleteListener(null);

        }

    }

    @Override

    public void setOnVideoSizeChangedListener(OnVideoSizeChangedListener listener) {

        if (listener != null) {

            final OnVideoSizeChangedListener finalListener = listener;

            mBackEndMediaPlayer.setOnVideoSizeChangedListener(new OnVideoSizeChangedListener() {

                @Override

                public void onVideoSizeChanged(IMediaPlayer mp, int width, int height, int sar_num, int sar_den) {

                    finalListener.onVideoSizeChanged(MediaPlayerProxy.this, width, height, sar_num, sar_den);

                }

            });

        } else {

            mBackEndMediaPlayer.setOnVideoSizeChangedListener(null);

        }

    }

    @Override

    public void setOnErrorListener(OnErrorListener listener) {

        if (listener != null) {

            final OnErrorListener finalListener = listener;

            mBackEndMediaPlayer.setOnErrorListener(new OnErrorListener() {

                @Override

                public boolean onError(IMediaPlayer mp, int what, int extra) {

                    return finalListener.onError(MediaPlayerProxy.this, what, extra);

                }

            });

        } else {

            mBackEndMediaPlayer.setOnErrorListener(null);

        }

    }

    @Override

    public void setOnInfoListener(OnInfoListener listener) {

        if (listener != null) {

            final OnInfoListener finalListener = listener;

            mBackEndMediaPlayer.setOnInfoListener(new OnInfoListener() {

                @Override

                public boolean onInfo(IMediaPlayer mp, int what, int extra) {

                    return finalListener.onInfo(MediaPlayerProxy.this, what, extra);

                }

            });

        } else {

            mBackEndMediaPlayer.setOnInfoListener(null);

        }

    }

    @Override

    public void setAudioStreamType(int streamtype) {

        mBackEndMediaPlayer.setAudioStreamType(streamtype);

    }

    @Override

    public void setKeepInBackground(boolean keepInBackground) {

        mBackEndMediaPlayer.setKeepInBackground(keepInBackground);

    }

    @Override

    public int getVideoSarNum() {

        return mBackEndMediaPlayer.getVideoSarNum();

    }

    @Override

    public int getVideoSarDen() {

        return mBackEndMediaPlayer.getVideoSarDen();

    }

    @Override

    public void setWakeMode(Context context, int mode) {

        mBackEndMediaPlayer.setWakeMode(context, mode);

    }

    @Override

    public ITrackInfo[] getTrackInfo() {

        return mBackEndMediaPlayer.getTrackInfo();

    }

    @Override

    public void setLooping(boolean looping) {

        mBackEndMediaPlayer.setLooping(looping);

    }

    @Override

    public boolean isLooping() {

        return mBackEndMediaPlayer.isLooping();

    }

}

/*

 * Copyright (C) 2015 Zhang Rui <bbcallen@gmail.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package tv.danmaku.ijk.media.player;

import android.annotation.TargetApi;

import android.graphics.SurfaceTexture;

import android.os.Build;

import android.view.Surface;

import android.view.SurfaceHolder;

@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)

public class TextureMediaPlayer extends MediaPlayerProxy implements IMediaPlayer, ISurfaceTextureHolder {

    private SurfaceTexture mSurfaceTexture;

    private ISurfaceTextureHost mSurfaceTextureHost;

    public TextureMediaPlayer(IMediaPlayer backEndMediaPlayer) {

        super(backEndMediaPlayer);

    }

    public void releaseSurfaceTexture() {

        if (mSurfaceTexture != null) {

            if (mSurfaceTextureHost != null) {

                mSurfaceTextureHost.releaseSurfaceTexture(mSurfaceTexture);

            } else {

                mSurfaceTexture.release();

            }

            mSurfaceTexture = null;

        }

    }

    //--------------------

    // IMediaPlayer

    //--------------------

    @Override

    public void reset() {

        super.reset();

        releaseSurfaceTexture();

    }

    @Override

    public void release() {

        super.release();

        releaseSurfaceTexture();

    }

    @Override

    public void setDisplay(SurfaceHolder sh) {

        if (mSurfaceTexture == null)

            super.setDisplay(sh);

    }

    @Override

    public void setSurface(Surface surface) {

        if (mSurfaceTexture == null)

            super.setSurface(surface);

    }

    //--------------------

    // ISurfaceTextureHolder

    //--------------------

    @Override

    public void setSurfaceTexture(SurfaceTexture surfaceTexture) {

        if (mSurfaceTexture == surfaceTexture)

            return;

        releaseSurfaceTexture();

        mSurfaceTexture = surfaceTexture;

        if (surfaceTexture == null) {

            super.setSurface(null);

        } else {

            super.setSurface(new Surface(surfaceTexture));

        }

    }

    @Override

    public SurfaceTexture getSurfaceTexture() {

        return mSurfaceTexture;

    }

    @Override

    public void setSurfaceTextureHost(ISurfaceTextureHost surfaceTextureHost) {

        mSurfaceTextureHost = surfaceTextureHost;

    }

}

/*

 * Copyright (C) 2013-2014 Zhang Rui <bbcallen@gmail.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package tv.danmaku.ijk.media.player.annotations;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

 * is used by the JNI generator to create the necessary JNI

 * bindings and expose this method to native code.

 */

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.CLASS)

public @interface AccessedByNative {

}

/*

 * Copyright (C) 2013-2014 Zhang Rui <bbcallen@gmail.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package tv.danmaku.ijk.media.player.annotations;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

 * is used by the JNI generator to create the necessary JNI

 * bindings and expose this method to native code.

 */

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.CLASS)

public @interface CalledByNative {

    /*

     * If present, tells which inner class the method belongs to.

     */

    String value() default "";

}

/*

 * Copyright (C) 2013-2014 Zhang Rui <bbcallen@gmail.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package tv.danmaku.ijk.media.player.exceptions;

public class IjkMediaException extends Exception {

    private static final long serialVersionUID = 7234796519009099506L;

}

package tv.danmaku.ijk.media.player.ffmpeg;

public class FFmpegApi {

    public static native String av_base64_encode(byte in[]);

}

/*

 * Copyright (C) 2015 Zhang Rui <bbcallen@gmail.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package tv.danmaku.ijk.media.player.misc;

import android.annotation.TargetApi;

import android.media.MediaFormat;

import android.os.Build;

public class AndroidMediaFormat implements IMediaFormat {

    private final MediaFormat mMediaFormat;

    public AndroidMediaFormat(MediaFormat mediaFormat) {

        mMediaFormat = mediaFormat;

    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)

    @Override

    public int getInteger(String name) {

        if (mMediaFormat == null)

            return 0;

        return mMediaFormat.getInteger(name);

    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)

    @Override

    public String getString(String name) {

        if (mMediaFormat == null)

            return null;

        return mMediaFormat.getString(name);

    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)

    @Override

    public String toString() {

        StringBuilder out = new StringBuilder(128);

        out.append(getClass().getName());

        out.append('{');

        if (mMediaFormat != null) {

            out.append(mMediaFormat.toString());

        } else {

            out.append("null");

        }

        out.append('}');

        return out.toString();

    }

}

/*

 * Copyright (C) 2015 Zhang Rui <bbcallen@gmail.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package tv.danmaku.ijk.media.player.misc;

import android.annotation.TargetApi;

import android.media.MediaFormat;

import android.media.MediaPlayer;

import android.os.Build;

public class AndroidTrackInfo implements ITrackInfo {

    private final MediaPlayer.TrackInfo mTrackInfo;

    public static AndroidTrackInfo[] fromMediaPlayer(MediaPlayer mp) {

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN)

            return fromTrackInfo(mp.getTrackInfo());

        return null;

    }

    private static AndroidTrackInfo[] fromTrackInfo(MediaPlayer.TrackInfo[] trackInfos) {

        if (trackInfos == null)

            return null;

        AndroidTrackInfo androidTrackInfo[] = new AndroidTrackInfo[trackInfos.length];

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

            androidTrackInfo[i] = new AndroidTrackInfo(trackInfos[i]);

        }

        return androidTrackInfo;

    }

    private AndroidTrackInfo(MediaPlayer.TrackInfo trackInfo) {

        mTrackInfo = trackInfo;

    }

    @TargetApi(Build.VERSION_CODES.KITKAT)

    @Override

    public IMediaFormat getFormat() {

        if (mTrackInfo == null)

            return null;

        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT)

            return null;

        MediaFormat mediaFormat = mTrackInfo.getFormat();

        if (mediaFormat == null)

            return null;

        return new AndroidMediaFormat(mediaFormat);

    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)

    @Override

    public String getLanguage() {

        if (mTrackInfo == null)

            return "und";

        return mTrackInfo.getLanguage();

    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)

    @Override

    public int getTrackType() {

        if (mTrackInfo == null)

            return MEDIA_TRACK_TYPE_UNKNOWN;

        return mTrackInfo.getTrackType();

    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)

    @Override

    public String toString() {

        StringBuilder out = new StringBuilder(128);

        out.append(getClass().getSimpleName());

        out.append('{');

        if (mTrackInfo != null) {

            out.append(mTrackInfo.toString());

        } else {

            out.append("null");

        }

        out.append('}');

        return out.toString();

    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)

    @Override

    public String getInfoInline() {

        if (mTrackInfo != null) {

            return mTrackInfo.toString();

        } else {

            return "null";

        }

    }

}

/*

 * Copyright (C) 2015 Zhang Rui <bbcallen@gmail.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package tv.danmaku.ijk.media.player.misc;

import java.io.IOException;

@SuppressWarnings("RedundantThrows")

public interface IMediaDataSource {

    int	 readAt(long position, byte[] buffer, int offset, int size) throws IOException;

    long getSize() throws IOException;

    void close() throws IOException;

}

/*

 * Copyright (C) 2015 Zhang Rui <bbcallen@gmail.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package tv.danmaku.ijk.media.player.misc;

public interface IMediaFormat {

    // Common keys

    String KEY_MIME = "mime";

    // Video Keys

    String KEY_WIDTH = "width";

    String KEY_HEIGHT = "height";

    String getString(String name);

    int getInteger(String name);

}

/*

 * Copyright (C) 2015 Zhang Rui <bbcallen@gmail.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at