[melted] / mlt / src / miracle / miracle_unit.c

/*
 * dvunit.c -- DV Transmission Unit Implementation
 * Copyright (C) 2002-2003 Ushodaya Enterprises Limited
 * Author: 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 <stdio.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/poll.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <signal.h>

#include <libdv/dv1394.h>
#include <libraw1394/raw1394.h>
#include <libavc1394/avc1394_vcr.h>
#include <sys/mman.h>

#include "dvunit.h"
#include "dvframe.h"
#include "dvframepool.h"
#include "dvqueue.h"
#include "dvpump.h"
#include "dverror.h"
#include "dvplayer.h"
#include "raw1394util.h"
#include "log.h"
#include "dvlocal.h"

/* Forward references */
static void dv_unit_status_communicate( dv_unit );

/** dv1394 device file names based upon devfs default names. */

static char *devices[4][4] = {
        {
        "/dev/ieee1394/dv/host0/NTSC/in",
        "/dev/ieee1394/dv/host0/NTSC/out",
        "/dev/ieee1394/dv/host0/PAL/in",
        "/dev/ieee1394/dv/host0/PAL/out",
        },{
        "/dev/ieee1394/dv/host1/NTSC/in",
        "/dev/ieee1394/dv/host1/NTSC/out",
        "/dev/ieee1394/dv/host1/PAL/in",
        "/dev/ieee1394/dv/host1/PAL/out"
        },{
        "/dev/ieee1394/dv/host2/NTSC/in",
        "/dev/ieee1394/dv/host2/NTSC/out",
        "/dev/ieee1394/dv/host2/PAL/in",
        "/dev/ieee1394/dv/host2/PAL/out"
        },{
        "/dev/ieee1394/dv/host3/NTSC/in",
        "/dev/ieee1394/dv/host3/NTSC/out",
        "/dev/ieee1394/dv/host3/PAL/in",
        "/dev/ieee1394/dv/host3/PAL/out"
        }
};

static int device_count[4] = {0,0,0,0};

/** Allocate a new DV transmission unit.

    \param dv1394d_fd The file descriptor of a dv1394 device file to 
                      use for transmission.
    \param guid The node GUID of the receiving device.
    \param channel The channel to use for transmission.
    \return A new dv_unit handle.
*/

dv_unit dv_unit_init( octlet_t guid, int channel )
{
        dv_unit unit = malloc( sizeof( dv_unit_t ) );
        if ( unit != NULL )
        {
                int node_id;
                
                memset( unit, 0, sizeof( dv_unit_t ) );
                unit->guid = guid;
                unit->buffer_size = 25;
                unit->is_terminated = 1;
                unit->channel = channel;
                unit->dv1394_fd = -1;
                unit->n_frames = DV1394_MAX_FRAMES / 2;
                unit->n_fill = 1;

                /* get a raw1394 handle for plug control */
                if ( ( node_id = raw1394_find_node( &(unit->raw1394), guid ) ) != -1 )
                {
                        if ( dv_unit_online( unit ) == 1 )
                                dv1394d_log( LOG_DEBUG, "Added online unit with GUID %08x%08x", 
                                        (quadlet_t) (unit->guid>>32), (quadlet_t) (unit->guid & 0xffffffff) );
                        else
                        {
                                dv_unit_close( unit );
                                unit = NULL;
                        }
                }
                else
                {
                        dv1394d_log( LOG_DEBUG, "Added offline unit with GUID %08x%08x", 
                                (quadlet_t) (unit->guid>>32), (quadlet_t) (unit->guid & 0xffffffff) );
                }
        }
        return unit;
}

/** Allow stdin to feed the unit (redundant now that senddv has been dropped).
*/

void dv_unit_allow_stdin( dv_unit unit, int flag )
{
        unit->allow_stdin = flag;
}

/** Override the default buffer/pump size - this must be done prior to the pumps
        creation.
*/

void dv_unit_set_buffer_size( dv_unit unit, int size )
{
        if ( size > 0 )
        {
                if ( unit->pump == NULL )
                        unit->buffer_size = size;
                else
                        unit->buffer_size = dv_pump_resize( unit->pump, size );
        }
}

int dv_unit_get_buffer_size( dv_unit unit )
{
        return unit->buffer_size;
}

void dv_unit_set_n_frames( dv_unit unit, int size )
{
        if ( size > 0 && size <= DV1394_MAX_FRAMES / 2 )
                unit->n_frames = size;
}

int dv_unit_get_n_frames( dv_unit unit )
{
        return unit->n_frames;
}

void dv_unit_set_n_fill( dv_unit unit, int size )
{
        unit->n_fill = size;
}

int dv_unit_get_n_fill( dv_unit unit )
{
        return unit->n_fill;
}

/** Set the notifier info
*/

void dv_unit_set_notifier( dv_unit this, dv1394_notifier notifier, char *root_dir )
{
        this->notifier = notifier;
        this->root_dir = root_dir;
        dv_unit_status_communicate( this );
}

/** Communicate the current status to all threads waiting on the notifier.
*/

static void dv_unit_status_communicate( dv_unit unit )
{
        if ( unit != NULL && unit->notifier != NULL && unit->root_dir != NULL )
        {
                dv1394_status_t status;
                if ( dv_unit_get_status( unit, &status ) == 0 )
                        if ( !( ( status.status == unit_playing || status.status == unit_paused ) &&
                                        strcmp( status.clip, "" ) && 
                                    !strcmp( status.tail_clip, "" ) && 
                                        status.position == 0 && 
                                        status.in == 0 && 
                                        status.out == 0 ) )
                                dv1394_notifier_put( unit->notifier, &status );
        }
}

/** Load a clip into the unit clearing existing play list.

    \todo error handling
    \param unit A dv_unit handle.
    \param clip The absolute file name of the clip to load.
    \param in   The starting frame (-1 for 0)
        \param out  The ending frame (-1 for maximum)
*/

dv_error_code dv_unit_load( dv_unit unit, const char *clip, long in, long out, int flush )
{
        dv_player player = dv_unit_get_dv_player( unit );
        dv_error_code error = dv_player_get_error( player );
        if ( error == dv_pump_ok )
        {
                error = dv_player_replace_file( player, (char*) clip, in, out, flush );
                dv1394d_log( LOG_DEBUG, "loaded clip %s", clip );
                if ( unit->is_terminated )
                        dv_unit_status_communicate( unit );
        }
        return error;
}

dv_error_code dv_unit_insert( dv_unit unit, const char *clip, int index, long in, long out )
{
        dv_player player = dv_unit_get_dv_player( unit );
        dv_error_code error = dv_player_get_error( player );
        if ( error == dv_pump_ok )
        {
                error = dv_player_insert_file( player, (char*) clip, index, in, out );
                dv1394d_log( LOG_DEBUG, "inserted clip %s", clip );
                if ( unit->is_terminated )
                        dv_unit_status_communicate( unit );
        }
        return error;
}

dv_error_code dv_unit_remove( dv_unit unit, int index )
{
        dv_player player = dv_unit_get_dv_player( unit );
        dv_error_code error = dv_player_get_error( player );
        if ( error == dv_pump_ok )
        {
                error = dv_player_remove_clip( player, index );
                dv1394d_log( LOG_DEBUG, "removed clip %d", index );
                if ( unit->is_terminated )
                        dv_unit_status_communicate( unit );
        }
        return error;
}

dv_error_code dv_unit_clean( dv_unit unit )
{
        dv_player player = dv_unit_get_dv_player( unit );
        dv_error_code error = dv_player_get_error( player );
        if ( error == dv_pump_ok )
        {
                error = dv_player_clean( player );
                dv1394d_log( LOG_DEBUG, "Cleaned playlist" );
                if ( unit->is_terminated )
                        dv_unit_status_communicate( unit );
        }
        return error;
}

dv_error_code dv_unit_move( dv_unit unit, int src, int dest )
{
        dv_player player = dv_unit_get_dv_player( unit );
        dv_error_code error = dv_player_get_error( player );
        if ( error == dv_pump_ok )
        {
                error = dv_player_move_clip( player, src, dest );
                dv1394d_log( LOG_DEBUG, "moved clip %d to %d", src, dest );
                if ( unit->is_terminated )
                        dv_unit_status_communicate( unit );
        }
        return error;
}

/** Add a clip to the unit play list.

    \todo error handling
    \param unit A dv_unit handle.
    \param clip The absolute file name of the clip to load.
    \param in   The starting frame (-1 for 0)
        \param out  The ending frame (-1 for maximum)
*/

dv_error_code dv_unit_append( dv_unit unit, const char *clip, long in, long out )
{
        dv_player player = dv_unit_get_dv_player( unit );
        dv_error_code error = dv_player_add_file( player, (char*) clip, in, out );
        dv_unit_status_communicate( unit );
        return error;
}

void *output_cleanup( void *arg )
{
        dv_unit unit = arg;
        if ( unit != NULL && unit->mmap != NULL )
        {
                unit->is_terminated = 1;
                dv_unit_status_communicate( unit );
                munmap( unit->mmap, unit->mmap_length );
                /* this actually stops transmission as opposed to allowing the 
                   last frame to loop in the OHCI DMA context. */
                ioctl( unit->dv1394_fd, DV1394_SHUTDOWN, NULL );
        }

        return NULL;
}

/** The dv1394 transmission thread.

    \param arg A dv_unit handle.
*/

static void *output( void *arg )
{
        dv_unit unit = arg;
        dv_frame frames[ DV1394_MAX_FRAMES ];
        int frames_dropped = 0; /* count of total frames dropped (repeated) */
        struct dv1394_status status;
        char errstr[64];
        int n_fill = unit->n_fill;
        int n_frames = unit->n_frames;
        
        /* Determine the number of frames to wait for/fill on each iteration */
        if ( n_fill < 1 )
                n_fill = 1;
        else if ( n_fill > unit->n_frames )
                n_fill = n_frames / 2;

        unit->mmap = mmap( NULL,unit->mmap_length,PROT_WRITE,MAP_SHARED,unit->dv1394_fd,0 );
        if ( unit->mmap == MAP_FAILED || unit->mmap == NULL )
        {
                perror( "mmap" );
                return NULL;
        }

        pthread_cleanup_push( output_cleanup, (void *)arg );

        while ( dv_pump_get_available_output_count( unit->pump ) || 
                !( dv_unit_has_terminated( unit ) || dv_pump_has_terminated( unit->pump) ) )
        {
                int available = 0;

                if ( ioctl( unit->dv1394_fd, DV1394_WAIT_FRAMES, n_fill ) < 0)
                        perror( "DV1394_WAIT_FRAMES" );

                pthread_testcancel();

                /* update the status for the next iteration and detect dropped frames */
                if ( ioctl( unit->dv1394_fd, DV1394_GET_STATUS, &status ) >= 0)
                {
                        pthread_testcancel();

                        /*
                        printf( "dv1394 status: active=%02d, #clear=%02d, first clear=%02d\n", 
                                status.active_frame, status.n_clear_frames, status.first_clear_frame);
                        */
                
                        /* report dropped frames */
                        if( status.dropped_frames > 0 )
                        {
                                frames_dropped += status.dropped_frames;
                                dv1394d_log( LOG_WARNING, "dv1394 repeated %d frames with %d available.", 
                                                         status.dropped_frames, dv_pump_get_available_output_count( unit->pump ) );
                        }

                        available = dv_pump_get_output_block( unit->pump, (void **)frames, n_fill );

                        dv_unit_status_communicate( unit );
                        
                        /* The only time we get 0 frames is when the unit is being stopped. */
                        if ( available != 0 )
                        {
                                int size = dv_frame_size( frames[ 0 ] );
                                int pos = status.first_clear_frame;
                                int index = 0;

                                for ( index = 0; index < available; index ++ )
                                        memcpy( unit->mmap + ( ( pos + index ) % n_frames ) * size, dv_frame_data( frames[ index ] ), size );

                                if ( ioctl( unit->dv1394_fd, DV1394_SUBMIT_FRAMES, available ) >= 0)
                                {
                                        for ( index = 0; index < available - 1; index ++ )
                                        {
                                                dv_frame_clear_error( frames[ index ] );
                                                dv_frame_id_clear( dv_frame_get_id( frames[ index ] ) );
                                        }                       
                                        dv_pump_return_output_block( unit->pump );
                                        pthread_testcancel();
                                }
                                else
                                {
                                        dv1394d_log( LOG_ERR, "failed to write frames to dv1394: %s.", strerror_r( errno, errstr, 63 ) );
                                        dv_pump_terminate( unit->pump );
                                        dv_pump_flush( unit->pump );
                                        pthread_testcancel();
                                }
                        }
                }
                else
                {
                        dv1394d_log( LOG_ERR, "failed to get dv1394 status: %s.", strerror_r( errno, errstr, 63 ) );
                        dv_pump_return_used_output( unit->pump );
                }
        }

        if ( frames_dropped > 0 )
                dv1394d_log( LOG_WARNING, "dv1394 repeated %d frames total during this transmission.", frames_dropped );

        pthread_cleanup_pop( 1 );

        return NULL;
}

/** Start playing the clip.

    Start a dv-pump and commence dv1394 transmission.

    \todo error handling
    \param unit A dv_unit handle.
    \param speed An integer that specifies the playback rate as a
                 percentage multiplied by 100.
*/

void dv_unit_play( dv_unit_t *unit, int speed )
{
        dv_player player = dv_unit_get_dv_player( unit );

        if ( unit->is_terminated == 1 && ( dv_player_get_total_frames( player ) > 0 || unit->allow_stdin ) )
        {
                int retval;
                dv_frame frame = NULL;
                struct dv1394_init setup =
                {
                        api_version: DV1394_API_VERSION,
                        channel: unit->channel,
                        /* this only sets the *requested* size of the ringbuffer,
                           in frames */ 
                        n_frames: unit->n_frames,
                        /* we set the format later */
                        cip_n: unit->dv1394_cip_n,
                        cip_d: unit->dv1394_cip_d,
                        syt_offset: unit->dv1394_syt_offset
                };
                pthread_attr_t attr;

                if ( unit->in == NULL )
                {
                        if ( !unit->allow_stdin || dv_player_get_total_frames( player ) != 0 )
                                unit->in = dv_player_get_dv_input( player );
                        else
                                unit->in = dv_input_init( unit->pump );
                }
                else
                {
                        dv_input_join_thread( unit->in );
                        pthread_join( unit->out, NULL );
                }

                unit->is_terminated = 0;
                dv_pump_restart( unit->pump );
                dv_input_start_thread( unit->in );
                dv_player_set_speed( player, (double) speed/1000.0 );

                /* first we read a little data to see if this is PAL or NTSC
                   so we can initialize dv1394 properly */
                frame = dv_pump_get_available_output( unit->pump );
        
                /* initialize dv1394 */
                setup.format = dv_frame_is_pal(frame) ? DV1394_PAL : DV1394_NTSC;
                
                retval = ioctl( unit->dv1394_fd, DV1394_INIT, &setup );
                if (retval < 0)
                {
                        perror( "DV1394_INIT" );
                        return;
                }

                unit->mmap_length = unit->n_frames * dv_frame_size( frame );

                pthread_attr_init( &attr );
                pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
                pthread_attr_setinheritsched( &attr, PTHREAD_INHERIT_SCHED );
                pthread_create( &unit->out, &attr, output, unit );
        }
        else 
        {
                dv_player_set_speed( player, (double) speed/1000.0 );
        }
        dv_unit_status_communicate( unit );
}

/** Stop playback.

    Terminates the dv_pump and halts dv1394 transmission.

    \param unit A dv_unit handle.
*/

void dv_unit_terminate( dv_unit unit )
{
        unit->is_terminated = 1;
        if ( unit->pump != NULL )
        {
                dv_pump_terminate( unit->pump );
                dv_pump_flush( unit->pump );
        }
}

/** Query the status of unit playback.

    \param unit A dv_unit handle.
    \return 1 if the unit is not playing, 0 if playing.
*/

int dv_unit_has_terminated( dv_unit unit )
{
        return unit->is_terminated;
}

/** Get the dv_player from the dv_unit.

    \param unit A dv_unit handle.
    \return A dv_player handle.
*/

dv_player dv_unit_get_dv_player( dv_unit unit )
{
        if ( unit != NULL )
        {
                if ( unit->pump == NULL )
                {
                        unit->pump = dv_pump_init( unit->buffer_size );
                        if ( unit->pump != NULL )
                                unit->player = dv_player_init( unit->pump );
                }
                return unit->player;
        }
        return NULL;
}


/** Transfer the currently loaded clip to another unit
*/

int dv_unit_transfer( dv_unit dest_unit, dv_unit src_unit )
{
        dv_player src_player = dv_unit_get_dv_player( src_unit );
        dv_player dest_player = dv_unit_get_dv_player( dest_unit );

        if( dest_player != NULL && src_player != NULL )
                dv_player_replace_player( dest_player, src_player );

        return 0;
}

/** Get the guid associated to this unit.
*/

octlet_t dv_unit_get_guid( dv_unit unit )
{
        return unit->guid;
}

/** Get the node id associated to this unit.
*/

int dv_unit_get_nodeid( dv_unit unit )
{
        return (unit->node_id & 0x3f);
}

/** Get the channel associated to this unit.
*/

int dv_unit_get_channel( dv_unit unit )
{
        return (unit->channel);
}

/** Turn unit online.
*/

int dv_unit_online( dv_unit unit )
{
        int result = 0;
        int port, node_id;
        
        if ( unit->raw1394 != NULL )
                raw1394_close( unit->raw1394 );
        
        node_id = raw1394_find_node( &(unit->raw1394), unit->guid );
        if ( node_id != -1 )
        {
                unit->node_id = 0xffc0 | node_id;       
                port = dv_unit_get_port( unit );
        
                unit->dv1394_fd = open( devices[ port ][ device_count[port] ], O_RDWR );
                if ( unit->dv1394_fd < 0 )
                {
                        dv1394d_log( LOG_ERR, "failed to open dv1394 device - %s\n", devices[ port ][ device_count[port] ] );
                        dv_unit_close( unit );
                }
                else
                {
                        device_count[ port ] ++;
                        if ( establish_p2p_connection( unit->raw1394, unit->node_id, (unsigned int *) &(unit->channel) ) )
                        {
                                avc1394_vcr_record( unit->raw1394, unit->node_id );
                                unit->online = 1;
                                dv_unit_status_communicate( unit );
                                result = 1;
                        }
                }
        }
                                
        return result;
}

/** Turn unit offline.
*/

void dv_unit_offline( dv_unit unit )
{
        if ( unit->online == 1 )
        {
                if ( unit->is_terminated == 0 )
                        dv_unit_terminate( unit );
                unit->online = 0;
                if ( unit->raw1394 != NULL )
                {
                        avc1394_vcr_stop( unit->raw1394, unit->node_id );
                        break_p2p_connection( unit->raw1394, unit->node_id, unit->channel );
                }
                if ( unit->dv1394_fd > -1 )
                {
                        close( unit->dv1394_fd );
                        device_count[ dv_unit_get_port( unit ) ] --;
                }
                dv_unit_status_communicate( unit );
                dv1394d_log( LOG_DEBUG, "Unit with GUID %08x%08x is now offline.",
                        (quadlet_t) (unit->guid>>32), (quadlet_t) (unit->guid & 0xffffffff) );
        }
}

/** Determine if unit is offline.
*/

int dv_unit_is_offline( dv_unit unit )
{
        return (unit->online == 0);
}

/** Obtain the status for a given unit
*/

int dv_unit_get_status( dv_unit unit, dv1394_status status )
{
        int error = -1;

        memset( status, 0, sizeof( dv1394_status_t ) );

        if ( unit != NULL )
        {
                dv_player player = dv_unit_get_dv_player( unit );

                error = 0;

                if ( player != NULL )
                {
                        dv_frame head = dv_pump_get_head( player->pump );
                        dv_frame tail = dv_pump_get_tail( player->pump );

                        status->speed = (int)( dv_player_get_speed( player ) * 1000.0 );
                        status->fps = dv_player_frames_per_second( player, 0 );

                        if ( head != NULL )
                        {
                                dv_frame_id id = dv_frame_get_id( head );
                                if ( id->resource != NULL )
                                {
                                        const char *resource = id->resource;
                                        if ( resource != NULL && unit->root_dir != NULL )
                                                resource += strlen( unit->root_dir ) - ( unit->root_dir[ strlen( unit->root_dir ) - 1 ] == '/' );
                                        strncpy( status->clip, resource, sizeof( status->clip ) );
                                }
                                else
                                {
                                        char *title = dv_player_get_name( player, dv_player_get_clip_containing( player, 0 ), unit->root_dir );
                                        if ( title != NULL )
                                                strncpy( status->clip, title, sizeof( status->clip ) );
                                }

                                status->position = id->relative;
                                status->in = id->in;
                                status->out = id->out;
                                status->length = id->length;
                                status->seek_flag = id->seek_flag;
                        }
                        else
                        {
                                char *title = dv_player_get_name( player, dv_player_get_clip_containing( player, 0 ), unit->root_dir );
                                if ( title != NULL )
                                        strncpy( status->clip, title, sizeof( status->clip ) );
                        }

                        if ( tail != NULL )
                        {
                                dv_frame_id id = dv_frame_get_id( tail );
                                const char *resource = id->resource;
                                if ( resource != NULL && unit->root_dir != NULL )
                                        resource += strlen( unit->root_dir ) - ( unit->root_dir[ strlen( unit->root_dir ) - 1 ] == '/' );
                                if ( resource != NULL )
                                        strncpy( status->tail_clip, resource, sizeof( status->clip ) );
                                status->tail_position = id->relative;
                                status->tail_in = id->in;
                                status->tail_out = id->out;
                                status->tail_length = id->length;
                        }
                        
                        status->generation = player->generation;
                        status->clip_index = dv_unit_get_current_clip( unit );
                }

                if ( dv_unit_is_offline( unit ) )
                        status->status = unit_offline;
                else if ( !strcmp( status->clip, "" ) )
                        status->status = unit_not_loaded;
                else if ( dv_unit_has_terminated( unit ) )
                        status->status = unit_stopped;
                else if ( status->speed == 0 )
                        status->status = unit_paused;
                else
                        status->status = unit_playing;
        }
        else
        {
                status->status = unit_undefined;
        }

        status->unit = unit->unit;

        return error;
}

/** Change position in the playlist.
*/

void dv_unit_change_position( dv_unit unit, int clip, long position )
{
        dv_player player = dv_unit_get_dv_player( unit );
        dv_player_set_clip_position( player, clip, position );
        dv_unit_status_communicate( unit );
}

/** Change speed.
*/

void dv_unit_change_speed( dv_unit unit, int speed )
{
        if ( dv_unit_has_terminated( unit ) )
                dv_unit_change_position( unit, 0, 0 );
        else
                dv_unit_play( unit, speed );
}

int     dv_unit_get_current_clip( dv_unit unit )
{
        dv_player player = dv_unit_get_dv_player( unit );
        unsigned long position = dv_player_get_position( player );
        return dv_player_get_clip_containing( player, position );
}

/** Set a clip's in point
*/

int dv_unit_set_clip_in( dv_unit unit, int index, long position )
{
        int error = 0;
        dv_player player = dv_unit_get_dv_player( unit );

        if ( player != NULL )
        {
                dv_unit_change_speed( unit, 0 );
                if ( dv_player_set_in_point( player, index, (unsigned long) position ) == position )
                        dv_player_set_clip_position( player, index, position );
                else
                        error = -2;
        }
        else
        {
                error = -1;
        }

        dv_unit_status_communicate( unit );

        return error;

}

/** Set a clip's out point.
*/

int dv_unit_set_clip_out( dv_unit unit, int index, long position )
{
        int error = 0;
        dv_player player = dv_unit_get_dv_player( unit );

        if ( player != NULL )
        {
                dv_unit_change_speed( unit, 0 );
                if ( dv_player_set_out_point( player, index, position ) == position )
                        dv_player_set_clip_position( player, index, position );
                else
                        error = -2;
        }
        else
        {
                error = -1;
        }

        dv_unit_status_communicate( unit );

        return error;
}

/** Step by specified position.
*/

void dv_unit_step( dv_unit unit, int offset )
{
        dv_player player = dv_unit_get_dv_player( unit );
        dv_player_change_position( player, dv_seek_relative, offset );
}

/** Set the unit's clip mode regarding in and out points.
*/

void dv_unit_set_mode( dv_unit unit, dv_player_clip_mode mode )
{
        dv_player player = dv_unit_get_dv_player( unit );
        if ( player != NULL )
                dv_player_set_clip_mode( player, mode );
        dv_unit_status_communicate( unit );
}

/** Get the unit's clip mode regarding in and out points.
*/

dv_player_clip_mode dv_unit_get_mode( dv_unit unit )
{
        dv_player player = dv_unit_get_dv_player( unit );
        return dv_player_get_clip_mode( player );
}

/** Set the unit's clip mode regarding eof handling.
*/

void dv_unit_set_eof_action( dv_unit unit, dv_player_eof_action action )
{
        dv_player player = dv_unit_get_dv_player( unit );
        dv_player_set_eof_action( player, action );
        dv_unit_status_communicate( unit );
}

/** Get the unit's clip mode regarding eof handling.
*/

dv_player_eof_action dv_unit_get_eof_action( dv_unit unit )
{
        dv_player player = dv_unit_get_dv_player( unit );
        return dv_player_get_eof_action( player );
}

/** Release the unit

    \todo error handling
    \param unit A dv_unit handle.
*/

void dv_unit_close( dv_unit unit )
{
        if ( unit != NULL )
        {
                dv1394d_log( LOG_DEBUG, "closing unit..." );
                dv_unit_offline( unit );
                if ( unit->pump != NULL )
                {
                        dv_pump_terminate( unit->pump );
                        dv_pump_flush( unit->pump );
                        dv_pump_return_used_output( unit->pump );
                        dv_input_join_thread( unit->in );
                        if ( !unit->is_terminated )
                                pthread_join( unit->out, NULL );
                        dv_pump_close( unit->pump );
                        unit->pump = NULL;
                }
                raw1394_close( unit->raw1394 );
                free( unit );
                dv1394d_log( LOG_DEBUG, "... unit closed." );
        }
}

/** Get the raw1394 port associated to this unit.
*/

int dv_unit_get_port( dv_unit unit )
{
        if ( unit->raw1394 != NULL )
                return (int) raw1394_get_userdata( unit->raw1394 );
        else
                return -1;
}

/** Set the dv1394 file descriptor for the unit.
*/

void dv_unit_set_dv1394_fd( dv_unit unit, int fd )
{
        unit->dv1394_fd = fd;
}

/** Get the dv1394 syt_offset (timestamp latency) property.
*/

unsigned int dv_unit_get_syt_offset( dv_unit unit )
{
        return unit->dv1394_syt_offset;
}

/** Get the dv1394 cip_n (timing numerator) property.
*/

unsigned int dv_unit_get_cip_n( dv_unit unit )
{
        return unit->dv1394_cip_n;
}

/** Get the dv1394 cip_d (timing denominator) property.
*/

unsigned int dv_unit_get_cip_d( dv_unit unit )
{
        return unit->dv1394_cip_d;
}

/** Set the dv1394 syt_offset (timestamp latency) property.

    Stops and restarts the unit if playing.
*/

void dv_unit_set_syt_offset( dv_unit unit, unsigned int syt_offset )
{
        int restart = !unit->is_terminated;
        int speed = (int)( dv_player_get_speed( dv_unit_get_dv_player(unit) ) * 1000.0 );
        
        dv_unit_terminate( unit );
        unit->dv1394_syt_offset = syt_offset;
        if ( restart )
                dv_unit_play( unit, speed );
}
        
/** Set the dv1394 cip_n (timing numerator) property.

    Stops and restarts the unit if playing.
*/

void dv_unit_set_cip_n( dv_unit unit, unsigned int cip_n )
{
        int restart = !unit->is_terminated;
        int speed = (int)( dv_player_get_speed( dv_unit_get_dv_player(unit) ) * 1000.0 );
        
        dv_unit_terminate( unit );
        unit->dv1394_cip_n = cip_n;
        if ( restart )
                dv_unit_play( unit, speed );
}

/** Set the dv1394 cip_d (timing denominator) property.

    Stops and restarts the unit if playing.
*/

void dv_unit_set_cip_d( dv_unit unit, unsigned int cip_d )
{
        int restart = !unit->is_terminated;
        int speed = (int)( dv_player_get_speed( dv_unit_get_dv_player(unit) ) * 1000.0 );
        
        dv_unit_terminate( unit );
        unit->dv1394_cip_d = cip_d;
        if ( restart )
                dv_unit_play( unit, speed );
}

/** Terminate, but only the output thread and close dv1394.
*/

void dv_unit_suspend( dv_unit unit )
{
        if ( unit->is_terminated == 0 )
        {
                unit->is_terminated = 1;
                unit->is_suspended = 1;
                dv_pump_terminate( unit->pump );
                dv_pump_flush( unit->pump );
                pthread_cancel( unit->out );
        }
        if ( unit->dv1394_fd > -1 )
        {
                close( unit->dv1394_fd );
                device_count[ dv_unit_get_port( unit ) ] --;
        }
        unit->dv1394_fd = -1;
        dv_unit_status_communicate( unit );
}


/** Restore unit on the bus, re-open dv1394, start playback if pump is running.
*/

void dv_unit_restore( dv_unit unit )
{
        int result = 0;
        int port, node_id;
        
        if ( unit->raw1394 != NULL )
                raw1394_close( unit->raw1394 );
        
        node_id = raw1394_find_node( &(unit->raw1394), unit->guid );
        if ( node_id != -1 )
        {
                unit->node_id = 0xffc0 | node_id;       
                port = dv_unit_get_port( unit );
        
                unit->dv1394_fd = open( devices[ port ][ device_count[port] ], O_RDWR );
                if ( unit->dv1394_fd < 0 )
                {
                        dv1394d_log( LOG_ERR, "failed to open dv1394 device - %s\n", devices[ port ][ device_count[port] ] );
                        dv_unit_close( unit );
                }
                else
                {
                        device_count[ port ] ++;
                        break_p2p_connection( unit->raw1394, unit->node_id, unit->channel );
                        if ( establish_p2p_connection( unit->raw1394, unit->node_id, (unsigned int *) &(unit->channel) ) )
                        {
                                avc1394_vcr_record( unit->raw1394, unit->node_id );
                                unit->online = 1;
                                result = 1;
                        }
                }
        }
        if ( unit->is_suspended == 1 )
        {
                int retval;
                dv_frame frame = dv_pump_get_available_output( unit->pump );
                struct dv1394_init setup =
                {
                        api_version: DV1394_API_VERSION,
                        channel: unit->channel,
                        /* this only sets the *requested* size of the ringbuffer,
                           in frames */ 
                        n_frames: unit->n_frames,
                        format: dv_frame_is_pal(frame) ? DV1394_PAL : DV1394_NTSC,
                        cip_n: unit->dv1394_cip_n,
                        cip_d: unit->dv1394_cip_d,
                        syt_offset: unit->dv1394_syt_offset
                };
                pthread_attr_t attr;

                dv_input_join_thread( unit->in );
                unit->is_terminated = 0;
                unit->is_suspended = 0;
                dv_pump_restart( unit->pump );
                dv_input_start_thread( unit->in );
                
                /* initialize dv1394 */
                retval = ioctl( unit->dv1394_fd, DV1394_INIT, &setup );
                if ( retval < 0 )
                        return;
                
                pthread_attr_init( &attr );
                pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
                pthread_attr_setinheritsched( &attr, PTHREAD_INHERIT_SCHED );
                /* pthread_attr_setschedpolicy( &attr, SCHED_RR ); */
                pthread_create( &unit->out, &attr, output, unit );
        }
        dv_unit_status_communicate( unit );
}