info.c

video linux conference

                    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 )
{ 

    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*/
	psz_name = 
	  CDDAFormatStr( p_access, p_cdda,
			 config_GetPsz( p_access, config_varname ),
			 psz_mrl, i_track );
	free(psz_mrl);
	return psz_name;
    }
    return(NULL);
}

/* Adds a string-valued entry to the playlist information under "Track"
   if the string is not null or the null string.
 */
#define add_playlist_track_info_str(TITLE, FIELD)                        \
    if (FIELD && strlen(FIELD))                                          \
    {                                                                    \
        vlc_input_item_AddInfo( &p_item->input, _("Track"), _(TITLE),    \
                              "%s", FIELD);                              \
    }

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 );
    p_child->input.i_duration   = i_mduration;
    free(psz_mrl);
    free(psz_title);

    if( !p_child ) return NULL;

    playlist_NodeAddItem( p_playlist, p_child,
                          p_item->pp_parents[0]->i_view,
                          p_item, PLAYLIST_APPEND, PLAYLIST_END );
    playlist_CopyParents( p_item, p_child );

    return p_child;
}

int CDDAAddMetaToItem( access_t *p_access, cdda_data_t *p_cdda,
                       playlist_item_t *p_item, int i_track,
                       vlc_bool_t b_single )
{
    add_playlist_track_info_str("Source",  p_cdda->psz_source);
    vlc_input_item_AddInfo( &p_item->input, _("Track"), _("Track Number"),
                           "%d", i_track );

    if (p_cdda->p_cdtext[i_track])
    {
        const cdtext_t *p = p_cdda->p_cdtext[i_track];
        add_playlist_track_info_str("Arranger (CD-Text)",
                                    p->field[CDTEXT_ARRANGER]);
        add_playlist_track_info_str("Composer (CD-Text)",
                                    p->field[CDTEXT_COMPOSER]);
        add_playlist_track_info_str("Genre (CD-Text)",
                                    p->field[CDTEXT_GENRE]);
        add_playlist_track_info_str("Message (CD-Text)",
                                    p->field[CDTEXT_MESSAGE]);
        add_playlist_track_info_str("Performer (CD-Text)",
                                    p->field[CDTEXT_PERFORMER]);
        add_playlist_track_info_str("Songwriter (CD-Text)",
                                    p->field[CDTEXT_SONGWRITER]);
        add_playlist_track_info_str("Title (CD-Text)",
                                    p->field[CDTEXT_TITLE]);
    }

#ifdef HAVE_LIBCDDB
    if (p_cdda->b_cddb_enabled)
    {
        cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc,
                                            i_track-p_cdda->i_first_track);

        if (t)
        {
            if (t->artist)
                add_playlist_track_info_str("Artist (CDDB)",
                                             t->artist);
            if (t->title)
                add_playlist_track_info_str("Title (CDDB)",
                                            t->title);
            if (t->ext_data)
                add_playlist_track_info_str("Extended information (CDDB)",
                                            t->ext_data);
        }
    }
#endif /*HAVE_LIBCDDB*/

    return VLC_SUCCESS;
}

/* 
   Fixes up playlist. 
*/
int
CDDAFixupPlaylist( access_t *p_access, cdda_data_t *p_cdda, 
                   vlc_bool_t 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;
    vlc_bool_t b_play = VLC_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 = (playlist_t *) vlc_object_find( p_access, 
						     VLC_OBJECT_PLAYLIST,
						     FIND_ANYWHERE );
	if( !p_playlist )
	  {
	      msg_Warn( p_access, "can't find playlist" );
	      return VLC_EGENERIC;
	  }
    }

    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) {

      p_item = playlist_LockItemGetByInput( p_playlist,
                        ((input_thread_t *)p_access->p_parent)->input.p_item );

      if( p_item == p_playlist->status.p_item && !b_single_track )
	{
	  b_play = VLC_TRUE;
	}
      else
	{
	  b_play = VLC_FALSE;
	}
    }

    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();

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

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


	if (p_item) 
	{
	    CDDAAddMetaToItem( p_access, p_cdda, p_item, i_track, VLC_FALSE );
	    p_item->input.i_duration = i_track_frames 
	      * (CLOCK_FREQ / CDIO_CD_FRAMES_PER_SEC);
	    p_item->input.psz_uri    = 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 );

        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();

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

            t->i_length = I64C(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 );
	      CDDAAddMetaToItem( p_access, p_cdda, p_child, i_track, 
				 VLC_TRUE );
	    }
        }

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

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

    if (p_playlist) vlc_object_release( p_playlist );
    return VLC_SUCCESS;
}


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