Add configurable permits for omx lock + other improvements.

Author: carlonluca

piomxtextures_pocplayer/piomxtextures_pocplayer.pro

@@ -27,7 +27,7 @@ CONFIG += -std=c++11
 
 INCLUDEPATH += $$_PRO_FILE_PWD_/../3rdparty/LightLogger
 
-SOURCES     += main.cpp \
+SOURCES += main.cpp \
     poc_qmlutils.cpp \
     poc_utils.cpp \
     poc_uptime.cpp

piomxtextures_samples/piomxtextures_samples.pro

@@ -25,7 +25,7 @@ TEMPLATE = lib
 
 QT += quick multimedia
 
-OTHER_FILES += video_*
+OTHER_FILES += video*
 
 DISTFILES += \
     audio_simple.qml \

piomxtextures_src/omx_logging.h

@@ -3,22 +3,20 @@
  * Author:  Luca Carlon
  * Date:    05.07.2015
  *
- * Copyright (c) 2015 Luca Carlon. All rights reserved.
+ * Copyright (c) 2016 Luca Carlon.
+ * All rights reserved.
  *
- * This file is part of PiOmxTextures.
- *
- * PiOmxTextures is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * PiOmxTextures is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with PiOmxTextures.  If not, see <http://www.gnu.org/licenses/>.
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by Luca Carlon. The name of Luca Carlon may not be
+ * used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 
 #ifndef OMX_LOGGING_H

piomxtextures_src/omx_mediaprocessor.cpp

@@ -186,6 +186,7 @@ OMX_MediaProcessor::OMX_MediaProcessor(OMX_EGLBufferProviderSh provider) :
 	m_buffer_empty(true),
 	m_pendingStop(false),
 	m_pendingPause(false),
+	m_pendingSeek(false),
 	m_subtitle_index(0),
 	m_audio_index(0),
 	m_streamLength(0),
@@ -509,6 +510,7 @@ bool OMX_MediaProcessor::playInt()
 		return false;
 	}
 
+	log_info("Play command received.");
 	if (m_av_clock->OMXPlaySpeed() != DVD_PLAYSPEED_NORMAL && m_av_clock->OMXPlaySpeed() != DVD_PLAYSPEED_PAUSE) {
 		LOG_VERBOSE(LOG_TAG, "resume\n");
 		m_playspeedCurrent = playspeed_normal;
@@ -573,6 +575,7 @@ bool OMX_MediaProcessor::stopInt()
 		return false;
 	}
 
+	log_info("Stop command received.");
 	m_pendingStop = true;
 
 	// Wait for command completion.
@@ -622,33 +625,43 @@ bool OMX_MediaProcessor::pauseInt()
 		m_player_subtitles.Pause();
 #endif
 
+	log_info("Pause command received");
 	setSpeed(playspeeds[m_playspeedCurrent]);
 	m_av_clock->OMXPause();
 
 	// Wait for command completion.
 	m_mutexPending.lock();
 	if (m_pendingPause) {
-		LOG_VERBOSE(LOG_TAG, "Waiting for the pause command to finish.");
+		LOG_VERBOSE(LOG_TAG, "Waiting for the pause command to finish");
 		m_waitPendingCommand.wait(&m_mutexPending);
 	}
 	m_mutexPending.unlock();
 
 	setState(STATE_PAUSED);
 
-	log_verbose("Pause command issued.");
+	log_verbose("Pause command completed");
 	return true;
 }
 
 /*------------------------------------------------------------------------------
 |    OMX_MediaProcessor::seek
 +-----------------------------------------------------------------------------*/
 bool OMX_MediaProcessor::seek(qint64 position)
+{
+   return INVOKE("seekInt",
+                 INVOKE_CONN,
+                 Q_ARG(qint64, position));
+}
+
+/*------------------------------------------------------------------------------
+|    OMX_MediaProcessor::seekInt
++-----------------------------------------------------------------------------*/
+bool OMX_MediaProcessor::seekInt(qint64 position)
 {
 	QMutexLocker locker(&m_sendCmd);
 
-	LOG_VERBOSE(LOG_TAG, "Seek %lldms.", position);
 	if (!m_av_clock)
-		return false;
+      		return false;
 
 	// Get current position in ms.
 	qint64 currentMs  = m_av_clock->OMXMediaTime(false)*1E-3;
@@ -658,8 +671,19 @@ bool OMX_MediaProcessor::seek(qint64 position)
 	if (!incrementMs)
 		return true;
 
+	log_info("Seek command to %lldms received", position);
 	m_incrMs = incrementMs;
+	m_pendingSeek = true;
+
+	// Wait for command completion.
+	m_mutexPending.lock();
+	if (m_pendingSeek) {
+		log_verbose("Waiting for the seek command to finish.");
+		m_waitPendingCommand.wait(&m_mutexPending);
+	}
+	m_mutexPending.unlock();
 
+	log_verbose("Seek command completed");
 	return true;
 }
 
@@ -830,16 +854,20 @@ void OMX_MediaProcessor::mediaDecoding()
 
 			if (m_omx_reader->SeekTime((int)seek_pos, m_incrMs < 0.0f, &startpts)) {
 				unsigned t = (unsigned)(startpts*1e-6);
-				log_info("Seek to: %02d:%02d:%02d", (t/3600), (t/60)%60, t%60);
+				log_verbose("Seeked to: %02d:%02d:%02d", (t/3600), (t/60)%60, t%60);
 				flushStreams(startpts);
+				log_debug("Streams flushed");
 			}
 
 			sentStarted = false;
 
-			if (m_omx_reader->IsEof())
+			if (m_omx_reader->IsEof()) {
+				log_debug("EOF");
 				break;
+			}
 
 			if (m_has_video && !m_player_video->Reset()) {
+				log_debug("RESET failed on seek");
 				m_incrMs = 0;
 				break;
 			}
@@ -861,6 +889,13 @@ void OMX_MediaProcessor::mediaDecoding()
 			m_packetAfterSeek = false;
 			m_seekFlush       = false;
 			m_incrMs          = 0;
+
+			m_mutexPending.lock();
+			if (UNLIKELY(m_pendingSeek)) {
+				m_waitPendingCommand.wakeAll();
+				m_pendingSeek = false;
+			}
+			m_mutexPending.unlock();
 		}
 		else if (UNLIKELY(m_packetAfterSeek && TRICKPLAY(m_av_clock->OMXPlaySpeed()))) {
 			double seek_pos     = 0;
@@ -969,11 +1004,12 @@ void OMX_MediaProcessor::mediaDecoding()
 			// Enable this to enable pause for buffering.
 			if (m_state != STATE_PAUSED && (m_omx_reader->IsEof() || m_omx_pkt || TRICKPLAY(m_av_clock->OMXPlaySpeed()) || (audio_fifo_high && video_fifo_high))) {
 				if (m_av_clock->OMXIsPaused()) {
-					log_verbose("Resume %.2f,%.2f (%d,%d,%d,%d) EOF:%d PKT:%p\n",
+					log_verbose("Resume %.2f,%.2f (%d,%d,%d,%d) EOF:%d PKT:%p",
 									audio_fifo, video_fifo, audio_fifo_low, video_fifo_low, audio_fifo_high, video_fifo_high, m_omx_reader->IsEof(), m_omx_pkt);
 
 					setMediaStatus(OMX_MediaStatus::MEDIA_STATUS_BUFFERED);
 					m_av_clock->OMXResume();
+					log_debug("Resume completed");
 				}
 			}
 			else if (m_state == STATE_PAUSED || audio_fifo_low || video_fifo_low)
@@ -1139,29 +1175,40 @@ void OMX_MediaProcessor::setSpeed(int iSpeed)
 +-----------------------------------------------------------------------------*/
 void OMX_MediaProcessor::flushStreams(double pts)
 {
+	log_debug("Stopping av_clock");
 	m_av_clock->OMXStop();
+
+	log_debug("Pausing av_clock");
 	m_av_clock->OMXPause();
 
 	if (m_has_video) {
+		log_verbose("Flushing");
 		m_player_video->Flush();
 		m_provider->flush();
 	}
 
-	if (m_has_audio)
+	if (m_has_audio) {
+		log_debug("Flushing audio");
 		m_player_audio->Flush();
+	}
 
-	if (pts != DVD_NOPTS_VALUE)
+	if (pts != DVD_NOPTS_VALUE) {
+		log_debug("Set media time in flushStreams");
 		m_av_clock->OMXMediaTime(pts);
+	}
 
 #ifdef ENABLE_SUBTITLES
 	if (m_has_subtitle)
 		m_player_subtitles->Flush();
 #endif
 
 	if (m_omx_pkt) {
+		log_debug("Freeing packet in flushStreams");
 		m_omx_reader->FreePacket(m_omx_pkt);
 		m_omx_pkt = NULL;
 	}
+
+	log_debug("flushStreams finished");
 }
 
 /*------------------------------------------------------------------------------

piomxtextures_src/omx_mediaprocessor.h

@@ -186,6 +186,7 @@ private slots:
     bool playInt();
     bool stopInt();
     bool pauseInt();
+    bool seekInt(qint64 position);
     void mediaDecoding();
     void closeAll();
     bool cleanup();
@@ -228,7 +229,8 @@ private slots:
 #endif
     bool m_buffer_empty;
     bool m_pendingStop;
-	 bool m_pendingPause;
+    bool m_pendingPause;
+    bool m_pendingSeek;
 
     int m_subtitle_index;
     int m_audio_index;

piomxtextures_src/omx_omxplayer_logging.cpp

@@ -53,7 +53,7 @@
 
 #include "omx_logging.h"
 
-#define ENABLE_OMXPLAYER_LOGS
+//#define ENABLE_OMXPLAYER_LOGS
 
 /*------------------------------------------------------------------------------
 |    definitions

piomxtextures_src/omx_staticconf.cpp

@@ -36,6 +36,7 @@ static std::once_flag flag2;
 static std::once_flag flag3;
 static std::once_flag flag4;
 static std::once_flag flag5;
+static std::once_flag flag6;
 
 /*------------------------------------------------------------------------------
 |    OMX_StaticConf::getHalfFramerate
@@ -133,8 +134,26 @@ QString OMX_StaticConf::getOmxWatchdogFile()
          return;
       watchdogFile = QString(ba);
 
-      log_verbose("OMX_HEALTHY is %s", qPrintable(watchdogFile));
+      log_info("OMX_HEALTHY is %s", qPrintable(watchdogFile));
    });
 
    return watchdogFile;
 }
+
+/*------------------------------------------------------------------------------
+|    OMX_StaticConf::getOmxWatchdogPermits
++-----------------------------------------------------------------------------*/
+int OMX_StaticConf::getOmxWatchdogPermits()
+{
+	static int watchdogPermits = 1000;
+	std::call_once(flag6, [] {
+		QByteArray omxPermits = qgetenv("OMX_PERMITS");
+		if (omxPermits.isEmpty() || omxPermits.isNull())
+			return;
+		watchdogPermits = QString::fromUtf8(omxPermits).toInt();
+
+		log_info("OMX_PERMITS is %d", watchdogPermits);
+	});
+
+	return watchdogPermits;
+}

piomxtextures_src/omx_staticconf.h

@@ -39,7 +39,8 @@ class OMX_StaticConf
 	static int getInterlaceQpu();
 	static int getTextureCount();
 	static bool getHalfFramerate();
-   static QString getOmxWatchdogFile();
+	static QString getOmxWatchdogFile();
+	static int getOmxWatchdogPermits();
 };
 
 #endif // OMX_STATICCONF_H

piomxtextures_src/omx_textureprovider.h

@@ -144,10 +144,15 @@ class OMX_EGLBufferProvider : public QObject
 		m_emptyQueue.clear();
 		m_filledQueue.clear();
 		m_currentDecoder = NULL;
-		m_currentRenderer = NULL;
+
+		// Leave the current texture in the renderer.
+		//m_currentRenderer = NULL;
 
 		m_emptyQueue.append(m_available);
-		m_semEmpty.release(TEXTURE_COUNT - m_semEmpty.available());
+		m_emptyQueue.removeAll(m_currentRenderer);
+
+		int t = m_currentRenderer ? 1 : 0;
+		m_semEmpty.release(TEXTURE_COUNT - m_semEmpty.available() - t);
 	}
 
 public slots:

piomxtextures_src/omxplayer_lib/OMXCore.cpp

@@ -38,15 +38,15 @@
 #endif
 
 #include <omx_logging.h>
+#include <omx_staticconf.h>
 
 //#define OMX_DEBUG_EVENTS
 //#define OMX_DEBUG_EVENTHANDLER
 
 #ifdef OMX_THREAD_UNSAFE
 #define log_lock log_disabled
 
-// lcarlon: temporary implementation.
-QSemaphore COMXCoreComponent::m_mxOmx(2);
+QSemaphore COMXCoreComponent::m_mxOmx(OMX_StaticConf::getOmxWatchdogPermits());
 
 /*------------------------------------------------------------------------------
 |    COMXCoreComponent::testOmx
@@ -55,7 +55,7 @@ bool COMXCoreComponent::testOmx()
 {
 	// Try to lock and timeout in 1s.
 	log_debug("Testing OpenMAX health...");
-   const bool alive = m_mxOmx.tryAcquire(1, 1000);
+        const bool alive = m_mxOmx.tryAcquire(1, 1000);
 	if (alive)
 		m_mxOmx.release();