Cómo leer el código fuente del framework de Android
/**
* Configure el codificador de video para grabar. Si no se llama a este método
*, el archivo de salida no contendrá la pista de vídeo. Llámame después
* setOutputFormat() y antes de prepare().
*
* @param video_encoder El codificador de vídeo que se utilizará.
* @Throw IllegalStateException (si se llama antes)
* Después de setOutputFormat() o prepare()
* @Ver video multimedia de Android. codificador
*/
codificador de video set void nativo público (int video _ codificador)
lanza IllegalStateException123456789101112
Este es un método local. De acuerdo con las reglas de JNI, debemos ir a Android_media_media recorder.CPP para ver la implementación de este método:
Static void
Android_media_media recorder_setvideo encoder(JNIEnv * env, jobject thiz, jint ve )
{
ALOGV("setvideoencer(% d)",ve);
if(ve <VIDEO_ENCODER_DEFAULT || ve >=video_encoder_list_end){
jniThrowException(env, "Java/lang/IllegalArgumentException", "Codificador de vídeo no válido");
return;
}
sp <MediaRecorder>mr = getMediaRecorder(env,thiz);
Llamada a Process Media Recorder(env,Mr-> setVideoEncoder(ve), "java/lang/RuntimeException", "setVideoEncoder falló."); p>
}1234567891011
La clave son las dos últimas frases. sp es un puntero en Android y no se puede ver ~ por lo que las dos últimas oraciones significan llamar al método setVideoEncoder de la capa nativa MediaRecorder.
Vaya a MediaRecorder.cpp para ver el método setVideoEncoder:
status _ t media recorder::setvideo encoder(int ve)
{
ALOGV("setvideoencer(% d)",ve);
if (mMediaRecorder == NULL) {
ALOGE("La grabadora multimedia no se ha inicializado");
Devuelve operación_inválida;
}
if (!mIsVideoSourceSet) {
ALOGE("Intente configurar la codificación de vídeo sin configurar primero el fuente de vídeo ");
Devuelve invalid_operative;
}
if(misvideencoderset){
ALOGE("El codificador de vídeo se ha configurado ");
devuelve operación_inválida;
}
if (!(mCurrentState & ampmedia_recorder_datasource_configured) ){
ALOGE("setVideoEncoder fue llamado en estado no válido (%d)", mCurrentState);
Devuelve invalid_operative;
} p>
status_t ret = mMediaRecorder-> setvideo encoder(ve) ;
if (ok! = ret) {
ALOGV(" setvideodencoder falló: % d ", ret);
mCurrentState = MEDIA _ RECORDER _ ERROR
devolver ret
}
mIsVideoEncoderSet = true
p>
Devolver ret
} 1234567891011121314151617181920212223242526272829
El MMediaReorder aquí está definido en MediaRecorder.h:
sp & ltIMediaRecorder & gtmMediaRecorder1
Se puede ver que es una variable de tipo IMediaRecorder y pertenece al tipo de interfaz. Eche un vistazo a la definición de su interfaz.
En IMediaRecorder.h:
Clase IMediaRecorder: Interfaz pública
{
Pública:
DECLARE _ META _ INTERFACE(grabadora multimedia) ;
Estado virtual_t configurar cámara(const sp<hardware::ICamera>&camera,
const sp<ICameraRecordingProxy>& proxy)=0;
Estado virtual_t setPreviewSurface(const sp<IGraphicBufferProducer>& superficie)=0;
Estado virtual_t setVideoSource(int vs)=0;
Estado virtual_t setAudioSource(int as)= 0;
Estado virtual_t setOutputFormat( int of)= 0;
Codificador virtual state_t setvideo(int ve) = 0;
Codificador virtual status_t setaudio(int AE)= 0;
Virtual status_t setOutputFile(int fd, int64_t offset, int 64_t length)= 0;
Virtual state_t setVideoSize(int width, int height)= 0;
Virtual state_t setVideoFrameRate(int frames_per_segundo) = 0;
Parámetros de configuración de estado virtual (const String8 & ampparams) = 0;
Estado virtual _ t establece el oyente (const sp & lt; IMediaRecorderClient & gt& amplistener) = 0;
Estado virtual _ t establece el nombre del cliente (cadena constante 16 y nombre del cliente) = 0
Estado virtual_t listo() = 0
Estado virtual; _ t obtener amplitud máxima (int * max) = 0;
Estado virtual_t start()= 0;
Estado virtual_t stop()= 0;
Estado virtual _ t reset() = 0
Estado virtual _ t pausa() =
Estado virtual _ t resume() = 0; >Virtual status_t init()= 0;
virtual status_t close()= 0;
virtual status_t release()= 0;
virtual status_t setInputSurface( const sp<IGraphicBufferConsumer>& Surface)=0;
virtual sp<IGraphicBufferProducer>querysurfacediasource()=0;
};
// -
BnMediaRecorder clase: público BnInterface & ltIMediaRecorder & gt
{
Público:
Contrato de estado virtual (uint32_t
Código,
constPackage y Empresa de envío. data,
Pack * respuesta,
uint 32 _ t flags = 0
};
Na ~crítico Ha llegado un paso. Básicamente los he perseguido hasta aquí antes, e incluso si termino de perseguirlos, no sé cómo seguir persiguiéndolos. Más tarde, leí sobre Binder y aprendí sobre el papel de BnInterface. La interfaz bn es una parte clave de Binder. No entraré en detalles aquí. Solo recuerde, lo que vamos a buscar a continuación es BnMediaRecorder.
Busque globalmente ":public BnMediaRecorder", es decir, busque su clase de implementación y busque la siguiente definición en MediaRecorderClient.h:
Clase MediaRecorderClient:public BnMediaRecorder
{
Clase notificador de muerte de servicio:público I carpeta::destinatario de muerte
{
Público:
Notificador de muerte de servicio (
servicio const sp & ltIBinder & gt& amp,
const sp & ltIMediaRecorderClient & gt& amp oyente,
int cual
virtual ~ ServiceDeathNotifier();
La carpeta de vacío virtual murió (const WP<IBinder>&who);
Privada:
int mWhich
sp & ltIBinder & gtmService
wp & ltIMediaRecorderClient & gtmListener
};
Público:
estado virtual_t configurar cámara (const sp<. Hardware::ICamera>&Camera,
const sp<ICameraRecordingProxy>&Proxy);
Estado virtual_t setPreviewSurface(const sp& lt; IGraphicBufferProducer>& superficie);
Estado virtual_t setVideoSource(int vs );
Virtual state_t setAudioSource(int as);
Virtual state_t setOutputFormat(int of);
Virtual state_t setvideo codificador(int ve); p>
Codificador virtual state_t setaudio(int AE);
virtual status_t setOutputFile(int fd, int64_t offset,
int64_t length);
virtual status_t setVideoSize(int width, int height);
Virtual state_t setVideoFrameRate(int frames_per_segundo);
Parámetros de configuración de estado virtual (const String8 y ampparams);
Virtual state_t setListener(
p>const sp & ltIMediaRecorderClient & gt& oyente);
Virtual status_t establece el nombre del cliente (const string 16 & nombre del cliente);
Estado virtual _t preparar();
Estado virtual_t obtener amplitud máxima(int * max);
Estado virtual_t inicio();
Estado virtual _t detener ();
Estado virtual_ t reset();
Estado virtual_ t pausa(
);
Estado virtual_t reanudar();
Estado virtual_t init();
Estado virtual_t cerrar();
Estado virtual_t release();
Volcado de estado virtual(int fd, const Vector & ltString16 >& apargs);
Estado virtual_t setInputSurface(const sp & lt; IGraphicBufferConsumer & gt & Surface);
SP virtual & ltIGraphicBufferProducer & gtquerysurfacediasource();
Privado:
Clase amiga MediaPlayerService // constructor privado de acceso usado
MediaRecorderClient(
const sp & ltMediaPlayerService & gt& amp service,
pid_t pid,
const string 16 & amp;opPackageName);
virtual ~ MediaRecorderClient();
carpeta sp & ltI::destinatario de muerte & gt;mCameraDeathListener
carpeta sp & ltI::destinatario de muerte & gt; pid _ t mPid
Bloqueo mutex;
MediaRecorderBase * mRecorder
sp & ltMediaPlayerService & gtmMediaPlayerService
};1234567891011121314151617181920212223242526272829303132333435363 738 394041424344454647484950515253545556575 85960616263646566 p>
Entonces vayamos a MediaRecorderClient.cpp y echemos un vistazo:
status _ t MediaRecorderClient::setvideo encoder(int ve)
p>{
ALOGV("setvideoencer(% d)",ve);
Mutex::Autolock lock(mLock);
if (mRecorder == NULL) {
ALOGE("Grabadora no inicializada");
Devolver NO _ INIT
}
Devolver mRecorder->setvideo encoder((video _ encoder)ve);
}12345678910
El mRecorder aquí está definido en MediaRecorderClient.h:
MediaRecorderBase * mRecorder1
Vamos , sigamos buscando ":public MediaRecorderBase" y lo encontramos en StagefrightRecorder.h, luego vayamos a StagefrightRecorder.cpp y echemos un vistazo~
status _ t stageforshrecorder::setvideo encoder(video _ enco
der ve){
ALOGV(" setvideodencoder:% d ", ve
if(ve <video_encoder_default||
ve & gt=video_encoder_list_end ){
ALOGE("Codificador de vídeo no válido: %d ", ve);
Devuelve un valor incorrecto;
}
mVideoEncoder = ve
Regresar OK;
}123456789101112
Está bien, esto terminó ~ Finalmente encontraremos que la implementación de la interfaz en MediaRecorder básicamente caerá en este StagefrightRecorder .cpp.