最简单的基于FFmpeg的移动端例子

package org.libsdl.app; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.List; import android.app.*; import android.content.*; import android.view.*; import android.view.inputmethod.BaseInputConnection; import android.view.inputmethod.EditorInfo; import android.view.inputmethod.InputConnection; import android.view.inputmethod.InputMethodManager; import android.widget.AbsoluteLayout; import android.os.*; import android.util.Log; import android.graphics.*; import android.media.*; import android.hardware.*; /** SDL Activity */ public class SDLActivity extends Activity { private static final String TAG = "SDL"; // Keep track of the paused state public static boolean mIsPaused, mIsSurfaceReady, mHasFocus; public static boolean mExitCalledFromJava; // Main components protected static SDLActivity mSingleton; protected static SDLSurface mSurface; protected static View mTextEdit; protected static ViewGroup mLayout; protected static SDLJoystickHandler mJoystickHandler; // This is what SDL runs in. It invokes SDL_main(), eventually protected static Thread mSDLThread; // Audio protected static AudioTrack mAudioTrack; // Load the .so static { System.loadLibrary("SDL2"); //System.loadLibrary("SDL2_image"); //System.loadLibrary("SDL2_mixer"); //System.loadLibrary("SDL2_net"); //System.loadLibrary("SDL2_ttf"); System.loadLibrary("SDL2main"); } public static void initialize() { // The static nature of the singleton and Android quirkyness force us to initialize everything here // Otherwise, when exiting the app and returning to it, these variables *keep* their pre exit values mSingleton = null; mSurface = null; mTextEdit = null; mLayout = null; mJoystickHandler = null; mSDLThread = null; mAudioTrack = null; mExitCalledFromJava = false; mIsPaused = false; mIsSurfaceReady = false; mHasFocus = true; } // Setup @Override protected void onCreate(Bundle savedInstanceState) { Log.v("SDL", "onCreate():" + mSingleton); super.onCreate(savedInstanceState); SDLActivity.initialize(); // So we can call stuff from static callbacks mSingleton = this; // Set up the surface mSurface = new SDLSurface(getApplication()); if(Build.VERSION.SDK_INT >= 12) { mJoystickHandler = new SDLJoystickHandler_API12(); } else { mJoystickHandler = new SDLJoystickHandler(); } mLayout = new AbsoluteLayout(this); mLayout.addView(mSurface); setContentView(mLayout); } // Events @Override protected void onPause() { Log.v("SDL", "onPause()"); super.onPause(); SDLActivity.handlePause(); } @Override protected void onResume() { Log.v("SDL", "onResume()"); super.onResume(); SDLActivity.handleResume(); } @Override public void onWindowFocusChanged(boolean hasFocus) { super.onWindowFocusChanged(hasFocus); Log.v("SDL", "onWindowFocusChanged(): " + hasFocus); SDLActivity.mHasFocus = hasFocus; if (hasFocus) { SDLActivity.handleResume(); } } @Override public void onLowMemory() { Log.v("SDL", "onLowMemory()"); super.onLowMemory(); SDLActivity.nativeLowMemory(); } @Override protected void onDestroy() { Log.v("SDL", "onDestroy()"); // Send a quit message to the application SDLActivity.mExitCalledFromJava = true; SDLActivity.nativeQuit(); // Now wait for the SDL thread to quit if (SDLActivity.mSDLThread != null) { try { SDLActivity.mSDLThread.join(); } catch(Exception e) { Log.v("SDL", "Problem stopping thread: " + e); } SDLActivity.mSDLThread = null; //Log.v("SDL", "Finished waiting for SDL thread"); } super.onDestroy(); // Reset everything in case the user re opens the app SDLActivity.initialize(); } @Override public boolean dispatchKeyEvent(KeyEvent event) { int keyCode = event.getKeyCode(); // Ignore certain special keys so they're handled by Android if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN || keyCode == KeyEvent.KEYCODE_VOLUME_UP || keyCode == KeyEvent.KEYCODE_CAMERA || keyCode == 168 || /* API 11: KeyEvent.KEYCODE_ZOOM_IN */ keyCode == 169 /* API 11: KeyEvent.KEYCODE_ZOOM_OUT */ ) { return false; } return super.dispatchKeyEvent(event); } /** Called by onPause or surfaceDestroyed. Even if surfaceDestroyed * is the first to be called, mIsSurfaceReady should still be set * to 'true' during the call to onPause (in a usual scenario). */ public static void handlePause() { if (!SDLActivity.mIsPaused && SDLActivity.mIsSurfaceReady) { SDLActivity.mIsPaused = true; SDLActivity.nativePause(); mSurface.enableSensor(Sensor.TYPE_ACCELEROMETER, false); } } /** Called by onResume or surfaceCreated. An actual resume should be done only when the surface is ready. * Note: Some Android variants may send multiple surfaceChanged events, so we don't need to resume * every time we get one of those events, only if it comes after surfaceDestroyed */ public static void handleResume() { if (SDLActivity.mIsPaused && SDLActivity.mIsSurfaceReady && SDLActivity.mHasFocus) { SDLActivity.mIsPaused = false; SDLActivity.nativeResume(); mSurface.enableSensor(Sensor.TYPE_ACCELEROMETER, true); } } /* The native thread has finished */ public static void handleNativeExit() { SDLActivity.mSDLThread = null; mSingleton.finish(); } // Messages from the SDLMain thread static final int COMMAND_CHANGE_TITLE = 1; static final int COMMAND_UNUSED = 2; static final int COMMAND_TEXTEDIT_HIDE = 3; protected static final int COMMAND_USER = 0x8000; /** * This method is called by SDL if SDL did not handle a message itself. * This happens if a received message contains an unsupported command. * Method can be overwritten to handle Messages in a different class. * @param command the command of the message. * @param param the parameter of the message. May be null. * @return if the message was handled in overridden method. */ protected boolean onUnhandledMessage(int command, Object param) { return false; } /** * A Handler class for Messages from native SDL applications. * It uses current Activities as target (e.g. for the title). * static to prevent implicit references to enclosing object. */ protected static class SDLCommandHandler extends Handler { @Override public void handleMessage(Message msg) { Context context = getContext(); if (context == null) { Log.e(TAG, "error handling message, getContext() returned null"); return; } switch (msg.arg1) { case COMMAND_CHANGE_TITLE: if (context instanceof Activity) { ((Activity) context).setTitle((String)msg.obj); } else { Lo