access.c

vlc源码

        p_cdda->e_paranoia = PARANOIA_MODE_DISABLE;
        if( psz_paranoia && *psz_paranoia )
        {
            if( !strncmp( psz_paranoia, "full", strlen("full") ) )
                p_cdda->e_paranoia = PARANOIA_MODE_FULL;
            else if( !strncmp(psz_paranoia, "overlap", strlen("overlap")) )
                p_cdda->e_paranoia = PARANOIA_MODE_OVERLAP;

            /* Use CD Paranoia? */
            if( p_cdda->e_paranoia )
            {
                p_cdda->paranoia_cd =
                            cdio_cddap_identify_cdio( p_cdio, 1, NULL );
                /* We'll set for verbose paranoia messages. */
                cdio_cddap_verbose_set( p_cdda->paranoia_cd,
                                        CDDA_MESSAGE_PRINTIT,
                                        CDDA_MESSAGE_PRINTIT );
                if ( 0 != cdio_cddap_open(p_cdda->paranoia_cd) )
                {
                    msg_Warn( p_cdda_input, "unable to get paranoia support - "
                                "continuing without it." );
                    p_cdda->e_paranoia = PARANOIA_MODE_DISABLE;
                }
                else
                {
                    p_cdda->paranoia = cdio_paranoia_init(p_cdda->paranoia_cd);
                    cdio_paranoia_seek( p_cdda->paranoia, p_cdda->i_lsn,
                                        SEEK_SET);

                    /* Set reading mode for full or overlap paranoia,
                     * but allow skipping sectors. */
                    cdio_paranoia_modeset( p_cdda->paranoia,
                            PARANOIA_MODE_FULL == p_cdda->e_paranoia ?
                            PARANOIA_MODE_FULL^PARANOIA_MODE_NEVERSKIP :
                            PARANOIA_MODE_OVERLAP^PARANOIA_MODE_NEVERSKIP );
                }
            }
        }
        free( psz_paranoia );
    }
#endif

    /* Build a WAV header to put in front of the output data.
       This gets sent back in the Block (read) routine.
     */
    memset( &p_cdda->waveheader, 0, sizeof(WAVEHEADER) );

    SetWLE( &p_cdda->waveheader.Format, 1 ); /*WAVE_FORMAT_PCM*/
    SetWLE( &p_cdda->waveheader.BitsPerSample, 16);

    p_cdda->waveheader.MainChunkID = VLC_FOURCC('R', 'I', 'F', 'F');
    p_cdda->waveheader.Length = 0;                     /* we just don't know */
    p_cdda->waveheader.ChunkTypeID = VLC_FOURCC('W', 'A', 'V', 'E');
    p_cdda->waveheader.SubChunkID  = VLC_FOURCC('f', 'm', 't', ' ');

    SetDWLE( &p_cdda->waveheader.SubChunkLength, 16);
    SetWLE( &p_cdda->waveheader.Modus, 2);
    SetDWLE( &p_cdda->waveheader.SampleFreq, CDDA_FREQUENCY_SAMPLE);
    SetWLE( &p_cdda->waveheader.BytesPerSample,
            2 /*Modus*/ * 16 /*BitsPerSample*/ / 8 );
    SetDWLE( &p_cdda->waveheader.BytesPerSec,
             2*16/8 /*BytesPerSample*/ * CDDA_FREQUENCY_SAMPLE );

    p_cdda->waveheader.DataChunkID = VLC_FOURCC('d', 'a', 't', 'a');
    p_cdda->waveheader.DataLength  = 0;    /* we just don't know */

    /* PTS delay */
    var_Create( p_access, MODULE_STRING "-caching",
                VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
    vlc_object_release( p_cdda->p_input );
    free( psz_source );
    return VLC_SUCCESS;

 error:
    cdio_destroy( p_cdda->p_cdio );
    free( psz_source );
    if( p_cdda )
    {
        if ( p_cdda->p_input )
            vlc_object_release( p_cdda->p_input );
        free(p_cdda);
    }
    return i_rc;
}

/*****************************************************************************
 * CDDAClose: closes cdda and frees any resources associded with it.
 *****************************************************************************/
void CDDAClose (vlc_object_t *p_this )
{
    access_t    *p_access = (access_t *) p_this;
    cdda_data_t *p_cdda   = (cdda_data_t *) p_access->p_sys;
    track_t      i;

#if LIBCDIO_VERSION_NUM >= 73
    if( p_cdda->b_audio_ctl )
        cdio_audio_stop(p_cdda->p_cdio);
#endif

    dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "" );

    /* Remove playlist titles */
    for( i = 0; i < p_cdda->i_titles; i++ )
    {
        vlc_input_title_Delete( p_cdda->p_title[i] );
    }

#ifdef HAVE_LIBCDDB
    cddb_log_set_handler( (cddb_log_handler_t) uninit_log_handler );
    if( p_cdda->b_cddb_enabled )
        cddb_disc_destroy( p_cdda->cddb.disc );
#endif

    cdio_destroy( p_cdda->p_cdio );
    cdio_log_set_handler( uninit_log_handler );

#if LIBCDIO_VERSION_NUM >= 72
    if( p_cdda->paranoia )
        cdio_paranoia_free(p_cdda->paranoia);
    if( p_cdda->paranoia_cd )
        cdio_cddap_close_no_free_cdio( p_cdda->paranoia_cd );
#endif

    free( p_cdda->psz_mcn );
    free( p_cdda->psz_source );

#if LIBCDDB_VERSION_NUM >= 1
    libcddb_shutdown();
#endif
    free( p_cdda );
    p_cdda = NULL;
    p_cdda_input = NULL;
}

/*****************************************************************************
 * Control: The front-end or vlc engine calls here to ether get
 * information such as meta information or plugin capabilities or to
 * issue miscellaneous "set" requests.
 *****************************************************************************/
static int CDDAControl( access_t *p_access, int i_query, va_list args )
{
    cdda_data_t  *p_cdda = (cdda_data_t *) p_access->p_sys;
    int          *pi_int;
    int i;

    dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT|INPUT_DBG_EVENT),
               "query %d", i_query );

    switch( i_query )
    {
        /* Pass back a copy of meta information that was gathered when we
           during the Open/Initialize call.
         */
        case ACCESS_GET_META:
        {
#if 0
            vlc_meta_t **pp_meta = (vlc_meta_t**)va_arg( args, vlc_meta_t** );
            if( p_cdda->p_meta )
            {
                *pp_meta = vlc_meta_Duplicate( p_cdda->p_meta );
                dbg_print( INPUT_DBG_META, "%s", "Meta copied" );
                return VLC_SUCCESS;
            }
            else
#endif
            {
                msg_Warn( p_access, "tried to copy NULL meta info" );
                return VLC_EGENERIC;
            }
        }

        case ACCESS_CAN_CONTROL_PACE:
        {
            bool *pb_bool = (bool*)va_arg( args, bool* );
            *pb_bool = p_cdda->b_audio_ctl ? false : true;
            dbg_print( INPUT_DBG_META, "can control pace? %d", *pb_bool);
            return VLC_SUCCESS;
        }

        case ACCESS_CAN_FASTSEEK:
            dbg_print( INPUT_DBG_META, "can fast seek?");
            goto common;
        case ACCESS_CAN_SEEK:
            dbg_print( INPUT_DBG_META, "can seek?");
            goto common;
        case ACCESS_CAN_PAUSE:
            dbg_print( INPUT_DBG_META, "can pause?");
 common:
            {
                bool *pb_bool = (bool*)va_arg( args, bool* );
                *pb_bool = true;
                return VLC_SUCCESS;
            }

        /* */
        case ACCESS_GET_MTU:
        {
            pi_int = (int*)va_arg( args, int * );
            *pi_int = p_cdda-> i_blocks_per_read * CDIO_CD_FRAMESIZE_RAW;
            dbg_print( INPUT_DBG_META, "Get MTU %d", *pi_int);
            break;
        }

        case ACCESS_GET_PTS_DELAY:
        {
            int64_t *pi_64 = (int64_t*)va_arg( args, int64_t * );
            *pi_64 = var_GetInteger( p_access, MODULE_STRING "-caching" )
              * MILLISECONDS_PER_SEC;
            break;
        }

        case ACCESS_GET_TITLE_INFO:
        {
            input_title_t ***ppp_title =
             (input_title_t***)va_arg( args, input_title_t*** );

            pi_int    = (int*)va_arg( args, int* );
            *((int*)va_arg( args, int* )) = 1; /* Title offset */

            dbg_print ( INPUT_DBG_EVENT,
                        "GET TITLE: i_tracks %d, i_tracks %d",
                        p_cdda->i_tracks, p_cdda->i_tracks );

            CDDAMetaInfo( p_access, CDIO_INVALID_TRACK );

            if( p_cdda->b_nav_mode)
            {
                char *psz_title = CDDAFormatTitle( p_access, p_cdda->i_track );
                input_Control( p_cdda->p_input, INPUT_SET_NAME, psz_title );
                free(psz_title);
            }

            /* Duplicate title info */
            if( p_cdda->i_titles == 0 )
            {
                *pi_int = 0; ppp_title = NULL;
                return VLC_SUCCESS;
            }
            *pi_int = p_cdda->i_titles;
            *ppp_title = calloc(1, sizeof( input_title_t **)
                                           * p_cdda->i_titles );

            if (!*ppp_title)
                return VLC_ENOMEM;

            for( i = 0; i < p_cdda->i_titles; i++ )
            {
                if ( p_cdda->p_title[i] )
                {
                    (*ppp_title)[i] =
                        vlc_input_title_Duplicate( p_cdda->p_title[i] );
                }
            }
            break;
        }

        case ACCESS_SET_TITLE:
        {
            i = (int)va_arg( args, int );

            dbg_print( INPUT_DBG_EVENT, "set title %d", i );
            if( i != p_access->info.i_title )
            {
                const track_t i_track = p_cdda->i_first_track + i;
                /* Update info */
                p_access->info.i_title = i;
                if( p_cdda->b_nav_mode)
                {
                    lsn_t i_last_lsn;
                    char *psz_title = CDDAFormatTitle( p_access, i_track );
                    input_Control( p_cdda->p_input, INPUT_SET_NAME,
                                   psz_title );
                    free( psz_title );
                    p_cdda->i_track = i_track;
                    i_last_lsn = cdio_get_track_lsn( p_cdda->p_cdio,
                                                CDIO_CDROM_LEADOUT_TRACK );
                    if( CDIO_INVALID_LSN != i_last_lsn )
                        p_access->info.i_size = (int64_t) CDIO_CD_FRAMESIZE_RAW
                                                            * i_last_lsn ;
                    p_access->info.i_pos = (int64_t)
                                    cdio_get_track_lsn( p_cdda->p_cdio, i_track )
                                                        * CDIO_CD_FRAMESIZE_RAW;
                }
                else
                {
                    p_access->info.i_size = p_cdda->p_title[i]->i_size;
                    p_access->info.i_pos  = 0;
                }
                p_access->info.i_update = INPUT_UPDATE_TITLE|INPUT_UPDATE_SIZE;

                /* Next sector to read */
                p_cdda->i_lsn = cdio_get_track_lsn( p_cdda->p_cdio, i_track );
            }
            break;
        }

        case ACCESS_SET_PAUSE_STATE:
            dbg_print( INPUT_DBG_META, "Pause");
            if( p_cdda->b_audio_ctl )
                cdda_audio_pause( p_cdda->p_cdio );
            break;

        case ACCESS_SET_SEEKPOINT:
            dbg_print( INPUT_DBG_META, "set seekpoint");
            return VLC_EGENERIC;

        case ACCESS_SET_PRIVATE_ID_STATE:
            dbg_print( INPUT_DBG_META, "set private id state");
            return VLC_EGENERIC;

        default:
            msg_Warn( p_access, "unimplemented query in control" );
            return VLC_EGENERIC;

    }
    return VLC_SUCCESS;
}

/*****************************************************************************
  CDDAInit:

 Initialize information pertaining to the CD: the number of tracks,
 first track number, LSNs for each track and the leadout. The leadout
 information is stored after the last track. The LSN array is
 0-origin, same as p_access->info.  Add first_track to get what track
 number this is on the CD. Note: libcdio uses the real track number.

 On input we assume p_cdda->p_cdio and p_cdda->i_track have been set.

 We return the VLC-type status, e.g. VLC_SUCCESS, VLC_ENOMEM, etc.
 *****************************************************************************/
static int CDDAInit( access_t *p_access, cdda_data_t *p_cdda )
{
    discmode_t  discmode = CDIO_DISC_MODE_NO_INFO;

    p_cdda->i_tracks       = cdio_get_num_tracks( p_cdda->p_cdio );
    p_cdda->i_first_track  = cdio_get_first_track_num( p_cdda->p_cdio );

    discmode = cdio_get_discmode( p_cdda->p_cdio );
    switch( discmode )
    {
        case CDIO_DISC_MODE_CD_DA:
        case CDIO_DISC_MODE_CD_MIXED:
            /* These are possible for CD-DA */
            break;
        default:
            /* These are not possible for CD-DA */
            msg_Err( p_access,
                "Disc seems not to be CD-DA. libcdio reports it is %s",
                discmode2str[discmode]
                );
            return VLC_EGENERIC;
    }

    /* Set reading start LSN. */
    p_cdda->i_lsn = cdio_get_track_lsn(p_cdda->p_cdio, p_cdda->i_track);

    return VLC_SUCCESS;
}

/*
 * Local variables:
 *  mode: C
 *  style: gnu
 * End:
 */