| Name | Value Type | Description |
|---|---|---|
| {@link #KEY_MIME} | String | The type of the format. |
| {@link #KEY_MAX_INPUT_SIZE} | Integer | optional, maximum size of a buffer of input data |
| {@link #KEY_BIT_RATE} | Integer | encoder-only, desired bitrate in bits/second |
| Name | Value Type | Description |
|---|---|---|
| {@link #KEY_WIDTH} | Integer | |
| {@link #KEY_HEIGHT} | Integer | |
| {@link #KEY_COLOR_FORMAT} | Integer | set by the user + * for encoders, readable in the output format of decoders |
| {@link #KEY_FRAME_RATE} | Integer or Float | encoder-only |
| {@link #KEY_I_FRAME_INTERVAL} | Integer | encoder-only |
| {@link #KEY_MAX_WIDTH} | Integer | decoder-only, optional, max-resolution width |
| {@link #KEY_MAX_HEIGHT} | Integer | decoder-only, optional, max-resolution height |
| {@link #KEY_REPEAT_PREVIOUS_FRAME_AFTER} | Long | video encoder in surface-mode only |
| {@link #KEY_PUSH_BLANK_BUFFERS_ON_STOP} | Integer(1) | video decoder rendering to a surface only |
| Name | Value Type | Description |
|---|---|---|
| {@link #KEY_CHANNEL_COUNT} | Integer | |
| {@link #KEY_SAMPLE_RATE} | Integer | |
| {@link #KEY_IS_ADTS} | Integer | optional, if decoding AAC audio content, setting this key to 1 indicates that each audio frame is prefixed by the ADTS header. |
| {@link #KEY_AAC_PROFILE} | Integer | encoder-only, optional, if content is AAC audio, specifies the desired profile. |
| {@link #KEY_CHANNEL_MASK} | Integer | optional, a mask of audio channel assignments |
| {@link #KEY_FLAC_COMPRESSION_LEVEL} | Integer | encoder-only, optional, if content is FLAC audio, specifies the desired compression level. |
| {@link #KEY_MIME} | String | The type of the format. |
| {@link #KEY_LANGUAGE} | String | The language of the content. |
+ * MediaMetadataRetriever mmr = new MediaMetadataRetriever(this); + * mmr.setDataSource(this, mediaUri); + * String title = mmr.extractMetadata(METADATA_KEY_TITLE); + * Bitmap frame = mmr.getFrameAtTime(-1); + * mmr.release(); + *+ */ +public class MediaMetadataRetriever { + private AssetFileDescriptor mFD = null; + + static { + File libFile; + String LIB_ROOT=""; + + try { + libFile = new File(Vitamio.getLibraryPath()+"libstlport_shared.so" ); + if(libFile.exists()){ + LIB_ROOT=Vitamio.getLibraryPath(); + }else{ + libFile = new File(Vitamio.getDataPath()+"libstlport_shared.so" ); + if(libFile.exists()){ + LIB_ROOT=Vitamio.getDataPath(); + } + } + }catch(Exception e){ + Log.e("scanner err", " load library err "); + } + if(LIB_ROOT==null){ + System.loadLibrary("stlport_shared"); + System.loadLibrary("vscanner"); + loadFFmpeg_native("libffmpeg.so"); + }else{ + System.load(LIB_ROOT+ "libstlport_shared.so"); + System.load(LIB_ROOT+ "libvscanner.so"); + loadFFmpeg_native(LIB_ROOT+"libffmpeg.so"); + } + + + native_init(); + } + + private int mNativeContext; + + public MediaMetadataRetriever(Context ctx) { + native_setup(); + } + + private static native boolean loadFFmpeg_native(String ffmpegPath); + + public void setDataSource(Context context, Uri uri) throws IOException, IllegalArgumentException, + SecurityException, IllegalStateException { + if (context == null || uri == null) + throw new IllegalArgumentException(); + String scheme = uri.getScheme(); + if (scheme == null || scheme.equals("file")) { + setDataSource(FileUtils.getPath(uri.toString())); + return; + } + + try { + ContentResolver resolver = context.getContentResolver(); + mFD = resolver.openAssetFileDescriptor(uri, "r"); + if (mFD == null) + return; + setDataSource(mFD.getParcelFileDescriptor().getFileDescriptor()); + return; + } catch (Exception e) { + closeFD(); + } + Log.e("Couldn't open file on client side, trying server side %s", uri.toString()); + setDataSource(uri.toString()); + return; + } + + public native void setDataSource(String path) throws IOException, IllegalArgumentException, + IllegalStateException; + + public native void setDataSource(FileDescriptor fd) throws IOException, IllegalArgumentException, + IllegalStateException; + + /** + * Call this method after setDataSource(). This method retrieves the meta data + * value associated with the keyCode. + * + * The keyCode currently supported is listed below as METADATA_XXX constants. + * With any other value, it returns a null pointer. + * + * @param keyCode One of the constants listed below at the end of the class. + * @return The meta data value associate with the given keyCode on success; + * null on failure. + */ + public native String extractMetadata(String keyCode) throws IllegalStateException; + + public native Bitmap getFrameAtTime(long timeUs) throws IllegalStateException; + + /** + * Call this method after setDataSource(). This method finds the optional + * graphic or album/cover art associated associated with the data source. If + * there are more than one pictures, (any) one of them is returned. + * + * @return null if no such graphic is found. + */ + public native byte[] getEmbeddedPicture() throws IllegalStateException; + + private native void _release(); + + private native void native_setup(); + + private static native final void native_init(); + + private native final void native_finalize(); + + public void release() { + _release(); + closeFD(); + } + + @Override + protected void finalize() throws Throwable { + try { + native_finalize(); + } finally { + super.finalize(); + } + } + + private void closeFD() { + if (mFD != null) { + try { + mFD.close(); + } catch (IOException e) { + } + mFD = null; + } + } + + /* + * Do not change these metadata key values without updating their + * counterparts in c file + */ + + /** + * The metadata key to retrieve the information about the album title of the + * data source. + */ + public static final String METADATA_KEY_ALBUM = "album"; + /** + * The metadata key to retrieve the main creator of the set/album, if + * different from artist. e.g. "Various Artists" for compilation albums. + */ + public static final String METADATA_KEY_ALBUM_ARTIST = "album_artist"; + /** + * The metadata key to retrieve the information about the artist of the data + * source. + */ + public static final String METADATA_KEY_ARTIST = "artist"; + + /** + * The metadata key to retrieve the any additional description of the file. + */ + public static final String METADATA_KEY_COMMENT = "comment"; + /** + * The metadata key to retrieve the information about the author of the data + * source. + */ + public static final String METADATA_KEY_AUTHOR = "author"; + /** + * The metadata key to retrieve the information about the composer of the data + * source. + */ + public static final String METADATA_KEY_COMPOSER = "composer"; + /** + * The metadata key to retrieve the name of copyright holder. + */ + public static final String METADATA_KEY_COPYRIGHT = "copyright"; + /** + * The metadata key to retrieve the date when the file was created, preferably + * in ISO 8601. + */ + public static final String METADATA_KEY_CREATION_TIME = "creation_time"; + /** + * The metadata key to retrieve the date when the work was created, preferably + * in ISO 8601. + */ + public static final String METADATA_KEY_DATE = "date"; + /** + * The metadata key to retrieve the number of a subset, e.g. disc in a + * multi-disc collection. + */ + public static final String METADATA_KEY_DISC = "disc"; + /** + * The metadata key to retrieve the name/settings of the software/hardware + * that produced the file. + */ + public static final String METADATA_KEY_ENCODER = "encoder"; + /** + * The metadata key to retrieve the person/group who created the file. + */ + public static final String METADATA_KEY_ENCODED_BY = "encoded_by"; + /** + * The metadata key to retrieve the original name of the file. + */ + public static final String METADATA_KEY_FILENAME = "filename"; + /** + * The metadata key to retrieve the content type or genre of the data source. + */ + public static final String METADATA_KEY_GENRE = "genre"; + /** + * The metadata key to retrieve the main language in which the work is + * performed, preferably in ISO 639-2 format. Multiple languages can be + * specified by separating them with commas. + */ + public static final String METADATA_KEY_LANGUAGE = "language"; + /** + * The metadata key to retrieve the artist who performed the work, if + * different from artist. E.g for "Also sprach Zarathustra", artist would be + * "Richard Strauss" and performer "London Philharmonic Orchestra". + */ + public static final String METADATA_KEY_PERFORMER = "performer"; + /** + * The metadata key to retrieve the name of the label/publisher. + */ + public static final String METADATA_KEY_PUBLISHER = "publisher"; + /** + * The metadata key to retrieve the name of the service in broadcasting + * (channel name). + */ + public static final String METADATA_KEY_SERVICE_NAME = "service_name"; + /** + * The metadata key to retrieve the name of the service provider in + * broadcasting. + */ + public static final String METADATA_KEY_SERVICE_PROVIDER = "service_provider"; + /** + * The metadata key to retrieve the data source title. + */ + public static final String METADATA_KEY_TITLE = "title"; + /** + * The metadata key to retrieve the number of this work in the set, can be in + * form current/total. + */ + public static final String METADATA_KEY_TRACK = "track"; + /** + * The metadata key to retrieve the total bitrate of the bitrate variant that + * the current stream is part of. + */ + public static final String METADATA_KEY_VARIANT_BITRATE = "bitrate"; + /** + * The metadata key to retrieve the playback duration of the data source. + */ + public static final String METADATA_KEY_DURATION = "duration"; + /** + * The metadata key to retrieve the audio codec of the work. + */ + public static final String METADATA_KEY_AUDIO_CODEC = "audio_codec"; + /** + * The metadata key to retrieve the video codec of the work. + */ + public static final String METADATA_KEY_VIDEO_CODEC = "video_codec"; + /** + * This key retrieves the video rotation angle in degrees, if available. The + * video rotation angle may be 0, 90, 180, or 270 degrees. + */ + public static final String METADATA_KEY_VIDEO_ROTATION = "rotate"; + /** + * If the media contains video, this key retrieves its width. + */ + public static final String METADATA_KEY_VIDEO_WIDTH = "width"; + /** + * If the media contains video, this key retrieves its height. + */ + public static final String METADATA_KEY_VIDEO_HEIGHT = "height"; + /** + * The metadata key to retrieve the number of tracks, such as audio, video, + * text, in the data source, such as a mp4 or 3gpp file. + */ + public static final String METADATA_KEY_NUM_TRACKS = "num_tracks"; + /** + * If this key exists the media contains audio content. if has audio, return + * 1. + */ + public static final String METADATA_KEY_HAS_AUDIO = "has_audio"; + /** + * If this key exists the media contains video content. if has video, return + * 1. + */ + public static final String METADATA_KEY_HAS_VIDEO = "has_video"; + +} \ No newline at end of file diff --git a/vitamio/src/io/vov/vitamio/MediaPlayer.java b/vitamio/src/io/vov/vitamio/MediaPlayer.java new file mode 100644 index 0000000..50cb3fd --- /dev/null +++ b/vitamio/src/io/vov/vitamio/MediaPlayer.java @@ -0,0 +1,1817 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * Copyright (C) 2013 YIXIA.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 io.vov.vitamio; + +import android.annotation.SuppressLint; +import android.content.ContentResolver; +import android.content.Context; +import android.content.res.AssetFileDescriptor; +import android.graphics.Bitmap; +import android.graphics.Canvas; +import android.media.AudioFormat; +import android.media.AudioManager; +import android.media.AudioTrack; +import android.net.Uri; +import android.os.Build; +import android.os.Build.VERSION; +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.os.PowerManager; +import android.text.TextUtils; +import android.util.SparseArray; +import android.view.Surface; +import android.view.SurfaceHolder; + +import io.vov.vitamio.utils.ContextUtils; +import io.vov.vitamio.utils.FileUtils; +import io.vov.vitamio.utils.Log; + +import java.io.File; +import java.io.FileDescriptor; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.UnsupportedEncodingException; +import java.nio.ByteBuffer; +import java.nio.charset.Charset; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.atomic.AtomicBoolean; + +/** + * MediaPlayer class can be used to control playback of audio/video files and + * streams. An example on how to use the methods in this class can be found in + * {@link io.vov.vitamio.widget.VideoView}. This class will function the same as + * android.media.MediaPlayer in most cases. Please see Audio and + * Video for additional help using MediaPlayer. + */ +@SuppressLint("NewApi") +public class MediaPlayer { + public static final int CACHE_TYPE_NOT_AVAILABLE = 1; + public static final int CACHE_TYPE_START = 2; + public static final int CACHE_TYPE_UPDATE = 3; + public static final int CACHE_TYPE_SPEED = 4; + public static final int CACHE_TYPE_COMPLETE = 5; + public static final int CACHE_INFO_NO_SPACE = 1; + public static final int CACHE_INFO_STREAM_NOT_SUPPORT = 2; + public static final int MEDIA_ERROR_UNKNOWN = 1; + public static final int MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK = 200; + + /** File or network related operation errors. */ + public static final int MEDIA_ERROR_IO = -5; + /** Bitstream is not conforming to the related coding standard or file spec. */ + public static final int MEDIA_ERROR_MALFORMED = -1007; + /** Bitstream is conforming to the related coding standard or file spec, but + * the media framework does not support the feature. */ + public static final int MEDIA_ERROR_UNSUPPORTED = -1010; + /** Some operation takes too long to complete, usually more than 3-5 seconds. */ + public static final int MEDIA_ERROR_TIMED_OUT = -110; + /** + * The video is too complex for the decoder: it can't decode frames fast + * enough. Possibly only the audio plays fine at this stage. + * + * @see io.vov.vitamio.MediaPlayer.OnInfoListener + */ + public static final int MEDIA_INFO_VIDEO_TRACK_LAGGING = 700; + /** + * MediaPlayer is temporarily pausing playback internally in order to buffer + * more data. + */ + public static final int MEDIA_INFO_BUFFERING_START = 701; + /** + * MediaPlayer is resuming playback after filling buffers. + */ + public static final int MEDIA_INFO_BUFFERING_END = 702; + + public static final int MEDIA_INFO_FILE_OPEN_OK = 704; + public static final int MEDIA_INFO_UNKNOW_TYPE = 1001; + public static final int MEDIA_INFO_GET_CODEC_INFO_ERROR = 1002; + + /** + * The media cannot be seeked (e.g live stream) + * + * @see io.vov.vitamio.MediaPlayer.OnInfoListener + */ + public static final int MEDIA_INFO_NOT_SEEKABLE = 801; + /** + * The rate in KB/s of av_read_frame() + * + * @see io.vov.vitamio.MediaPlayer.OnInfoListener + */ + public static final int MEDIA_INFO_DOWNLOAD_RATE_CHANGED = 901; + public static final int VIDEOQUALITY_LOW = -16; + public static final int VIDEOQUALITY_MEDIUM = 0; + public static final int VIDEOQUALITY_HIGH = 16; + + public static final int VIDEOCHROMA_RGB565 = 0; + public static final int VIDEOCHROMA_RGBA = 1; + /** + * The subtitle displayed is embeded in the movie + */ + public static final int SUBTITLE_INTERNAL = 0; + /** + * The subtitle displayed is an external file + */ + public static final int SUBTITLE_EXTERNAL = 1; + /** + * The external subtitle types which Vitamio supports. + */ + public static final String[] SUB_TYPES = {".srt", ".ssa", ".smi", ".txt", ".sub", ".ass", ".webvtt"}; + private static final int MEDIA_NOP = 0; + private static final int MEDIA_PREPARED = 1; + private static final int MEDIA_PLAYBACK_COMPLETE = 2; + private static final int MEDIA_BUFFERING_UPDATE = 3; + private static final int MEDIA_SEEK_COMPLETE = 4; + private static final int MEDIA_SET_VIDEO_SIZE = 5; + private static final int MEDIA_ERROR = 100; + private static final int MEDIA_INFO = 200; + private static final int MEDIA_CACHE = 300; + private static final int MEDIA_HW_ERROR = 400; + private static final int MEDIA_TIMED_TEXT = 1000; + private static final int MEDIA_CACHING_UPDATE = 2000; + private static final String MEDIA_CACHING_SEGMENTS = "caching_segment"; + private static final String MEDIA_CACHING_TYPE = "caching_type"; + private static final String MEDIA_CACHING_INFO = "caching_info"; + private static final String MEDIA_SUBTITLE_STRING = "sub_string"; + private static final String MEDIA_SUBTITLE_BYTES = "sub_bytes"; + private static final String MEDIA_SUBTITLE_TYPE = "sub_type"; + private static final int SUBTITLE_TEXT = 0; + private static final int SUBTITLE_BITMAP = 1; + private static AtomicBoolean NATIVE_OMX_LOADED = new AtomicBoolean(false); + private Context mContext; + private Surface mSurface; + private SurfaceHolder mSurfaceHolder; + private EventHandler mEventHandler; + private PowerManager.WakeLock mWakeLock = null; + private boolean mScreenOnWhilePlaying; + private boolean mStayAwake; + private Metadata mMeta; + private TrackInfo[] mInbandTracks; + private TrackInfo mOutOfBandTracks; + private AssetFileDescriptor mFD = null; + private OnHWRenderFailedListener mOnHWRenderFailedListener; + private OnPreparedListener mOnPreparedListener; + private OnCompletionListener mOnCompletionListener; + private OnBufferingUpdateListener mOnBufferingUpdateListener; + private OnCachingUpdateListener mOnCachingUpdateListener; + private OnSeekCompleteListener mOnSeekCompleteListener; + private OnVideoSizeChangedListener mOnVideoSizeChangedListener; + private OnErrorListener mOnErrorListener; + /** + * Register a callback to be invoked when an info/warning is available. + * + * @param listener + * the callback that will be run + */ + private OnInfoListener mOnInfoListener; + private OnTimedTextListener mOnTimedTextListener; + private AudioTrack mAudioTrack; + private int mAudioTrackBufferSize; + private Surface mLocalSurface; + private Bitmap mBitmap; + private ByteBuffer mByteBuffer; + + /** + * Default constructor. The same as Android's MediaPlayer(). + *
+ * When done with the MediaPlayer, you should call {@link #release()}, to free + * the resources. If not released, too many MediaPlayer instances may result + * in an exception. + *
+ */ + public MediaPlayer(Context ctx) { + this(ctx, false); + } + + private static String path; + + /** + * Default constructor. The same as Android's MediaPlayer(). + *+ * When done with the MediaPlayer, you should call {@link #release()}, to free + * the resources. If not released, too many MediaPlayer instances may result + * in an exception. + *
+ * + * @param preferHWDecoder MediaPlayer will try to use hardware accelerated decoder if true + */ + private static boolean load_omxnative_lib(String path, String name){ + boolean load=false; + + File file=new File(Vitamio.getBrowserLibraryPath() + "/" + name ); + if(file.exists()) + { + load=loadOMX_native(Vitamio.getBrowserLibraryPath()+ "/" + name); + return load; + } + + if(path==""){ + load=loadOMX_native(name); + } + else{ + load=loadOMX_native(path + name); + } + return load; + } + private static boolean loadVVO_native_lib(String path, String name){ + boolean load=false; + File file=new File(Vitamio.getBrowserLibraryPath() + "/"+ name ); + if(file.exists()) + { + load=loadVVO_native(Vitamio.getBrowserLibraryPath() + "/" + name); + return load; + } + + if(path==""){ + load=loadVVO_native(name); + } + else{ + load=loadVVO_native(path + name); + } + return load; + } + + private static boolean loadVAO_native_lib(String path, String name){ + boolean load=false; + File file=new File(Vitamio.getBrowserLibraryPath() + "/"+ name ); + if(file.exists()) + { + load=loadVAO_native(Vitamio.getBrowserLibraryPath() + "/"+ name); + return load; + } + if(path==""){ + load=loadVAO_native(name); + } + else{ + load=loadVAO_native(path + name); + } + return load; + } + + private static boolean loadFFmpeg_native_lib(String path, String name){ + boolean load=false; + File file=new File(Vitamio.getBrowserLibraryPath() + "/"+ name ); + if(file.exists()) + { + load=loadFFmpeg_native(Vitamio.getBrowserLibraryPath() + "/"+ name); + return load; + } + if(path==""){ + load=loadFFmpeg_native(name); + } + else{ + load=loadFFmpeg_native(path + name); + } + return load; + } + private static boolean load_lib(String path, String name){ + File file=new File(Vitamio.getBrowserLibraryPath() + "/"+ name ); + if(file.exists()) + { + System.load(Vitamio.getBrowserLibraryPath() + "/"+ name); + return true; + } + if(path==""){ + System.load(name); + } + else{ + System.load(path + name); + } + return true; + } + public MediaPlayer(Context ctx, boolean preferHWDecoder) { + mContext = ctx; + + String LIB_ROOT; + if(VERSION.SDK_INT > 23) { + LIB_ROOT = Vitamio.getLibraryPath(); + } + else if(VERSION.SDK_INT > 20) { + LIB_ROOT = ""; + } + else{ + LIB_ROOT = Vitamio.getLibraryPath(); + } + + if (preferHWDecoder) { + if (!NATIVE_OMX_LOADED.get()) { + if (Build.VERSION.SDK_INT > 17) + load_omxnative_lib( LIB_ROOT , "libOMX.18.so"); + + else if (Build.VERSION.SDK_INT > 13) + load_omxnative_lib( LIB_ROOT , "libOMX.14.so"); + else if (Build.VERSION.SDK_INT > 10) + load_omxnative_lib( LIB_ROOT , "libOMX.11.so"); + else + load_omxnative_lib( LIB_ROOT , "libOMX.9.so"); + NATIVE_OMX_LOADED.set(true); + } + } else { + try { + unloadOMX_native(); + } catch (UnsatisfiedLinkError e) { + Log.e("unloadOMX failed %s", e.toString()); + } + NATIVE_OMX_LOADED.set(false); + } + + Looper looper; + if ((looper = Looper.myLooper()) != null) + mEventHandler = new EventHandler(this, looper); + else if ((looper = Looper.getMainLooper()) != null) + mEventHandler = new EventHandler(this, looper); + else + mEventHandler = null; + + native_init(); + } + + static { + File libFile; + String LIB_ROOT=""; + + try { + libFile = new File(Vitamio.getLibraryPath()+"libstlport_shared.so" ); + if(libFile.exists()){ + LIB_ROOT=Vitamio.getLibraryPath(); + }else{ + libFile = new File(Vitamio.getDataPath()+"libstlport_shared.so" ); + if(libFile.exists()){ + LIB_ROOT=Vitamio.getDataPath(); + } + } + + if(LIB_ROOT==null){ + System.loadLibrary("stlport_shared"); + System.loadLibrary("vplayer"); + loadFFmpeg_native("libffmpeg.so"); + loadVVO_native("libvvo.9.so"); + loadVVO_native("libvvo.9.so"); + loadVAO_native("libvao.0.so"); + }else{ + System.load(LIB_ROOT+ "libstlport_shared.so"); + System.load(LIB_ROOT+ "libvplayer.so"); + loadFFmpeg_native(LIB_ROOT+"libffmpeg.so"); + loadVVO_native(LIB_ROOT+ "libvvo.9.so"); + loadVAO_native( LIB_ROOT+ "libvao.0.so"); + } + + }catch(Exception e){ + Log.e("load library err "); + } + + } + + private static void postEventFromNative(Object mediaplayer_ref, int what, int arg1, int arg2, Object obj) { + MediaPlayer mp = (MediaPlayer) (mediaplayer_ref); + if (mp == null) + return; + + try { + //synchronized (mp.mEventHandler) { + if (mp.mEventHandler != null) { + Message m = mp.mEventHandler.obtainMessage(what, arg1, arg2, obj); + mp.mEventHandler.sendMessage(m); + } + } catch (Exception e) { + Log.e("exception: " + e); + } + } + + private static native boolean loadVAO_native(String vaoPath); + + private static native boolean loadVVO_native(String vvoPath); + + private static native boolean loadOMX_native(String omxPath); + + private static native void unloadOMX_native(); + + private static native boolean loadFFmpeg_native(String ffmpegPath); + + private native void _setVideoSurface(Surface surface); + + /** + * Sets the SurfaceHolder to use for displaying the video portion of the + * media. This call is optional. Not calling it when playing back a video will + * result in only the audio track being played. + * + * @param sh the SurfaceHolder to use for video display + */ + public void setDisplay(SurfaceHolder sh) { + if (sh == null) { + releaseDisplay(); + } else { + mSurfaceHolder = sh; + mSurface = sh.getSurface(); + _setVideoSurface(mSurface); + updateSurfaceScreenOn(); + } + } + + /** + * Sets the Surface to use for displaying the video portion of the media. This + * is similar to {@link #setDisplay(SurfaceHolder)}. + * + * @param surface the Surface to use for video display + */ + public void setSurface(Surface surface) { + if (surface == null) { + releaseDisplay(); + } else { + mSurfaceHolder = null; + mSurface = surface; + _setVideoSurface(mSurface); + updateSurfaceScreenOn(); + } + } + + /** + * Sets the data source (file-path or http/rtsp URL) to use. + * + * @param path the path of the file, or the http/rtsp URL of the stream you want + * to play + * @throws IllegalStateException if it is called in an invalid state + * + * + * Whenpath refers to a local file, the file may
+ * actually be opened by a process other than the calling
+ * application. This implies that the pathname should be an absolute
+ * path (as any other process runs with unspecified current working
+ * directory), and that the pathname should reference a
+ * world-readable file. As an alternative, the application could
+ * first open the file for reading, and then use the file descriptor
+ * form {@link #setDataSource(FileDescriptor)}.
+ */
+ public void setDataSource(String path) throws IOException, IllegalArgumentException, SecurityException, IllegalStateException {
+ _setDataSource(path, null, null);
+ }
+
+ /**
+ * Sets the data source as a content Uri.
+ *
+ * @param context the Context to use when resolving the Uri
+ * @param uri the Content URI of the data you want to play
+ * @throws IllegalStateException if it is called in an invalid state
+ */
+ public void setDataSource(Context context, Uri uri) throws IOException, IllegalArgumentException, SecurityException, IllegalStateException {
+ setDataSource(context, uri, null);
+ }
+
+ public void setDataSource(Context context, Uri uri, Map+ * In any valid state, if it is called multiple times on the same type of + * track (ie. Video, Audio, Timed Text), the most recent one will be chosen. + *
+ *+ * The first audio and video tracks are selected by default if available, even + * though this method is not called. However, no timed text track will be + * selected until this function is called. + *
+ * + * @param index the index of the track to be selected. The valid range of the + * index is 0..total number of track - 1. The total number of tracks + * as well as the type of each individual track can be found by + * calling {@link #getTrackInfo()} method. + * @see io.vov.vitamio.MediaPlayer#getTrackInfo + */ + public void selectTrack(int index) { + selectOrDeselectBandTrack(index, true /* select */); + } + + /** + * Deselect a track. + *+ * Currently, the track must be a timed text track and no audio or video + * tracks can be deselected. + *
+ * + * @param index the index of the track to be deselected. The valid range of the + * index is 0..total number of tracks - 1. The total number of tracks + * as well as the type of each individual track can be found by + * calling {@link #getTrackInfo()} method. + * @see io.vov.vitamio.MediaPlayer#getTrackInfo + */ + public void deselectTrack(int index) { + selectOrDeselectBandTrack(index, false /* select */); + } + + private void selectOrDeselectBandTrack(int index, boolean select) { + if (mOutOfBandTracks != null) { + SparseArray+ * Bitmap thumb = ThumbnailUtils.createVideoThumbnail(this, videoPath, MINI_KIND); + *+ */ +public class ThumbnailUtils { + private static final int OPTIONS_NONE = 0x0; + private static final int OPTIONS_SCALE_UP = 0x1; + public static final int OPTIONS_RECYCLE_INPUT = 0x2; + public static final int TARGET_SIZE_MINI_THUMBNAIL_WIDTH = 426; + public static final int TARGET_SIZE_MINI_THUMBNAIL_HEIGHT = 320; + public static final int TARGET_SIZE_MICRO_THUMBNAIL_WIDTH = 212; + public static final int TARGET_SIZE_MICRO_THUMBNAIL_HEIGHT = 160; + + + public static Bitmap createVideoThumbnail(Context ctx, String filePath, int kind) { + if (!Vitamio.isInitialized(ctx)) { + return null; + } + Bitmap bitmap = null; + MediaMetadataRetriever retriever = null; + try { + retriever = new MediaMetadataRetriever(ctx); + retriever.setDataSource(filePath); + bitmap = retriever.getFrameAtTime(-1); + } catch (Exception ex) { + } finally { + try { + retriever.release(); + } catch (RuntimeException ex) { + } + } + + if (bitmap != null) { + if (kind == Video.Thumbnails.MICRO_KIND) + bitmap = extractThumbnail(bitmap, TARGET_SIZE_MICRO_THUMBNAIL_WIDTH, TARGET_SIZE_MICRO_THUMBNAIL_HEIGHT, OPTIONS_RECYCLE_INPUT); + else if (kind == Video.Thumbnails.MINI_KIND) + bitmap = extractThumbnail(bitmap, TARGET_SIZE_MINI_THUMBNAIL_WIDTH, TARGET_SIZE_MINI_THUMBNAIL_HEIGHT, OPTIONS_RECYCLE_INPUT); + } + return bitmap; + } + + public static Bitmap extractThumbnail(Bitmap source, int width, int height) { + return extractThumbnail(source, width, height, OPTIONS_NONE); + } + + public static Bitmap extractThumbnail(Bitmap source, int width, int height, int options) { + if (source == null) + return null; + + float scale; + if (source.getWidth() < source.getHeight()) + scale = width / (float) source.getWidth(); + else + scale = height / (float) source.getHeight(); + Matrix matrix = new Matrix(); + matrix.setScale(scale, scale); + Bitmap thumbnail = transform(matrix, source, width, height, OPTIONS_SCALE_UP | options); + return thumbnail; + } + + private static Bitmap transform(Matrix scaler, Bitmap source, int targetWidth, int targetHeight, int options) { + boolean scaleUp = (options & OPTIONS_SCALE_UP) != 0; + boolean recycle = (options & OPTIONS_RECYCLE_INPUT) != 0; + + int deltaX = source.getWidth() - targetWidth; + int deltaY = source.getHeight() - targetHeight; + if (!scaleUp && (deltaX < 0 || deltaY < 0)) { + Bitmap b2 = Bitmap.createBitmap(targetWidth, targetHeight, Bitmap.Config.ARGB_8888); + Canvas c = new Canvas(b2); + + int deltaXHalf = Math.max(0, deltaX / 2); + int deltaYHalf = Math.max(0, deltaY / 2); + Rect src = new Rect(deltaXHalf, deltaYHalf, deltaXHalf + Math.min(targetWidth, source.getWidth()), deltaYHalf + Math.min(targetHeight, source.getHeight())); + int dstX = (targetWidth - src.width()) / 2; + int dstY = (targetHeight - src.height()) / 2; + Rect dst = new Rect(dstX, dstY, targetWidth - dstX, targetHeight - dstY); + c.drawBitmap(source, src, dst, null); + if (recycle) + source.recycle(); + return b2; + } + + float bitmapWidthF = source.getWidth(); + float bitmapHeightF = source.getHeight(); + float bitmapAspect = bitmapWidthF / bitmapHeightF; + float viewAspect = (float) targetWidth / targetHeight; + + float scale = bitmapAspect > viewAspect ? targetHeight / bitmapHeightF : targetWidth / bitmapWidthF; + if (scale < .9F || scale > 1F) + scaler.setScale(scale, scale); + else + scaler = null; + + Bitmap b1; + if (scaler != null) + b1 = Bitmap.createBitmap(source, 0, 0, source.getWidth(), source.getHeight(), scaler, true); + else + b1 = source; + + if (recycle && b1 != source) + source.recycle(); + + int dx1 = Math.max(0, b1.getWidth() - targetWidth); + int dy1 = Math.max(0, b1.getHeight() - targetHeight); + + Bitmap b2 = Bitmap.createBitmap(b1, dx1 / 2, dy1 / 2, targetWidth, targetHeight); + + if (b2 != b1 && (recycle || b1 != source)) + b1.recycle(); + + return b2; + } + +} \ No newline at end of file diff --git a/vitamio/src/io/vov/vitamio/VIntent.java b/vitamio/src/io/vov/vitamio/VIntent.java new file mode 100644 index 0000000..1deb02a --- /dev/null +++ b/vitamio/src/io/vov/vitamio/VIntent.java @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2013 YIXIA.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 io.vov.vitamio; + +/** + * Common intent actions used by Vitamio component. + */ +public class VIntent { + public static final String ACTION_MEDIA_SCANNER_SCAN_DIRECTORY = "com.yixia.vitamio.action.MEDIA_SCANNER_SCAN_DIRECTORY"; + public static final String ACTION_MEDIA_SCANNER_SCAN_FILE = "com.yixia.vitamio.action.MEDIA_SCANNER_SCAN_FILE"; + public static final String ACTION_MEDIA_SCANNER_STARTED = "com.yixia.vitamio.action.MEDIA_SCANNER_STARTED"; + public static final String ACTION_MEDIA_SCANNER_FINISHED = "com.yixia.vitamio.action.MEDIA_SCANNER_FINISHED"; +} diff --git a/vitamio/src/io/vov/vitamio/Vitamio.java b/vitamio/src/io/vov/vitamio/Vitamio.java new file mode 100644 index 0000000..e0d372a --- /dev/null +++ b/vitamio/src/io/vov/vitamio/Vitamio.java @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2013 YIXIA.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 io.vov.vitamio; + +import android.annotation.SuppressLint; +import android.content.Context; +import android.os.Build.VERSION; + +import io.vov.vitamio.utils.CPU; +import io.vov.vitamio.utils.ContextUtils; +import io.vov.vitamio.utils.IOUtils; +import io.vov.vitamio.utils.Log; + + + +/** + * Inspect this class before using any other Vitamio classes. + * + * Don't modify this class, or the full Vitamio library may be broken. + */ +public class Vitamio { + private static String vitamioPackage; + private static String vitamioLibraryPath; + private static String vitamioDataPath; + private static String browserlibraryPath; + + /** + * Check if Vitamio is initialized at this device + * + * @param ctx Android Context + * @return true if the Vitamio has been initialized. + */ + @SuppressLint("NewApi") + public static boolean isInitialized(Context ctx) { + vitamioPackage = ctx.getPackageName(); + + vitamioLibraryPath = ctx.getApplicationInfo().nativeLibraryDir + "/"; + vitamioDataPath = ContextUtils.getDataDir(ctx) + "lib/"; + browserlibraryPath = ctx.getApplicationContext().getDir("libs", Context.MODE_PRIVATE).getPath(); + + return true; + } + + public static String getVitamioPackage() { + return vitamioPackage; + } + + + public static final String getLibraryPath() { + return vitamioLibraryPath; + } + + public static final String getDataPath() { + return vitamioDataPath; + } + + public static final String getBrowserLibraryPath() { + return browserlibraryPath; + } + +} diff --git a/vitamio/src/io/vov/vitamio/VitamioLicense.java b/vitamio/src/io/vov/vitamio/VitamioLicense.java new file mode 100644 index 0000000..13aeb63 --- /dev/null +++ b/vitamio/src/io/vov/vitamio/VitamioLicense.java @@ -0,0 +1,24 @@ +/* + * Copyright (C) 2013 YIXIA.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 io.vov.vitamio; + +/** + * DON'T MODIFY THIS FILE IF YOU WANT TO USE VITAMIO + */ +public class VitamioLicense { + public static final String LICENSE = "Copyright (c) YIXIA (http://yixia.com).\nTHIS SOFTWARE (Vitamio) IS WORK OF YIXIA (http://yixia.com)"; +} \ No newline at end of file diff --git a/vitamio/src/io/vov/vitamio/activity/InitActivity.java b/vitamio/src/io/vov/vitamio/activity/InitActivity.java new file mode 100644 index 0000000..afa9688 --- /dev/null +++ b/vitamio/src/io/vov/vitamio/activity/InitActivity.java @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2013 YIXIA.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 io.vov.vitamio.activity; + +import android.app.Activity; +import android.app.ProgressDialog; +import android.content.Context; +import android.content.Intent; +import android.os.AsyncTask; +import android.os.Bundle; +import android.os.Handler; +import android.os.Message; +import android.view.WindowManager; + +import io.vov.vitamio.Vitamio; + +import java.lang.ref.WeakReference; + +public class InitActivity extends Activity { + public static final String FROM_ME = "fromVitamioInitActivity"; + private ProgressDialog mPD; + private UIHandler uiHandler; + + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); + uiHandler = new UIHandler(this); + + new AsyncTask
The padding '=' characters at the end are considered optional, but + * if any are present, there must be the correct number of them. + * + * @param str the input String to decode, which is converted to + * bytes using the default charset + * @param flags controls certain features of the decoded output. + * Pass {@code DEFAULT} to decode standard Base64. + * + * @throws IllegalArgumentException if the input contains + * incorrect padding + */ + public static byte[] decode(String str, int flags) { + return decode(str.getBytes(), flags); + } + + /** + * Decode the Base64-encoded data in input and return the data in + * a new byte array. + * + *
The padding '=' characters at the end are considered optional, but + * if any are present, there must be the correct number of them. + * + * @param input the input array to decode + * @param flags controls certain features of the decoded output. + * Pass {@code DEFAULT} to decode standard Base64. + * + * @throws IllegalArgumentException if the input contains + * incorrect padding + */ + public static byte[] decode(byte[] input, int flags) { + return decode(input, 0, input.length, flags); + } + + /** + * Decode the Base64-encoded data in input and return the data in + * a new byte array. + * + *
The padding '=' characters at the end are considered optional, but
+ * if any are present, there must be the correct number of them.
+ *
+ * @param input the data to decode
+ * @param offset the position within the input array at which to start
+ * @param len the number of bytes of input to decode
+ * @param flags controls certain features of the decoded output.
+ * Pass {@code DEFAULT} to decode standard Base64.
+ *
+ * @throws IllegalArgumentException if the input contains
+ * incorrect padding
+ */
+ public static byte[] decode(byte[] input, int offset, int len, int flags) {
+ // Allocate space for the most data the input could represent.
+ // (It could contain less if it contains whitespace, etc.)
+ Decoder decoder = new Decoder(flags, new byte[len*3/4]);
+
+ if (!decoder.process(input, offset, len, true)) {
+ throw new IllegalArgumentException("bad base-64");
+ }
+
+ // Maybe we got lucky and allocated exactly enough output space.
+ if (decoder.op == decoder.output.length) {
+ return decoder.output;
+ }
+
+ // Need to shorten the array, so allocate a new one of the
+ // right size and copy.
+ byte[] temp = new byte[decoder.op];
+ System.arraycopy(decoder.output, 0, temp, 0, decoder.op);
+ return temp;
+ }
+
+ /* package */ static class Decoder extends Coder {
+ /**
+ * Lookup table for turning bytes into their position in the
+ * Base64 alphabet.
+ */
+ private static final int DECODE[] = {
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
+ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ };
+
+ /**
+ * Decode lookup table for the "web safe" variant (RFC 3548
+ * sec. 4) where - and _ replace + and /.
+ */
+ private static final int DECODE_WEBSAFE[] = {
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
+ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,
+ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ };
+
+ /** Non-data values in the DECODE arrays. */
+ private static final int SKIP = -1;
+ private static final int EQUALS = -2;
+
+ /**
+ * States 0-3 are reading through the next input tuple.
+ * State 4 is having read one '=' and expecting exactly
+ * one more.
+ * State 5 is expecting no more data or padding characters
+ * in the input.
+ * State 6 is the error state; an error has been detected
+ * in the input and no future input can "fix" it.
+ */
+ private int state; // state number (0 to 6)
+ private int value;
+
+ final private int[] alphabet;
+
+ public Decoder(int flags, byte[] output) {
+ this.output = output;
+
+ alphabet = ((flags & URL_SAFE) == 0) ? DECODE : DECODE_WEBSAFE;
+ state = 0;
+ value = 0;
+ }
+
+ /**
+ * @return an overestimate for the number of bytes {@code
+ * len} bytes could decode to.
+ */
+ public int maxOutputSize(int len) {
+ return len * 3/4 + 10;
+ }
+
+ /**
+ * Decode another block of input data.
+ *
+ * @return true if the state machine is still healthy. false if
+ * bad base-64 data has been detected in the input stream.
+ */
+ public boolean process(byte[] input, int offset, int len, boolean finish) {
+ if (this.state == 6) return false;
+
+ int p = offset;
+ len += offset;
+
+ // Using local variables makes the decoder about 12%
+ // faster than if we manipulate the member variables in
+ // the loop. (Even alphabet makes a measurable
+ // difference, which is somewhat surprising to me since
+ // the member variable is final.)
+ int state = this.state;
+ int value = this.value;
+ int op = 0;
+ final byte[] output = this.output;
+ final int[] alphabet = this.alphabet;
+
+ while (p < len) {
+ // Try the fast path: we're starting a new tuple and the
+ // next four bytes of the input stream are all data
+ // bytes. This corresponds to going through states
+ // 0-1-2-3-0. We expect to use this method for most of
+ // the data.
+ //
+ // If any of the next four bytes of input are non-data
+ // (whitespace, etc.), value will end up negative. (All
+ // the non-data values in decode are small negative
+ // numbers, so shifting any of them up and or'ing them
+ // together will result in a value with its top bit set.)
+ //
+ // You can remove this whole block and the output should
+ // be the same, just slower.
+ if (state == 0) {
+ while (p+4 <= len &&
+ (value = ((alphabet[input[p] & 0xff] << 18) |
+ (alphabet[input[p+1] & 0xff] << 12) |
+ (alphabet[input[p+2] & 0xff] << 6) |
+ (alphabet[input[p+3] & 0xff]))) >= 0) {
+ output[op+2] = (byte) value;
+ output[op+1] = (byte) (value >> 8);
+ output[op] = (byte) (value >> 16);
+ op += 3;
+ p += 4;
+ }
+ if (p >= len) break;
+ }
+
+ // The fast path isn't available -- either we've read a
+ // partial tuple, or the next four input bytes aren't all
+ // data, or whatever. Fall back to the slower state
+ // machine implementation.
+
+ int d = alphabet[input[p++] & 0xff];
+
+ switch (state) {
+ case 0:
+ if (d >= 0) {
+ value = d;
+ ++state;
+ } else if (d != SKIP) {
+ this.state = 6;
+ return false;
+ }
+ break;
+
+ case 1:
+ if (d >= 0) {
+ value = (value << 6) | d;
+ ++state;
+ } else if (d != SKIP) {
+ this.state = 6;
+ return false;
+ }
+ break;
+
+ case 2:
+ if (d >= 0) {
+ value = (value << 6) | d;
+ ++state;
+ } else if (d == EQUALS) {
+ // Emit the last (partial) output tuple;
+ // expect exactly one more padding character.
+ output[op++] = (byte) (value >> 4);
+ state = 4;
+ } else if (d != SKIP) {
+ this.state = 6;
+ return false;
+ }
+ break;
+
+ case 3:
+ if (d >= 0) {
+ // Emit the output triple and return to state 0.
+ value = (value << 6) | d;
+ output[op+2] = (byte) value;
+ output[op+1] = (byte) (value >> 8);
+ output[op] = (byte) (value >> 16);
+ op += 3;
+ state = 0;
+ } else if (d == EQUALS) {
+ // Emit the last (partial) output tuple;
+ // expect no further data or padding characters.
+ output[op+1] = (byte) (value >> 2);
+ output[op] = (byte) (value >> 10);
+ op += 2;
+ state = 5;
+ } else if (d != SKIP) {
+ this.state = 6;
+ return false;
+ }
+ break;
+
+ case 4:
+ if (d == EQUALS) {
+ ++state;
+ } else if (d != SKIP) {
+ this.state = 6;
+ return false;
+ }
+ break;
+
+ case 5:
+ if (d != SKIP) {
+ this.state = 6;
+ return false;
+ }
+ break;
+ }
+ }
+
+ if (!finish) {
+ // We're out of input, but a future call could provide
+ // more.
+ this.state = state;
+ this.value = value;
+ this.op = op;
+ return true;
+ }
+
+ // Done reading input. Now figure out where we are left in
+ // the state machine and finish up.
+
+ switch (state) {
+ case 0:
+ // Output length is a multiple of three. Fine.
+ break;
+ case 1:
+ // Read one extra input byte, which isn't enough to
+ // make another output byte. Illegal.
+ this.state = 6;
+ return false;
+ case 2:
+ // Read two extra input bytes, enough to emit 1 more
+ // output byte. Fine.
+ output[op++] = (byte) (value >> 4);
+ break;
+ case 3:
+ // Read three extra input bytes, enough to emit 2 more
+ // output bytes. Fine.
+ output[op++] = (byte) (value >> 10);
+ output[op++] = (byte) (value >> 2);
+ break;
+ case 4:
+ // Read one padding '=' when we expected 2. Illegal.
+ this.state = 6;
+ return false;
+ case 5:
+ // Read all the padding '='s we expected and no more.
+ // Fine.
+ break;
+ }
+
+ this.state = state;
+ this.op = op;
+ return true;
+ }
+ }
+
+ // --------------------------------------------------------
+ // encoding
+ // --------------------------------------------------------
+
+ /**
+ * Base64-encode the given data and return a newly allocated
+ * String with the result.
+ *
+ * @param input the data to encode
+ * @param flags controls certain features of the encoded output.
+ * Passing {@code DEFAULT} results in output that
+ * adheres to RFC 2045.
+ */
+ public static String encodeToString(byte[] input, int flags) {
+ try {
+ return new String(encode(input, flags), "US-ASCII");
+ } catch (UnsupportedEncodingException e) {
+ // US-ASCII is guaranteed to be available.
+ throw new AssertionError(e);
+ }
+ }
+
+ /**
+ * Base64-encode the given data and return a newly allocated
+ * String with the result.
+ *
+ * @param input the data to encode
+ * @param offset the position within the input array at which to
+ * start
+ * @param len the number of bytes of input to encode
+ * @param flags controls certain features of the encoded output.
+ * Passing {@code DEFAULT} results in output that
+ * adheres to RFC 2045.
+ */
+ public static String encodeToString(byte[] input, int offset, int len, int flags) {
+ try {
+ return new String(encode(input, offset, len, flags), "US-ASCII");
+ } catch (UnsupportedEncodingException e) {
+ // US-ASCII is guaranteed to be available.
+ throw new AssertionError(e);
+ }
+ }
+
+ /**
+ * Base64-encode the given data and return a newly allocated
+ * byte[] with the result.
+ *
+ * @param input the data to encode
+ * @param flags controls certain features of the encoded output.
+ * Passing {@code DEFAULT} results in output that
+ * adheres to RFC 2045.
+ */
+ public static byte[] encode(byte[] input, int flags) {
+ return encode(input, 0, input.length, flags);
+ }
+
+ /**
+ * Base64-encode the given data and return a newly allocated
+ * byte[] with the result.
+ *
+ * @param input the data to encode
+ * @param offset the position within the input array at which to
+ * start
+ * @param len the number of bytes of input to encode
+ * @param flags controls certain features of the encoded output.
+ * Passing {@code DEFAULT} results in output that
+ * adheres to RFC 2045.
+ */
+ public static byte[] encode(byte[] input, int offset, int len, int flags) {
+ Encoder encoder = new Encoder(flags, null);
+
+ // Compute the exact length of the array we will produce.
+ int output_len = len / 3 * 4;
+
+ // Account for the tail of the data and the padding bytes, if any.
+ if (encoder.do_padding) {
+ if (len % 3 > 0) {
+ output_len += 4;
+ }
+ } else {
+ switch (len % 3) {
+ case 0: break;
+ case 1: output_len += 2; break;
+ case 2: output_len += 3; break;
+ }
+ }
+
+ // Account for the newlines, if any.
+ if (encoder.do_newline && len > 0) {
+ output_len += (((len-1) / (3 * Encoder.LINE_GROUPS)) + 1) *
+ (encoder.do_cr ? 2 : 1);
+ }
+
+ encoder.output = new byte[output_len];
+ encoder.process(input, offset, len, true);
+
+ assert encoder.op == output_len;
+
+ return encoder.output;
+ }
+
+ /* package */ static class Encoder extends Coder {
+ /**
+ * Emit a new line every this many output tuples. Corresponds to
+ * a 76-character line length (the maximum allowable according to
+ * RFC 2045).
+ */
+ public static final int LINE_GROUPS = 19;
+
+ /**
+ * Lookup table for turning Base64 alphabet positions (6 bits)
+ * into output bytes.
+ */
+ private static final byte ENCODE[] = {
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+ 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+ 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+ 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/',
+ };
+
+ /**
+ * Lookup table for turning Base64 alphabet positions (6 bits)
+ * into output bytes.
+ */
+ private static final byte ENCODE_WEBSAFE[] = {
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+ 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+ 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+ 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_',
+ };
+
+ final private byte[] tail;
+ /* package */ int tailLen;
+ private int count;
+
+ final public boolean do_padding;
+ final public boolean do_newline;
+ final public boolean do_cr;
+ final private byte[] alphabet;
+
+ public Encoder(int flags, byte[] output) {
+ this.output = output;
+
+ do_padding = (flags & NO_PADDING) == 0;
+ do_newline = (flags & NO_WRAP) == 0;
+ do_cr = (flags & CRLF) != 0;
+ alphabet = ((flags & URL_SAFE) == 0) ? ENCODE : ENCODE_WEBSAFE;
+
+ tail = new byte[2];
+ tailLen = 0;
+
+ count = do_newline ? LINE_GROUPS : -1;
+ }
+
+ /**
+ * @return an overestimate for the number of bytes {@code
+ * len} bytes could encode to.
+ */
+ public int maxOutputSize(int len) {
+ return len * 8/5 + 10;
+ }
+
+ public boolean process(byte[] input, int offset, int len, boolean finish) {
+ // Using local variables makes the encoder about 9% faster.
+ final byte[] alphabet = this.alphabet;
+ final byte[] output = this.output;
+ int op = 0;
+ int count = this.count;
+
+ int p = offset;
+ len += offset;
+ int v = -1;
+
+ // First we need to concatenate the tail of the previous call
+ // with any input bytes available now and see if we can empty
+ // the tail.
+
+ switch (tailLen) {
+ case 0:
+ // There was no tail.
+ break;
+
+ case 1:
+ if (p+2 <= len) {
+ // A 1-byte tail with at least 2 bytes of
+ // input available now.
+ v = ((tail[0] & 0xff) << 16) |
+ ((input[p++] & 0xff) << 8) |
+ (input[p++] & 0xff);
+ tailLen = 0;
+ };
+ break;
+
+ case 2:
+ if (p+1 <= len) {
+ // A 2-byte tail with at least 1 byte of input.
+ v = ((tail[0] & 0xff) << 16) |
+ ((tail[1] & 0xff) << 8) |
+ (input[p++] & 0xff);
+ tailLen = 0;
+ }
+ break;
+ }
+
+ if (v != -1) {
+ output[op++] = alphabet[(v >> 18) & 0x3f];
+ output[op++] = alphabet[(v >> 12) & 0x3f];
+ output[op++] = alphabet[(v >> 6) & 0x3f];
+ output[op++] = alphabet[v & 0x3f];
+ if (--count == 0) {
+ if (do_cr) output[op++] = '\r';
+ output[op++] = '\n';
+ count = LINE_GROUPS;
+ }
+ }
+
+ // At this point either there is no tail, or there are fewer
+ // than 3 bytes of input available.
+
+ // The main loop, turning 3 input bytes into 4 output bytes on
+ // each iteration.
+ while (p+3 <= len) {
+ v = ((input[p] & 0xff) << 16) |
+ ((input[p+1] & 0xff) << 8) |
+ (input[p+2] & 0xff);
+ output[op] = alphabet[(v >> 18) & 0x3f];
+ output[op+1] = alphabet[(v >> 12) & 0x3f];
+ output[op+2] = alphabet[(v >> 6) & 0x3f];
+ output[op+3] = alphabet[v & 0x3f];
+ p += 3;
+ op += 4;
+ if (--count == 0) {
+ if (do_cr) output[op++] = '\r';
+ output[op++] = '\n';
+ count = LINE_GROUPS;
+ }
+ }
+
+ if (finish) {
+ // Finish up the tail of the input. Note that we need to
+ // consume any bytes in tail before any bytes
+ // remaining in input; there should be at most two bytes
+ // total.
+
+ if (p-tailLen == len-1) {
+ int t = 0;
+ v = ((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 4;
+ tailLen -= t;
+ output[op++] = alphabet[(v >> 6) & 0x3f];
+ output[op++] = alphabet[v & 0x3f];
+ if (do_padding) {
+ output[op++] = '=';
+ output[op++] = '=';
+ }
+ if (do_newline) {
+ if (do_cr) output[op++] = '\r';
+ output[op++] = '\n';
+ }
+ } else if (p-tailLen == len-2) {
+ int t = 0;
+ v = (((tailLen > 1 ? tail[t++] : input[p++]) & 0xff) << 10) |
+ (((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 2);
+ tailLen -= t;
+ output[op++] = alphabet[(v >> 12) & 0x3f];
+ output[op++] = alphabet[(v >> 6) & 0x3f];
+ output[op++] = alphabet[v & 0x3f];
+ if (do_padding) {
+ output[op++] = '=';
+ }
+ if (do_newline) {
+ if (do_cr) output[op++] = '\r';
+ output[op++] = '\n';
+ }
+ } else if (do_newline && op > 0 && count != LINE_GROUPS) {
+ if (do_cr) output[op++] = '\r';
+ output[op++] = '\n';
+ }
+
+ assert tailLen == 0;
+ assert p == len;
+ } else {
+ // Save the leftovers in tail to be consumed on the next
+ // call to encodeInternal.
+
+ if (p == len-1) {
+ tail[tailLen++] = input[p];
+ } else if (p == len-2) {
+ tail[tailLen++] = input[p];
+ tail[tailLen++] = input[p+1];
+ }
+ }
+
+ this.op = op;
+ this.count = count;
+
+ return true;
+ }
+ }
+
+ private Base64() { } // don't instantiate
+}
diff --git a/vitamio/src/io/vov/vitamio/utils/CPU.java b/vitamio/src/io/vov/vitamio/utils/CPU.java
new file mode 100644
index 0000000..3fd557d
--- /dev/null
+++ b/vitamio/src/io/vov/vitamio/utils/CPU.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2012 YIXIA.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 io.vov.vitamio.utils;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import android.os.Build;
+import android.text.TextUtils;
+
+public class CPU {
+ private static final Map
+ * Change the animation style resource for this controller.
+ *
+ * If the controller is showing, calling this method will take effect only the
+ * next time the controller is shown.
+ *
+ *
+ * @param aspectRatio video aspect ratio, will audo detect if 0.
+ */
+ public void setVideoLayout(int layout, float aspectRatio) {
+ LayoutParams lp = getLayoutParams();
+ Pair