working all decoders properly

Author: havlenapetr

jni/libmediaplayer/decoder.h

@@ -28,7 +28,6 @@ class IDecoder
 protected:
     PacketQueue*                mQueue;
     AVStream*             		mStream;
-    AVCodecContext*				mCodecCtx;
     bool                        mDecoding;
     pthread_t                   mThread;
 

jni/libmediaplayer/decoder_audio.cpp

@@ -5,10 +5,8 @@
 
 #define TAG "FFMpegAudioDecoder"
 
-DecoderAudio::DecoderAudio(AVStream*            		stream,
-						   struct DecoderAudioConfig* 	config)  : IDecoder(stream)
+DecoderAudio::DecoderAudio(AVStream* stream) : IDecoder(stream)
 {
-    mConfig = config;
 }
 
 DecoderAudio::~DecoderAudio()
@@ -24,10 +22,12 @@ bool DecoderAudio::prepare(const char *err)
     mSamplesSize = AVCODEC_MAX_AUDIO_FRAME_SIZE;
     mSamples = (int16_t *) av_malloc(mSamplesSize);
 
-    if(Output::AudioDriver_set(mConfig->streamType,
-							   mConfig->sampleRate,
-							   mConfig->format,
-							   mConfig->channels) != ANDROID_AUDIOTRACK_RESULT_SUCCESS) {
+    if(Output::AudioDriver_set(MUSIC,
+							   mStream->codec->sample_rate,
+							   PCM_16_BIT,
+							   (mStream->codec->channels == 2) ?
+									   CHANNEL_OUT_STEREO : CHANNEL_OUT_MONO) != ANDROID_AUDIOTRACK_RESULT_SUCCESS)
+    {
        err = "Couldnt' set audio track";
        return false;
     }

jni/libmediaplayer/decoder_audio.h

@@ -3,24 +3,14 @@
 
 #include "decoder.h"
 
-struct DecoderAudioConfig
-{
-     int                streamType;
-     int                sampleRate;
-     int                format;
-     int                channels;
-};
-
 class DecoderAudio : public IDecoder
 {
 public:
-    DecoderAudio(AVStream*            		stream,
-                 struct DecoderAudioConfig* config);
+    DecoderAudio(AVStream* stream);
 
     ~DecoderAudio();
 
 private:
-    struct DecoderAudioConfig*  mConfig;
     int16_t*                    mSamples;
     int                         mSamplesSize;
 

jni/libmediaplayer/decoder_video.cpp

@@ -9,10 +9,8 @@ extern "C" {
 
 #define TAG "FFMpegVideoDecoder"
 
-DecoderVideo::DecoderVideo(AVStream*            		stream,
-						   struct DecoderVideoConfig*	config) : IDecoder(stream)
+DecoderVideo::DecoderVideo(AVStream* stream) : IDecoder(stream)
 {
-	mConfig = config;
 }
 
 DecoderVideo::~DecoderVideo()
@@ -39,8 +37,23 @@ bool DecoderVideo::prepare(const char *err)
 		return false;
 	}
 
-	if(Output::VideoDriver_getPixels(mConfig->width, 
-									 mConfig->height, 
+	mConvertCtx = sws_getContext(mStream->codec->width,
+								 mStream->codec->height,
+								 mStream->codec->pix_fmt,
+								 mStream->codec->width,
+								 mStream->codec->height,
+								 PIX_FMT_RGB565,
+								 SWS_POINT,
+								 NULL,
+								 NULL,
+								 NULL);
+	if (mConvertCtx == NULL) {
+		err = "Couldn't allocate mConvertCtx";
+		return false;
+	}
+
+	if(Output::VideoDriver_getPixels(mStream->codec->width,
+									 mStream->codec->height,
 									 &pixels) != ANDROID_SURFACE_RESULT_SUCCESS) {
 		err = "Couldn't get pixels from android surface wrapper";
 		return false;
@@ -52,8 +65,8 @@ bool DecoderVideo::prepare(const char *err)
 	avpicture_fill((AVPicture *) mFrame, 
 				   (uint8_t *)pixels, 
 				   PIX_FMT_RGB565, 
-				   mConfig->width, 
-				   mConfig->height);
+				   mStream->codec->width,
+				   mStream->codec->height);
 
 	return true;
 }
@@ -63,22 +76,22 @@ bool DecoderVideo::process(AVPacket *packet)
     int	completed;
 
 	// Decode video frame
-	avcodec_decode_video(mCodecCtx, 
+	avcodec_decode_video(mStream->codec,
 						 mTempFrame,
 						 &completed,
 						 packet->data, 
 						 packet->size);
 
 	if (completed) {
 		// Convert the image from its native format to RGB
-		sws_scale(mConfig->img_convert_ctx, 
+		sws_scale(mConvertCtx,
 			      mTempFrame->data,
 			      mTempFrame->linesize,
 				  0,
-				  mConfig->height, 
+				  mStream->codec->height,
 				  mFrame->data,
 				  mFrame->linesize);
-		
+
 		Output::VideoDriver_updateSurface();
 		return true;
 	}

jni/libmediaplayer/decoder_video.h

@@ -3,25 +3,17 @@
 
 #include "decoder.h"
 
-struct DecoderVideoConfig
-{
-	int					width;
-	int					height;
-	struct SwsContext*	img_convert_ctx;
-};
-
 class DecoderVideo : public IDecoder
 {
 public:
-    DecoderVideo(AVStream*					stream,
-				 struct DecoderVideoConfig*	config);
-
+    DecoderVideo(AVStream* stream);
     ~DecoderVideo();
 
 private:
-	struct DecoderVideoConfig*	mConfig;
 	AVFrame*					mFrame;
 	AVFrame*					mTempFrame;
+	struct SwsContext*			mConvertCtx;
+
     bool                        prepare(const char *err);
     bool                        decode(void* ptr);
     bool                        process(AVPacket *packet);

jni/libmediaplayer/mediaplayer.cpp

@@ -174,42 +174,16 @@ status_t MediaPlayer::setDataSource(const char *url)
     return NO_ERROR;
 }
 
-AVFrame* MediaPlayer::createAndroidFrame()
-{
-	void*		pixels;
-	AVFrame*	frame;
-	
-	frame = avcodec_alloc_frame();
-	if (frame == NULL) {
-		return NULL;
-	}
-	
-	if(Output::VideoDriver_getPixels(mVideoWidth, 
-							 mVideoHeight, 
-							 &pixels) != ANDROID_SURFACE_RESULT_SUCCESS) {
-		return NULL;
-	}
-	
-	// Assign appropriate parts of buffer to image planes in pFrameRGB
-	// Note that pFrameRGB is an AVFrame, but AVFrame is a superset
-	// of AVPicture
-	avpicture_fill((AVPicture *) frame, 
-				   (uint8_t *)pixels, 
-				   PIX_FMT_RGB565, 
-				   mVideoWidth, 
-				   mVideoHeight);
-	
-	return frame;
-}
-
 status_t MediaPlayer::suspend() {
 	__android_log_print(ANDROID_LOG_INFO, TAG, "suspend");
 
 	mCurrentState = MEDIA_PLAYER_STOPPED;
-	if(mDecoderAudio != NULL)
-	{
+	if(mDecoderAudio != NULL) {
 		mDecoderAudio->stop();
 	}
+	if(mDecoderVideo != NULL) {
+		mDecoderVideo->stop();
+	}
 
 	if(pthread_join(mPlayerThread, NULL) != 0) {
 		__android_log_print(ANDROID_LOG_ERROR, TAG, "Couldn't cancel player thread");
@@ -247,33 +221,6 @@ status_t MediaPlayer::setVideoSurface(JNIEnv* env, jobject jsurface)
     return NO_ERROR;
 }
 
-status_t MediaPlayer::processVideo(AVPacket *packet, AVFrame *pFrame)
-{
-	int	completed;
-	
-	// Decode video frame
-	avcodec_decode_video(mFFmpegStorage.video.codec_ctx, 
-						 mFFmpegStorage.pFrame, 
-						 &completed,
-						 packet->data, 
-						 packet->size);
-	
-	if (completed) {
-		// Convert the image from its native format to RGB
-		sws_scale(mFFmpegStorage.img_convert_ctx, 
-				  mFFmpegStorage.pFrame->data, 
-				  mFFmpegStorage.pFrame->linesize, 
-				  0,
-				  mVideoHeight, 
-				  pFrame->data, 
-				  pFrame->linesize);
-		
-		Output::VideoDriver_updateSurface();
-		return NO_ERROR;
-	}
-	return INVALID_OPERATION;
-}
-
 bool MediaPlayer::shouldCancel(PacketQueue* queue)
 {
 	return (mCurrentState == MEDIA_PLAYER_STATE_ERROR || mCurrentState == MEDIA_PLAYER_STOPPED ||
@@ -298,83 +245,34 @@ bool MediaPlayer::shouldCancel(PacketQueue* queue)
                 }
                 frames++;
                 */
-void MediaPlayer::decodeVideo(void* ptr)
-{
-    AVPacket        pPacket;
-    AVFrame*        pFrameRGB;
-    bool            run = true;
-
-    if((pFrameRGB = createAndroidFrame()) == NULL) {
-        mCurrentState = MEDIA_PLAYER_STATE_ERROR;
-    }
-	
-    __android_log_print(ANDROID_LOG_INFO, TAG, "decoding video");
-
-    while (run)
-    {
-        if(mCurrentState == MEDIA_PLAYER_PAUSED) {
-            usleep(50);
-            continue;
-        }
-        if (shouldCancel(mVideoQueue)) {
-            run = false;
-            continue;
-        }
-        if(mVideoQueue->get(&pPacket, true) < 0)
-        {
-            mCurrentState = MEDIA_PLAYER_STATE_ERROR;
-        }
-        if(processVideo(&pPacket, pFrameRGB) != NO_ERROR)
-        {
-            mCurrentState = MEDIA_PLAYER_STATE_ERROR;
-        }
-
-        AVStream* vs = mFFmpegStorage.pFormatCtx->streams[mFFmpegStorage.video.stream];
-        if(pPacket.dts != AV_NOPTS_VALUE) {
-        	mTime = pPacket.dts;
-        } else {
-        	mTime = 0;
-        }
-        mTime *= av_q2d(vs->time_base);
-        //__android_log_print(ANDROID_LOG_INFO, TAG, "time: %i", pts);
-        // Free the packet that was allocated by av_read_frame
-        av_free_packet(&pPacket);
-    }
-
-	__android_log_print(ANDROID_LOG_INFO, TAG, "decoding video ended");
-
-    Output::VideoDriver_unregister();
-
-    // Free the RGB image
-    av_free(pFrameRGB);
-}
 
 void MediaPlayer::decodeMovie(void* ptr)
 {
 	AVPacket pPacket;
-        char err[256];
+    char err[256];
 
-	pthread_create(&mVideoThread, NULL, startVideoDecoding, NULL);
-
-	DecoderAudioConfig cfg;
-	cfg.streamType = MUSIC;
-	cfg.sampleRate = mFFmpegStorage.audio.codec_ctx->sample_rate;
-	cfg.format = PCM_16_BIT;
-	cfg.channels = (mFFmpegStorage.audio.codec_ctx->channels == 2) ? CHANNEL_OUT_STEREO : CHANNEL_OUT_MONO;
-	AVStream* stream = mFFmpegStorage.pFormatCtx->streams[mFFmpegStorage.audio.stream];
-	mDecoderAudio = new DecoderAudio(stream, &cfg);
+	AVStream* stream_audio = mFFmpegStorage.pFormatCtx->streams[mFFmpegStorage.audio.stream];
+	mDecoderAudio = new DecoderAudio(stream_audio);
 	if(!mDecoderAudio->startAsync(err))
 	{
 		__android_log_print(ANDROID_LOG_INFO, TAG, "Couldn't start audio decoder: %s", err);
 		return;
 	}
 
+	AVStream* stream_video = mFFmpegStorage.pFormatCtx->streams[mFFmpegStorage.video.stream];
+	mDecoderVideo = new DecoderVideo(stream_video);
+	if(!mDecoderVideo->startAsync(err))
+	{
+		__android_log_print(ANDROID_LOG_INFO, TAG, "Couldn't start video decoder: %s", err);
+		return;
+	}
+
 	mCurrentState = MEDIA_PLAYER_STARTED;
 	__android_log_print(ANDROID_LOG_INFO, TAG, "playing %ix%i", mVideoWidth, mVideoHeight);
 	while (mCurrentState != MEDIA_PLAYER_DECODED && mCurrentState != MEDIA_PLAYER_STOPPED &&
 		   mCurrentState != MEDIA_PLAYER_STATE_ERROR)
 	{
-		if (mVideoQueue->size() > FFMPEG_PLAYER_MAX_QUEUE_SIZE &&
+		if (mDecoderVideo->packets()/*mVideoQueue->size()*/ > FFMPEG_PLAYER_MAX_QUEUE_SIZE &&
 				mDecoderAudio->packets() > FFMPEG_PLAYER_MAX_QUEUE_SIZE) {
 			usleep(200);
 			continue;
@@ -387,7 +285,7 @@ void MediaPlayer::decodeMovie(void* ptr)
 
 		// Is this a packet from the video stream?
 		if (pPacket.stream_index == mFFmpegStorage.video.stream) {
-			mVideoQueue->put(&pPacket);
+			mDecoderVideo->enqueue(&pPacket);
 		} 
 		else if (pPacket.stream_index == mFFmpegStorage.audio.stream) {
 			mDecoderAudio->enqueue(&pPacket);
@@ -401,7 +299,7 @@ void MediaPlayer::decodeMovie(void* ptr)
 	//waits on end of video thread
 	__android_log_print(ANDROID_LOG_ERROR, TAG, "waiting on video thread");
 	int ret = -1;
-	if((ret = pthread_join(mVideoThread, NULL)) != 0) {
+	if((ret = mDecoderVideo->wait()) != 0) {
 		__android_log_print(ANDROID_LOG_ERROR, TAG, "Couldn't cancel video thread: %i", ret);
 	}
 
@@ -417,12 +315,6 @@ void MediaPlayer::decodeMovie(void* ptr)
 	__android_log_print(ANDROID_LOG_INFO, TAG, "end of playing");
 }
 
-void*  MediaPlayer::startVideoDecoding(void* ptr)
-{
-	__android_log_print(ANDROID_LOG_INFO, TAG, "starting video thread");
-    sPlayer->decodeVideo(ptr);
-}
-
 void* MediaPlayer::startPlayer(void* ptr)
 {
     __android_log_print(ANDROID_LOG_INFO, TAG, "starting main player thread");