cdda.c

uclinux 下的vlc播放器源代码

            p_access->info.i_update |= INPUT_UPDATE_TITLE | INPUT_UPDATE_SIZE |
                                       INPUT_UPDATE_META;
            p_access->info.i_title++;
            p_access->info.i_size =
                        p_sys->title[p_access->info.i_title]->i_size;
            p_access->info.i_pos = 0;
        }
        /* Don't read too far */
        if( p_sys->i_sector + i_blocks >=                                                       p_sys->p_sectors[p_access->info.i_title + 1] )
        {
            i_blocks = p_sys->p_sectors[ p_access->info.i_title + 1] -
                         p_sys->i_sector;
        }
    }

    /* Do the actual reading */
    if( !( p_block = block_New( p_access, i_blocks * CDDA_DATA_SIZE ) ) )
    {
        msg_Err( p_access, "cannot get a new block of size: %i",
                 i_blocks * CDDA_DATA_SIZE );
        return NULL;
    }

    if( ioctl_ReadSectors( VLC_OBJECT(p_access), p_sys->vcddev,
            p_sys->i_sector, p_block->p_buffer, i_blocks, CDDA_TYPE ) < 0 )
    {
        msg_Err( p_access, "cannot read sector %i", p_sys->i_sector );
        block_Release( p_block );

        /* Try to skip one sector (in case of bad sectors) */
        p_sys->i_sector++;
        p_access->info.i_pos += CDDA_DATA_SIZE;
        return NULL;
    }

    /* Update a few values */
    p_sys->i_sector += i_blocks;
    p_access->info.i_pos += p_block->i_buffer;

    return p_block;
}

/****************************************************************************
 * Seek
 ****************************************************************************/
static int Seek( access_t *p_access, int64_t i_pos )
{
    access_sys_t *p_sys = p_access->p_sys;

    /* Next sector to read */
    p_sys->i_sector = p_sys->p_sectors[
                                        (p_sys->b_single_track ?
                                         p_sys->i_track :
                                         p_access->info.i_title + 1)
                                      ] +
                                i_pos / CDDA_DATA_SIZE;
    p_access->info.i_pos = i_pos;

    return VLC_SUCCESS;
}

/*****************************************************************************
 * Control:
 *****************************************************************************/
static int Control( access_t *p_access, int i_query, va_list args )
{
    access_sys_t *p_sys = p_access->p_sys;
    vlc_bool_t   *pb_bool;
    int          *pi_int;
    int64_t      *pi_64;
    input_title_t ***ppp_title;
    int i;
    char         *psz_title;
    vlc_meta_t  **pp_meta;

    switch( i_query )
    {
        /* */
        case ACCESS_CAN_SEEK:
        case ACCESS_CAN_FASTSEEK:
        case ACCESS_CAN_PAUSE:
        case ACCESS_CAN_CONTROL_PACE:
            pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
            *pb_bool = VLC_TRUE;
            break;

        /* */
        case ACCESS_GET_MTU:
            pi_int = (int*)va_arg( args, int * );
            *pi_int = CDDA_DATA_ONCE;
            break;

        case ACCESS_GET_PTS_DELAY:
            pi_64 = (int64_t*)va_arg( args, int64_t * );
            *pi_64 = var_GetInteger( p_access, "cdda-caching" ) * 1000;
            break;

        /* */
        case ACCESS_SET_PAUSE_STATE:
            break;

        case ACCESS_GET_TITLE_INFO:
            if( p_sys->b_single_track )
                return VLC_EGENERIC;
            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 */

            /* Duplicate title infos */
            *pi_int = p_sys->i_titles;
            *ppp_title = malloc(sizeof( input_title_t **) * p_sys->i_titles );
            for( i = 0; i < p_sys->i_titles; i++ )
            {
                (*ppp_title)[i] = vlc_input_title_Duplicate( p_sys->title[i] );
            }
            break;

        case ACCESS_SET_TITLE:
            if( p_sys->b_single_track ) return VLC_EGENERIC;
            i = (int)va_arg( args, int );
            if( i != p_access->info.i_title )
            {
                /* Update info */
                p_access->info.i_update |=
                    INPUT_UPDATE_TITLE|INPUT_UPDATE_SIZE|INPUT_UPDATE_META;
                p_access->info.i_title = i;
                p_access->info.i_size = p_sys->title[i]->i_size;
                p_access->info.i_pos = 0;

                /* Next sector to read */
                p_sys->i_sector = p_sys->p_sectors[i];
            }
            break;

        case ACCESS_GET_META:
             if( p_sys->b_single_track ) return VLC_EGENERIC;
             psz_title = malloc( strlen( _("Audio CD - Track ") ) + 5 );
             snprintf( psz_title, 100, _("Audio CD - Track %i" ),
                                        p_access->info.i_title+1 );
             pp_meta = (vlc_meta_t**)va_arg( args, vlc_meta_t** );
             *pp_meta = vlc_meta_New();
             vlc_meta_Add( *pp_meta, _(VLC_META_TITLE), psz_title );
             free( psz_title );
             break;

        case ACCESS_SET_SEEKPOINT:
        case ACCESS_SET_PRIVATE_ID_STATE:
            return VLC_EGENERIC;

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

    }
    return VLC_SUCCESS;
}

static int GetTracks( access_t *p_access, vlc_bool_t b_separate,
                      playlist_t *p_playlist, playlist_item_t *p_parent )
{
    access_sys_t *p_sys = p_access->p_sys;
    int i;
    playlist_item_t *p_item;
    char *psz_name;
    p_sys->i_titles = ioctl_GetTracksMap( VLC_OBJECT(p_access),
                                          p_sys->vcddev, &p_sys->p_sectors );
    if( p_sys->i_titles < 0 )
    {
        msg_Err( p_access, "unable to count tracks" );
        return VLC_EGENERIC;;
    }
    else if( p_sys->i_titles <= 0 )
    {
        msg_Err( p_access, "no audio tracks found" );
        return VLC_EGENERIC;
    }

    if( b_separate )
    {
        if( p_parent->i_children == -1 )
        {
            playlist_LockItemToNode( p_playlist, p_parent );
        }
        psz_name = strdup( "Audio CD" );
        vlc_mutex_lock( &p_playlist->object_lock );
        playlist_ItemSetName( p_parent, psz_name );
        vlc_mutex_unlock( &p_playlist->object_lock );
        var_SetInteger( p_playlist, "item-change",
                        p_parent->input.i_id );
        free( psz_name );

#ifdef HAVE_LIBCDDB
        GetCDDBInfo( p_access, p_sys->i_titles, p_sys->p_sectors );
        if( p_sys->p_disc )
        {
            if( cddb_disc_get_title( p_sys->p_disc ) )
            {
                asprintf( &psz_name, "%s", cddb_disc_get_title( p_sys->p_disc )
                         );
                vlc_mutex_lock( &p_playlist->object_lock );
                playlist_ItemSetName( p_parent, psz_name );
                vlc_mutex_unlock( &p_playlist->object_lock );
                var_SetInteger( p_playlist, "item-change",
                                p_parent->input.i_id );
                free( psz_name );
            }
        }
#endif
    }

    /* Build title table */
    for( i = 0; i < p_sys->i_titles; i++ )
    {
        msg_Dbg( p_access, "track[%d] start=%d", i, p_sys->p_sectors[i] );
        if( !b_separate )
        {
            input_title_t *t = p_sys->title[i] = vlc_input_title_New();

            asprintf( &t->psz_name, _("Track %i"), i + 1 );
            t->i_size = ( p_sys->p_sectors[i+1] - p_sys->p_sectors[i] ) *
                        (int64_t)CDDA_DATA_SIZE;

            t->i_length = I64C(1000000) * t->i_size / 44100 / 4;
        }
        else
        {
            char *psz_uri;
            int i_path_len = p_access->psz_path ? strlen( p_access->psz_path )
                                                : 0;
            char *psz_opt;

            psz_name = malloc( strlen( _("Audio CD - Track ") ) + 5 );
            psz_opt = malloc( strlen( "cdda-track=" ) + 3 );

            psz_uri = (char*)malloc( i_path_len + 13 );
            snprintf( psz_uri, i_path_len + 13, "cdda://%s",
                                p_access->psz_path ? p_access->psz_path : "" );
            sprintf( psz_opt, "cdda-track=%i", i+1 );

            /* Define a "default name" */
            sprintf( psz_name, _("Audio CD - Track %i"), (i+1) );

            /* Create playlist items */
            p_item = playlist_ItemNewWithType( VLC_OBJECT( p_playlist ),
                                 psz_uri, psz_name, ITEM_TYPE_DISC );
            playlist_ItemAddOption( p_item, psz_opt );
#ifdef HAVE_LIBCDDB
            /* If we have CDDB info, change the name */
            if( p_sys->p_disc )
            {
                char *psz_result;
                cddb_track_t *t = cddb_disc_get_track( p_sys->p_disc, i );
                if( t!= NULL )
                {
                    if( cddb_track_get_title( t )  != NULL )
                    {
                        vlc_input_item_AddInfo( &p_item->input,
                                            _(VLC_META_INFO_CAT),
                                            _(VLC_META_TITLE),
                                            cddb_track_get_title( t ) );
                        if( p_item->input.psz_name )
                            free( p_item->input.psz_name );
                        asprintf( &p_item->input.psz_name, "%s",
                                  cddb_track_get_title( t ) );
                    }
                    psz_result = cddb_track_get_artist( t );
                    if( psz_result )
                    {
                        vlc_input_item_AddInfo( &p_item->input,
                                            _(VLC_META_INFO_CAT),
                                            _(VLC_META_ARTIST), psz_result );
                    }
                }
            }
#endif
            playlist_NodeAddItem( p_playlist, p_item,
                                  p_parent->pp_parents[0]->i_view,
                                  p_parent, PLAYLIST_APPEND, PLAYLIST_END );
            free( psz_uri ); free( psz_opt ); free( psz_name );
        }
    }

    p_sys->i_sector = p_sys->p_sectors[0];
    if( p_sys->b_separate_items )
    {
        p_sys->i_titles = 0;
    }

   return VLC_SUCCESS;
}

#ifdef HAVE_LIBCDDB
static void GetCDDBInfo( access_t *p_access, int i_titles, int *p_sectors )
{
    int i, i_matches;
    int64_t  i_length = 0, i_size = 0;
    cddb_conn_t  *p_cddb = cddb_new();

//    cddb_log_set_handler( CDDBLogHandler );

    if( !p_cddb )
    {
        msg_Warn( p_access, "unable to use CDDB" );
        goto cddb_destroy;
    }

    cddb_set_email_address( p_cddb, "[e-mail]" );
    cddb_set_server_name( p_cddb, config_GetPsz( p_access, "cddb-server" ) );
    cddb_set_server_port( p_cddb, config_GetInt( p_access, "cddb-port" ) );

    /// \todo
    cddb_cache_disable( p_cddb );

//    cddb_cache_set_dir( p_cddb,
//                     config_GetPsz( p_access,
//                                    MODULE_STRING "-cddb-cachedir") );

    cddb_set_timeout( p_cddb, 10 );

    /// \todo
    cddb_http_disable( p_cddb);

    p_access->p_sys->p_disc = cddb_disc_new();

    if(! p_access->p_sys->p_disc )
    {
        msg_Err( p_access, "unable to create CDDB disc structure." );
        goto cddb_end;
    }

    for(i = 0; i < i_titles ; i++ )
    {
        cddb_track_t *t = cddb_track_new();
        cddb_track_set_frame_offset(t, p_sectors[i] );
        cddb_disc_add_track( p_access->p_sys->p_disc, t );
        i_size = ( p_sectors[i+1] - p_sectors[i] ) *
                   (int64_t)CDDA_DATA_SIZE;
        i_length += I64C(1000000) * i_size / 44100 / 4  ;
    }

    cddb_disc_set_length( p_access->p_sys->p_disc, (int)(i_length/1000000) );

    if (!cddb_disc_calc_discid(p_access->p_sys->p_disc ))
    {
        msg_Err( p_access, "CDDB disc ID calculation failed" );
        goto cddb_destroy;
    }

    i_matches = cddb_query( p_cddb, p_access->p_sys->p_disc);

    if (i_matches > 0)
    {
        if (i_matches > 1)
             msg_Warn( p_access, "found %d matches in CDDB. Using first one.",
                                 i_matches);
        cddb_read( p_cddb, p_access->p_sys->p_disc );

//        cddb_disc_print( p_access->p_sys->p_disc );
    }
    else
    {
        msg_Warn( p_access, "CDDB error: %s", cddb_error_str(errno));
    }

cddb_destroy:
    cddb_destroy( p_cddb);

cddb_end: ;
}
#endif /*HAVE_LIBCDDB*/