access.c

video linux conference

    if ( VLC_SUCCESS != i_rc ) goto error;

    cdda_play_track( p_access, i_track );

    CDDAFixupPlaylist( p_access, p_cdda, b_single_track );

#if LIBCDIO_VERSION_NUM >= 72
    {
   
      char *psz_paranoia = config_GetPsz( p_access, 
					  MODULE_STRING "-paranoia" );
      p_cdda->e_paranoia = paranoia_none;
      if( psz_paranoia && *psz_paranoia )
      {

	if( !strncmp( psz_paranoia, "full", strlen("full") )  )
	  p_cdda->e_paranoia = paranoia_full;
	else if( !strncmp( psz_paranoia, "overlap", strlen("overlap") )  )
	  p_cdda->e_paranoia = paranoia_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_none;
	  } 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_full == p_cdda->e_paranoia ?
				  PARANOIA_MODE_FULL^PARANOIA_MODE_NEVERSKIP :
				  PARANOIA_MODE_OVERLAP^PARANOIA_MODE_NEVERSKIP
				  );
	  }
	}
      }
    }
#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 );
    return VLC_SUCCESS;

 error:
    cdio_destroy( p_cdda->p_cdio );
    if( psz_source) 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

    if (p_cdda->psz_mcn)    free( p_cdda->psz_mcn );
    if (p_cdda->psz_source) 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:
        {
            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 {
	        msg_Warn( p_access, "tried to copy NULL meta info" );
		return VLC_EGENERIC;
	    }
        }

        case ACCESS_CAN_CONTROL_PACE:
	  {
            vlc_bool_t *pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
            *pb_bool = p_cdda->b_audio_ctl ? VLC_FALSE : VLC_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:
        {
            vlc_bool_t *pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
            *pb_bool = VLC_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:
 */