events.h

linux下实现视频播放的播放器

/*
 *  Copyright (C) 2005-2007  gulikoza
 *
 *  This program 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.
 *
 *  This program 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/* $Id$ */

#ifndef EVENTS_H
#define EVENTS_H

#define MODULE "event_queue"

#include "log.h"

class EventQueue
{
private:
    SDL_semaphore * sem;
    SDL_Event events[10];
    MUTEX * event_lock;
    int next_event;

    void CopyEvent(SDL_Event * ev)
    {
	SDL_memcpy(ev, &events[0], sizeof(SDL_Event));
	for(int i = 1; i < next_event; i++)
	    SDL_memcpy(&events[i-1], &events[i], sizeof(SDL_Event));
	next_event--;
    }

public:
    EventQueue():next_event(0)
    {
	SDL_memset(events, 0, sizeof(SDL_Event)*10);
	event_lock = MUTEX_CREATE();
	if(event_lock == NULL)
	    throw "event_queue: Failed to create mutex";

	sem = SDL_CreateSemaphore(0);
	if(sem == NULL) {
	    MUTEX_DESTROY(event_lock);
	    throw "event_queue: Failed to create semaphore";
	}
    }

    void Push(SDL_Event * ev)
    {
	MUTEX_LOCK(event_lock);
	if(next_event == 10) {
	    ERROR_MSG("full, event dropped!");
	    MUTEX_UNLOCK(event_lock);
	    return;
	}
	SDL_memcpy(&events[next_event], ev, sizeof(SDL_Event));
	next_event++;
	MUTEX_UNLOCK(event_lock);
	if(!SDL_SemValue(sem))
	    SDL_SemPost(sem);
    }

    int Peek(void)
    {
	MUTEX_LOCK(event_lock);
	int ret = (next_event != 0);
	MUTEX_UNLOCK(event_lock);
	return ret;
    }

    int Poll(SDL_Event * ev)
    {
	MUTEX_LOCK(event_lock);
	if(next_event == 0) {
	    // No events pending...
	    MUTEX_UNLOCK(event_lock);
	    return 0;
	}

	CopyEvent(ev);
	MUTEX_UNLOCK(event_lock);
	return 1;
    }

    int Wait(SDL_Event * ev)
    {
	MUTEX_LOCK(event_lock);
	while(next_event == 0) {
	    // Wait for event
	    MUTEX_UNLOCK(event_lock);
#ifdef SEM_SILENT
	    SDL_SemWait(sem);
#else
	    while(SDL_SemWaitTimeout(sem, 1000) == SDL_MUTEX_TIMEDOUT) {
		ERROR_MSG("Semaphore timeout expired, line: %d, thread: %u", __LINE__, SDL_ThreadID());
	    }
#endif
	    MUTEX_LOCK(event_lock);
	}

	CopyEvent(ev);
	MUTEX_UNLOCK(event_lock);
	return 1;
    }

    ~EventQueue()
    {
	MUTEX_DESTROY(event_lock);
	SDL_DestroySemaphore(sem);
    }
};
extern EventQueue * events;

#undef MODULE
#endif // EVENTS_H