serialdvdemu/Video.cpp

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <memory.h>
#include "Video.h"
#include "DVDEmu.h"

#define OPCODE_STOP 1
#define OPCODE_PLAY 2
#define OPCODE_PAUSE 3
#define OPCODE_UNPAUSE 4

/* Emulator state */
struct video_state
{
    pthread_t thread;
    pthread_mutex_t lock;
    unsigned char queue[256];
    unsigned int queue_pos;
    unsigned int power_state;
    unsigned int playing_state;
    unsigned int paused_state;
    unsigned int pause_delay;
    unsigned int chapter;
    unsigned int max_chapter;
    char * dvd_path;
} video_state;

void *VideoThread( void *state )
{
    /* Get state to read from */
    struct video_state *private_state = (struct video_state *)state;
    int loaded = 0;

    while( true )
    {
        /* Process video commands, safe to read this because
         * if it is non-zero we will try locking anyway. */
        if( private_state->queue_pos > 0 )
        {
            pthread_mutex_lock(&private_state->lock);
            unsigned int amount = 0;
            unsigned int opcode = private_state->queue[0];
            unsigned int arg = private_state->queue[1];
            switch( opcode )
            {
                case OPCODE_STOP:
                    /* Stop */
                    amount = 1;
                    break;
                case OPCODE_PAUSE:
                    /* Pause */
                    amount = 1;
                    break;
                case OPCODE_UNPAUSE:
                    /* Pause */
                    amount = 1;
                    break;
                case OPCODE_PLAY:
                    /* Seek */
                    amount = 2;
                    break;
            }

            /* Remove if needed */
            if( amount < private_state->queue_pos )
            {
                memmove(&private_state->queue[0], &private_state->queue[amount], private_state->queue_pos - amount);
            }
            private_state->queue_pos -= amount;

            pthread_mutex_unlock(&private_state->lock);

            /* Perform operation */
            switch( opcode )
            {
                case OPCODE_STOP:
                    /* Stop */
                    if( loaded )
                    {
                        exec_shell("./control.sh stop > /dev/null 2> /dev/null");
                        exec_shell("killall dbus-daemon > /dev/null 2> /dev/null");
                        exec_shell("killall omxplayer > /dev/null 2> /dev/null");
                        exec_shell("killall omxplayer.bin > /dev/null 2> /dev/null");
                        loaded = 0;
                    }
                    break;
                case OPCODE_PAUSE:
                    /* Pause */
                    if( loaded )
                    {
                        exec_shell("./control.sh pause > /dev/null 2> /dev/null");
                    }
                    break;
                case OPCODE_UNPAUSE:
                    /* Pause */
                    if( loaded )
                    {
                        if( private_state->pause_delay )
                        {
                            usleep( private_state->pause_delay * 1000 );
                        }
                        exec_shell("./control.sh pause > /dev/null 2> /dev/null");
                    }
                    break;
                case OPCODE_PLAY:
                    /* Play */
                    if( !loaded )
                    {
                        /* TODO: Search for videos based on prepended zero or not.
                         * Also accept any extension that we support.
                         */
                        char syscall[256];
                        sprintf(syscall, "omxplayer --loop -b --no-osd %s%02d.m4v > /dev/null 2> /dev/null &", private_state->dvd_path, arg);
                        exec_shell(syscall);
                        /* Wait for it to start */
                        while( 1 )
                        {
                            int exitcode = exec_shell("./control.sh status > /dev/null 2> /dev/null");
                            if( exitcode == 0 )
                            {
                                break;
                            }
                        }
                        loaded = 1;
                    }
                    break;
            }
        }
        else
        {
            /* Sleep for a bit */
            usleep( 10000 );
        }
    }

    return NULL;
}

void VideoThreadAction( unsigned int opcode, unsigned int argument )
{
    pthread_mutex_lock(&video_state.lock);

    switch(opcode)
    {
        case OPCODE_STOP:
            /* Stop */
            video_state.queue[video_state.queue_pos] = OPCODE_STOP;
            video_state.queue_pos++;
            break;
        case OPCODE_PAUSE:
            /* Pause */
            video_state.queue[video_state.queue_pos] = OPCODE_PAUSE;
            video_state.queue_pos++;
            break;
        case OPCODE_UNPAUSE:
            /* Pause */
            video_state.queue[video_state.queue_pos] = OPCODE_UNPAUSE;
            video_state.queue_pos++;
            break;
        case OPCODE_PLAY:
            /* Seek */
            video_state.queue[video_state.queue_pos] = OPCODE_PLAY;
            video_state.queue_pos++;
            video_state.queue[video_state.queue_pos] = argument;
            video_state.queue_pos++;
            break;
    }

    pthread_mutex_unlock(&video_state.lock);
}

void VideoInit( char * path, int chapters )
{
    video_state.power_state = 0;
    video_state.playing_state = 0;
    video_state.paused_state = 0;
    video_state.chapter = 1;
    video_state.dvd_path = path;
    video_state.max_chapter = chapters;
    video_state.pause_delay = 0;

    verbose_printf( "Disc has %d chapters.\n", video_state.max_chapter );

    /* Start video playback thread */
    memset( video_state.queue, 0, sizeof(video_state.queue) );
    video_state.queue_pos = 0;
    pthread_mutex_init(&video_state.lock, NULL);
    pthread_create(&video_state.thread, NULL, VideoThread, &video_state);
}

void VideoSetPauseDelay( unsigned int milliseconds )
{
    video_state.pause_delay = milliseconds;
}

void PowerOn()
{
    if( !video_state.power_state )
    {
        verbose_printf( "* Exit standby mode.\n" );

        video_state.power_state = 1;
        Stop();
    }
}

void PowerOff()
{
    if( video_state.power_state )
    {
        Stop();

        verbose_printf( "* Enter standby mode.\n" );

        video_state.power_state = 0;
    }
}

void Play()
{
    if( !video_state.power_state )
    {
        PowerOn();
    }

    if( !video_state.playing_state )
    {
        verbose_printf( "* Enter playing state.\n" );

        SeekToChapter(video_state.chapter);

        video_state.playing_state = 1;
        video_state.paused_state = 0;
    }
    else
    {
        /* Unpause only if we need to */
        Unpause();
    }
}

void Pause()
{
    if( video_state.power_state &&
        video_state.playing_state &&
        !video_state.paused_state )
    {
        verbose_printf( "* Enter paused state.\n" );

        VideoThreadAction( OPCODE_PAUSE, 0 );

        video_state.playing_state = 1;
        video_state.paused_state = 1;
    }
}

void Unpause()
{
    if( video_state.power_state &&
        video_state.playing_state &&
        video_state.paused_state )
    {
        verbose_printf( "* Exit paused state.\n" );

        VideoThreadAction( OPCODE_UNPAUSE, 0 );

        video_state.playing_state = 1;
        video_state.paused_state = 0;
    }
}

int SeekToChapter( unsigned int chapter )
{
    if( video_state.power_state )
    {
        /* Is the chapter in bounds? */
        if( chapter >= 1 && chapter <= video_state.max_chapter )
        {
            verbose_printf( "* Seek to chapter %d.\n", chapter );

            /* Kill player */
            VideoThreadAction( OPCODE_STOP, 0 );

            /* Seek */
            VideoThreadAction( OPCODE_PLAY, chapter );
            video_state.playing_state = 1;

            /* Repause if needed */
            if( video_state.paused_state )
            {
                VideoThreadAction( OPCODE_PAUSE, 0 );
            }

            video_state.chapter = chapter;
            return 1;
        }
        else
        {
            return 0;
        }
    }
    else
    {
        /* Nothing seek-wise while off */
        return 0;
    }
}

void Stop()
{
    if( video_state.power_state && 
        ( video_state.playing_state ||
          video_state.paused_state ) )
    {
        /* If we are paused, exit the pause state */
        Unpause();

        verbose_printf( "* Enter idle state.\n" );

        VideoThreadAction( OPCODE_STOP, 0 );

        video_state.playing_state = 0;
        video_state.paused_state = 0;
        video_state.chapter = 1;
    }
}

int GetChapter()
{
    return video_state.chapter;
}

int IsPowered()
{
    return video_state.power_state;
}

int IsPlaying()
{
    return video_state.playing_state;
}