info.c

vlc源码

                    }
                    goto format_str;
                break;
#else
            case 'a':
                if (p_cdda->p_cdtext[0]
                && p_cdda->p_cdtext[0]->field[CDTEXT_PERFORMER])
                psz = p_cdda->p_cdtext[0]->field[CDTEXT_PERFORMER];
                    goto format_str;
            case 'A':
                if (p_cdda->p_cdtext[0]
                    && p_cdda->p_cdtext[0]->field[CDTEXT_TITLE])
                psz = p_cdda->p_cdtext[0]->field[CDTEXT_TITLE];
                goto format_str;
            case 'G':
                if (p_cdda->p_cdtext[0]
                && p_cdda->p_cdtext[0]->field[CDTEXT_GENRE])
                    psz = p_cdda->p_cdtext[0]->field[CDTEXT_GENRE];
                goto format_str;
            case 'I':
                if (p_cdda->p_cdtext[0]
                    && p_cdda->p_cdtext[0]->field[CDTEXT_DISCID])
                    add_format_str_info(p_cdda->p_cdtext[0]->field[CDTEXT_DISCID]);
                break;
            case 'p':
                if ( CDIO_INVALID_TRACK == i_track ) break;
                if (p_cdda->p_cdtext[i_track]
                    && p_cdda->p_cdtext[i_track]->field[CDTEXT_PERFORMER])
                psz = p_cdda->p_cdtext[i_track]->field[CDTEXT_PERFORMER];
                goto format_str;
            case 't':
                if ( CDIO_INVALID_TRACK == i_track ) break;
                if (p_cdda->p_cdtext[i_track]
                    && p_cdda->p_cdtext[i_track]->field[CDTEXT_TITLE])
                    psz = p_cdda->p_cdtext[i_track]->field[CDTEXT_TITLE];
                else
                    psz = psz_mrl;
                goto format_str;
            case 'e':
                if ( CDIO_INVALID_TRACK == i_track ) break;
                if (p_cdda->p_cdtext[i_track]
                    && p_cdda->p_cdtext[i_track]->field[CDTEXT_MESSAGE])
                psz = p_cdda->p_cdtext[i_track]->field[CDTEXT_MESSAGE];
                goto format_str;
                break;
#endif /*HAVE_LIBCDDB*/

            case 's':
                if ( CDIO_INVALID_TRACK != i_track )
                {
                    char psz_buffer[MSTRTIME_MAX_SIZE];
                    unsigned int i_track_frames =
                    cdio_get_track_sec_count(p_cdda->p_cdio, i_track);
                    mtime_t i_duration =
                        i_track_frames / CDIO_CD_FRAMES_PER_SEC;
                    add_format_str_info( secstotimestr( psz_buffer,
                            i_duration ) );
                    break;
                }

            /* Fall through to disc duration if CDIO_INVALID_TRACK  */
            case 'S':
                {
                    char psz_buffer[MSTRTIME_MAX_SIZE];
                    unsigned int i_track_frames =
                    cdio_get_track_lba(p_cdda->p_cdio,
                        CDIO_CDROM_LEADOUT_TRACK);
                    mtime_t i_duration =
                    i_track_frames / CDIO_CD_FRAMES_PER_SEC;
                    add_format_str_info( secstotimestr( psz_buffer,
                            i_duration ) );
                    break;
                }

            case 'M':
                add_format_str_info(psz_mrl);
                break;

            case 'm':
                add_format_str_info(p_cdda->psz_mcn);
                break;

            case 'n':
                add_format_num_info(p_cdda->i_tracks, "%d");
                break;

            case 'T':
                add_format_num_info(i_track, "%02d");
                break;
            format_str:
                if (psz)
                    add_format_str_info(psz);
                break;
#ifdef HAVE_LIBCDDB
            not_special:
#endif
            default:
                *tp++ = '%';
                *tp++ = format_str[i];
                saw_control_prefix = false;
        }
    }
    return strdup(temp_str);
}

/* Return a MRL for the given track. The caller must free the
   allocated string. */
static char *
CDDAFormatMRL( const access_t *p_access, track_t i_track )
{
    cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys;
    const unsigned int psz_mrl_max = strlen(CDDA_MRL_PREFIX)
      + strlen(p_cdda->psz_source) +
      + strlen("@T") + strlen("100") + 1;
    char *psz_mrl = calloc( 1, psz_mrl_max );

    if (CDIO_INVALID_TRACK == i_track)
      snprintf(psz_mrl, psz_mrl_max, "%s%s",
           CDDA_MRL_PREFIX, p_cdda->psz_source);
    else
      snprintf(psz_mrl, psz_mrl_max, "%s%s@T%u",
           CDDA_MRL_PREFIX, p_cdda->psz_source, i_track);
    return psz_mrl;
}


/* Return a title string as specified by the titel format string for the
   given track. The caller must free the allocated string. */
char *
CDDAFormatTitle( const access_t *p_access, track_t i_track )
{

    const char *config_varname = MODULE_STRING "-title-format";
    cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys;
    char *psz_mrl = CDDAFormatMRL( p_access, i_track );

    if( psz_mrl )
    {
        char *psz_name;
#ifdef HAVE_LIBCDDB
        if (p_cdda->b_cddb_enabled)
        {
            config_varname = MODULE_STRING "-cddb-title-format";
        }
#endif /*HAVE_LIBCDDB*/
        char* psz_config_varname = config_GetPsz( p_access, config_varname );
        psz_name = CDDAFormatStr( p_access, p_cdda, psz_config_varname,
                                  psz_mrl, i_track );
        free( psz_config_varname );
        free( psz_mrl );
        return psz_name;
    }
    return NULL;
}

static playlist_item_t *
CDDACreatePlaylistItem( const access_t *p_access, cdda_data_t *p_cdda,
                        playlist_t *p_playlist, playlist_item_t *p_item,
                        track_t i_track )
{
    unsigned int i_track_frames =
    cdio_get_track_lsn(p_cdda->p_cdio, i_track+1) -
    cdio_get_track_lsn(p_cdda->p_cdio, i_track);
    mtime_t i_mduration = i_track_frames * (CLOCK_FREQ / CDIO_CD_FRAMES_PER_SEC) ;
    char *psz_title = NULL;
    char *psz_mrl   = NULL;

    playlist_item_t *p_child = NULL;

    if( !p_item ) return NULL;

    psz_title = CDDAFormatTitle( p_access, i_track ) ;
    psz_mrl = CDDAFormatMRL( p_access, i_track  ) ;

    dbg_print( INPUT_DBG_META, "mrl: %s, title: %s, duration, %ld",
               psz_mrl, psz_title, (long int) i_mduration / 1000000 );

    p_child = playlist_ItemNew( p_playlist, psz_mrl, psz_title );
    input_item_SetDuration( p_child->p_input,
            (mtime_t) i_mduration );
    free(psz_mrl);
    free(psz_title);

    if( !p_child ) return NULL;
    return p_child;
}

/*
   Fixes up playlist.
*/
int
CDDAFixupPlaylist( access_t *p_access, cdda_data_t *p_cdda,
                   bool b_single_track )
{
    int i;
    playlist_t * p_playlist = NULL;
    const track_t i_first_track = p_cdda->i_first_track;
    playlist_item_t *p_item = NULL;
    bool b_play = false;
    track_t    i_track;

#ifdef HAVE_LIBCDDB
    p_cdda->b_cddb_enabled =
        config_GetInt( p_access, MODULE_STRING "-cddb-enabled" );
    if( b_single_track && !p_cdda->b_cddb_enabled )
        return VLC_SUCCESS;
#else
    if( b_single_track )
        return VLC_SUCCESS;
#endif

    if (! p_cdda->b_nav_mode ) {
        p_playlist = pl_Yield( p_access );
    }

    if( b_single_track || p_cdda->b_nav_mode ) {
        i_track = p_cdda->i_track;
    }
    else
    {
        i_track = CDIO_INVALID_TRACK;
    }
    CDDAMetaInfoInit( p_access );
    CDDAMetaInfo( p_access, p_cdda->i_track );

    if( p_playlist )
    {
        input_thread_t *p_input = (input_thread_t*)vlc_object_find( p_access, VLC_OBJECT_INPUT, FIND_PARENT );
        if( p_input )
        {
            p_item = playlist_ItemGetByInput( p_playlist, input_GetItem(p_input), pl_Unlocked );

            if( p_item == p_playlist->status.p_item && !b_single_track )
                b_play = true;
            else
                b_play = false;
            vlc_object_release( p_input );
        }
    }

    if( b_single_track && !p_cdda->b_nav_mode )
    {
        /*May fill out more information when the playlist user interface becomes
           more mature.
         */
        track_t i_track = p_cdda->i_track;
        unsigned int i_track_frames =
        cdio_get_track_sec_count(p_cdda->p_cdio, i_track);

        input_title_t *t = p_cdda->p_title[0] = //i_track-i_first_track] =
        vlc_input_title_New();

        if( asprintf( &t->psz_name, _("Track %i"), i_track ) == -1 )
            t->psz_name = NULL;
        t->i_size = i_track_frames * (int64_t) CDIO_CD_FRAMESIZE_RAW;
        t->i_length = INT64_C(1000000) * t->i_size / CDDA_FREQUENCY_SAMPLE / 4;

        if( p_item )
        {
            input_item_SetDuration( p_item->p_input, (mtime_t) i_track_frames
            * (CLOCK_FREQ / CDIO_CD_FRAMES_PER_SEC) );
                input_item_SetURI( p_item->p_input,
                        CDDAFormatMRL( p_access, i_track ) );
        }

        p_cdda->i_titles = 1;
        p_access->info.i_update = INPUT_UPDATE_TITLE;
    }
    else
    {
        input_title_t *t;

        if( !p_cdda->b_nav_mode )
            playlist_ItemToNode( p_playlist, p_item, pl_Unlocked );

        for( i = 0 ; i < p_cdda->i_tracks ; i++ )
        {
            playlist_item_t *p_child;
            const track_t i_track = i_first_track + i;
            unsigned int i_track_frames =
                cdio_get_track_sec_count(p_cdda->p_cdio, i_track);

            t = p_cdda->p_title[i] = vlc_input_title_New();

            if( asprintf( &t->psz_name, _("Track %i"), i_track ) == -1 )
                t->psz_name = NULL;
            t->i_size = i_track_frames * (int64_t) CDIO_CD_FRAMESIZE_RAW;

            t->i_length = INT64_C(1000000) * t->i_size
                / CDDA_FREQUENCY_SAMPLE / 4;

            if ( ! p_cdda->b_nav_mode )
            {
                p_child = CDDACreatePlaylistItem( p_access, p_cdda, p_playlist,
                                                  p_item, i_track );
            }
        }

        p_cdda->i_titles = p_cdda->i_tracks;
        p_access->info.i_update |= INPUT_UPDATE_TITLE|INPUT_UPDATE_SIZE;
        if( p_item )
        {
            input_item_SetDuration( p_item->p_input, (mtime_t) p_access->info.i_size
                    * (CLOCK_FREQ / CDIO_CD_FRAMES_PER_SEC) );
            input_item_SetURI( p_item->p_input,
                    CDDAFormatMRL( p_access, p_cdda->i_track ) );
        }
    }

    if( b_play )
    {
        playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, pl_Unlocked,
                          p_playlist->status.p_item, NULL );
    }

    if (p_playlist) pl_Release( p_access );
    return VLC_SUCCESS;
}


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