page_magick.cc

Go to the documentation of this file.

/*
* page_magick.cc -- FX Page definition
* Copyright (C) 2002 Charles Yates <charles.yates@pandora.be>
* Copyright (C) 2002-2007 Dan Dennedy <dan@dennedy.org>
*
* 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.
*/


#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iostream>
#include <vector>
using std::cerr;
using std::endl;
using std::vector;

#include <string>
#include <iostream>
using std::cerr;
using std::endl;

#include <glade/glade.h>

#include "kino_extra.h"
#include "page_magick.h"
#include "kino_common.h"
#include "page.h"
#include "storyboard.h"
#include "page_editor.h"
#include "displayer.h"
#include "message.h"
#include "error.h"
#include "commands.h"
#include "gtkenhancedscale.h"
#include "export.h"

PlayList &GetCurrentPlayList( )
{
    return * common->getPlayList( );
}

extern "C"
{
#include "support.h"

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dlfcn.h>
#include <dirent.h>

    extern GladeXML* magick_glade;
    extern struct navigate_control g_nav_ctl;

    static bool buttonMutex = false;

    void
    on_togglebutton_magick_start_toggled ( GtkToggleButton * togglebutton,
                                           gpointer user_data )
    {
        if ( !buttonMutex )
        {
            buttonMutex = true;
            common->getPageMagick() ->StartRender();
            buttonMutex = false;
        }
    }

    void
    on_notebook_magick_switch_video_page ( GtkNotebook * notebook,
                                     GtkNotebookPage * page,
                                     gint page_num,
                                     gpointer user_data )
    {
        PageMagick* magick = common->getPageMagick();
        magick->SetKeyFrameControllerClient( 0 );
        magick->ShowCurrentStatus( magick->GetCurrentPosition(), LOCKED_KEY, false, false );
        videoStop();
        magick->OnTimeRangeChanged();
    }

    void
    on_notebook_magick_switch_page ( GtkNotebook * notebook,
                                     GtkNotebookPage * page,
                                     gint page_num,
                                     gpointer user_data )
    {
        PageMagick* magick = common->getPageMagick();
        videoStop();
        magick->OnTimeRangeChanged();
    }

    gboolean
    on_hscale_transition_start_button_press_event
    ( GtkWidget * widget,
      GdkEventButton * event,
      gpointer user_data )
    {
        GtkWidget * lower = lookup_widget ( common->getPageMagick() ->window, "hscale_transition_start" );
        GtkWidget *upper = lookup_widget ( common->getPageMagick() ->window, "hscale_transition_end" );
        GtkAdjustment *adjust_lower = GTK_RANGE( lower ) ->adjustment;
        GtkAdjustment *adjust_upper = GTK_RANGE( upper ) ->adjustment;
        adjust_upper->lower = adjust_lower->value;
        g_signal_emit_by_name( adjust_upper, "changed" );
        return FALSE;
    }


    gboolean
    on_hscale_transition_start_button_release_event
    ( GtkWidget * widget,
      GdkEventButton * event,
      gpointer user_data )
    {
        GtkWidget * lower = lookup_widget ( common->getPageMagick() ->window, "hscale_transition_start" );
        GtkWidget *upper = lookup_widget ( common->getPageMagick() ->window, "hscale_transition_end" );
        GtkAdjustment *adjust_lower = GTK_RANGE( lower ) ->adjustment;
        GtkAdjustment *adjust_upper = GTK_RANGE( upper ) ->adjustment;
        adjust_upper->lower = adjust_lower->value;
        g_signal_emit_by_name( adjust_upper, "changed" );
        common->getPageMagick() ->RefreshStatus( true );
        return FALSE;
    }


    gboolean
    on_hscale_transition_end_button_press_event
    ( GtkWidget * widget,
      GdkEventButton * event,
      gpointer user_data )
    {
        GtkWidget * lower = lookup_widget ( common->getPageMagick() ->window, "hscale_transition_start" );
        GtkWidget *upper = lookup_widget ( common->getPageMagick() ->window, "hscale_transition_end" );
        GtkAdjustment *adjust_lower = GTK_RANGE( lower ) ->adjustment;
        GtkAdjustment *adjust_upper = GTK_RANGE( upper ) ->adjustment;
        adjust_lower->upper = adjust_upper->value;
        g_signal_emit_by_name( adjust_lower, "changed" );
        return FALSE;
    }


    gboolean
    on_hscale_transition_end_button_release_event
    ( GtkWidget * widget,
      GdkEventButton * event,
      gpointer user_data )
    {

        GtkWidget * lower = lookup_widget ( common->getPageMagick() ->window, "hscale_transition_start" );
        GtkWidget *upper = lookup_widget ( common->getPageMagick() ->window, "hscale_transition_end" );
        GtkAdjustment *adjust_lower = GTK_RANGE( lower ) ->adjustment;
        GtkAdjustment *adjust_upper = GTK_RANGE( upper ) ->adjustment;
        adjust_lower->upper = adjust_upper->value;
        g_signal_emit_by_name( adjust_lower, "changed" );
        common->getPageMagick() ->RefreshStatus( true );
        return FALSE;
    }

    void
    on_button_magick_file_clicked    (GtkButton       *button,
                                            gpointer         user_data)
    {
        const char *filename = common->getFileToSave( _("Enter a File Name to Save As") );
        gtk_widget_grab_focus( lookup_widget( GTK_WIDGET( button ), "entry_magick_file" ) );
        if ( strcmp( filename, "" ) )
            gtk_entry_set_text( GTK_ENTRY( lookup_widget( GTK_WIDGET( button ), "entry_magick_file" ) ), filename );
    }

    void
    on_spinbutton_magick_start_value_changed(GtkSpinButton   *spinbutton,
                                             gpointer         user_data)
    {
        GtkSpinButton *endSpin = GTK_SPIN_BUTTON( lookup_widget( GTK_WIDGET( spinbutton ), "spinbutton_magick_end" ) );
        gtk_spin_button_set_range( endSpin, gtk_spin_button_get_value( spinbutton ),
            common->getPlayList() ->GetNumFrames() - 1 );
        gtk_entry_set_text( GTK_ENTRY( lookup_widget( GTK_WIDGET( spinbutton ), "entry_magick_start" ) ),
            common->getTime().parseFramesToString( ( int )gtk_spin_button_get_value( spinbutton ),
            common->getTimeFormat() ).c_str() );
        common->getPageMagick()->OnTimeRangeChanged();
    }
    
    void
    on_entry_magick_start_activate         (GtkEntry        *entry,
                                            gpointer         user_data)
    {
        common->getTime().parseValueToString( gtk_entry_get_text( entry ), common->getTimeFormat() );
        GtkSpinButton *spinbutton = GTK_SPIN_BUTTON( lookup_widget( GTK_WIDGET( entry ), "spinbutton_magick_start" ) );
        gtk_spin_button_set_value( spinbutton, common->getTime().getFrames() );
        on_spinbutton_magick_start_value_changed( spinbutton, NULL );
    }
    
    gboolean
    on_entry_magick_start_focus_out_event  (GtkWidget       *widget,
                                            GdkEventFocus   *event,
                                            gpointer         user_data)
    {
        on_entry_magick_start_activate( GTK_ENTRY( widget ), NULL );
        g_nav_ctl.escaped = FALSE;
        return FALSE;
    }
    
    void
    on_spinbutton_magick_end_value_changed (GtkSpinButton   *spinbutton,
                                            gpointer         user_data)
    {
        GtkSpinButton *startSpin = GTK_SPIN_BUTTON( lookup_widget( GTK_WIDGET( spinbutton ), "spinbutton_magick_start" ) );
        gtk_spin_button_set_range( startSpin, 0, gtk_spin_button_get_value( spinbutton ) );
        gtk_entry_set_text( GTK_ENTRY( lookup_widget( GTK_WIDGET( spinbutton ), "entry_magick_end" ) ),
            common->getTime().parseFramesToString( ( int )gtk_spin_button_get_value( spinbutton ),
            common->getTimeFormat() ).c_str() );
        common->getPageMagick()->OnTimeRangeChanged();
    }

    void
    on_entry_magick_end_activate           (GtkEntry        *entry,
                                            gpointer         user_data)
    {
        common->getTime().parseValueToString( gtk_entry_get_text( entry ), common->getTimeFormat() );
        GtkSpinButton *spinbutton = GTK_SPIN_BUTTON( lookup_widget( GTK_WIDGET( entry ), "spinbutton_magick_end" ) );
        gtk_spin_button_set_value( spinbutton, common->getTime().getFrames() );
        on_spinbutton_magick_end_value_changed( spinbutton, NULL );
    }
    
    gboolean
    on_entry_magick_end_focus_out_event    (GtkWidget       *widget,
                                            GdkEventFocus   *event,
                                            gpointer         user_data)
    {
        on_entry_magick_end_activate( GTK_ENTRY( widget ), NULL );
        g_nav_ctl.escaped = FALSE;
        return FALSE;
    }
    
    void
    on_spinbutton_magick_limit_value_changed (GtkSpinButton   *spinbutton,
                                            gpointer         user_data)
    {
        gtk_entry_set_text( GTK_ENTRY( lookup_widget( GTK_WIDGET( spinbutton ), "entry_magick_limit" ) ),
            common->getTime().parseFramesToString( ( int )gtk_spin_button_get_value( spinbutton ),
            common->getTimeFormat() ).c_str() );
        common->getPageMagick()->OnTimeRangeChanged();
    }

    void
    on_entry_magick_limit_activate           (GtkEntry        *entry,
                                            gpointer         user_data)
    {
        common->getTime().parseValueToString( gtk_entry_get_text( entry ), common->getTimeFormat() );
        GtkSpinButton *spinbutton = GTK_SPIN_BUTTON( lookup_widget( GTK_WIDGET( entry ), "spinbutton_magick_limit" ) );
        gtk_spin_button_set_value( spinbutton, common->getTime().getFrames() );
        on_spinbutton_magick_limit_value_changed( spinbutton, NULL );
    }
    
    gboolean
    on_entry_magick_limit_focus_out_event    (GtkWidget       *widget,
                                            GdkEventFocus   *event,
                                            gpointer         user_data)
    {
        on_entry_magick_limit_activate( GTK_ENTRY( widget ), NULL );
        g_nav_ctl.escaped = FALSE;
        return FALSE;
    }
    
    static gboolean doScrub = FALSE;
    gboolean
    on_scrubbar_magick_button_press_event ( GtkWidget * widget,
                                      GdkEventButton * event,
                                      gpointer user_data )
    {
        doScrub = TRUE;
        videoStop();
        return FALSE;
    }


    gboolean
    on_scrubbar_magick_button_release_event ( GtkWidget * widget,
                                        GdkEventButton * event,
                                        gpointer user_data )
    {
        doScrub = FALSE;
        return FALSE;
    }

    gboolean
    on_scrubbar_magick_value_changed_event ( GtkWidget * widget,
                                       GdkEventButton * event,
                                       gpointer user_data )
    {
        if ( doScrub )
        {
            videoStop();
            moveToFrame( int( gtk_adjustment_get_value( GTK_ADJUSTMENT( widget ) ) ) );
        }
        return FALSE;
    }

    void
    on_time_range_changed(GtkWidget   *widget,
                          gpointer       user_data)
    {
        common->getPageMagick()->OnTimeRangeChanged();
    }

    void
    on_togglebutton_key_frame_toggled ( GtkToggleButton * togglebutton,
                                        gpointer user_data )
    {
        if ( !buttonMutex )
        {
            buttonMutex = true;
            PageMagick* magick = static_cast< PageMagick* >( user_data );
            magick->OnKeyFrameControllerKeyChanged( togglebutton );
            buttonMutex = false;
        }
    }

    static int _getOneSecond( void )
    {
        Frame & frame = *( GetFramePool() ->GetFrame( ) );
        common->getPlayList() ->GetFrame( common->g_currentFrame, frame );
        int value = ( frame.IsPAL() ? 25 : 30 );
        GetFramePool( ) ->DoneWithFrame( &frame );
        return value;
    }
}

bool Plugin::Open( char *file )
{
    ptr = dlopen( file, RTLD_NOW );
    return ptr != NULL;
}

void Plugin::Close( )
{
    if ( ptr != NULL )
        dlclose( ptr );
}

void *Plugin::Find( char *symbol )
{
    return dlsym( ptr, symbol );
}

const char *Plugin::GetError( )
{
    return dlerror();
}

PluginCollection::PluginCollection( )
{}

PluginCollection::~PluginCollection( )
{
    for ( unsigned int index = 0; index < collection.size(); index ++ )
    {
        collection[ index ] ->Close();
        delete collection[ index ];
    }
}

void PluginCollection::Initialise( char *directory )
{
    char * filename;
    char *extension;
    DIR *dir;
    struct dirent *entry;
    struct stat statbuf;

    dir = opendir( directory );

    if ( dir )
    {
        while ( ( entry = readdir( dir ) ) != NULL )
        {
            filename = g_strdup_printf( "%s/%s", directory, entry->d_name );
            extension = strrchr( entry->d_name, '.' );
            if ( extension != NULL && !stat( filename, &statbuf ) && S_ISREG( statbuf.st_mode ) )
            {
                if ( !strcmp( extension, ".so" ) )
                {
                    RegisterPlugin( filename );
                }
            }
            g_free( filename );
        }
        closedir( dir );
    }
}

void PluginCollection::RegisterPlugin( char *filename )
{
    Plugin * plugin = new Plugin;
    if ( plugin->Open( filename ) )
    {
        cerr << ">>> Registering plugin " << filename << endl;
        collection.push_back( plugin );
    }
    else
    {
        cerr << ">>> Rejecting plugin " << filename << " : " << plugin->GetError() << endl;
        delete plugin;
    }
}

unsigned int PluginCollection::Count()
{
    return collection.size();
}

Plugin *PluginCollection::Get( unsigned int index )
{
    return collection[ index ];
}

void PluginImageCreateRepository::InstallPlugins( Plugin *plugin )
{
    GDKImageCreate * ( *func ) ( int ) = ( GDKImageCreate * ( * ) ( int ) ) plugin->Find( "GetImageCreate" );
    if ( func != NULL )
    {
        int index = 0;
        GDKImageCreate *entry = func( index ++ );
        while ( entry != NULL )
        {
            if ( entry->IsUsable( ) )
                Register( entry );
            entry = func( index ++ );
        }
    }
}

void PluginImageFilterRepository::InstallPlugins( Plugin *plugin )
{
    GDKImageFilter * ( *func ) ( int ) = ( GDKImageFilter * ( * ) ( int ) ) plugin->Find( "GetImageFilter" );
    if ( func != NULL )
    {
        int index = 0;
        GDKImageFilter *entry = func( index ++ );
        while ( entry != NULL )
        {
            if ( entry->IsUsable( ) )
                Register( entry );
            entry = func( index ++ );
        }
    }
}

void PluginImageTransitionRepository::InstallPlugins( Plugin *plugin )
{
    GDKImageTransition * ( *func ) ( int ) = ( GDKImageTransition * ( * ) ( int ) ) plugin->Find( "GetImageTransition" );
    if ( func != NULL )
    {
        int index = 0;
        GDKImageTransition *entry = func( index ++ );
        while ( entry != NULL )
        {
            if ( entry->IsUsable( ) )
                Register( entry );
            entry = func( index ++ );
        }
    }
}

void PluginAudioFilterRepository::InstallPlugins( Plugin *plugin )
{
    GDKAudioFilter * ( *func ) ( int ) = ( GDKAudioFilter * ( * ) ( int ) ) plugin->Find( "GetAudioFilter" );
    if ( func != NULL )
    {
        int index = 0;
        GDKAudioFilter *entry = func( index ++ );
        while ( entry != NULL )
        {
            if ( entry->IsUsable( ) )
                Register( entry );
            entry = func( index ++ );
        }
    }
}

void PluginAudioTransitionRepository::InstallPlugins( Plugin *plugin )
{
    GDKAudioTransition * ( *func ) ( int ) = ( GDKAudioTransition * ( * ) ( int ) ) plugin->Find( "GetAudioTransition" );
    if ( func != NULL )
    {
        int index = 0;
        GDKAudioTransition *entry = func( index ++ );
        while ( entry != NULL )
        {
            if ( entry->IsUsable( ) )
                Register( entry );
            entry = func( index ++ );
        }
    }
}

class PageMagickFrames;
class PageMagickImage;
class PageMagickAudio;

class PageMagickInfo
{
private:
    PageMagickFrames *frameSource;
    PageMagickImage *imageManipulator;
    PageMagickAudio *audioManipulator;
public:
    KinoCommon *common;
    int begin;
    int end;
    double increment;
    bool reverse;
    int anteFrame;
    int postFrame;
    int width;
    int height;
    int isPAL;
    int isWide;
    int frequency;
    short channels;
    int samples_this_frame;
    bool preview;
    PageMagickInfo( KinoCommon *common );
    ~PageMagickInfo();
    void SetLowQuality( bool quality );
    KinoCommon *GetCommon( )
    {
        return this->common;
    }
    void Initialise();
    PageMagickFrames *GetFrameSource();
    PageMagickImage *GetImageManipulator();
    PageMagickAudio *GetAudioManipulator();
    void SetBegin( int begin )
    {
        this->begin = begin > 0 ? begin : 0;
    }
    void SetEnd( int end )
    {
        this->end = end > 0 ? end : 0;
    }
    void SetPostFrame( int postFrame )
    {
        this->postFrame = postFrame;
    }
    void SetAnteFrame( int anteFrame )
    {
        this->anteFrame = anteFrame;
    }
    void GetAnteFrame( uint8_t *pixels );
    void GetPostFrame( uint8_t *pixels );
    int GetPostFrame( )
    {
        return this->postFrame;
    }
    int GetAnteFrame( )
    {
        return this->anteFrame;
    }
};

namespace
{

class time_info
{
public:
    time_info( const PageMagickInfo& Info, const int FrameIndex, const double StartPosition = 0.0, const double EndPosition = 1.0 ) :
            info( Info ),
            frame_index( FrameIndex ),
            start_position( StartPosition ),
            end_position( EndPosition )
    {
        // Sanity checks ...
        if ( start_position > end_position )
            throw _( "Invalid position range" );
    }

    unsigned int frame_count() const
    {
        return info.end - info.begin + 1;
    }

    double duration() const
    {
        return end_position - start_position;
    }

    double position() const
    {
        double position = static_cast<double>( frame_index - info.begin ) / static_cast<double>( frame_count() ) * duration() + start_position;
        if ( info.reverse )
            position = 1 - position;
        return position;
    }

    double frame_delta() const
    {
        return duration() / static_cast<double>( frame_count() );
    }

    friend std::ostream& operator<<( std::ostream& Stream, const time_info& RHS )
    {
        Stream << RHS.frame_count() << " " << RHS.duration() << " " << RHS.frame_index << " " << RHS.position() << " " << RHS.frame_delta();
        return Stream;
    }

private:
    const PageMagickInfo& info;
    const int frame_index;
    const double start_position;
    const double end_position;
};

} // namespace

class PageMagickFrames
{
public:
    virtual ~PageMagickFrames() {}
    virtual void Initialise( PageMagickInfo * )
    { }
    virtual void GetFrame( uint8_t *pixels, int16_t **audio, int i )
    { }
    virtual void GetFrame( uint8_t *pixels, int width, int height, int16_t **audio, int i )
    { }
    virtual void Close()
    { }
    virtual bool IsSynth( )
    {
        return false;
    }
};

class PageMagickImage
{
public:
    virtual ~PageMagickImage() {}
    virtual void Initialise( PageMagickInfo *info )
    { }
    ;
    virtual void PreGetFrame( int keyPosition = -1 ) // -1 = automatic
    { }
    ;
    virtual void GetFrame( uint8_t *pixels, int i )
    { }
    ;
    virtual void Close()
    { }
    ;
    virtual bool ChangesImage( )
    {
        return true;
    }
};

class PageMagickAudio
{
public:
    virtual ~PageMagickAudio() {}
    virtual void Initialise( PageMagickInfo * )
    { }
    ;
    virtual void GetFrame( int16_t **audio, int i, int& samples, int locked_samples )
    { }
    ;
    virtual void Close()
    { }
    ;
};

class PageMagickOverwrite : public PageMagickFrames
{
private:
    PageMagickInfo *info;
public:
    void Initialise( PageMagickInfo * );
    void GetFrame( uint8_t *pixels, int16_t **audio, int i );
    void GetFrame( uint8_t *pixels, int width, int height, int16_t **audio, int i );
    void Close();
};

void PageMagickOverwrite::Initialise( PageMagickInfo *info )
{
    this->info = info;
    // Obtain begining and ending of sequence
    info->SetBegin( 0 );
    info->SetEnd( info->GetCommon() ->getPlayList() ->GetNumFrames() - 1 );
    info->increment = 1;
    info->reverse = false;

    GtkEntry *startSpin = GTK_ENTRY( lookup_widget( info->GetCommon() ->getPageMagick() ->window, "spinbutton_magick_start" ) );
    GtkEntry *endSpin = GTK_ENTRY( lookup_widget( info->GetCommon() ->getPageMagick() ->window, "spinbutton_magick_end" ) );

    if ( info->GetCommon() ->getPlayList() ->GetNumFrames() != 0 )
    {
        info->SetBegin( atoi( gtk_entry_get_text( startSpin ) ) );
        info->SetEnd( atoi( gtk_entry_get_text( endSpin ) ) );
        GtkToggleButton *limit = GTK_TOGGLE_BUTTON( lookup_widget( info->GetCommon() ->getPageMagick() ->window, "checkbutton_magick_frame_limit" ) );
        if ( gtk_toggle_button_get_active( limit ) )
        {
            GtkEntry * spin = GTK_ENTRY( lookup_widget( info->GetCommon() ->getPageMagick() ->window, "spinbutton_magick_limit" ) );
            GtkMenu *menu = GTK_MENU( gtk_option_menu_get_menu( GTK_OPTION_MENU( lookup_widget( info->GetCommon() ->getPageMagick() ->window, "optionmenu_magick_frame_offset" ) ) ) );
            GtkWidget *active_item = gtk_menu_get_active( menu );
            if ( g_list_index ( GTK_MENU_SHELL ( menu ) ->children, active_item ) == 1 )
            {
                int end = info->begin + atoi( gtk_entry_get_text( spin ) ) - 1;
                if ( end < info->end )
                    info->SetEnd( end );
            }
            else
            {
                info->SetBegin( info->end - atoi( gtk_entry_get_text( spin ) ) + 1 );
            }
        }
        info->SetAnteFrame( info->begin - 1 );
        info->SetPostFrame( info->end + 1 );
    }
    else
    {
        throw _( "No frames available for rewriting." );
    }

    // Determine speed
    GtkToggleButton *speed = GTK_TOGGLE_BUTTON( lookup_widget( info->GetCommon() ->getPageMagick() ->window, "checkbutton_speed" ) );
    if ( gtk_toggle_button_get_active( speed ) )
    {
        GtkRange * range = GTK_RANGE( lookup_widget( info->GetCommon() ->getPageMagick() ->window, "hscale_speed" ) );
        info->increment = range->adjustment->value;
    }

    // Determine direction
    GtkToggleButton *reverse = GTK_TOGGLE_BUTTON( lookup_widget( info->GetCommon() ->getPageMagick() ->window, "checkbutton_reverse" ) );
    info->reverse = gtk_toggle_button_get_active( reverse );
}

void PageMagickOverwrite::GetFrame( uint8_t *pixels, int16_t **audio, int i )
{
    Frame* infoFrame = GetFramePool()->GetFrame();
    common->getPlayList() ->GetFrame( i, *( infoFrame ) );

    if ( pixels )
    {
        infoFrame->decoder->quality = DV_QUALITY_BEST;
        infoFrame->ExtractRGB( pixels );
    }

    if ( audio )
    {
        AudioInfo ainfo;
        infoFrame->GetAudioInfo( ainfo );
        if ( ainfo.channels )
        {
            AudioResample<int16_ne_t,int16_ne_t> * resampler = AudioResampleFactory<int16_ne_t,int16_ne_t>::createAudioResample(
                                            AUDIO_RESAMPLE_SRC_SINC_BEST_QUALITY, info->frequency, false );
            resampler->Resample( *infoFrame );
            info->samples_this_frame = resampler->size / ( 2 * ainfo.channels );
            int16_t *p = resampler->output;
            for ( int s = 0; s < info->samples_this_frame; s++ )
                for ( int c = 0; c < ainfo.channels; c++ )
                    audio[ c ][ s ] = *p++;
            delete resampler;
        }
    }
    GetFramePool()->DoneWithFrame( infoFrame );
}

void PageMagickOverwrite::GetFrame( uint8_t *pixels, int width, int height, int16_t **audio, int i )
{
    Frame* infoFrame = GetFramePool()->GetFrame();
    common->getPlayList() ->GetFrame( i, *( infoFrame ) );

    if ( audio )
    {
        AudioInfo ainfo;
        infoFrame->GetAudioInfo( ainfo );
        if ( ainfo.channels )
        {
            AudioResample<int16_ne_t,int16_ne_t> *resampler = AudioResampleFactory<int16_ne_t,int16_ne_t>::createAudioResample(
                                    AUDIO_RESAMPLE_SRC_SINC_BEST_QUALITY, info->frequency, false );
            resampler->Resample( *infoFrame );
            info->samples_this_frame = resampler->size / ( 2 * ainfo.channels );
            int16_t *p = resampler->output;
            for ( int s = 0; s < info->samples_this_frame; s++ )
                for ( int c = 0; c < ainfo.channels; c++ )
                    audio[ c ][ s ] = *p++;
            delete resampler;
        }
    }
    if ( pixels )
    {
        infoFrame->decoder->quality = DV_QUALITY_BEST;
        infoFrame->ExtractRGB( pixels );
        if ( ( infoFrame->GetWidth() != width || infoFrame->GetHeight() != height ) )
        {
            GdkPixbuf * i1 = gdk_pixbuf_new_from_data( pixels, GDK_COLORSPACE_RGB, FALSE, 8,
                            infoFrame->GetWidth(), infoFrame->GetHeight(), infoFrame->GetWidth() * 3, NULL, NULL );
            GdkPixbuf *i2 = gdk_pixbuf_scale_simple( i1, width, height, GDK_INTERP_HYPER );
            memcpy( pixels, gdk_pixbuf_get_pixels( i2 ), width * height * 3 );
            g_object_unref( i2 );
            g_object_unref( i1 );
        }
    }
    GetFramePool()->DoneWithFrame( infoFrame );
}

void PageMagickOverwrite::Close( )
{
    cerr << ">>> Deleting " << info->begin << " << " << info->end << endl;
    info->GetCommon() ->getPlayList() ->Delete( info->begin, info->end );
}

class PageMagickCreate : public PageMagickFrames
{
private:
    PageMagickInfo *info;
    uint8_t *image;
    GDKImageCreate *creator;

public:
    PageMagickCreate();
    virtual ~PageMagickCreate();
    void Initialise( PageMagickInfo * );
    void GetFrame( uint8_t *pixels, int16_t **audio, int i );
    void GetFrame( uint8_t *pixels, int width, int height, int16_t **audio, int i );
    virtual bool IsSynth( )
    {
        return true;
    }
};

PageMagickCreate::PageMagickCreate() : image( NULL )
{
    image = new uint8_t[ 720 * 576 * 3 ];
}

PageMagickCreate::~PageMagickCreate()
{
    delete[] image;
}

void PageMagickCreate::Initialise( PageMagickInfo *info )
{
    this->info = info;
    // Get the start of the scene
    info->SetBegin( common->getPlayList()->FindStartOfScene( common->g_currentFrame ) );
    info->increment = 1;
    info->reverse = false;
    info->SetAnteFrame( info->begin - 1 );
    info->SetPostFrame( info->begin );

/* Commented to simplify UI to always create before current scene
    GtkToggleButton *frameToggle = GTK_TOGGLE_BUTTON( lookup_widget( common->getPageMagick() ->window, "radiobutton_magick_create_before" ) );
    if ( gtk_toggle_button_get_active( frameToggle ) )
    {
        GtkEntry * spin = GTK_ENTRY( lookup_widget( common->getPageMagick() ->window, "spinbutton_magick_create_before" ) );
        info->begin = atoi( gtk_entry_get_text( spin ) );
    }
*/

    creator = info->GetCommon() ->getPageMagick() ->GetImageCreate();
    if ( creator != NULL )
    {
        creator->CreatePAL( info->isPAL );
        creator->InterpretWidgets( GTK_BIN( lookup_widget( common->getPageMagick() ->window, "frame_magick_frames_create" ) ) );
    }
    else
        throw _( "Invalid image creator selected" );

    // Indicate proper duration
    info->SetEnd( info->begin + creator->GetNumberOfFrames() - 1 );
}

void PageMagickCreate::GetFrame( uint8_t *pixels, int16_t **audio, int i )
{
    // Sanity checks ...
    if ( !creator )
        throw _( "Invalid image creator selected" );

    if ( pixels )
    {
        creator->CreateFrame( image, info->width, info->height, time_info( *info, i ).position(), time_info( *info, i ).frame_delta() );
        memcpy( pixels, image, info->width * info->height * 3 );
    }

    if ( audio )
    {
        for ( int i = 0; i < 4; i ++ )
            memset( audio[ i ], 0, 2 * DV_AUDIO_MAX_SAMPLES * sizeof( int16_t ) );
        GDKAudioImport *import = dynamic_cast <GDKAudioImport *>( creator );
        if ( import != NULL )
            import->CreateAudio( audio, &info->channels, &info->frequency, &info->samples_this_frame );
    }
}

void PageMagickCreate::GetFrame( uint8_t *pixels, int width, int height, int16_t **audio, int i )
{
    // Sanity checks ...
    if ( !creator )
        throw _( "Invalid image creator selected" );

    if ( pixels )
    {
        creator->CreateFrame( image, width, height, time_info( *info, i ).position(), time_info( *info, i ).frame_delta() );
        memcpy( pixels, image, width * height * 3 );
    }

    if ( audio )
    {
        for ( int i = 0; i < 4; i ++ )
            memset( audio[ i ], 0, 2 * DV_AUDIO_MAX_SAMPLES * sizeof( int16_t ) );
        GDKAudioImport *import = dynamic_cast <GDKAudioImport *>( creator );
        if ( import != NULL )
            import->CreateAudio( audio, &info->channels, &info->frequency, &info->samples_this_frame );
    }
}

class PageMagickTransition : public PageMagickImage
{
private:
    PageMagickInfo *info;
    GDKImageTransition *transition;
    uint8_t keyFrame[ 720 * 576 * 3 ];
    bool animateKey;
    int direction;
    double start_position;
    double end_position;
public:
    void Initialise( PageMagickInfo *info );
    void PreGetFrame( int keyPosition );
    void GetFrame( uint8_t *pixels, int i );
    void Close();
};

void PageMagickTransition::Initialise( PageMagickInfo *info )
{
    this->info = info;
    this->animateKey = false;

    transition = info->GetCommon() ->getPageMagick() ->GetImageTransition();
    if ( transition != NULL )
        transition->InterpretWidgets( GTK_BIN( lookup_widget( common->getPageMagick() ->window, "frame_magick_image_transition" ) ) );
    else
        throw _( "Invalid image transition selected" );

    GtkToggleButton *toggle = GTK_TOGGLE_BUTTON( lookup_widget( common->getPageMagick() ->window, "radiobutton_magick_transition_colour" ) );

    if ( gtk_toggle_button_get_active( toggle ) )
    {
        GdkColor color;
        GtkColorButton * colorButton = GTK_COLOR_BUTTON( lookup_widget( info->GetCommon() ->getPageMagick() ->window, "colorpicker_magick_transition" ) );
        gtk_color_button_get_color( colorButton, &color );
        
        for ( uint8_t * p = keyFrame; p < ( keyFrame + info->width * info->height * 3 ); )
        {
            *p ++ = color.red >> 8;
            *p ++ = color.green >> 8;
            *p ++ = color.blue >> 8;
        }
    }
    else
    {
        GtkMenu *menu = GTK_MENU( gtk_option_menu_get_menu( GTK_OPTION_MENU( lookup_widget( info->GetCommon() ->getPageMagick() ->window, "optionmenu_magick_transition_frame" ) ) ) );
        GtkWidget *active_item = gtk_menu_get_active( menu );
        switch ( g_list_index ( GTK_MENU_SHELL ( menu ) ->children, active_item ) )
        {
        case 1:
            info->GetPostFrame( keyFrame );
            break;
        case 2:
            info->GetAnteFrame( keyFrame );
            break;
        case 0:
            animateKey = true;
            break;
        }
    }

    GtkMenu *menu = GTK_MENU( gtk_option_menu_get_menu( GTK_OPTION_MENU( lookup_widget( info->GetCommon() ->getPageMagick() ->window, "optionmenu_direction" ) ) ) );
    GtkWidget *active_item = gtk_menu_get_active( menu );
    direction = g_list_index ( GTK_MENU_SHELL ( menu ) ->children, active_item );

    GtkRange *range = GTK_RANGE( lookup_widget( info->GetCommon() ->getPageMagick() ->window, "hscale_transition_start" ) );
    start_position = range->adjustment->value;
    range = GTK_RANGE( lookup_widget( info->GetCommon() ->getPageMagick() ->window, "hscale_transition_end" ) );
    end_position = range->adjustment->value;
}

void PageMagickTransition::PreGetFrame( int keyPosition )
{
    if ( animateKey )
    {
        if ( keyPosition > -1 )
            info->postFrame = info->end + keyPosition;
        info->GetPostFrame( keyFrame );
    }
    info->postFrame ++;
}

void PageMagickTransition::GetFrame( uint8_t *pixels, int i )
{
    // Sanity checks ...
    if ( !transition )
        throw _( "Invalid image transition selected" );

    transition->GetFrame( pixels, keyFrame, info->width, info->height, time_info( *info, i, start_position, end_position ).position(), time_info( *info, i, start_position, end_position ).frame_delta(), direction == 1 );
}

void PageMagickTransition::Close( )
{
    if ( this->animateKey )
    {
        cerr << ">>> Deleting " << info->begin << " << " << info->begin + ( info->end - info->begin ) / info->increment << endl;
        info->GetCommon() ->getPlayList() ->Delete( info->begin, ( int ) ( info->begin + ( info->end - info->begin ) / info->increment ) );
    }
}

class PageMagickFilter : public PageMagickImage
{
private:
    PageMagickInfo *info;
    GDKImageFilter *filter;
public:
    void Initialise( PageMagickInfo *info );
    void GetFrame( uint8_t *pixels, int i );
    bool ChangesImage( );
    void PreGetFrame( int keyPosition )
    {
        if ( keyPosition > -1 )
            info->postFrame = info->end + keyPosition;
        else
            info->postFrame ++;
    }
};

void PageMagickFilter::Initialise( PageMagickInfo *info )
{
    this->info = info;
    filter = info->GetCommon() ->getPageMagick() ->GetImageFilter();
    if ( filter != NULL )
        filter->InterpretWidgets( GTK_BIN( lookup_widget( common->getPageMagick() ->window, "frame_magick_image_filter" ) ) );
    else
        throw _( "Invalid image filter selected" );
}

void PageMagickFilter::GetFrame( uint8_t *pixels, int i )
{
    // Sanity checks ...
    if ( !filter )
        throw _( "Invalid image filter selected" );

    filter->FilterFrame( pixels, info->width, info->height, time_info( *info, i ).position(), time_info( *info, i ).frame_delta() );
}

bool PageMagickFilter::ChangesImage( )
{
    NullImageFilter * no_image_encode = dynamic_cast <NullImageFilter *>( filter );
    return no_image_encode == NULL;
}

class PageMagickAudioFilter : public PageMagickAudio
{
private:
    PageMagickInfo *info;
    GDKAudioFilter *filter;
public:
    void Initialise( PageMagickInfo *info );
    void GetFrame( int16_t **audio, int i, int& samples, int locked_samples );
};

void PageMagickAudioFilter::Initialise( PageMagickInfo *info )
{
    this->info = info;
    filter = info->GetCommon() ->getPageMagick() ->GetAudioFilter();
    if ( filter != NULL )
        filter->InterpretWidgets( GTK_BIN( lookup_widget( common->getPageMagick() ->window, "frame_magick_audio_filter" ) ) );
    else
        throw _( "Invalid audio filter selected" );
}

void PageMagickAudioFilter::GetFrame( int16_t **audio, int i, int& samples, int locked_samples )
{
    // Sanity checks ...
    if ( !filter )
        throw _( "Invalid audio filter selected" );
    if ( !filter->IsAFrameConsumer() )
        samples = locked_samples;
    filter->GetFrame( audio, info->frequency, info->channels, samples, time_info( *info, i ).position(), time_info( *info, i ).frame_delta() );
}

class PageMagickAudioTransition : public PageMagickAudio
{
private:
    PageMagickInfo *info;
    int16_t *audio_buffers[ 4 ];
    GDKAudioTransition *transition;
AudioResample<int16_ne_t,int16_ne_t> * resampler;
public:
    PageMagickAudioTransition();
    virtual ~PageMagickAudioTransition();
    void Initialise( PageMagickInfo *info );
    void GetFrame( int16_t **audio, int i, int& samples, int locked_samples );
};

PageMagickAudioTransition::PageMagickAudioTransition() : resampler( 0 )
{
    for ( int index = 0; index < 4; index ++ )
        audio_buffers[ index ] = new int16_t[ 2 * DV_AUDIO_MAX_SAMPLES ];
}

PageMagickAudioTransition::~PageMagickAudioTransition()
{
    for ( int index = 0; index < 4; index ++ )
        delete[] audio_buffers[ index ];
    delete resampler;
}

void PageMagickAudioTransition::Initialise( PageMagickInfo *info )
{
    this->info = info;

    transition = info->GetCommon() ->getPageMagick() ->GetAudioTransition();
    if ( transition != NULL )
        transition->InterpretWidgets( GTK_BIN( lookup_widget( common->getPageMagick() ->window, "frame_magick_audio_transition" ) ) );
    else
        throw _( "Invalid audio transition selected" );
}

void PageMagickAudioTransition::GetFrame( int16_t **audio, int i, int& samples, int locked_samples )
{
    // Sanity checks ...
    if ( !transition )
        throw _( "Invalid audio filter selected" );

    if ( transition->IsBFrameConsumer() )
    {
        // Pick up the b-frame audio (ugly.. moved by image transition when appropriate)
        // should also be resampled to the a-frames frequency - this is going to go haywire in
        // mixed sample rate projects :-/
        // In truth, even the aframes should be resampled to original aframes frequency... (fun, fun, fun)
        Frame* infoFrame = GetFramePool()->GetFrame();
        AudioInfo ainfo;
        common->getPlayList()->GetFrame( info->GetPostFrame() - 1, *( infoFrame ) );
        infoFrame->GetAudioInfo( ainfo );
        if ( ainfo.channels )
        {
            if ( !resampler )
                resampler = AudioResampleFactory<int16_ne_t,int16_ne_t>::createAudioResample(
                    AUDIO_RESAMPLE_SRC_SINC_BEST_QUALITY, info->frequency, true );
            resampler->Resample( *infoFrame );
            int16_t *p = resampler->output;
            samples = resampler->size / info->channels / 2;
            for ( int s = 0; s < samples; s++ )
                for ( int c = 0; c < info->channels; c++ )
                    audio_buffers[ c ][ s ] = *p++;
        }
        GetFramePool()->DoneWithFrame( infoFrame );
    }
    else
    {
        samples = locked_samples;
    }
    transition->GetFrame( audio, audio_buffers, info->frequency, info->channels, 
        samples, time_info( *info, i ).position(), time_info( *info, i ).frame_delta() );
}

PageMagickInfo::PageMagickInfo( KinoCommon *common ) : preview( false )
{
    this->common = common;
    this->frameSource = NULL;
    this->imageManipulator = NULL;
    this->audioManipulator = NULL;
}

PageMagickInfo::~PageMagickInfo()
{
    delete frameSource;
    delete imageManipulator;
    delete audioManipulator;
}

void PageMagickInfo::Initialise()
{
    Frame* infoFrame = GetFramePool()->GetFrame();
    
    // Get a sample frame to obtain recording info
    if ( common->getPlayList() ->GetFrame( 0, *infoFrame ) )
    {
        // Get all video and audio info required
        width = infoFrame->GetWidth();
        height = infoFrame->GetHeight();
        isPAL = infoFrame->IsPAL();
        isWide = infoFrame->IsWide();
        AudioInfo info;
        infoFrame->GetAudioInfo( info );
        if ( info.channels && info.frequency )
        {
            channels = info.channels;
            frequency = info.frequency;
            samples_this_frame = frequency / ( isPAL ? 25 : 30 );
        }
        else
        {
            channels = ( short ) 2;
            switch ( Preferences::getInstance().defaultAudio )
            {
            case AUDIO_32KHZ:
                frequency = 32000;
                break;
            case AUDIO_44KHZ:
                frequency = 44100;
                break;
            case AUDIO_48KHZ:
                frequency = 48000;
                break;
            }
            samples_this_frame = frequency / ( isPAL ? 25 : 30 );
        }
    }
    else
    {
        if ( Preferences::getInstance().defaultNormalisation != NORM_UNSPECIFIED )
        {
            isPAL = Preferences::getInstance().defaultNormalisation == NORM_PAL;
        }
        else
        {
            switch ( modal_confirm( "PAL", "NTSC", _("Please choose a video standard") ) )
            {
            case GTK_RESPONSE_ACCEPT:
                isPAL = true;
                Preferences::getInstance().defaultNormalisation = NORM_PAL;
                break;
            case GTK_RESPONSE_CLOSE:
                isPAL = false;
                Preferences::getInstance().defaultNormalisation = NORM_NTSC;
                break;
            default:
                // Do nothing - action cancelled
                GetFramePool()->DoneWithFrame( infoFrame );
                throw _("Aborted");
            }
        }
        width = 720;
        height = isPAL ? 576 : 480;
        isWide = Preferences::getInstance().defaultAspect == ASPECT_169;
        channels = ( short ) 2;
        switch ( Preferences::getInstance().defaultAudio )
        {
        case AUDIO_32KHZ:
            frequency = 32000;
            break;
        case AUDIO_44KHZ:
            frequency = 44100;
            break;
        case AUDIO_48KHZ:
            frequency = 48000;
            break;
        }
        samples_this_frame = frequency / ( isPAL ? 25 : 30 );
    }
    GetFramePool()->DoneWithFrame( infoFrame );

    preview = false;
}

void PageMagickInfo::SetLowQuality( bool low_quality )
{
    if ( preview != low_quality )
    {
        if ( low_quality )
        {
            width /= 4;
            height /= 4;
        }
        else
        {
            width *= 4;