video.c

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
//     
//    __                                ______
//   / /_______________  ____  ___     / ____/
//  / __/ ___/ ___/ __ \/ __ \/ _ \   /___ )  
// / /_(__  ) /__/ /_/ / /_/ /  __/  ____/ /  
// \__/____/\___/\____/ .___/\___/  /_____/   
//                   /_/                      
//     
/// \file video.c 
/// Definitions of video functions.
/// \example video01.c
////////////////////////////////////////////////////////////////////////////////

#include "../include/tscope5/video.h"
#include "../include/tscope5/video_internal.h"
#include "../include/tscope5/system_internal.h"


////////////////////////////////////////////////////////////////////////////////
/// @name Loading videos 
///
/// Videos can be read from a file using the functions below. 
//@{
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/// Open a video from a file.
///
/// \param file Path to the video file.
///
/// \return A pointer to the newly created video.
///
/// Available video types are: ogv.
////////////////////////////////////////////////////////////////////////////////
TS5_VIDEO *ts5_read_video(const char *file)
{
    ts5_check_video("ts5_read_video");
    ts5_log(TS5_LOGLEVEL_2, "ts5_read_video(%s)\n", file);

    TS5_VIDEO *video = NULL;
    video = (TS5_VIDEO *)al_malloc(sizeof(TS5_VIDEO));

    if (!video) {
        ts5_fatal("ts5_read_video: could not allocate video\n");
    }

    video->isplaying = 0;
    video->ispaused = 0;

    video->video = al_open_video(file);

    if (!video->video) {
        ts5_fatal("ts5_read_video: could not read video\n");
    }


    video->mixer = al_create_mixer(_ts5_status.audio.samplerate,
                        ALLEGRO_AUDIO_DEPTH_FLOAT32, 
                        al_get_voice_channels(_ts5_data.audio.voice));

    if (!video->mixer) {
        ts5_fatal("ts5_read_video: could not create mixer\n");
    }

    if (!al_attach_mixer_to_mixer(video->mixer,
            _ts5_data.audio.mixer)) {
        ts5_fatal("ts5_read_video: could not attach mixer to voice\n");
    }   
    
    
    double w, h;
    
    #if ALLEGRO_WIP_VERSION <= 11
        w = al_get_video_width(video->video); 
        h = al_get_video_height(video->video);
    
    #else
        w = al_get_video_scaled_width(video->video); 
        h = al_get_video_scaled_height(video->video);
        
    #endif
        
    
    video->nbuffers = 12;
    video->buffer = al_malloc(video->nbuffers * sizeof(ALLEGRO_BITMAP *));
    if (!video->buffer) {
        ts5_fatal("ts5_read_video: could not create video buffer\n");   
    }
    
    int i;
    for(i=0; i<video->nbuffers; i++) {
        video->buffer[i] = al_create_bitmap(w, h);
        if (!video->buffer[i]) {
            ts5_fatal("ts5_read_video: could not create video buffer\n");   
        }
    }   
        
    return video;
}


////////////////////////////////////////////////////////////////////////////////
/// Free the memory used by a video.
///
/// \param video Pointer to the video that will be freed.
///
/// This function should be called at the end of the program for
/// each video allocated or read by the user.
////////////////////////////////////////////////////////////////////////////////
void ts5_free_video(TS5_VIDEO *video)
{
    ts5_check_video("ts5_free_video");
    ts5_log(TS5_LOGLEVEL_2, "ts5_free_video(%p)\n", video->video);
    
    int i;
    for(i=0; i<video->nbuffers; i++) {
        al_destroy_bitmap(video->buffer[i]);
    }
    al_free(video->buffer);

    //al_detach_mixer(video->mixer);
    //al_destroy_mixer(video->mixer);
    video->mixer = NULL;

    al_close_video(video->video);
    al_free(video);
    video = NULL;
}


////////////////////////////////////////////////////////////////////////////////
//@}
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/// @name Playing videos
/// Videos can be played using the functions below. 
///
/// The audio part is played in the background automatically
/// so the user doesn't need to do anything special do make 
/// the audio audible.
///
/// The video is not displayed automatically but 
/// is provided frame by frame as a TS5_BITMAP.
///
/// The user will need to draw each frame on the screen
/// using the bitmap drawing functions to make the 
/// video visible.
///
/// see <a href="video01_8c-example.html">video01.c</a> 
/// for an example that shows how this works.
//@{
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/// Start playing a video.
///
/// \param video Pointer to the video that will be played.
////////////////////////////////////////////////////////////////////////////////
void ts5_play_video(TS5_VIDEO *video)
{
    ts5_check_video("ts5_play_video");
    ts5_log(TS5_LOGLEVEL_5, "ts5_play_video(%p)\n", video);

    if (!video) {
        ts5_fatal("ts5_play_video: video pointer is null\n");
    }

    if(!video->ispaused) {
        al_start_video(video->video, video->mixer);
        video->isplaying = 1;
    }
    else {

        #if ALLEGRO_WIP_VERSION <= 11
            al_pause_video(video->video, 0);

        #else
            al_set_video_playing(video->video, 1);
    
        #endif
    
    }
    video->ispaused = 0;        
}


////////////////////////////////////////////////////////////////////////////////
/// Pause playing a video.
///
/// \param video Pointer to the video that will be paused.
////////////////////////////////////////////////////////////////////////////////
void ts5_pause_video(TS5_VIDEO *video)
{
    ts5_check_video("ts5_pause_video");
    ts5_log(TS5_LOGLEVEL_5, "ts5_pause_video(%p)\n", video);

    if (!video) {
        ts5_fatal("ts5_pause_video: video pointer is null\n");
    }

    if (video->isplaying) {

        #if ALLEGRO_WIP_VERSION <= 11
            al_pause_video(video->video, 1);

        #else
            al_set_video_playing(video->video, 0);

        #endif

        video->ispaused = 1;
    }   
}


////////////////////////////////////////////////////////////////////////////////
/// Stop playing a video.
///
/// \param video Pointer to the video that will be stopped.
////////////////////////////////////////////////////////////////////////////////
void ts5_stop_video(TS5_VIDEO *video)
{
    ts5_check_video("ts5_stop_video");
    ts5_log(TS5_LOGLEVEL_5, "ts5_stop_video(%p)\n", video);

    if (!video) {
        ts5_fatal("ts5_stop_video: video pointer is null\n");
    }
    
    if (video->isplaying) {
        
        #if ALLEGRO_WIP_VERSION <= 11
            al_pause_video(video->video, 1);

        #else
            al_set_video_playing(video->video, 0);

        #endif
    
        video->ispaused = 1;
        video->isplaying = 0;
    }   
}


////////////////////////////////////////////////////////////////////////////////
/// Get the next frame of a video.
///
/// \param video Pointer to the video that will be queried.
////////////////////////////////////////////////////////////////////////////////
TS5_BITMAP *ts5_get_video_frame(TS5_VIDEO *video)
{
    ts5_check_video("ts5_get_video_frame");
    ts5_log(TS5_LOGLEVEL_5, "ts5_get_video_frame(%p)\n", video);

    if (!video) {
        ts5_fatal("ts5_get_video_frame: video pointer is null\n");
    }
    
    // delay some frames
    static long int num_frames_processed=0;
    int inbuf = (num_frames_processed + video->nbuffers - 1) % video->nbuffers;
    int outbuf = num_frames_processed % video->nbuffers;

    ALLEGRO_BITMAP *frame = al_get_video_frame(video->video);

    if (frame) {
        ALLEGRO_BITMAP *screen = al_get_target_bitmap();
        al_set_target_bitmap(video->buffer[inbuf]);
        al_draw_bitmap(frame, 0.0, 0.0, 0);
        al_set_target_bitmap(screen);
        num_frames_processed++;
    }

    return video->buffer[outbuf];
}


////////////////////////////////////////////////////////////////////////////////
//@}
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/// @name Video parameters
/// For each video the parameters can be queried/set using the functions below:
///
/// Video position and video gain can be adjusted 
/// at any time, even when the video is playing.
///
/// There is no function available to query the length of a video. 
//@{
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
/// Query whether a video is playing.
///
/// \param video Pointer to the video that will queried.
///
/// \return 1 if the video is playing, 0 if not.
////////////////////////////////////////////////////////////////////////////////
int ts5_get_video_status(TS5_VIDEO *video)
{
    ts5_check_video("ts5_get_video_status");
    ts5_log(TS5_LOGLEVEL_5, "ts5_get_video_status(%p)\n", video);

    if (!video) {
        ts5_fatal("ts5_get_video_status: video pointer is null\n");
    }

    return (video->isplaying && !video->ispaused);
}


////////////////////////////////////////////////////////////////////////////////
/// Get the aspect ratio of a video.
///
/// \param video Pointer to the video that will queried.
///
/// \return aspect ratio of the video.
////////////////////////////////////////////////////////////////////////////////
double ts5_get_video_aspect_ratio(TS5_VIDEO *video)
{
    ts5_check_video("ts5_get_video_status");
    ts5_log(TS5_LOGLEVEL_5, "ts5_get_video_status(%p)\n", video);

    if (!video) {
        ts5_fatal("ts5_get_video_status: video pointer is null\n");
    }

    double ratio;
    
    #if ALLEGRO_WIP_VERSION <= 11
        ratio = al_get_video_aspect_ratio(video->video);

    #else
        ratio = 1;

    #endif
    
    return ratio;
}


////////////////////////////////////////////////////////////////////////////////
/// Get the width of a video.
///
/// \param video Pointer to the video that will queried.
///
/// \return width of the video in pixels.
////////////////////////////////////////////////////////////////////////////////
double ts5_get_video_width(TS5_VIDEO *video)
{
    ts5_check_video("ts5_get_video_width");
    ts5_log(TS5_LOGLEVEL_5, "ts5_get_video_width(%p)\n", video);

    if (!video) {
        ts5_fatal("ts5_get_video_width: video pointer is null\n");
    }
    
    double w;

    #if ALLEGRO_WIP_VERSION <= 11
        w = al_get_video_width(video->video); 

    #else
        w = al_get_video_scaled_width(video->video); 
    
    #endif
    
    return w;
}


////////////////////////////////////////////////////////////////////////////////
/// Get the height of a video.
///
/// \param video Pointer to the video that will queried.
///
/// \return height of the video in pixels.
////////////////////////////////////////////////////////////////////////////////
double ts5_get_video_height(TS5_VIDEO *video)
{
    ts5_check_video("ts5_get_video_height");
    ts5_log(TS5_LOGLEVEL_5, "ts5_get_video_height(%p)\n", video);

    if (!video) {
        ts5_fatal("ts5_get_video_height: video pointer is null\n");
    }

    double h;
    
    #if ALLEGRO_WIP_VERSION <= 11
        h = al_get_video_height(video->video);

    #else
        h = al_get_video_scaled_height(video->video);

    #endif
    

    return h;
}


////////////////////////////////////////////////////////////////////////////////
/// Get the audio samplerate of a video.
///
/// \param video Pointer to the video that will queried.
///
/// \return audio samplerate of the video.
////////////////////////////////////////////////////////////////////////////////
double ts5_get_video_samplerate(TS5_VIDEO *video)
{
    ts5_check_video("ts5_get_video_samplerate");
    ts5_log(TS5_LOGLEVEL_5, "ts5_get_video_samplerate(%p)\n", video);

    if (!video) {
        ts5_fatal("ts5_get_video_samplerate: video pointer is null\n");
    }

    return al_get_video_audio_rate(video->video);
}


////////////////////////////////////////////////////////////////////////////////
/// Get the framerate of a video.
///
/// \param video Pointer to the video that will queried.
///
/// \return frame rate of the video.
////////////////////////////////////////////////////////////////////////////////
double ts5_get_video_framerate(TS5_VIDEO *video)
{
    ts5_check_video("ts5_get_video_framerate");
    ts5_log(TS5_LOGLEVEL_5, "ts5_get_video_framerate(%p)\n", video);

    if (!video) {
        ts5_fatal("ts5_get_video_framerate: video pointer is null\n");
    }

    return al_get_video_fps(video->video);
}


////////////////////////////////////////////////////////////////////////////////
/// Set the playback position of a video.
///
/// \param video Pointer to the video that will be adjusted.
/// \param position The new playback position.
///
/// \return the old playback position of the video in seconds.
////////////////////////////////////////////////////////////////////////////////
double ts5_set_video_position(TS5_VIDEO *video, double position)
{
    ts5_check_video("ts5_set_video_position");
    ts5_log(TS5_LOGLEVEL_5, "ts5_set_video_position(%p,%f)\n", video, position);

    if (!video) {
        ts5_fatal("ts5_set_video_position: video pointer is null\n");
    }
    
    double retval = al_get_video_position(video->video, 0);

    al_seek_video(video->video, position);

    return retval;
}


////////////////////////////////////////////////////////////////////////////////
/// Get the playback position of a video.
///
/// \param video Pointer to the video that will be queried.
///
/// \return the current playback position of the video in seconds.
////////////////////////////////////////////////////////////////////////////////
double ts5_get_video_position(TS5_VIDEO *video)
{
    ts5_check_video("ts5_get_video_position");
    ts5_log(TS5_LOGLEVEL_5, "ts5_get_video_position(%p)\n", video);

    if (!video) {
        ts5_fatal("ts5_get_video_position: video pointer is null\n");
    }

    return al_get_video_position(video->video, 0);
}


////////////////////////////////////////////////////////////////////////////////
/// Set the playback gain of a video.
///
/// \param video Pointer to the video that will be adjusted.
/// \param gain The new playback gain (1.0 is normal gain).
///
/// \return The old gain setting.
////////////////////////////////////////////////////////////////////////////////
double ts5_set_video_gain(TS5_VIDEO *video, double gain)
{
    ts5_check_video("ts5_set_video_gain");
    ts5_log(TS5_LOGLEVEL_5, "ts5_set_video_gain(%p,%f)\n", video, gain);

    if (!video) {
        ts5_fatal("ts5_set_video_gain: video pointer is null\n");
    }
    
    double retval = al_get_mixer_gain(video->mixer);
    al_set_mixer_gain(video->mixer, gain);

    return retval;
}


////////////////////////////////////////////////////////////////////////////////
/// Get the playback gain of a video.
///
/// \param video Pointer to the video that will be queried.
///
/// \return the current playback gain.
////////////////////////////////////////////////////////////////////////////////
double ts5_get_video_gain(TS5_VIDEO *video)
{
    ts5_check_video("ts5_get_video_gain");
    ts5_log(TS5_LOGLEVEL_5, "ts5_get_video_gain(%p)\n", video);

    if (!video) {
        ts5_fatal("ts5_get_video_gain: video pointer is null\n");
    }

    return al_get_mixer_gain(video->mixer);;
}


////////////////////////////////////////////////////////////////////////////////
//@}
////////////////////////////////////////////////////////////////////////////////