GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#include "audioomx.h"
}
void AudioOMX::ReturnEmptyOMXBuffer(OMX_BUFFERHEADERTYPE* buffer){
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
//Log::getInstance()->log("Audio", Log::NOTICE, "ReturnEmptyOMXBuffer %d",input_bufs_omx_free.size());
input_bufs_omx_free.push_back(buffer);
//Log::getInstance()->log("Audio", Log::NOTICE, "ReturnEmptyOMXBuffer %d",input_bufs_omx_free.size());
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
VideoOMX *video=(VideoOMX*)Video::getInstance();
video->signalOmx();
}
}
int AudioOMX::InitDecoderLibAV()
{
- libav_mutex.Lock();
+ libav_mutex.lock();
ac3codec_context_libav = avcodec_alloc_context3(ac3codec_libav);
if (!ac3codec_context_libav) {
Log::getInstance()->log("Audio", Log::DEBUG, "Alloc avcodec for ac3 decoding context failed!");
int avc_ret = avcodec_open2(ac3codec_context_libav, ac3codec_libav, NULL);
if (avc_ret < 0) {
Log::getInstance()->log("Audio", Log::DEBUG, "Opening libav codec failed \n");
- libav_mutex.Unlock();
+ libav_mutex.unlock();
return 0;
}
avc_ret = avcodec_open2(aaclatmcodec_context_libav, aaclatmcodec_libav, NULL);
if (avc_ret < 0) {
Log::getInstance()->log("Audio", Log::DEBUG, "Opening libav codec failed \n");
- libav_mutex.Unlock();
+ libav_mutex.unlock();
return 0;
}
mp23codec_context_libav = avcodec_alloc_context3(mp23codec_libav);
if (!ac3codec_context_libav) {
Log::getInstance()->log("Audio", Log::DEBUG, "Alloc avcodec for mp23 decoding context failed!");
- libav_mutex.Unlock();
+ libav_mutex.unlock();
return 0;
}
avc_ret = avcodec_open2(mp23codec_context_libav, mp23codec_libav, NULL);
if (avc_ret < 0) {
Log::getInstance()->log("Audio", Log::DEBUG, "Opening libav codec failed \n");
- libav_mutex.Unlock();
+ libav_mutex.unlock();
return 0;
}
#else
decode_frame_libav=avcodec_alloc_frame();
#endif
- libav_mutex.Unlock();
+ libav_mutex.unlock();
decompress_buffer_filled=0;
void AudioOMX::DeinitDecoderLibAV() {
- libav_mutex.Lock();
+ libav_mutex.lock();
if (ac3codec_context_libav) {
avcodec_close(ac3codec_context_libav);
av_free(ac3codec_context_libav);
}
- libav_mutex.Unlock();
+ libav_mutex.unlock();
}
return 0;
}
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
for (unsigned int i=0; i< port_def_type.nBufferCountActual;i++) {
OMX_BUFFERHEADERTYPE *buf_head=NULL;
error=OMX_AllocateBuffer(omx_aud_rend/*dec*/,&buf_head,omx_rend_input_port/*codec*/,NULL,port_def_type.nBufferSize);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Audio", Log::DEBUG, "Use OMX_AllocateBuffer failed %x", error);
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
return 0;
}
input_bufs_omx_all.push_back(buf_head);
firstsynched=false;
cur_input_buf_omx=NULL;
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
if (!video->CommandFinished(omx_aud_rend/*dec*/,OMX_CommandPortEnable,omx_rend_input_port /*codec*/)) {
return 0;
OMX_ERRORTYPE error;
cur_input_buf_omx=NULL;
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
for (UINT i=0; i< input_bufs_omx_all.size();i++) {
error=OMX_FreeBuffer(omx_aud_rend/*dec*/,omx_rend_input_port/*codec*/,input_bufs_omx_all[i]);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Audio", Log::DEBUG, "Use OMX_FreeBuffer failed %x", error);
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
return 0;
}
}
input_bufs_omx_all.clear();
input_bufs_omx_free.clear();
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
return 1;
}
//OMX_ERRORTYPE error;
cur_input_buf_omx=NULL;
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
while (input_bufs_omx_all.size()>0) {
if (input_bufs_omx_free.size()>0) {
// Destroy one buffer
}
}
} else {
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
MILLISLEEP(5);
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
}
}
Log::getInstance()->log("Audio", Log::DEBUG, "DestroyInputBufsOMXwhilePlaying %d %d", input_bufs_omx_all.size(),input_bufs_omx_free.size());
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
return 1;
}
{
//Check, if we have OMX output buffers
bool full;
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
full=(input_bufs_omx_free.size()==0);
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
return full;
}
}
}
if (!cur_input_buf_omx) {
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
if (input_bufs_omx_free.size()==0) {
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
//Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 6");
//Log::getInstance()->log("Audio", Log::DEBUG, "Deliver MediaPacket no free sample");
return 0; // we do not have a free media sample
cur_input_buf_omx->nOffset=0;
cur_input_buf_omx->nTimeStamp=VideoOMX::intToOMXTicks(0);
input_bufs_omx_free.pop_front();
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
}
//Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 7");
cur_input_buf_omx=NULL;
if (haveToCopy>0) {
// get5 new buffer
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
if (input_bufs_omx_free.size()==0) {
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
// Log::getInstance()->log("Audio", Log::DEBUG, "Deliver MediaPacket no free sample2");
return *samplepos; // we do not have a free media sample
}
cur_input_buf_omx->nFlags=OMX_BUFFERFLAG_TIME_UNKNOWN;
cur_input_buf_omx->nTimeStamp=VideoOMX::intToOMXTicks(0);
input_bufs_omx_free.pop_front();
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
}
//Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 12");
pthread_testcancel();
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate);
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldcanceltype);
- libav_mutex.Lock();
+ libav_mutex.lock();
if (!omx_running || !mp23codec_context_libav
|| !ac3codec_context_libav) {
- libav_mutex.Unlock();
+ libav_mutex.unlock();
return *samplepos;
}
- libav_mutex.Unlock();
+ libav_mutex.unlock();
// Log::getInstance()->log("Audio", Log::DEBUG,"libav out");
int save_size=incoming_paket_libav.size;
//Log::getInstance()->log("Audio", Log::DEBUG, "libav out2");
//Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 20");
if (!omx_running) {
- libav_mutex.Unlock();
+ libav_mutex.unlock();
return *samplepos;
}
int count = 0;
while (count < 10 && omx_running) {
count++;
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
if (input_bufs_omx_free.size() == 0) {
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
// Log::getInstance()->log("Audio", Log::DEBUG,
// "Deliver MediaPacket no free sample");
MILLISLEEP(5);
cur_input_buf_omx->nTimeStamp = VideoOMX::intToOMXTicks(0);
cur_input_buf_omx->nFlags=OMX_BUFFERFLAG_TIME_UNKNOWN;
input_bufs_omx_free.pop_front();
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
break;
}
if (!cur_input_buf_omx) return *samplepos;
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef AUDIOOMX_H
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
-
-#include "defines.h"
-#include "audio.h"
-#include "videoomx.h"
-
+#include <mutex>
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavresample/avresample.h>
}
-
-
+#include "defines.h"
+#include "audio.h"
+#include "videoomx.h"
class AudioOMX : public Audio
{
std::vector<OMX_BUFFERHEADERTYPE*> input_bufs_omx_all;
std::list<OMX_BUFFERHEADERTYPE*> input_bufs_omx_free;
- Mutex input_bufs_omx_mutex;
+ std::mutex input_bufs_omx_mutex;
OMX_BUFFERHEADERTYPE* cur_input_buf_omx;
bool omx_running;
bool omx_first_frame;
- Mutex libav_mutex;
+ std::mutex libav_mutex;
AVCodec *aaclatmcodec_libav;
AVCodecContext *aaclatmcodec_context_libav;
/*
- Copyright 2004-2005 Chris Tallon
+ Copyright 2004-2020 Chris Tallon
This file is part of VOMP.
int BoxStack::addVideoDisplay(Boxx* box,VideoDisplay vd)
{
- boxLock.Lock();
+ boxLock.lock();
videoStack.push(std::pair<Boxx*,VideoDisplay>(box,vd));
- boxLock.Unlock();
+ boxLock.unlock();
Video::getInstance()->setVideoDisplay(vd);
return 1;
}
{
if (!initted) return 0;
Log::getInstance()->log("BoxStack", Log::DEBUG, "add called");
- boxLock.Lock();
+ boxLock.lock();
Log::getInstance()->log("BoxStack", Log::DEBUG, "Locked for add");
if (numBoxes == 16)
{ //Error
Log::getInstance()->log("BoxStack", Log::ERR, "More than 16 boxes! Unlocked for add");
- boxLock.Unlock();
+ boxLock.unlock();
return 0;
}
boxes[numBoxes++] = v;
- boxLock.Unlock();
+ boxLock.unlock();
VideoDisplay vd;
if (v->getVideoDisplay(vd)) {
Log::getInstance()->log("BoxStack", Log::DEBUG, "Add video display");
if (!initted) return 0;
VideoDisplay *display = NULL;
- boxLock.Lock();
+ boxLock.lock();
Log::getInstance()->log("BoxStack", Log::DEBUG, "Locked for remove");
if (numBoxes == 0)
{
- boxLock.Unlock();
+ boxLock.unlock();
Log::getInstance()->log("BoxStack", Log::ERR, "Unlocked for remove numBoxes == 0");
return 0;
}
{
// not a Box we have!
// FIXME
- boxLock.Unlock();
+ boxLock.unlock();
Log::getInstance()->log("BoxStack", Log::ERR, "Unlocked for remove - no boxx deleted");
return 0;
}
}
- boxLock.Unlock();
+ boxLock.unlock();
toDelete->preDelete();
- boxLock.Lock();
+ boxLock.lock();
// Log::getInstance()->log("BoxStack", Log::DEBUG, "Starting deleteBox");
deleteBox(i);
videoStack.pop();
if (!videoStack.empty()) display=&videoStack.top().second;
}
- boxLock.Unlock();
+ boxLock.unlock();
Log::getInstance()->log("BoxStack", Log::DEBUG, "Unlocked for remove");
// Delete the box
void BoxStack::redrawAllBoxes()
{
- boxLock.Lock();
+ boxLock.lock();
for (int z = 0; z < numBoxes; z++)
{
}
- boxLock.Unlock();
+ boxLock.unlock();
update(NULL,NULL); // should blt all
}
{
Log::getInstance()->log("BoxStack", Log::DEBUG, "Update called");
if (!initted) return; // it is allowed to call this before init
- boxLock.Lock();
+ boxLock.lock();
Log::getInstance()->log("BoxStack", Log::DEBUG, "Locked for update");
// Get the z index of the box
if (z == numBoxes)
{
// not a Box we have!
- boxLock.Unlock();
+ boxLock.unlock();
Log::getInstance()->log("BoxStack", Log::ERR, "Unlocked for update! box not inside boxstack");
return;
}
}
if (!toUpdate) {
- boxLock.Unlock();
+ boxLock.unlock();
Log::getInstance()->log("BoxStack", Log::DEBUG, "Unlocked for update, no box present");
return ;
}
rl.pop_front();
}
- boxLock.Unlock();
+ boxLock.unlock();
Log::getInstance()->log("BoxStack", Log::DEBUG, "Unlocked for update");
}
while(numBoxes > 1)
{
- boxLock.Lock();
+ boxLock.lock();
if (numBoxes == 1)
{
- boxLock.Unlock();
+ boxLock.unlock();
break;
}
toDel = boxes[numBoxes - 1];
- boxLock.Unlock();
+ boxLock.unlock();
toDel->preDelete();
- boxLock.Lock();
+ boxLock.lock();
// If boxes[numBoxes - 1] isn't toDel then there's a problem
if (boxes[numBoxes - 1] == toDel)
videoStack.pop();
if (!videoStack.empty()) display=&videoStack.top().second;
}
- boxLock.Unlock();
+ boxLock.unlock();
//AVO: do the delete outside the lock to allow for recursive deletes
Log::getInstance()->log("BoxStack", Log::DEBUG, "going to delete boxx %p, num=%d", toDel, numBoxes);
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef BOXSTACK_H
#include <signal.h>
#include <list>
#include <stack>
-
-#ifndef WIN32
-#include <pthread.h>
-#endif
-
-#include "mutex.h"
+#include <mutex>
#include "boxx.h"
#include "region.h"
VideoDisplayStack videoStack;
- Mutex boxLock;
-
+ std::mutex boxLock;
void deleteBox(int z);
void repaintRevealed(int x, Region r);
#ifndef DEMUXERMEDIA_H
#define DEMUXERMEDIA_H
-#include "mutex.h"
#include <deque>
#include "demuxer.h"
#include "defines.h"
typedef struct { ULLONG pts; ULONG frame; } PTSMapEntry;
typedef std::deque<PTSMapEntry> PTSMap;
PTSMap pts_map;
- Mutex pts_map_mutex;
ULLONG firstPTS;
ULLONG currentPTS;
ULLONG lastPTS;
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#include "demuxerts.h"
ULONG ref_frame = 0;
int total = 0, actual = 0;
if (pts==0) return 0; //we are in startup
- pts_map_mutex.Lock();
+ pts_map_mutex.lock();
PTSMap::iterator iter = pts_map.begin();
while (iter != pts_map.end())
{
iter = pts_map.begin(); iter++;
pts_map.erase(iter, pts_map.end());
}
- pts_map_mutex.Unlock();
+ pts_map_mutex.unlock();
//Log::getInstance()->log("DemuxerTS", Log::DEBUG, "getFrameNumfromPTS pts %lld deleted %d difference %lld", pts, total,difference);
if ((h264 || packet.findSeqHeader(h264) > 1) && packet.hasPTS())
{
PTSMapEntry me;
- pts_map_mutex.Lock();
+ pts_map_mutex.lock();
if (pts_map.empty())
{
me.pts = packet.getPTS();
me.frame = frame_num;
- pts_map_mutex.Unlock();
- pts_map_mutex.Lock();
+ pts_map_mutex.unlock();
+ pts_map_mutex.lock();
pts_map.push_front(me);
}
me = pts_map.front();
- pts_map_mutex.Unlock();
+ pts_map_mutex.unlock();
//UINT fps = Video::getInstance()->getFPS();
double tfps=fps;
{
me.pts = packet.getPTS();
me.frame = frame_num;
- pts_map_mutex.Lock();
+ pts_map_mutex.lock();
pts_map.push_front(me);
- pts_map_mutex.Unlock();
+ pts_map_mutex.unlock();
}
}
}
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef DEMUXERTS_H
#define DEMUXERTS_H
-#include "mutex.h"
+#include <mutex>
#include <deque>
#include "demuxer.h"
typedef struct { ULLONG pts; ULONG frame; } PTSMapEntry;
typedef std::deque<PTSMapEntry> PTSMap;
PTSMap pts_map;
- Mutex pts_map_mutex;
+ std::mutex pts_map_mutex;
void parseTSPacketDetails(PESPacket &packet);
struct PictCountInfo pinfo;
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#include "demuxervdr.h"
ULLONG difference = (1LL<<33);
ULONG ref_frame = 0;
int total = 0, actual = 0;
- pts_map_mutex.Lock();
+ pts_map_mutex.lock();
PTSMap::iterator iter = pts_map.begin();
while (iter != pts_map.end())
{
iter = pts_map.begin(); iter++;
pts_map.erase(iter, pts_map.end());
}
- pts_map_mutex.Unlock();
+ pts_map_mutex.unlock();
if (difference == (1LL<<33))
return 0; // We cannot make sense of the pts
if (packet.findSeqHeader(h264) > 1 && packet.hasPTS())
{
PTSMapEntry me;
- pts_map_mutex.Lock();
+ pts_map_mutex.lock();
if (pts_map.empty())
{
me.pts = packet.getPTS();
me.frame = frame_num;
- pts_map_mutex.Unlock();
+ pts_map_mutex.unlock();
Log::getInstance()->log("Demuxer", Log::DEBUG, "+* PTS INIT *+ %llu %u", me.pts, me.frame);
- pts_map_mutex.Lock();
+ pts_map_mutex.lock();
pts_map.push_front(me);
}
me = pts_map.front();
- pts_map_mutex.Unlock();
+ pts_map_mutex.unlock();
// UINT fps = Video::getInstance()->getFPS();
ULLONG pts_expected = me.pts + 90000*((ULONG)((double)(frame_num - me.frame)) / fps);
Log::getInstance()->log("Demuxer", Log::DEBUG, "+* PTS JUMP *+ %llu %u", packet.getPTS(), frame_num);
me.pts = packet.getPTS();
me.frame = frame_num;
- pts_map_mutex.Lock();
+ pts_map_mutex.lock();
pts_map.push_front(me);
- pts_map_mutex.Unlock();
+ pts_map_mutex.unlock();
}
}
}
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef DEMUXERVDR_H
#define DEMUXERVDR_H
-#include "mutex.h"
+#include <mutex>
#include <deque>
#include "demuxer.h"
#include "defines.h"
typedef struct { ULLONG pts; ULONG frame; } PTSMapEntry;
typedef std::deque<PTSMapEntry> PTSMap;
PTSMap pts_map;
- Mutex pts_map_mutex;
+ std::mutex pts_map_mutex;
void parseVDRPacketDetails();
void dealWithSubtitlePacket();
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#define INITGUID
}
void DsAllocator::CleanupSurfaces() {
- Lock();
+ dsaLock.lock();
while(fullevrsamples.size()>0)
{
IMFSample *sample=fullevrsamples.front();
surfaces[i]=NULL;
}
start_get_evr_samples=false;
- Unlock();
+ dsaLock.unlock();
}
HRESULT STDMETHODCALLTYPE DsAllocator::InitializeDevice(DWORD_PTR userid,VMR9AllocationInfo* allocinf,DWORD*numbuf){
if (!surfallocnotify) return S_FALSE;
CleanupSurfaces();
- Lock();
+ dsaLock.lock();
surfaces.resize(*numbuf);
HRESULT hres= surfallocnotify->AllocateSurfaceHelper(allocinf,numbuf,&surfaces.at(0));
vheight=allocinf->dwHeight;
vwidth=allocinf->dwWidth;
start_get_evr_samples=false;
- Unlock();
+ dsaLock.unlock();
/* char buffer[1024];
sprintf(buffer,"%d * %d",allocinf->dwWidth,allocinf->dwHeight);
MessageBox(0,"hi",buffer,0);*/
void DsAllocator::LostDevice(IDirect3DDevice9 *d3ddev, IDirect3D9* d3d) {
if (!surfallocnotify) return ;
CleanupSurfaces();
- Lock();
+ dsaLock.lock();
// d3ddev=((OsdWin*)Osd::getInstance())->getD3dDev();
HMONITOR hmon=d3d->GetAdapterMonitor(D3DADAPTER_DEFAULT);
surfallocnotify->ChangeD3DDevice(d3ddev,hmon);
- Unlock();
+ dsaLock.unlock();
}
if (surfindex>=surfaces.size()) return E_FAIL;
if (surf==NULL) return E_POINTER;
- Lock();
+ dsaLock.lock();
surfaces[surfindex]->AddRef();
*surf=surfaces[surfindex];
- Unlock();
+ dsaLock.unlock();
return S_OK;
}
HRESULT STDMETHODCALLTYPE DsAllocator::AdviseNotify(IVMRSurfaceAllocatorNotify9* allnoty){
- Lock();
+ dsaLock.lock();
surfallocnotify=allnoty;
IDirect3DDevice9 *d3ddev;
//OK lets set the direct3d object from the osd
d3ddev=dynamic_cast<WindowsOsd*>(Osd::getInstance())->getD3dDev();
HMONITOR hmon=dynamic_cast<WindowsOsd*>(Osd::getInstance())->getD3d()->GetAdapterMonitor(D3DADAPTER_DEFAULT);
HRESULT hres=surfallocnotify->SetD3DDevice(d3ddev,hmon);
- Unlock();
+ dsaLock.unlock();
return hres;
}
HRESULT STDMETHODCALLTYPE DsAllocator::InitServicePointers(IMFTopologyServiceLookup *plooky)
{
if (!plooky) return E_POINTER;
- Lock();
+ dsaLock.lock();
inevrmode=true;
/* get all interfaces we need*/
__uuidof(IMFClock),(void**)&mfclock,&dwobjcts);
- Unlock();
+ dsaLock.unlock();
return S_OK;
}
HRESULT STDMETHODCALLTYPE DsAllocator::ReleaseServicePointers()
{
- Lock();
+ dsaLock.lock();
inevrmode=false;
/* TODO Set RenderState , sample type etc.*/
if (mfmediatype) mfmediatype->Release();
mfmediatype=NULL;
- Unlock();
+ dsaLock.unlock();
return S_OK;
}
void DsAllocator::GetEVRSamples()
{
- Lock();
+ dsaLock.lock();
MFCLOCK_STATE clockstate;
if (mfclock) mfclock->GetState(0,&clockstate);
//MessageBox(0,"get samples","samples",0);
if (mfclock && clockstate==MFCLOCK_STATE_STOPPED && fullevrsamples.size()>0)
{
- Unlock();
+ dsaLock.unlock();
return;
}
} else break;
}
- Unlock();
+ dsaLock.unlock();
}
HRESULT STDMETHODCALLTYPE DsAllocator::ProcessMessage(MFVP_MESSAGE_TYPE mess,ULONG_PTR mess_para)
HRESULT STDMETHODCALLTYPE DsAllocator::GetCurrentMediaType(IMFVideoMediaType **mtype)
{// MessageBox(0,"mediatype","mediatype",0);
if (mtype==NULL) return E_POINTER;
-Lock();
+dsaLock.lock();
if (mfmediatype==NULL)
{
- Unlock();
+ dsaLock.unlock();
*mtype=NULL;
return MF_E_NOT_INITIALIZED;
}
HRESULT hres=mfmediatype->QueryInterface(IID_IMFVideoMediaType,(void**)mtype);
-Unlock();
+dsaLock.unlock();
return hres;
}
gotcha=true;
- Lock();
+ dsaLock.lock();
if (mfmediatype) mfmediatype->Release();
mfmediatype=NULL;
mfmediatype=mixtype;
AllocateEVRSurfaces();
- Unlock();
+ dsaLock.unlock();
hres=mftransform->SetOutputType(0,mixtype,0);
if (hres!=S_OK)
{
- Lock();
+ dsaLock.lock();
if (mfmediatype) mfmediatype->Release();
mfmediatype=NULL;
gotcha=false;
- Unlock();
+ dsaLock.unlock();
}
format=D3DFMT_X8R8G8B8;
CleanupSurfaces();
- Lock();
+ dsaLock.lock();
WindowsOsd* osdwin = dynamic_cast<WindowsOsd*>(Osd::getInstance());
LPDIRECT3DDEVICE9 d3ddev=osdwin->getD3dDev();
osdwin->BeginPainting();
if (sample) emptyevrsamples.push(sample);
}
}
- Unlock();
+ dsaLock.unlock();
}
void DsAllocator::FlushEVRSamples()
{
- Lock();
+ dsaLock.lock();
while(fullevrsamples.size()>0)
{
IMFSample *sample=fullevrsamples.front();
fullevrsamples.pop();
emptyevrsamples.push(sample);
}
- Unlock();
+ dsaLock.unlock();
}
#define FAC 1
*surf=NULL;
*waittime=10;
- Lock();
+ dsaLock.lock();
if (fullevrsamples.size()==0) {
*waittime=1;
if (start_get_evr_samples) GetEVRSamples();
}
}
- Unlock();
+ dsaLock.unlock();
}
//Log::getInstance()->log("DsAllocator", Log::DEBUG , "Discard surface and get Wait");
if (start_get_evr_samples) GetEVRSamples();
//Log::getInstance()->log("DsAllocator", Log::DEBUG , "Discard surface and get Wait2");
- Lock();
+ dsaLock.lock();
if (fullevrsamples.size()==0) {
*waittime=0;
- Unlock();
+ dsaLock.unlock();
return;
}
IMFSample *sample=fullevrsamples.front();
break;
}
- Unlock();
+ dsaLock.unlock();
}
void DsAllocator::ResetSyncOffsets()
#include <queue>
#include <vector>
+#include <mutex>
#include <winsock2.h>
#include <dshow.h>
#include <vmr9.h>
#include <evr.h>
-#include "mutex.h"
//The Allocator and Presenter for VMR9 is also a Presnter for EVR
-class DsAllocator: public IVMRSurfaceAllocator9, IVMRImagePresenter9, Mutex,IMFVideoDeviceID,
+class DsAllocator: public IVMRSurfaceAllocator9, IVMRImagePresenter9, IMFVideoDeviceID,
IMFTopologyServiceLookupClient,public IMFVideoPresenter,IMFGetService, IQualProp {
public:
DsAllocator();
int jitter;
int avgfps;
LONGLONG lastdelframe;
+
+ std::mutex dsaLock;
};
#endif
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#include "imageomx.h"
}
void ImageOMX::ReturnEmptyOMXBuffer(OMX_BUFFERHEADERTYPE* buffer){
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
/*if (buffer->pBuffer) {
free(buffer->pBuffer);
buffer->pBuffer = NULL;
//Log::getInstance()->log("Image", Log::NOTICE, "ReturnEmptyOMXBuffer %d",input_bufs_omx_free.size());
input_bufs_omx_free.push_back(buffer);
//Log::getInstance()->log("Image", Log::NOTICE, "ReturnEmptyOMXBuffer %d",input_bufs_omx_free.size());
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
VideoOMX* video = static_cast<VideoOMX*>(Video::getInstance());
video->signalOmx();
void ImageOMX::ReturnFillOMXBuffer(OMX_BUFFERHEADERTYPE* /*buffer*/)
{
- //input_bufs_omx_mutex.Lock();
+ //input_bufs_omx_mutex.lock();
omx_egl_filled = true;
//output_bufs_omx_full.push_back(buffer);
- //input_bufs_omx_mutex.Unlock();
+ //input_bufs_omx_mutex.unlock();
VideoOMX* video = static_cast<VideoOMX*>(Video::getInstance());
video->signalOmx();
}
// Use Buffer
OMX_BUFFERHEADERTYPE * bufhead;
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
int count =0;
while (input_bufs_omx_free.size()==0) {
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
//Log::getInstance()->log("Image", Log::DEBUG, "DMP mark 6");
//Log::getInstance()->log("Image", Log::DEBUG, "Deliver MediaPacket no free sample");
//return 0; // we do not have a free media sample
if (count>100) return false;
MILLISLEEP(10);
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
}
bufhead=input_bufs_omx_free.front();
//bufhead->pBuffer=buffer;
bufhead->pAppPrivate=this;
input_bufs_omx_free.pop_front();
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
bufhead->nFilledLen=length;//bufhead->nAllocLen;
return 0;
}
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
for (unsigned int i=0; i< port_def_type.nBufferCountActual;i++) {
OMX_BUFFERHEADERTYPE *buf_head=NULL;
error=OMX_UseBuffer(omx_imag_decode/*dec*/,&buf_head,omx_image_input_port/*codec*/,this,port_def_type.nBufferSize, buffer);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Image", Log::DEBUG, "Use OMX_UseBuffer failed %x", error);
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
return 0;
}
input_bufs_omx_all.push_back(buf_head);
omx_first_frame=true;
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
if (!video->CommandFinished(omx_imag_decode/*dec*/,OMX_CommandPortEnable, omx_image_input_port /*codec*/)) {
return 0;
{
OMX_ERRORTYPE error;
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
for (UINT i=0; i< input_bufs_omx_all.size();i++) {
Log::getInstance()->log("Image", Log::DEBUG, "OMX_FreeBuffer mark");
//if (input_bufs_omx_all[i]->pBuffer) free(input_bufs_omx_all[i]->pBuffer);
error=OMX_FreeBuffer(omx_imag_decode/*dec*/,omx_image_input_port/*codec*/,input_bufs_omx_all[i]);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Image", Log::DEBUG, "Use OMX_FreeBuffer failed %x", error);
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
return 0;
}
}
input_bufs_omx_all.clear();
input_bufs_omx_free.clear();
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
return 1;
}
{
//OMX_ERRORTYPE error;
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
while (input_bufs_omx_all.size()>0) {
if (input_bufs_omx_free.size()>0) {
// Destroy one buffer
}
}
} else {
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
MILLISLEEP(5);
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
}
}
Log::getInstance()->log("Image", Log::DEBUG, "DestroyInputBufsOMXwhilePlaying %d %d", input_bufs_omx_all.size(),input_bufs_omx_free.size());
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
return 1;
}
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef IMAGEOMX_H
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
+#include <mutex>
#include <EGL/egl.h>
#include <EGL/eglext.h>
std::vector<OMX_BUFFERHEADERTYPE*> input_bufs_omx_all;
std::list<OMX_BUFFERHEADERTYPE*> input_bufs_omx_free;
//list<OMX_BUFFERHEADERTYPE*> output_bufs_omx_full;
- Mutex input_bufs_omx_mutex;
+ std::mutex input_bufs_omx_mutex;
bool omx_running;
bool omx_first_frame;
+++ /dev/null
-/*
- Copyright 2004-2005 Chris Tallon
-
- This file is part of VOMP.
-
- VOMP 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 2 of the License, or
- (at your option) any later version.
-
- VOMP 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 VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-*/
-#include "mutex.h"
-
-// FIXME - delete me.
-
-
-
-#ifndef WIN32
-#include <unistd.h>
-#include <sys/syscall.h>
-#endif
-
-Mutex::Mutex() {
-#ifndef WIN32
- pthread_mutex_init(&my_mutex, NULL);
-#else
- my_mutex=CreateMutex(NULL,FALSE,NULL);
-#endif
-}
-
-Mutex::~Mutex() {
-#ifdef WIN32
- CloseHandle(my_mutex);
-#endif
-}
-
-void Mutex::Lock() {
-#ifndef WIN32
- pthread_mutex_lock(&my_mutex);
-#else
- WaitForSingleObject(my_mutex, INFINITE );
-#endif
-}
-
-void Mutex::Unlock() {
-#ifndef WIN32
- pthread_mutex_unlock(&my_mutex);
-#else
- ReleaseMutex(my_mutex);
-#endif
-}
-
+++ /dev/null
-/*
- Copyright 2004-2005 Chris Tallon
-
- This file is part of VOMP.
-
- VOMP 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 2 of the License, or
- (at your option) any later version.
-
- VOMP 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 VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-*/
-
-#ifndef MUTEX_H
-#define MUTEX_H
-
-#ifndef WIN32
-#include <pthread.h>
-#else
-#include <winsock2.h>
-#include <windows.h>
-#endif
-
-
-
-class Mutex
-{
-public:
- Mutex();
- ~Mutex();
- void Lock();
- void Unlock();
-protected:
-#ifndef WIN32
- pthread_mutex_t my_mutex;
-#else
- HANDLE my_mutex;
-#endif
-};
-#endif
OBJ_COMMON = command.o tcp.o dsock.o thread.o timers.o i18n.o vdp6.o \
- message.o messagequeue.o wol.o audio.o video.o log.o mutex.o \
+ message.o messagequeue.o wol.o audio.o video.o log.o \
vdr.o recman.o recording.o recinfo.o channel.o rectimer.o event.o \
directory.o mark.o option.o player.o playerradio.o vfeed.o afeed.o \
demuxer.o demuxervdr.o demuxerts.o stream.o osd.o surface.o \
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
-#include "osdopengl.h"
#include "videoomx.h"
#include "surfaceopengl.h"
-
#include "message.h"
#include "command.h"
+#include "osdopengl.h"
+
#define BACKBUFFER_WIDTH 1280
#define BACKBUFFER_HEIGHT 720
OsdOpenGL::OsdOpenGL()
{
- glmutex.Lock();
+ glmutex.lock();
external_driving=false;
}
- glmutex.Unlock();
+ glmutex.unlock();
}
int OsdOpenGL::getFD()
if (egl_display==EGL_NO_DISPLAY) {
Log::getInstance()->log("OSD", Log::WARN, "Could not get egl display! %x",eglGetError());
- glmutex.Unlock();
+ glmutex.unlock();
return 0;
}
if (eglInitialize(egl_display, NULL, NULL)==EGL_FALSE) {
Log::getInstance()->log("OSD", Log::WARN, "Initialising display failed! %x",eglGetError());
- glmutex.Unlock();
+ glmutex.unlock();
return 0;
}
if (eglChooseConfig(egl_display, attributs, &egl_ourconfig, 1, &number)==EGL_FALSE) {
Log::getInstance()->log("OSD", Log::WARN, "Choosing egl config failed! %x",eglGetError());
- glmutex.Unlock();
+ glmutex.unlock();
return 0;
}
egl_context=eglCreateContext(egl_display,egl_ourconfig,EGL_NO_CONTEXT,attr_context);
if (egl_context==EGL_NO_CONTEXT) {
Log::getInstance()->log("OSD", Log::WARN, "Creating egl context failed! %x",eglGetError());
- glmutex.Unlock();
+ glmutex.unlock();
return 0;
}
display_width=display_height=0;
if (graphics_get_display_size(0, &display_width, &display_height)<0) {
Log::getInstance()->log("OSD", Log::WARN, "Getting display size failed! (BCM API) ");
- glmutex.Unlock();
+ glmutex.unlock();
return 0;
}
Log::getInstance()->log("OSD", Log::NOTICE, "Displaysize is %d x %d ",display_width, display_height);
egl_surface = eglCreateWindowSurface(egl_display,egl_ourconfig, &nativewindow,NULL );
if (egl_surface==EGL_NO_SURFACE) {
Log::getInstance()->log("OSD", Log::WARN, "Creating egl window surface failed!");
- glmutex.Unlock();
+ glmutex.unlock();
return 0;
}
if (eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context)== EGL_FALSE) {
Log::getInstance()->log("OSD", Log::WARN, "Making egl Current failed");
- glmutex.Unlock();
+ glmutex.unlock();
return 0;
}
// Test stuff
if (!osd_shader.init()) {
Log::getInstance()->log("OSD", Log::WARN, "Init Osd Shader failed");
- glmutex.Unlock();
+ glmutex.unlock();
return 0;
}
}
- glmutex.Unlock();
+ glmutex.unlock();
threadStart();
return 1;
int OsdOpenGL::shutdown()
{
if (!initted) return 0;
- glmutex.Lock();
+ glmutex.lock();
initted = 0;
threadStop();
delete screen;
void OsdOpenGL::threadMethod()
{
// We have to claim the gl context for this thread
- //glmutex.Lock();
+ //glmutex.lock();
- //glmutex.Unlock();
+ //glmutex.unlock();
int ts=0;
while (true)
{
void OsdOpenGL::BeginPainting() {//We synchronize calls to d3d between different threads
- glmutex.Lock();
+ glmutex.lock();
if (initted) {
if (eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context)== EGL_FALSE) {
Log::getInstance()->log("OSD", Log::WARN, "Making egl Current failed in thread %d",eglGetError());
void OsdOpenGL::EndPainting() {
eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
- glmutex.Unlock();
+ glmutex.unlock();
}
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef OSDOPENGL_H
#define OSDOPENGL_H
#include <stdio.h>
-
-
+#include <mutex>
#include <GLES2/gl2.h>
#include <EGL/egl.h>
#include "defines.h"
#include "log.h"
#include "threadp.h"
-#include "mutex.h"
#include "videoomx.h"
#include "glosdshader.h"
-
-
-
-
-
struct OSDCOLOR{
GLfloat r;
GLfloat g;
GLfloat v;
};
-
-
-
-
-
class OsdOpenGL : public Osd, public Thread_TYPE
{
public:
// This indicates, that currently a video is played, thus the osd updates are driven by the Videosystem
bool external_driving;
- Mutex glmutex;
+ std::mutex glmutex;
long long lastrendertime;
void InternalRendering();
void InitVertexBuffer(float scalex,float scaley);
GLOsdShader osd_shader;
-
-
-
/* BCM specific */
uint32_t display_height;
uint32_t mode;
-
EGLDisplay egl_display;
EGLSurface egl_surface;
EGLContext egl_context;
OsdOpenVG::OsdOpenVG()
{
- vgmutex.Lock();
- taskmutex.Lock();
+ vgmutex.lock();
+ taskmutex.lock();
lastrendertime=getTimeMS();
display_height=0;
display_width=0;
}
}
- vgmutex.Unlock();
- taskmutex.Unlock();
+ vgmutex.unlock();
+ taskmutex.unlock();
}
if (egl_display==EGL_NO_DISPLAY) {
Log::getInstance()->log("OSD", Log::WARN, "Could not get egl display! %x",eglGetError());
- vgmutex.Unlock();
+ vgmutex.unlock();
return 0;
}
if (eglInitialize(egl_display, NULL, NULL)==EGL_FALSE) {
Log::getInstance()->log("OSD", Log::WARN, "Initialising display failed! %x",eglGetError());
- vgmutex.Unlock();
+ vgmutex.unlock();
return 0;
}
if (eglBindAPI(EGL_OPENVG_API)==EGL_FALSE) {
Log::getInstance()->log("OSD", Log::WARN, "Binding openvg api failed! %x",eglGetError());
- vgmutex.Unlock();
+ vgmutex.unlock();
return 0;
}
if (eglChooseConfig(egl_display, attributs, &egl_ourconfig, 1, &number)==EGL_FALSE) {
Log::getInstance()->log("OSD", Log::WARN, "Choosing egl config failed! %x",eglGetError());
- vgmutex.Unlock();
+ vgmutex.unlock();
return 0;
}
egl_context=eglCreateContext(egl_display,egl_ourconfig,NULL,NULL);
if (egl_context==EGL_NO_CONTEXT) {
Log::getInstance()->log("OSD", Log::WARN, "Creating egl context failed! %x",eglGetError());
- vgmutex.Unlock();
+ vgmutex.unlock();
return 0;
}
display_width=display_height=0;
if (graphics_get_display_size(0, &display_width, &display_height)<0) {
Log::getInstance()->log("OSD", Log::WARN, "Getting display size failed! (BCM API) ");
- vgmutex.Unlock();
+ vgmutex.unlock();
return 0;
}
Log::getInstance()->log("OSD", Log::NOTICE, "Displaysize is %d x %d ",display_width, display_height);
egl_surface = eglCreateWindowSurface(egl_display,egl_ourconfig, &nativewindow,NULL );
if (egl_surface==EGL_NO_SURFACE) {
Log::getInstance()->log("OSD", Log::WARN, "Creating egl window surface failed!");
- vgmutex.Unlock();
+ vgmutex.unlock();
return 0;
}
Log::getInstance()->log("OSD", Log::DEBUG, "Making egl current in1%d",syscall(SYS_gettid));
if (eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context)== EGL_FALSE) {
Log::getInstance()->log("OSD", Log::WARN, "Making egl Current failed");
- vgmutex.Unlock();
+ vgmutex.unlock();
return 0;
}
// Test stuff
threadStart();
- taskmutex.Unlock();
- vgmutex.Unlock();
+ taskmutex.unlock();
+ vgmutex.unlock();
#ifdef PICTURE_DECODER_OMX
imageomx=new ImageOMX(&reader);
processTasks();
Log::getInstance()->log("OSD", Log::DEBUG, "shutdown mark3");
- taskmutex.Lock();
- vgmutex.Lock();
+ taskmutex.lock();
+ vgmutex.lock();
}
void OsdOpenVG::InternalRendering(){
- vgmutex.Lock();
+ vgmutex.lock();
Colour bg=DrawStyle::WALLPAPER;
float colclear[]={1.f,1.0f,1.f,1.f};
if (bg.alpha==0) colclear[3]=0.f;
//Show it to the user!
eglSwapBuffers(egl_display, egl_surface);
- vgmutex.Unlock();
+ vgmutex.unlock();
}
bool OsdOpenVG::processTasks()
{
bool worked=false;
- taskmutex.Lock();
- vgmutex.Lock();
+ taskmutex.lock();
+ vgmutex.lock();
while (vgcommands.size()>0)
{
OpenVGCommand comm=vgcommands.front();
vgcommands.pop_front();
- taskmutex.Unlock();
+ taskmutex.unlock();
OpenVGResponse resp;
resp.result=handleTask(comm);
resp.id=comm.id;
- taskmutex.Lock();
+ taskmutex.lock();
if (comm.id) {
vgresponses.push_back(resp);
}
- taskmutex.Unlock();
- vgmutex.Unlock();
+ taskmutex.unlock();
+ vgmutex.unlock();
//threadCheckExit();
vgtaskSignal.signal();
- taskmutex.Lock();
- vgmutex.Lock();
+ taskmutex.lock();
+ vgmutex.lock();
worked=true;
}
- taskmutex.Unlock();
- vgmutex.Unlock();
+ taskmutex.unlock();
+ vgmutex.unlock();
return worked;
}
bool OsdOpenVG::haveOpenVGResponse(unsigned int id,unsigned int * resp)
{
- taskmutex.Lock();
+ taskmutex.lock();
if (vgresponses.size()>0)
{
std::deque<OpenVGResponse>::iterator itty=vgresponses.begin();
{
if ((*itty).id==id) {
*resp=(*itty).result;
- taskmutex.Unlock();
+ taskmutex.unlock();
return true;
}
itty++;
}
}
- taskmutex.Unlock();
+ taskmutex.unlock();
return false;
}
unsigned int OsdOpenVG::putOpenVGCommand(OpenVGCommand& comm,bool wait)
{
- taskmutex.Lock();
+ taskmutex.lock();
if (wait){
comm.id=wait_id;
wait_id++;
comm.id=0; // we are not waiting
}
vgcommands.push_back(comm);
- taskmutex.Unlock();
+ taskmutex.unlock();
threadSignal();
while (wait) {
unsigned int resp;
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef OSDOPENVG_H
#define OSDOPENVG_H
#include <stdio.h>
-
+#include <mutex>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include "defines.h"
#include "log.h"
#include "threadp.h"
-#include "mutex.h"
#include "signal.h"
#include "videoomx.h"
#include "staticartwork.h"
- Mutex vgmutex;
- Mutex taskmutex;
+ std::mutex vgmutex;
+ std::mutex taskmutex;
Signal vgtaskSignal;
std::deque<OpenVGCommand> vgcommands;
std::deque<OpenVGResponse> vgresponses;
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#include "osdvector.h"
int OsdVector::restore()
{
// First clear the contents of all registered surfaces
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
//Now go through all surfaces and draw them
std::list<SurfaceCommands>::iterator curdraw=scommands.begin();
tvmedias_load_inv.clear();
tvmedias_loaded.clear();
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
return 1;
}
void OsdVector::drawSurfaces()
{
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
std::list<SurfaceCommands*> todraw; //First figure out if a surfaces is below another surface
std::list<SurfaceCommands>::iterator itty1=scommands.begin();
while (itty1!=scommands.end()) {
curdraw++;
}
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
}
void OsdVector::updateOrAddSurface(const SurfaceVector *surf,float x,float y,float height,float width,
std::vector<SVGCommand>& commands)
{
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
//First determine it is already in our system
std::list<SurfaceCommands>::iterator itty=scommands.begin();
while (itty!=scommands.end()) {
referenceSVGCommand((*itty).commands);
cleanupOrphanedRefs();
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
}
void OsdVector::removeSurface(const SurfaceVector *surf)
{
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
//First determine it is already in our system
std::list<SurfaceCommands>::iterator itty=scommands.begin();
while (itty!=scommands.end()) {
}
itty++;
}
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
}
int OsdVector::getLoadIndexRef(LoadIndex index)
{
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
if (loadindex_ref.find(index)==loadindex_ref.end()) {
return -1;
} else {
return loadindex_ref[index];
}
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
}
void OsdVector::incLoadIndexRef(LoadIndex index)
int OsdVector::getImageRef(ImageIndex index)
{
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
if (images_ref.find(index)==images_ref.end()) {
return -1;
} else {
return images_ref[index];
}
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
}
void OsdVector::incStyleRef(VectorHandle index)
VectorHandle OsdVector::getStyleRef(const DrawStyle &c)
{
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
VectorHandle style_handle = 0;
if (!styles_lastit_valid || (*styles_lastit).first!=c) {
styles_lastit_valid=false;
if (styles_lastit==styles.end())
{
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
style_handle=createStyleRef(c);
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
styles_lastit = styles.insert(std::pair<DrawStyle, VectorHandle>(c, style_handle)).first;
} else {
if (styles_ref_lastit==styles_ref.end()) {
//invalid handle recreate
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
style_handle=createStyleRef(c);
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
(*styles_lastit).second=style_handle;
} else styles_ref_lastit_valid=true;
}
styles_lastit_valid=true;
incStyleRef(style_handle);
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
return style_handle;
}
{
ImageIndex image_handle=0;
LoadIndex loadindex=0;
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
if (tvmedias.find(tvmedia)==tvmedias.end())
{
loadindex=loadTVMedia(tvmedia);
/*tvmedias[tvmedia]=createTVMedia(tvmedia,width,height);
incImageRef(image_handle);*/
image=image_handle;
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
return loadindex;
}
ImageIndex image_index=0;
Log::getInstance()->log("OsdVector", Log::DEBUG, "TVMedia Picture for request id %llx arrived %x",index, imageIndex);
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
TVMediaInfo tvmedia=tvmedias_load_inv[index];
if (imageIndex) {
std::map<LoadIndex,int>::iterator itty=loadindex_ref.find(index);
incImageRef(image_index); // hold one index until all loadings refs are gone;
}
}
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
}
ImageIndex OsdVector::getMonoBitmapRef(void *base,int width,int height)
{
ImageIndex image_handle;
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
if (monobitmaps.find(base)==monobitmaps.end())
{
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
image_handle=createMonoBitmap(base,width,height);
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
monobitmaps[base]=image_handle;
} else {
image_handle=monobitmaps[base];
if (images_ref.find(image_handle)==images_ref.end()) {
//invalid handle recreate
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
image_handle=createMonoBitmap(base,width,height);
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
monobitmaps[base]=image_handle;
}
}
incImageRef(image_handle);
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
return image_handle;
}
{
ImageIndex image_handle;
image_handle=createImagePalette(width,height,image_data,palette_data);
- surfaces_mutex.Lock();
+ surfaces_mutex.lock();
palettepics.push_back(image_handle);
incImageRef(image_handle);
- surfaces_mutex.Unlock();
+ surfaces_mutex.unlock();
return image_handle;
}
OsdVector::PictureReader::~PictureReader()
{
- decoders_lock.Lock();
+ decoders_lock.lock();
while ( decoders.size()) {
PictureDecoder* dec=decoders.front();
decoders.pop_front();
delete dec;
}
- decoders_lock.Unlock();
+ decoders_lock.unlock();
}
void OsdVector::PictureReader::init()
void OsdVector::PictureReader::addDecoder(PictureDecoder* decoder)
{
- decoders_lock.Lock();
+ decoders_lock.lock();
decoder->init();
decoders.push_front(decoder);
- decoders_lock.Unlock();
+ decoders_lock.unlock();
}
void OsdVector::PictureReader::removeDecoder(PictureDecoder* decoder)
{
- decoders_lock.Lock();
+ decoders_lock.lock();
std::list<PictureDecoder*>::iterator itty=decoders.begin();
while (itty!=decoders.end()) {
if ((*itty) == decoder)
Log::getInstance()->log("OsdVector", Log::DEBUG, "removeDecoder");
decoder->shutdown();
delete decoder;
- decoders_lock.Unlock();
+ decoders_lock.unlock();
}
void OsdVector::PictureReader::threadMethod()
{
todos=false;
PictureInfo pictinf;
- decoders_lock.Lock();
+ decoders_lock.lock();
std::list<PictureDecoder*>::iterator itty=decoders.begin();
while (itty!=decoders.end()) {
todos = true;
}
- decoders_lock.Unlock();
+ decoders_lock.unlock();
}
//Log::getInstance()->log("OsdVector", Log::DEBUG, "TVMedia Sleep Picture Reader");
void OsdVector::PictureReader::invalidateLoadIndex(LoadIndex index)
{
- pict_lock_incoming.Lock();
+ pict_lock_incoming.lock();
invalid_loadindex.insert(index);
- pict_lock_incoming.Unlock();
+ pict_lock_incoming.unlock();
}
void OsdVector::PictureReader::informFallback(LoadIndex index, int fallback)
{
- pict_lock_incoming.Lock();
+ pict_lock_incoming.lock();
inform_fallback[index]=fallback;
- pict_lock_incoming.Unlock();
+ pict_lock_incoming.unlock();
}
void OsdVector::PictureReader::receivePicture(VDR_ResponsePacket *vresp)
{
- pict_lock_incoming.Lock();
+ pict_lock_incoming.lock();
pict_incoming.push(vresp);
- pict_lock_incoming.Unlock();
+ pict_lock_incoming.unlock();
threadSignal();
}
void OsdVector::PictureReader::addStaticImage(unsigned int id)
{
- pict_lock_incoming.Lock();
+ pict_lock_incoming.lock();
pict_incoming_static.push(id);
invalid_loadindex.erase(((long long) id) << 32LL);
- pict_lock_incoming.Unlock();
+ pict_lock_incoming.unlock();
threadSignal();
}
{
bool decoded = false;
bool valid = true;
- pict_lock_incoming.Lock();
+ pict_lock_incoming.lock();
if (pict_incoming.size()) {
VDR_ResponsePacket *vresp=pict_incoming.front();
pict_incoming.pop();
valid = false;
invalid_loadindex.erase(setpos);
}
- pict_lock_incoming.Unlock();
+ pict_lock_incoming.unlock();
if (!valid) { // we do not want it anymore skip it;
delete vresp;
return true;
freed = true;
} else {
int fallback=-1;
- pict_lock_incoming.Lock();
+ pict_lock_incoming.lock();
if (inform_fallback.find(vresp->getStreamID())!=inform_fallback.end()) {
fallback=inform_fallback[vresp->getStreamID()];
}
- pict_lock_incoming.Unlock();
+ pict_lock_incoming.unlock();
if (fallback >= 0 && ((OsdVector*)Osd::getInstance())->getStaticImageData(fallback, &userdata, &length))
{
decode = true;
free(userdata);
}
}
- pict_lock_incoming.Lock();
+ pict_lock_incoming.lock();
inform_fallback.erase(vresp->getStreamID());
- pict_lock_incoming.Unlock();
+ pict_lock_incoming.unlock();
//else osd->informPicture(vresp->getStreamID(), 0);
delete vresp;
} else if (pict_incoming_static.size()){
valid = false;
invalid_loadindex.erase(setpos);
}
- pict_lock_incoming.Unlock();
+ pict_lock_incoming.unlock();
if (!valid) { // we do not want it anymore skip it;
return true;
}
}
}
} else {
- pict_lock_incoming.Unlock();
+ pict_lock_incoming.unlock();
}
#ifndef OSDVECTOR_H
#define OSDVECTOR_H
-#include "osd.h"
-#include "mutex.h"
-#include "colour.h"
#include <set>
#include <list>
#include <vector>
#include <map>
#include <queue>
#include <string>
+#include <mutex>
+
+#include "osd.h"
+#include "colour.h"
#include "tvmedia.h"
#include "vdr.h"
void threadMethod();
- Mutex pict_lock_incoming; //locks
- Mutex decoders_lock;
+ std::mutex pict_lock_incoming; //locks
+ std::mutex decoders_lock;
std::queue<VDR_ResponsePacket*> pict_incoming;
std::queue<unsigned int> pict_incoming_static;
std::list<PictureDecoder*> decoders;
std::list<SurfaceCommands> scommands;
- Mutex surfaces_mutex;
+ std::mutex surfaces_mutex;
float byte_char_width[256];
- queuemutex.Lock();
+ queuemutex.lock();
HRESULT hres;
DXGI_SURFACE_DESC surf_desc;
D3DPOOL_DEFAULT, &surfinfo.surf9, &surfinfo.sharedhandle);
if (hres != S_OK) {
Log::getInstance()->log("OSD", Log::WARN, "Could not create Texture for Direct3D9 !");
- queuemutex.Unlock();
+ queuemutex.unlock();
return 0;
}
hres = d3ddevice->CreateQuery(D3DQUERYTYPE_EVENT, &surfinfo.query9);
if (hres != S_OK) {
Log::getInstance()->log("OSD", Log::WARN, "Could not create Query for Direct3D9 !");
- queuemutex.Unlock();
+ queuemutex.unlock();
return 0;
}
hres = d3ddevice10->OpenSharedResource(surfinfo.sharedhandle, __uuidof(ID3D10Resource), (void**)&tempres);
if (hres != S_OK) {
Log::getInstance()->log("OSD", Log::WARN, "Could not open resourcee for Direct3D10 !");
- queuemutex.Unlock();
+ queuemutex.unlock();
return 0;
}
hres = tempres->QueryInterface(__uuidof(ID3D10Texture2D), (void**)&surfinfo.surf10);
if (hres != S_OK) {
Log::getInstance()->log("OSD", Log::WARN, "Could not query surface for Direct3D10 !");
- queuemutex.Unlock();
+ queuemutex.unlock();
return 0;
}
tempres->Release();
hres = surfinfo.surf10->QueryInterface(__uuidof(IDXGISurface), (void**)&surfinfo.surfdxgi);
if (hres != S_OK) {
Log::getInstance()->log("OSD", Log::WARN, "Could not query surface for DXGI !");
- queuemutex.Unlock();
+ queuemutex.unlock();
return 0;
}
hres = d2dfactory->CreateDxgiSurfaceRenderTarget(surfinfo.surfdxgi, &rt_prop, &surfinfo.rendtarget2D);
if (hres != S_OK) {
Log::getInstance()->log("OSD", Log::WARN, "Could not create render target!");
- queuemutex.Unlock();
+ queuemutex.unlock();
return 0;
}
hres = d3ddevice10->CreateQuery(&qdesc, &surfinfo.query10);
if (hres != S_OK) {
Log::getInstance()->log("OSD", Log::WARN, "Could not create Query for Direct2D Direct3D10 !");
- queuemutex.Unlock();
+ queuemutex.unlock();
return 0;
}
allsurfs.push_back(surfinfo);
aspect_correction = ((float)OSD_BUFFER_HEIGHT) / 576.f / (((float)OSD_BUFFER_WIDTH) / 720.f);
- queuemutex.Unlock();
+ queuemutex.unlock();
initPaths();
destroyPaths();
- queuemutex.Lock();
+ queuemutex.lock();
if (currentosd_render.surf9) {
currentosd_render.surf9 = NULL;
}
while (d3dtod2d.size()) d3dtod2d.pop();
while (d2dtod3d.size()) d2dtod3d.pop();
- queuemutex.Unlock();
+ queuemutex.unlock();
LPDIRECT3DTEXTURE9 OsdWinVector::getNextOsdTexture()
{
- queuemutex.Lock();
+ queuemutex.lock();
if (d2dtod3d.size())
{
SurfaceInfo surfinfo = d2dtod3d.front();
d2dtod3d.pop();
//}
}
- queuemutex.Unlock();
+ queuemutex.unlock();
return currentosd_render.surf9;
}
void OsdWinVector::updateOsd()
{
- queuemutex.Lock();
+ queuemutex.lock();
if (d3dtod2d.size())
{
currentosd_backbuffer = d3dtod2d.front();
if (currentosd_backbuffer.query9->GetData(NULL, 0, 0) == S_OK) {
- //queuemutex.Unlock();
+ //queuemutex.unlock();
currentosd_backbuffer.query10->Begin();
currentosd_backbuffer.rendtarget2D->BeginDraw();
d3ddevice10->Flush();
currentosd_backbuffer.query10->End();
- //queuemutex.Lock();
+ //queuemutex.lock();
d3dtod2d.pop();
d2dtod3d.push(currentosd_backbuffer);
}
- queuemutex.Unlock();
+ queuemutex.unlock();
}
ID2D1RenderTarget * OsdWinVector::LockOsdDrawing()
{
- queuemutex.Lock();
+ queuemutex.lock();
if (d3dtod2d.size())
{
currentosd_backbuffer=d3dtod2d.front();
return currentosd_backbuffer.rendtarget2D;
}
- queuemutex.Unlock();
+ queuemutex.unlock();
int loop = 0;
while (loop < 100) {
- queuemutex.Lock();
+ queuemutex.lock();
if (d3dtod2d.size())
{
currentosd_backbuffer = d3dtod2d.front();
return currentosd_backbuffer.rendtarget2D;
}
- queuemutex.Unlock();
+ queuemutex.unlock();
MILLISLEEP(100);
loop++;
}
void OsdWinVector::UnlockOsdDrawing()
{
- queuemutex.Unlock();
+ queuemutex.unlock();
}
void OsdWinVector::lostDestroyObjects()
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef OSDWINVECTOR_H
#define OSDWINVECTOR_H
#include <stdio.h>
-
-#include "osdvector.h"
-#include "defines.h"
-#include "log.h"
-#include "windowsosd.h"
-#include "mutex.h"
#include <d3d10_1.h>
#include <d2d1.h>
#include <dwrite.h>
#include <queue>
#include <list>
+#include <mutex>
+
+#include "osdvector.h"
+#include "defines.h"
+#include "log.h"
+#include "windowsosd.h"
ID2D1RenderTarget * LockOsdDrawing();
void UnlockOsdDrawing();
- Mutex queuemutex;
+ std::mutex queuemutex;
void initPaths();
void destroyPaths();
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
data=NULL;
sheight=swidth=0;
// fastdraw=false;
- srf_mutex.Lock();
+ srf_mutex.lock();
}
SurfaceOpenGL::~SurfaceOpenGL()
{
- srf_mutex.Lock();
+ srf_mutex.lock();
if (data) {
free(data);
data=NULL;
} else {
glDeleteTextures(1,&gltexture);
}
- srf_mutex.Unlock();
+ srf_mutex.unlock();
}
int SurfaceOpenGL::create(UINT width, UINT height)
//osd->EndPainting();
- srf_mutex.Unlock();
+ srf_mutex.unlock();
return 1;
}
}
int SurfaceOpenGL::fillblt(int x, int y, int width, int height, const DrawStyle& c) {
- srf_mutex.Lock();
+ srf_mutex.lock();
//since this might be called before surface
//allocation we will wait in this case, hopefully without deadlocks
if (screen == this || !data ) {
//This should not happen!
- srf_mutex.Unlock();
+ srf_mutex.unlock();
return 0;
}
glViewport(0,0,swidth,sheight);*/
//osd->EndPainting();
- srf_mutex.Unlock();
+ srf_mutex.unlock();
unsigned int my_c=InternalColour(c.rgba());
void SurfaceOpenGL::startFastDraw(){
- srf_mutex.Lock();
+ srf_mutex.lock();
}
void SurfaceOpenGL::endFastDraw(){
- srf_mutex.Unlock();
+ srf_mutex.unlock();
}
void SurfaceOpenGL::drawPixel(int x, int y, Colour & colour, bool fastdraw) {
}
//OsdWin* osd;
if (!fastdraw) {
- srf_mutex.Lock(); //since this might be called before surface
+ srf_mutex.lock(); //since this might be called before surface
}
//allocation we will wait in this case, hopefully without deadlocks
row[0] = my_c;
if (!fastdraw) {
- srf_mutex.Unlock(); //since this might be called before surface
+ srf_mutex.unlock(); //since this might be called before surface
}
}
int SurfaceOpenGL::updateToScreen(int sx, int sy, int w, int h, int dx, int dy) // FIXME new, replace others with this FIXME
{
// Log::getInstance()->log("Surface", Log::WARN, "UTS Mark1");
- srf_mutex.Lock();//since this might be called before surface
+ srf_mutex.lock();//since this might be called before surface
//allocation we will wait in this case, hopefully without deadlocks
OsdOpenGL* osd=((OsdOpenGL*)(Osd::getInstance()));
osd->EndPainting();
- srf_mutex.Unlock();
+ srf_mutex.unlock();
return 0;
}
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef SURFACEOPENGL_H
#define SURFACEOPENGL_H
+#include <GLES2/gl2.h>
+#include <mutex>
+
#include "defines.h"
#include "surface.h"
-#include "mutex.h"
-#include <GLES2/gl2.h>
class SurfaceOpenGL : public Surface
{
- Mutex srf_mutex;
+ std::mutex srf_mutex;
protected:
void drawPixel(int x, int y, Colour& c, bool fastdraw=false);
void drawPixel(int x, int y, unsigned int c, bool fastdraw=false);
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
-#include "surfacevector.h"
-#include "bitmap.h"
-#include "staticartwork.h"
#include <wchar.h>
#include <stdlib.h>
#include <math.h>
+#include "bitmap.h"
+#include "staticartwork.h"
+#include "surfacevector.h"
SurfaceVector::SurfaceVector(OsdVector* vosd)
{
size_t length=strlen(text);
- command_mutex.Lock();
+ command_mutex.lock();
VectorHandle ref=osd->getStyleRef(c);
float *charwidtharray=osd->getCharWidthArray();
length -= num_bytes;
run += num_bytes;
if (shift>width && width >0) {
- command_mutex.Unlock();
+ command_mutex.unlock();
return 1;
}
num_bytes=mbrtowc(&tempo, run, length, &state);
#endif
commands.resize(commands_size+chars);
- command_mutex.Unlock();
+ command_mutex.unlock();
return 1;
}
/*
void SurfaceVector::drawJpeg(const char *fileName,int x, int y,int *width, int *height)
{
- command_mutex.Lock();
+ command_mutex.lock();
ImageIndex image=osd->getJpegRef(fileName,width,height);
commands.push_back(SVGCommand::PaintImage(x,y,*width,*height,image,0));
- command_mutex.Unlock();
+ command_mutex.unlock();
}
*/
void SurfaceVector::drawTVMedia(TVMediaInfo & tvmedia,float x, float y, float width, float height, Corner corner)
{
- command_mutex.Lock();
+ command_mutex.lock();
ImageIndex image=0;
LoadIndex load_index=osd->getTVMediaRef(tvmedia,image);
if (width!=0 && height!=0) {
commands.push_back(SVGCommand::PaintImageLoading(load_index,x,y,width,height,0,corner));
//Log::getInstance()->log("SurfaceVector", Log::DEBUG, "TVMedia Add instru image loading %d %d", load_index,image);
}
- command_mutex.Unlock();
+ command_mutex.unlock();
}
void SurfaceVector::drawClippingRectangle(float x, float y, float w, float h)
{
- command_mutex.Lock();
+ command_mutex.lock();
commands.push_back(SVGCommand::PaintClipping((float)x,(float)y,(float)w,(float)h));
- command_mutex.Unlock();
+ command_mutex.unlock();
}
int SurfaceVector::create(UINT width, UINT height)
int SurfaceVector::fillblt(int x, int y, int width, int height, const DrawStyle& c)
{
- command_mutex.Lock();
+ command_mutex.lock();
removeCommands(x,y,width,height); // remove commands below the box
VectorHandle ref=osd->getStyleRef(c);
commands.push_back(SVGCommand::PaintPath(x,y,width,height,PIRectangle,ref));
- command_mutex.Unlock();
+ command_mutex.unlock();
return 1;
}
void SurfaceVector::drawHorzLine(int x1, int x2, int y, const DrawStyle& c)
{
- command_mutex.Lock();
+ command_mutex.lock();
VectorHandle ref = osd->getStyleRef(c);
commands.push_back(SVGCommand::PaintPath(x1,y,x2-x1,1,PIHorzLine,ref));
- command_mutex.Unlock();
+ command_mutex.unlock();
}
void SurfaceVector::drawVertLine(int x, int y1, int y2, const DrawStyle& c){
- command_mutex.Lock();
+ command_mutex.lock();
VectorHandle ref = osd->getStyleRef(c);
commands.push_back(SVGCommand::PaintPath(x,y1,1,y2-y1,PIVertLine,ref));
- command_mutex.Unlock();
+ command_mutex.unlock();
}
void SurfaceVector::drawBitmap(int x, int y, const Bitmap& bm,const DisplayRegion & region)
{
//this is complicated
- command_mutex.Lock();
+ command_mutex.lock();
/*
unsigned int * data=(unsigned int*)malloc(sizeof(unsigned int)*bm.getWidth()*bm.getHeight());
for (UINT j = 0; j < bm.getHeight(); ++j){
SVGCommand temp=SVGCommand::PaintImage(tx,ty,tw,th,image,0);
removeCommands(tx,ty,tw,th);
commands.push_back(temp);
- command_mutex.Unlock();
+ command_mutex.unlock();
}
void SurfaceVector::drawPoint(int x, int y, DrawStyle& c, bool fastdraw){
- if (!fastdraw) command_mutex.Lock();
+ if (!fastdraw) command_mutex.lock();
VectorHandle ref = osd->getStyleRef(c);
commands.push_back(SVGCommand::PaintPath(x,y,1,1,PIPoint,ref));
- if (!fastdraw) command_mutex.Unlock();
+ if (!fastdraw) command_mutex.unlock();
}
void SurfaceVector::drawMonoBitmap(UCHAR* base, int dx, int dy, unsigned int height,unsigned int width, DrawStyle& nextColour)
{
- command_mutex.Lock();
+ command_mutex.lock();
ImageIndex image=osd->getMonoBitmapRef(base,width,height);
VectorHandle ref = osd->getStyleRef(nextColour);
removeCommands(dx,dy,width,height);
commands.push_back(SVGCommand::PaintImage(dx,dy,height,width,image,ref));
- command_mutex.Unlock();
+ command_mutex.unlock();
}
int SurfaceVector::updateToScreen(int sx, int sy, int w, int h, int dx, int dy)
{
// ok this method really works in a pixel oriented way
- command_mutex.Lock();
+ command_mutex.lock();
osd->updateOrAddSurface(this,dx-sx,dy-sy,swidth,sheight,commands);
- command_mutex.Unlock();
+ command_mutex.unlock();
return 1;
}
/* This is for systems which need a locking of the drawing surface to speed up drawing */
void SurfaceVector::startFastDraw() {
- command_mutex.Lock();
+ command_mutex.lock();
}
void SurfaceVector::endFastDraw() {
- command_mutex.Unlock();
+ command_mutex.unlock();
}
void SurfaceVector::drawTTChar(int ox, int oy,int x, int y, cTeletextChar c)
{
- command_mutex.Lock();
+ command_mutex.lock();
std::vector<SVGCommand>::iterator itty=commands.begin();
while (itty!=commands.end())
{
}
}
commands.push_back(SVGCommand::PaintTTchar(ox,oy,x,y,c.getInternal()));
- command_mutex.Unlock();
+ command_mutex.unlock();
}
#ifndef SURFACEVECTOR_H
#define SURFACEVECTOR_H
+#include <mutex>
#include <vector>
#include "surface.h"
std::vector<SVGCommand> commands;
int swidth, sheight;
- Mutex command_mutex;
+ std::mutex command_mutex;
OsdVector* osd;
void drawPixel(int /* x */, int /* y */, unsigned int /* c */, bool /* fastdraw */){}; // these are not supported!
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#include "videoomx.h"
void VideoOMX::AddOmxEvent(VPE_OMX_EVENT new_event)
{
- omx_event_mutex.Lock();
+ omx_event_mutex.lock();
omx_events.push_back(new_event);
- omx_event_mutex.Unlock();
+ omx_event_mutex.unlock();
omx_event_ready_signal.signal();
}
}
void VideoOMX::ReturnEmptyOMXBuffer(OMX_BUFFERHEADERTYPE* buffer){
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
//Log::getInstance()->log("Video", Log::NOTICE, "ReturnEmptyOMXBuffer %d %d",input_bufs_omx_free.size(),input_bufs_omx_all.size());
input_bufs_omx_free.push_back(buffer);
//Log::getInstance()->log("Video", Log::NOTICE, "ReturnEmptyOMXBuffer %d",input_bufs_omx_free.size());
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
omx_event_ready_signal.signal();
}
void VideoOMX::updateMode()
{
- clock_mutex.Lock();
+ clock_mutex.lock();
if (omx_running) {
int oldcancelstate;
int oldcanceltype;
"Set OMX_IndexConfigDisplayRegion1 failed %x", error);
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
return;
}
"Set OMX_IndexConfigDisplayRegion5 failed %x", error);
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
return;
}
"Set OMX_IndexConfigDisplayRegion2 failed %x", error);
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
return;
}
"Set OMX_IndexConfigDisplayRegion3 failed %x", error);
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
return;
}
"Getting display size failed! (BCM API) ");
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
return;
}
//UnSetFullscreen with window
"Set OMX_IndexConfigDisplayRegion failed %x", error);
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
return;
}
}
pthread_setcanceltype(oldcanceltype, NULL);
}
- clock_mutex.Unlock();
+ clock_mutex.unlock();
}
int VideoOMX::signalOff()
int VideoOMX::initClock()
{
OMX_ERRORTYPE error;
- clock_mutex.Lock();
+ clock_mutex.lock();
if (clock_references==0)
{
static OMX_CALLBACKTYPE callbacks= {&EventHandler_OMX,&EmptyBufferDone_OMX,&FillBufferDone_OMX};
- omx_event_mutex.Lock();
+ omx_event_mutex.lock();
omx_events.clear();
- omx_event_mutex.Unlock();
+ omx_event_mutex.unlock();
error=OMX_GetHandle(&omx_clock,L_VPE_OMX_CLOCK,NULL,&callbacks);
if (error!=OMX_ErrorNone) {
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX clock failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_GetParameter(omx_clock,OMX_IndexParamOtherInit,&p_param);
if (error!=OMX_ErrorNone) {
Log::getInstance()->log("Video", Log::DEBUG, "Init clock OMX_GetParameter failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
for (unsigned int i=0;i<p_param.nPorts;i++) {
if (!DisablePort(omx_clock,p_param.nStartPortNumber+i,true) ) {
Log::getInstance()->log("Video", Log::DEBUG, "Disable Ports OMX clock failed %d",i);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
}
Log::getInstance()->log("Video", Log::DEBUG, "init omx clock %x %x",this,omx_clock);
clock_references++;
- clock_mutex.Unlock();
+ clock_mutex.unlock();
return 1;
}
if (!initClock()) {
return 0;
}
- clock_mutex.Lock();
+ clock_mutex.lock();
OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE refclock;
memset(&refclock,0,sizeof(refclock));
error=OMX_SetConfig(omx_clock,OMX_IndexConfigTimeActiveRefClock,&refclock);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Clock OMX_IndexConfigTimeActiveRefClock failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_GetParameter(omx_clock,OMX_IndexParamOtherInit,&p_param);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init clock OMX_GetParameter failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
*p_omx_clock_output_port=p_param.nStartPortNumber+1;
*p_omx_clock=omx_clock;
- clock_mutex.Unlock();
+ clock_mutex.unlock();
return 1;
}
if (!initClock()) {
return 0;
}
- clock_mutex.Lock();
+ clock_mutex.lock();
if (clock_references==1) { // only if no audio is attached to this clock!
OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE refclock;
error=OMX_SetConfig(omx_clock,OMX_IndexConfigTimeActiveRefClock,&refclock);
if (error!=OMX_ErrorNone) {
Log::getInstance()->log("Video", Log::DEBUG, "Clock OMX_IndexConfigTimeActiveRefClock failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_GetParameter(omx_clock,OMX_IndexParamOtherInit,&p_param);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init clock OMX_GetParameter failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
}
omx_clock_output_port=p_param.nStartPortNumber;
- clock_mutex.Unlock();
+ clock_mutex.unlock();
return 1;
}
{
OMX_ERRORTYPE error;
Log::getInstance()->log("Video", Log::NOTICE, "enter Clockunpause");
- clock_mutex.Lock();
+ clock_mutex.lock();
if (clock_references>0 && clockpaused) {
OMX_TIME_CONFIG_SCALETYPE scale_type;
memset(&scale_type,0,sizeof(scale_type));
Log::getInstance()->log("Video", Log::NOTICE, "set playback speed ClockUnpause");
clockpaused=false;
}
- clock_mutex.Unlock();
+ clock_mutex.unlock();
}
{
OMX_ERRORTYPE error;
Log::getInstance()->log("Video", Log::NOTICE, "enter ClockPause");
- clock_mutex.Lock();
+ clock_mutex.lock();
if (clock_references>0 && !clockpaused) {
OMX_TIME_CONFIG_SCALETYPE scale_type;
memset(&scale_type,0,sizeof(scale_type));
Log::getInstance()->log("Video", Log::NOTICE, "set playback speed ClockPause");
clockpaused=true;
}
- clock_mutex.Unlock();
+ clock_mutex.unlock();
}
}
/* TODO end */
- clock_mutex.Lock();
+ clock_mutex.lock();
if (h264) {
error=OMX_GetHandle(&omx_vid_dec,L_VPE_OMX_H264_DECODER,NULL,&callbacks);
} else {
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX video decoder failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_GetParameter(omx_vid_dec,OMX_IndexParamVideoInit,&p_param);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX h264 decoder OMX_GetParameter failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!DisablePort(omx_vid_dec,omx_codec_input_port) || !DisablePort(omx_vid_dec,omx_codec_output_port)) {
Log::getInstance()->log("Video", Log::DEBUG, "Disable Ports OMX video decoder failed");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_SetParameter(omx_vid_dec,OMX_IndexParamBrcmVideoDecodeErrorConcealment,&conceal);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "OMX_IndexParamBrcmVideoDecodeErrorConcealment failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (error != OMX_ErrorNone) {
Log::getInstance()->log("Video", Log::DEBUG,
"Init OMX video deinterlacer failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
Log::getInstance()->log("Video", Log::DEBUG,
"Init OMX video deinterlacer OMX_GetParameter failed %x",
error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
|| !DisablePort(omx_vid_deint, omx_deint_output_port, true)) {
Log::getInstance()->log("Video", Log::DEBUG,
"Disable Ports OMX video deint failed");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_GetHandle(&omx_vid_sched,L_VPE_OMX_VIDEO_SCHED,NULL,&callbacks);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX video scheduler failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_GetParameter(omx_vid_sched,OMX_IndexParamVideoInit,&p_param);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX video scheduler OMX_GetParameter failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_GetParameter(omx_vid_sched,OMX_IndexParamOtherInit,&p_param);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX video scheduler OMX_GetParameter failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!DisablePort(omx_vid_sched,omx_shed_input_port,true) || !DisablePort(omx_vid_sched,omx_shed_output_port,true)
|| !DisablePort(omx_vid_sched,omx_shed_clock_port,true)) {
Log::getInstance()->log("Video", Log::DEBUG, "Disable Ports OMX video shed failed");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_GetHandle(&omx_vid_rend,L_VPE_OMX_VIDEO_REND,NULL,&callbacks);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX video rend failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_GetParameter(omx_vid_rend,OMX_IndexParamVideoInit,&p_param);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX video rend OMX_GetParameter failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!DisablePort(omx_vid_rend,omx_rend_input_port,true) /*|| !DisablePort(omx_vid_rend,omx_rend_output_port)*/
) {
Log::getInstance()->log("Video", Log::DEBUG, "Disable Ports OMX video rend failed");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_SetupTunnel(omx_clock,omx_clock_output_port,omx_vid_sched,omx_shed_clock_port);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "OMX_Setup tunnel clock to sched failed %x %d %d", error,omx_clock_output_port,omx_shed_clock_port);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!EnablePort(omx_clock,omx_clock_output_port,false) || !EnablePort(omx_vid_sched,omx_shed_clock_port,false)
) {
Log::getInstance()->log("Video", Log::DEBUG, "Enable Ports OMX clock shed failed");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!ChangeComponentState(omx_vid_sched,OMX_StateIdle)) {
Log::getInstance()->log("Video", Log::DEBUG, "vid_sched idle ChangeComponentState");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if ( !CommandFinished(omx_vid_sched,OMX_CommandPortEnable,omx_shed_clock_port)) {
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if ( !CommandFinished(omx_clock,OMX_CommandPortEnable,omx_clock_output_port)) {
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_SetParameter(omx_vid_dec,OMX_IndexParamVideoPortFormat,&ft_type);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX_IndexParamVideoPortFormat failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!ChangeComponentState(omx_vid_dec,OMX_StateIdle)) {
Log::getInstance()->log("Video", Log::DEBUG, "vid_dec ChangeComponentState");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_SetConfig(omx_vid_dec,OMX_IndexConfigBufferStall,&stall_conf);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX_IndexConfigBufferStall failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_SetConfig(omx_vid_dec,OMX_IndexConfigRequestCallback,&req_callback);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX_IndexConfigRequestCallback failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!PrepareInputBufsOMX()) {
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_SetupTunnel(omx_vid_dec,omx_codec_output_port,omx_vid_sched,omx_shed_input_port);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "OMX_Setup tunnel dec to sched failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!EnablePort(omx_vid_dec,omx_codec_output_port,false) || !EnablePort(omx_vid_sched,omx_shed_input_port,false)
) {
Log::getInstance()->log("Video", Log::DEBUG, "Enable Ports OMX codec shed failed");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if ( !CommandFinished(omx_vid_dec,OMX_CommandPortEnable,omx_codec_output_port) || !CommandFinished(omx_vid_sched,OMX_CommandPortEnable,omx_shed_input_port)) {
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_SetupTunnel(omx_vid_dec,omx_codec_output_port,omx_vid_deint,omx_deint_input_port);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "OMX_Setup tunnel dec to deint failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!EnablePort(omx_vid_dec,omx_codec_output_port,false) || !EnablePort(omx_vid_deint,omx_deint_input_port,false)
) {
Log::getInstance()->log("Video", Log::DEBUG, "Enable Ports OMX codec deint failed");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if ( !CommandFinished(omx_vid_dec,OMX_CommandPortEnable,omx_codec_output_port) || !CommandFinished(omx_vid_deint,OMX_CommandPortEnable,omx_deint_input_port)) {
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!ChangeComponentState(omx_vid_deint,OMX_StateIdle)) {
Log::getInstance()->log("Video", Log::DEBUG, "vid_deint ChangeComponentState");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_SetConfig(omx_vid_deint,OMX_IndexConfigCommonImageFilterParameters,&imagefilter);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX_IndexConfigCommonImageFilterParameters failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_SetupTunnel(omx_vid_deint,omx_deint_output_port,omx_vid_sched,omx_shed_input_port);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "OMX_Setup tunnel deint to sched failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!EnablePort(omx_vid_deint,omx_deint_output_port,false) || !EnablePort(omx_vid_sched,omx_shed_input_port,false)
) {
Log::getInstance()->log("Video", Log::DEBUG, "Enable Ports OMX deint shed failed");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if ( !CommandFinished(omx_vid_deint,OMX_CommandPortEnable,omx_deint_output_port) || !CommandFinished(omx_vid_sched,OMX_CommandPortEnable,omx_shed_input_port)) {
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!ChangeComponentState(omx_vid_dec,OMX_StateExecuting)) {
Log::getInstance()->log("Video", Log::DEBUG, "omx_vid_dec ChangeComponentState Execute");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_SetupTunnel(omx_vid_sched,omx_shed_output_port,omx_vid_rend,omx_rend_input_port);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "OMX_Setup tunnel sched to rend failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!EnablePort(omx_vid_sched,omx_shed_output_port,false) || !EnablePort(omx_vid_rend,omx_rend_input_port,false)
) {
Log::getInstance()->log("Video", Log::DEBUG, "Enable Ports OMX shed rend failed");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!CommandFinished(omx_vid_sched,OMX_CommandPortEnable,omx_shed_output_port)
|| !CommandFinished(omx_vid_rend,OMX_CommandPortEnable,omx_rend_input_port)) {
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!ChangeComponentState(omx_vid_rend,OMX_StateIdle)) {
Log::getInstance()->log("Video", Log::DEBUG, "vid_rend ChangeComponentState");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (dodeint) {
if (!ChangeComponentState(omx_vid_deint,OMX_StateExecuting)) {
Log::getInstance()->log("Video", Log::DEBUG, "vid_vid_deint ChangeComponentState");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!ChangeComponentState(omx_vid_sched,OMX_StateExecuting)) {
Log::getInstance()->log("Video", Log::DEBUG, "omx_vid_sched ChangeComponentState Execute");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
if (!ChangeComponentState(omx_vid_rend,OMX_StateExecuting)) {
Log::getInstance()->log("Video", Log::DEBUG, "omx_vid_rend ChangeComponentState Execute");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_SetConfig(omx_vid_rend,OMX_IndexConfigDisplayRegion,&dispconf);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX_IndexConfigDisplayRegion failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}*/
error=OMX_SetParameter(omx_vid_rend,OMX_IndexConfigDisplayRegion,&dispconf);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX_IndexConfigDisplayRegion failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_SetParameter(omx_vid_rend,OMX_IndexConfigDisplayRegion,&dispconf);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Init OMX_IndexConfigDisplayRegion failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}*/
iframemode=false;
omx_running=true;
- clock_mutex.Unlock();
+ clock_mutex.unlock();
clockUnpause();
updateMode();
{
//OMX_ERRORTYPE error;
OMX_STATETYPE temp_state;
- clock_mutex.Lock();
+ clock_mutex.lock();
OMX_GetState(omx_clock,&temp_state);
if (temp_state!=OMX_StateIdle) {
if (!ChangeComponentState(omx_clock,OMX_StateIdle)) {
Log::getInstance()->log("Video", Log::DEBUG, "omx_clock ChangeComponentState Idle failed");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
return 0;
}
}
- clock_mutex.Unlock();
+ clock_mutex.unlock();
return 1;
}
{
OMX_ERRORTYPE error;
OMX_STATETYPE temp_state;
- clock_mutex.Lock();
+ clock_mutex.lock();
OMX_GetState(omx_clock,&temp_state);
if (temp_state!=OMX_StateExecuting) {
if (!ChangeComponentState(omx_clock,OMX_StateExecuting)) {
Log::getInstance()->log("Video", Log::DEBUG, "omx_clock ChangeComponentState Execute failed");
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
error=OMX_SetConfig(omx_clock,OMX_IndexConfigTimeClockState,&clock_conf);
if (error!=OMX_ErrorNone) {
Log::getInstance()->log("Video", Log::DEBUG, "Clock IndexConfigTimeClockState failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
DeAllocateCodecsOMX();
return 0;
}
- clock_mutex.Unlock();
+ clock_mutex.unlock();
return 1;
}
int i=0;
int iend=(wait/5+1);
while (i<iend) {
- omx_event_mutex.Lock();
+ omx_event_mutex.lock();
std::list<VPE_OMX_EVENT>::iterator itty=omx_events.begin();
while (itty!=omx_events.end()) {
if (current.handle==handle) { //this is ours
if (current.event_type==OMX_EventError) {
omx_events.erase(itty);
- omx_event_mutex.Unlock();
+ omx_event_mutex.unlock();
Log::getInstance()->log("Video", Log::DEBUG, "WaitForEvent Finished on Error");
return 0;
} else if (current.event_type==event) {
omx_events.erase(itty);
- omx_event_mutex.Unlock();
+ omx_event_mutex.unlock();
Log::getInstance()->log("Video", Log::DEBUG, "WaitForEvent Finished Completed");
return 1;
}
itty++;
}
- omx_event_mutex.Unlock();
+ omx_event_mutex.unlock();
omx_event_ready_signal.waitForSignalTimed(10);
//MILLISLEEP(2);
i++;
int VideoOMX::clearEvents()
{
- omx_event_mutex.Lock();
+ omx_event_mutex.lock();
omx_events.clear();
- omx_event_mutex.Unlock();
+ omx_event_mutex.unlock();
return 1;
}
int VideoOMX::clearEventsForComponent(OMX_HANDLETYPE handle)
{
- omx_event_mutex.Lock();
+ omx_event_mutex.lock();
std::list<VPE_OMX_EVENT>::iterator itty=omx_events.begin();
while (itty!=omx_events.end()) {
VPE_OMX_EVENT current=*itty;
itty++;
}
- omx_event_mutex.Unlock();
+ omx_event_mutex.unlock();
return 1;
}
void VideoOMX::checkForStalledBuffers()
{
//Log::getInstance()->log("Video", Log::DEBUG, "Check stalled");
- clock_mutex.Lock();
- omx_event_mutex.Lock();
+ clock_mutex.lock();
+ omx_event_mutex.lock();
std::list<VPE_OMX_EVENT>::iterator itty=omx_events.begin();
while (itty!=omx_events.end()) {
VPE_OMX_EVENT current=*itty;
error=OMX_GetConfig(omx_vid_dec,OMX_IndexConfigBufferStall,&stall_conf);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Get OMX_IndexConfigBufferStall failed %x", error);
- clock_mutex.Unlock();
- omx_event_mutex.Unlock();
+ clock_mutex.unlock();
+ omx_event_mutex.unlock();
return ;
}
if (stall_conf.bStalled==OMX_TRUE) {
}
itty++;
}
- omx_event_mutex.Unlock();
- clock_mutex.Unlock();
+ omx_event_mutex.unlock();
+ clock_mutex.unlock();
}
{
int i=0;
while (i<200/*1000*/) {
- omx_event_mutex.Lock();
+ omx_event_mutex.lock();
std::list<VPE_OMX_EVENT>::iterator itty=omx_events.begin();
while (itty!=omx_events.end()) {
if (current.handle==handle) { //this is ours
if (current.event_type==OMX_EventError) {
omx_events.erase(itty);
- omx_event_mutex.Unlock();
+ omx_event_mutex.unlock();
Log::getInstance()->log("Video", Log::DEBUG, "Command Finished on Error %x",current.data1);
return 0;
} else if (current.event_type==OMX_EventCmdComplete && current.data1==command && current.data2==data2) {
omx_events.erase(itty);
- omx_event_mutex.Unlock();
+ omx_event_mutex.unlock();
//Log::getInstance()->log("Video", Log::DEBUG, "Command Finished Completed");
return 1;
}
itty++;
}
- omx_event_mutex.Unlock();
+ omx_event_mutex.unlock();
omx_event_ready_signal.waitForSignalTimed(10);
//MILLISLEEP(2);
i++;
return 0;
}
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
for (unsigned int i=0; i< port_def_type.nBufferCountActual;i++) {
// unsigned char* new_buffer_data=(unsigned char*)malloc(port_def_type.nbufferSize);
/* error=OMX_Usebuffer(omx_vid_dec,&buf_head,omx_codec_input_port,NULL,port_def_type.nbufferSize,new_buffer_data);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Use OMX_Usebuffer failed %x", error);
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
return 0;
}*/
error=OMX_AllocateBuffer(omx_vid_dec,&buf_head,omx_codec_input_port,NULL,port_def_type.nBufferSize);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Use OMX_AllocateBuffer failed %x", error);
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
return 0;
}
input_bufs_omx_all.push_back(buf_head);
firstsynched=false;
cur_input_buf_omx=NULL;
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
Log::getInstance()->log("Video", Log::DEBUG, "PrepareInputBufsOMX mark3");
OMX_ERRORTYPE error;
cur_input_buf_omx=NULL;
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
for (UINT i=0; i< input_bufs_omx_all.size();i++) {
// free(input_bufs_omx_all[i]->pBuffer);
// input_bufs_omx_all[i]->pBuffer=NULL;
error=OMX_FreeBuffer(omx_vid_dec,omx_codec_input_port,input_bufs_omx_all[i]);
if (error!=OMX_ErrorNone){
Log::getInstance()->log("Video", Log::DEBUG, "Use OMX_FreeBuffer failed %x", error);
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
return 0;
}
}
input_bufs_omx_all.clear();
input_bufs_omx_free.clear();
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
return 1;
}
cur_input_buf_omx=NULL;//write out old data
}
- clock_mutex.Lock();
+ clock_mutex.lock();
clearEvents();
if (omx_vid_dec) {
// first stop the omx elements
Log::getInstance()->log("Video", Log::DEBUG, "vid_dec ChangeComponentState");
}
- clock_mutex.Unlock();
+ clock_mutex.unlock();
idleClock();
- clock_mutex.Lock();
+ clock_mutex.lock();
if (dodeint) {
if (!ChangeComponentState(omx_vid_deint, OMX_StateIdle)) {
error=OMX_FreeHandle(omx_vid_rend);
if (dodeint) error=OMX_FreeHandle(omx_vid_deint);
omx_vid_dec=NULL;
- clock_mutex.Unlock();
+ clock_mutex.unlock();
destroyClock();
if (error!=OMX_ErrorNone) {
Log::getInstance()->log("Video", Log::DEBUG, "FreeHandle failed %d", error);
}
- } else clock_mutex.Unlock();
+ } else clock_mutex.unlock();
Log::getInstance()->log("Video", Log::DEBUG, "leave deallocate codecs OMX");
return 1;
void VideoOMX::destroyClock()
{
- clock_mutex.Lock();
+ clock_mutex.lock();
if (clock_references>0) {
clock_references--;
if (clock_references==0) {
}
}
- clock_mutex.Unlock();
+ clock_mutex.unlock();
}
int oldcanceltype;
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate);
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldcanceltype);
- clock_mutex.Lock();
+ clock_mutex.lock();
OMX_ERRORTYPE error;
OMX_TIME_CONFIG_CLOCKSTATETYPE clock_conf;
memset(&clock_conf, 0, sizeof(clock_conf));
ncur_clock_time = cur_clock_time = temp * 10LL;
}
}
- clock_mutex.Unlock();
+ clock_mutex.unlock();
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
}
Demuxer* demux=Demuxer::getInstance();
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate);
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldcanceltype);
- clock_mutex.Lock();
+ clock_mutex.lock();
if (WaitForEvent(omx_vid_dec,OMX_EventPortSettingsChanged,0)){
WaitForEvent(omx_vid_deint,OMX_EventPortSettingsChanged,0); //clear old messages
OMX_ERRORTYPE error;
if (error != OMX_ErrorNone) {
Log::getInstance()->log("Video", Log::DEBUG,
"OMX_IndexParamPortDefinition fix failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
return;
}
if (error != OMX_ErrorNone) {
Log::getInstance()->log("Video", Log::DEBUG,
"Set OMX_IndexParamPortDefinition1 failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
return;
if (error != OMX_ErrorNone) {
Log::getInstance()->log("Video", Log::DEBUG,
"Set OMX_IndexParamPortDefinition1 failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
return;
if (error != OMX_ErrorNone) {
Log::getInstance()->log("Video", Log::DEBUG,
"Get OMX_IndexParamPortDefinition2 failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
return;
if (error != OMX_ErrorNone) {
Log::getInstance()->log("Video", Log::DEBUG,
"Set OMX_IndexParamPortDefinition3 failed %x", error);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
return;
EnablePort(omx_vid_dec,omx_codec_output_port,true);
EnablePort(omx_vid_sched,omx_shed_input_port,true);
}
- clock_mutex.Unlock();
+ clock_mutex.unlock();
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
//pthread_testcancel();
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate);
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldcanceltype);
- clock_mutex.Lock();
+ clock_mutex.lock();
// Diagnosis code
/* OMX_ERRORTYPE error;
OMX_TIME_CONFIG_TIMESTAMPTYPE timestamp;
Log::getInstance()->log("Video", Log::NOTICE, "OMXETB %x %lld %lld %x",handle,temp,temp2,buffer->nFlags);*/
OMX_ERRORTYPE ret_val;
ret_val=OMX_EmptyThisBuffer(handle,buffer);
- clock_mutex.Unlock();
+ clock_mutex.unlock();
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
//pthread_testcancel();
{
//Check, if we have OMX output buffers
bool full;
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
full=(input_bufs_omx_free.size()==0);
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
checkForStalledBuffers(); // check if the decoder has a problem
if (full && omx_vid_stalled && !omx_first_frame) {
omx_vid_stalled=false;
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate);
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldcanceltype);
- clock_mutex.Lock();
+ clock_mutex.lock();
FlushRenderingPipe();
omx_first_frame=true;
- clock_mutex.Unlock();
+ clock_mutex.unlock();
pthread_setcancelstate(oldcancelstate, NULL);
pthread_setcanceltype(oldcanceltype, NULL);
}
//Log::getInstance()->log("Video", Log::DEBUG, "DMP mark 6");
if (!cur_input_buf_omx) {
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
if (input_bufs_omx_free.size()==0) {
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
//Log::getInstance()->log("Video", Log::DEBUG, "Deliver MediaPacket no free sample");
//Log::getInstance()->log("Video", Log::DEBUG, "DMP mark 7");
return 0; // we do not have a free media sample
cur_input_buf_omx->nOffset=0;
cur_input_buf_omx->nTimeStamp=intToOMXTicks(0);
input_bufs_omx_free.pop_front();
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
}
PutBufferToPres(cur_input_buf_omx);
cur_input_buf_omx=NULL;
// get5 new buffer
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
if (input_bufs_omx_free.size()==0) {
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
// Log::getInstance()->log("Video", Log::DEBUG, "Deliver MediaPacket no free sample2");
return *samplepos; // we do not have a free media sample
}
cur_input_buf_omx->nFlags=OMX_BUFFERFLAG_TIME_UNKNOWN;
cur_input_buf_omx->nTimeStamp=intToOMXTicks(0);
input_bufs_omx_free.pop_front();
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
//Log::getInstance()->log("Video", Log::DEBUG, "DMP mark 10");
}
//int haveToCopy = length;
if (!cur_input_buf_omx) {
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
if (input_bufs_omx_free.size() == 0) {
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
// Log::getInstance()->log("Video", Log::DEBUG,
// "Deliver MediaPacket no free sample");
return false; // we do not have a free media sample
cur_input_buf_omx->nOffset = 0;
cur_input_buf_omx->nTimeStamp = intToOMXTicks(0);
input_bufs_omx_free.pop_front();
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
}
int read_pos = 0;
while (count < 100 && omx_running && iframemode) {
count++;
- input_bufs_omx_mutex.Lock();
+ input_bufs_omx_mutex.lock();
if (input_bufs_omx_free.size() == 0) {
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
// Log::getInstance()->log("Video", Log::DEBUG,
// "Ifrane no free sample");
MILLISLEEP(5);
cur_input_buf_omx->nTimeStamp = intToOMXTicks(0);
cur_input_buf_omx->nFlags|= OMX_BUFFERFLAG_TIME_UNKNOWN;
input_bufs_omx_free.pop_front();
- input_bufs_omx_mutex.Unlock();
+ input_bufs_omx_mutex.unlock();
break;
}
if (!cur_input_buf_omx)
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with VOMP; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ along with VOMP. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef VIDEOOMX_H
#define VIDEOOMX_H
-#include "mutex.h"
-#include "signal.h"
-
-
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <string.h>
-
#include <stdint.h>
-
#include <list>
#include <vector>
+#include <mutex>
+#include "signal.h"
#include "defines.h"
#include "video.h"
int idleClock();
int getClockAudioandInit(OMX_HANDLETYPE *p_omx_clock,OMX_U32 *p_omx_clock_output_port);
int getClockVideoandInit();
- void LockClock() {clock_mutex.Lock();};
- void UnlockClock() {clock_mutex.Unlock();};
+ void LockClock() {clock_mutex.lock();};
+ void UnlockClock() {clock_mutex.unlock();};
OMX_ERRORTYPE ProtOMXEmptyThisBuffer(OMX_HANDLETYPE handle, OMX_BUFFERHEADERTYPE* buffer);
void clockPause();
void clockUnpause();
void interlaceSwitch4Demux();
- Mutex clock_mutex; //clock mutex is now responsible for all omx stuff
+ std::mutex clock_mutex; //clock mutex is now responsible for all omx stuff
long long cur_clock_time;
std::vector<OMX_BUFFERHEADERTYPE*> input_bufs_omx_all;
std::list<OMX_BUFFERHEADERTYPE*> input_bufs_omx_free;
- Mutex input_bufs_omx_mutex;
+ std::mutex input_bufs_omx_mutex;
OMX_BUFFERHEADERTYPE* cur_input_buf_omx;
void PutBufferToPres(OMX_BUFFERHEADERTYPE* buffer);
bool omx_running;
bool omx_first_frame;
- Mutex omx_event_mutex;
+ std::mutex omx_event_mutex;
Signal omx_event_ready_signal;
std::list<VPE_OMX_EVENT> omx_events;
projects / vompclient.git / commitdiff