2012-06-05 18 views
7

Sto provando a creare la libreria FFMPEG per la mia applicazione Android utilizzando NDK. Ho scaricato il codice sorgente dal suo sito web e penso di averlo creato (è il mio primo tentativo di lavorare con NDK e ffmpeg). Ho creato un file build.sh che sto usando per eseguirlo dalla riga di comando su Mac OS X. Ma ho qualche domanda ...Android NDK e FFMPEG build

Le prime cose sono che so che ho bisogno del file di Android.mk così posso utilizzare la libreria creata nella mia applicazione, ma non so come farlo per ragioni che ho detto sopra. Dopo aver eseguito il mio build.sh ottengo la cartella android con alcune cartelle e alcune librerie. Quindi la mia prima domanda è, come posso creare il file Android.mk di cui ho bisogno ... e forse se qualcuno può spiegarmi perché ne ho bisogno.

enter image description here

mia seconda domanda è ho bisogno di alcune librerie di ffmpeg per essere in grado di usarli dalla mia app, ma dopo che la build non riesco a vederli nel mio albero dei sorgenti. So che devo abilitarli nel mio build.sh e penso di averlo fatto, ma non riesco a vederli. Quindi qualsiasi tipo di informazione sul mio file di build sarà utile per capire come configurarlo. Ecco come sembra:

#!/bin/bash 
###################################################### 
# Usage: 
# put this script in top of FFmpeg source tree 
# ./build_android 
# It generates binary for following architectures: 
# ARMv6 
# ARMv6+VFP 
# ARMv7+VFPv3-d16 (Tegra2) 
# ARMv7+Neon (Cortex-A8) 
# Customizing: 
# 1. Feel free to change ./configure parameters for more features 
# 2. To adapt other ARM variants 
# set $CPU and $OPTIMIZE_CFLAGS 
# call build_one 
###################################################### 
NDK=~/Desktop/android-ndk-r5b 
PLATFORM=$NDK/platforms/android-8/arch-arm/ 
PREBUILT=$NDK/toolchains/arm-linux-androideabi-4.4.3/prebuilt/darwin-x86 
function build_one 
{ 
./configure \ 
    --target-os=darwin \ 
    --prefix=$PREFIX \ 
    --enable-cross-compile \ 
    --extra-libs="-lgcc" \ 
    --arch=arm \ 
    --cc=$PREBUILT/bin/arm-linux-androideabi-gcc \ 
    --cross-prefix=$PREBUILT/bin/arm-linux-androideabi- \ 
    --nm=$PREBUILT/bin/arm-linux-androideabi-nm \ 
    --sysroot=$PLATFORM \ 
    --extra-cflags=" -O3 -fpic -DANDROID -DHAVE_SYS_UIO_H=1 -Dipv6mr_interface=ipv6mr_ifindex -fasm -Wno-psabi -fno-short-enums -fno-strict-aliasing -finline-limit=300 $OPTIMIZE_CFLAGS " \ 
    --disable-doc \ 
    --disable-ffmpeg \ 
    --disable-ffplay \ 
    --disable-ffserver \ 
    --disable-ffprobe \ 
    --extra-ldflags="-Wl,-rpath-link=$PLATFORM/usr/lib -L$PLATFORM/usr/lib -nostdlib -lc -lm -ldl -llog" \ 
    --enable-zlib \ 
    --enable-version3 \ 
    --enable-nonfree \ 
    --enable-libmp3lame \ 
    --enable-libspeex \ 
    --enable-libtheora \ 
    --enable-libfaac \ 
    --enable-libvorbis \ 
    --enable-libaacplus \ 
    --prefix=$DIST_DIR \ 
    $ADDITIONAL_CONFIGURE_FLAG 

make clean 
make -j4 install 
$PREBUILT/bin/arm-linux-androideabi-ar d libavcodec/libavcodec.a inverse.o 
$PREBUILT/bin/arm-linux-androideabi-ld -rpath-link=$PLATFORM/usr/lib -L$PLATFORM/usr/lib -soname libffmpeg.so -shared -nostdlib -z,noexecstack -Bsymbolic --whole-archive --no-undefined -o $PREFIX/libffmpeg.so libavcodec/libavcodec.a libavformat/libavformat.a libavutil/libavutil.a libswscale/libswscale.a -lc -lm -lz -ldl -llog --warn-once --dynamic-linker=/system/bin/linker $PREBUILT/lib/gcc/arm-linux-androideabi/4.4.3/libgcc.a 
} 

#arm v6 
#CPU=armv6 
#OPTIMIZE_CFLAGS="-marm -march=$CPU" 
#PREFIX=./android/$CPU 
#ADDITIONAL_CONFIGURE_FLAG= 
#build_one 

#arm v7vfpv3 
CPU=armv7-a 
OPTIMIZE_CFLAGS="-mfloat-abi=softfp -mfpu=vfpv3-d16 -marm -march=$CPU " 
PREFIX=./android/$CPU 
ADDITIONAL_CONFIGURE_FLAG= 
build_one 

#arm v7vfp 
#CPU=armv7-a 
#OPTIMIZE_CFLAGS="-mfloat-abi=softfp -mfpu=vfp -marm -march=$CPU " 
#PREFIX=./android/$CPU-vfp 
#ADDITIONAL_CONFIGURE_FLAG= 
#build_one 

#arm v7n 
#CPU=armv7-a 
#OPTIMIZE_CFLAGS="-mfloat-abi=softfp -mfpu=neon -marm -march=$CPU -mtune=cortex-a8" 
#PREFIX=./android/$CPU 
#ADDITIONAL_CONFIGURE_FLAG=--enable-neon 
#build_one 

#arm v6+vfp 
#CPU=armv6 
#OPTIMIZE_CFLAGS="-DCMP_HAVE_VFP -mfloat-abi=softfp -mfpu=vfp -marm -march=$CPU" 
#PREFIX=./android/${CPU}_vfp 
#ADDITIONAL_CONFIGURE_FLAG= 
#build_one 

Grazie per qualsiasi tipo di informazione utile/suggerimenti/esempi e ecc

risposta

5

Prima di tutto, si dovrebbe leggere la documentazione per Android NDK e verificare alcune campione app. Questi dettagli sono disponibili in Android_NDK_home/docs e android_NDK_home/samples (dove android_NDK_home è il nome della cartella per Android NDK).

Inoltre, controllare questo link su StackOverflow: Using FFmpeg with Android-NDK

Per uno stept a passo, questa è una abbastanza buona: http://www.roman10.net/how-to-build-ffmpeg-for-android/

Inoltre, dovrete installare/configurare alcuni elementi sul vostro Eclipse per abilitare il supporto per lo sviluppo di applicazioni che sono costruiti con l'NDK: http://mhandroid.wordpress.com/2011/01/23/using-eclipse-for-android-cc-development/ http://wiki.eclipse.org/Sequoyah/ndk_checklist

E un buon proje ct che utilizza la libreria ffmpeg: https://github.com/havlenapetr/FFMpeg

+0

sarà presente anche funzionare se compilo in Ubuntu 12.10 macchina a 64-bit? E con l'ultimo NDK? – agony

+0

Mi dispiace agonia, non ne ho idea, ho usato solo il Mac. Ma non vedo alcun motivo per cui non dovrebbe funzionare su Ubuntu – bogdan

+0

@bogdan come usare questo per comprimere i video https://github.com/havlenapetr/FFMpeg –

11

ho fatto un tutorial su come costruire ffmpeg e x264 per android: zip with build of ffmpeg with x264

È anche possibile scaricare il file zip contenente i file necessari per fare una domanda su android.

+0

La tua url download è stata bloccata, fornisci qualsiasi altra assistenza allo stesso –

+0

Ancora funzionante l'url – Estevex

+1

@Estevex Url non funzionante Ho provato – Nisarg

9

Se vuoi istruzioni più dettagliate di come costruire ffmpeg e come usarlo per costruire applicazioni Android, si prega di fare riferimento al libro NDK Android libro di cucina: http://www.packtpub.com/android-native-development-kit-cookbook/book

Il Bonus Capitolo 1 è dedicato a sviluppo di applicazioni multimediali con NDK Android e ffmpeg, ed è disponibile gratuitamente al http://www.packtpub.com/sites/default/files/downloads/Developing_Multimedia_Applications_with_NDK.pdf

1

ffmpeg utilizza autoconf come sistema di generazione. Al momento della stesura di questo articolo, nessuno ha ancora creato un pacchetto di build Gradle per ffmpeg su Android.Per quanto ne so, Gradle non supporta ancora autoconf, il che rende piuttosto difficile farlo

Detto questo, dopo aver provato alcuni dei tutorial che erano là fuori, così come alcuni dei pre-costruiti pacchetti, abbiamo deciso di lanciare il nostro wrapper di script build Android per ffmpeg che include il supporto per OpenSSL e librtmp.

Lo si può trovare qui: https://github.com/cine-io/android-ffmpeg-with-rtmp

Prerequisito: Il Android NDK deve essere installato

Istruzioni:

$ git clone [email protected]:cine-io/android-ffmpeg-with-rtmp.git 
$ cd android-ffmpeg-with-rtmp 
$ ./build.sh 

Quando lo script è terminato, le librerie condivise richieste e L'eseguibile ffmpeg verrà inserito nella directory build/dist. Puoi includerli nel tuo progetto proprio come qualsiasi altro binario nativo.

+0

Ero eccitato nel vedere che questo potrebbe effettivamente lavoro, ma poi ho ricevuto un errore. Questo dovrebbe funzionare quando si costruisce su un Mac? La console ha raggiunto il punto in cui diceva "Impossibile configurare ffmpeg!" E il file build.log diceva "ERRORE: librtmp non trovato". Qualche idea? – bracken

0

Per costruire eseguibile di ffmpeg, io uso il seguente Android.mk:

SYSROOT-armeabi-v7a  := $(NDK_ROOT)/platforms/android-9/arch-arm/ 
SYSROOT-arm64-v8a := $(NDK_ROOT)/platforms/android-21/arch-arm64/ 
SYSROOT-x86  := $(NDK_ROOT)/platforms/android-9/arch-x86/ 
SYSROOT := $(SYSROOT-$(TARGET_ARCH_ABI)) 

TOOLCHAIN_TARGET_ARCH-armeabi-v7a := arm 
TOOLCHAIN_TARGET_ARCH-arm64-v8a := aarch64 
TOOLCHAIN_TARGET_ARCH-x86 := i686 
TOOLCHAIN_TARGET_ARCH := $(TOOLCHAIN_TARGET_ARCH-$(TARGET_ARCH_ABI)) 

TOOLCHAIN_TARGET_ABI-armeabi-v7a := androideabi 
TOOLCHAIN_TARGET_ABI-arm64-v8a := android 
TOOLCHAIN_TARGET_ABI-x86 := android 
TOOLCHAIN_TARGET_ABI := $(TOOLCHAIN_TARGET_ABI-$(TARGET_ARCH_ABI)) 

TOOLCHAIN_TRIPLET := $(TOOLCHAIN_TARGET_ARCH)-linux-$(TOOLCHAIN_TARGET_ABI)- 

TOOLCHAIN_NAME-$(TARGET_ARCH_ABI) := $(TOOLCHAIN_TRIPLET)$(TOOLCHAIN_VERSION) 
TOOLCHAIN_NAME-x86 := x86-$(TOOLCHAIN_VERSION) 
TOOLCHAIN_NAME := $(TOOLCHAIN_NAME-$(TARGET_ARCH_ABI)) 

TOOLCHAIN_VERSION_PREFIX := $(TOOLCHAIN_TRIPLET)$(TOOLCHAIN_VERSION) 

ARCH_ARM_MODE-armeabi := arm 
ARCH_ARM_MODE-armeabi-v7a := thumb 
ARCH_ARM_MODE-arm64-v8a := thumb 
ARCH_ARM_MODE := $(ARCH_ARM_MODE-$(TARGET_ARCH_ABI)) 

include $(CLEAR_VARS) 
LOCAL_ARM_MODE := $(ARCH_ARM_MODE) 

FFMPEG_PATH  := $(BUILD_DIRECTORY)/ffmpeg 

LOCAL_CFLAGS-armeabi-v7a := -march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=softfp 
LOCAL_CFLAGS-x86 := -m32 
LOCAL_CFLAGS-arm64-v8a := -march=armv8-a+simd+fp 

LOCAL_CFLAGS := $(LOCAL_CFLAGS-$(TARGET_ARCH_ABI)) 

LOCAL_LDFLAGS-x86 := -m32 -Wl,-eh-frame-hdr -Wl,-m,elf_i386 -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now 

LOCAL_LDFLAGS := $(LOCAL_LDFLAGS-$(TARGET_ARCH_ABI)) 

LOCAL_CFLAGS += -fPIE 
LOCAL_LDFLAGS += -fPIE -pie 

FFMPEG_CONFIG_OPTS := 

FFMPEG_CONFIG_OPTS += --target-os=linux 
FFMPEG_CONFIG_OPTS-$(TARGET_ARCH_ABI) := --cross-prefix=$(TOOLCHAIN_PREFIX) 
FFMPEG_CONFIG_OPTS-$(TARGET_ARCH_ABI) += --enable-cross-compile 
FFMPEG_CONFIG_OPTS-$(TARGET_ARCH_ABI) += --sysroot=$(SYSROOT) 
FFMPEG_CONFIG_OPTS += $(FFMPEG_CONFIG_OPTS-$(TARGET_ARCH_ABI)) 

## disable 
FFMPEG_CONFIG_OPTS += --disable-doc 
FFMPEG_CONFIG_OPTS += --disable-shared 
FFMPEG_CONFIG_OPTS += --disable-avdevice 
FFMPEG_CONFIG_OPTS += --disable-postproc 
FFMPEG_CONFIG_OPTS += --disable-network 
FFMPEG_CONFIG_OPTS += --disable-iconv 
FFMPEG_CONFIG_OPTS += --disable-zlib 
FFMPEG_CONFIG_OPTS += --disable-ffplay 
FFMPEG_CONFIG_OPTS += --disable-ffprobe 
FFMPEG_CONFIG_OPTS += --disable-ffserver 
FFMPEG_CONFIG_OPTS += --disable-swscale-alpha 
## enable 
FFMPEG_CONFIG_OPTS += --enable-pthreads 
FFMPEG_CONFIG_OPTS += --enable-small 

FFMPEG_CONFIG_OPTS += --extra-cflags="$(LOCAL_CFLAGS)" 
FFMPEG_CONFIG_OPTS += --extra-cxxflags="$(LOCAL_CXXFLAGS)" 
FFMPEG_CONFIG_OPTS += --extra-ldflags="$(LOCAL_LDFLAGS)" 

FFMPEG_CONFIG_OPTS += --enable-runtime-cpudetect 

ARMBITS-$(TARGET_ARCH_ABI) := 
ARMBITS-arm64-v8a := 64 
ARMBITS := $(ARMBITS-$(TARGET_ARCH_ABI)) 

FFMPEG_CONFIG_OPTS-$(TARGET_ARCH_ABI) := 

FFMPEG_CONFIG_OPTS-armeabi := --enable-armv5te 
FFMPEG_CONFIG_OPTS-armeabi += --enable-inline-asm 
FFMPEG_CONFIG_OPTS-armeabi += --arch=arm$(ARMBITS) 

FFMPEG_CONFIG_OPTS-armeabi-v7a := $(FFMPEG_CONFIG_OPTS-armeabi) 
FFMPEG_CONFIG_OPTS-armeabi-v7a += --enable-armv6 
FFMPEG_CONFIG_OPTS-armeabi-v7a += --enable-armv6t2 
FFMPEG_CONFIG_OPTS-armeabi-v7a += --enable-vfp 
FFMPEG_CONFIG_OPTS-armeabi-v7a += --enable-neon 
FFMPEG_CONFIG_OPTS-armeabi-v7a += --enable-thumb 
FFMPEG_CONFIG_OPTS-armeabi-v7a += --enable-fast-unaligned 

FFMPEG_CONFIG_OPTS-arm64-v8a := $(FFMPEG_CONFIG_OPTS-armeabi-v7a) 

FFMPEG_CONFIG_OPTS-x86 := --enable-yasm 
FFMPEG_CONFIG_OPTS-x86 += --arch=x86 

FFMPEG_CONFIG_OPTS += $(FFMPEG_CONFIG_OPTS-$(TARGET_ARCH_ABI)) 

LOCAL_MODULE := ffmpeg 
LOCAL_SRC_FILES := $(abspath $(TARGET_OBJS))/ffmpeg/lib...ffmpeg...so # see http://stackoverflow.com/a/17384650/192373 

clean: $(TARGET_OBJS)/ffmpeg/clean 

$(TARGET_OBJS)/ffmpeg/clean: PRIVATE_ABI := $(FFMPEG_TARGET_ABI) 
$(TARGET_OBJS)/ffmpeg/clean: 
    $(call host-echo-build-step,$(PRIVATE_ABI),Clean) "ffmpeg [$(PRIVATE_ABI)]" 
    $(hide) $(call host-rmdir,$(@D)) 

$(shell $(call host-mkdir,$(dir $(LOCAL_SRC_FILES)))) 
$(shell $(HOST_ECHO) >$(LOCAL_SRC_FILES)) 
.PHONY: $(LOCAL_SRC_FILES) 
$(LOCAL_SRC_FILES): $(TARGET_OBJS)/ffmpeg/ffmpeg 
    $(hide) $(call host-mv,$<,[email protected]) 

include $(PREBUILT_SHARED_LIBRARY) 

$(TARGET_OBJS)/ffmpeg/Makefile: FFMPEG_CONFIG_OPTS := $(FFMPEG_CONFIG_OPTS) 
$(TARGET_OBJS)/ffmpeg/Makefile: 
    $(hide) $(call host-mkdir,$(@D)) 
    $(hide) cd $(@D) && $(abspath $(FFMPEG_PATH))/configure $(FFMPEG_CONFIG_OPTS) 

$(TARGET_OBJS)/ffmpeg/ffmpeg: FFMPEG_CONFIG_OPTS := using toolchain:$(NDK_ROOT)/toolchains/$(TOOLCHAIN_NAME) compiler:$(TOOLCHAIN_COMPILER) triplet:$(TOOLCHAIN_TRIPLET) 
$(TARGET_OBJS)/ffmpeg/ffmpeg: $(TARGET_OBJS)/ffmpeg/Makefile 
    @echo $(FFMPEG_CONFIG_OPTS) 
    $(hide) $(MAKE) --no-print-directory -C $(@D)