hxplayer.cpp

linux下的一款播放器

    signals[CONTENT_STATE_CHANGED_SIGNAL] =
        g_signal_new("content_state_changed",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, content_concluded),
                     NULL, NULL,
                     g_cclosure_user_marshal_VOID__UINT_UINT,
                     G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT);


    signals[HAS_FEATURE_SIGNAL] =
        g_signal_new("has_feature",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, has_feature),
                     NULL, NULL,
                     g_cclosure_user_marshal_BOOLEAN__STRING,
                     G_TYPE_BOOLEAN, 1, G_TYPE_STRING);

    signals[VISUAL_STATE_CHANGED_SIGNAL] =
        g_signal_new("visual_state_changed",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, visual_state_changed),
                     NULL, NULL,
                     g_cclosure_marshal_VOID__BOOLEAN,
                     G_TYPE_NONE, 1, G_TYPE_BOOLEAN);    
        
    /* Properties */
    g_object_class_install_property (gobject_class,
                                     PROP_LOOP,
                                     g_param_spec_boolean ("loop",
                                                           _("Loop"),
                                                           _("Player should loop (indefinitely, if loop_count is not set)"),
                                                           FALSE,
                                                           (GParamFlags)G_PARAM_READWRITE));

    g_object_class_install_property (gobject_class,
                                     PROP_LOOP_COUNT,
                                     g_param_spec_uint ("loop_count",
                                                        _("Loop count"),
                                                        _("Number of times to repeat the opened content"),
                                                        0, UINT_MAX, 0,
                                                        (GParamFlags)G_PARAM_READWRITE));

    g_object_class_install_property (gobject_class,
                                     PROP_SHUFFLE,
                                     g_param_spec_boolean ("shuffle",
                                                          _("Shuffle"),
                                                          _("Shuffle opened content"),
                                                          FALSE,
                                                          (GParamFlags)G_PARAM_READWRITE));

    
    /* Initialize reference counting for the engine pump */
    g_pump_timer_id = 0;
    g_engine_ref_count = 0;

    /* Seed the random func (for use with shuffle) */
    srand(time(NULL));

    /* Override preferences callbacks */
    ClientEngineSetCallbacks(&g_hxclientengine_callbacks);
}


static void
hx_player_init(HXPlayer*      player,
               HXPlayerClass* /* klass */)
{
    GTK_WIDGET_SET_FLAGS (player, GTK_CAN_FOCUS);
    
    player->player = NULL;
    player->state = HX_CONTENT_STATE_NOT_LOADED;
    player->logo_pixmap = NULL;
    player->logo_height = 0;
    player->logo_width = 0;
    player->window = NULL;
    player->shuffle = FALSE;
    player->loop_count = 0;
    player->cur_loop = 0;
    player->loop = FALSE;
    player->group_title_buf = NULL;
    player->title_buf = NULL;
}


/**
 * hx_player_new:
 *
 * Creates a new #HXPlayer widget.
 *
 * @returns: a new #HXPlayer.
 *
 **/
GtkWidget*
hx_player_new(void)
{
    HXPlayer* player = (HXPlayer*)g_object_new(HX_TYPE_PLAYER, NULL);
    if(player)
    {
        g_players_list = g_list_append(g_players_list, player);
        
        /* Allocate a Window structure */
        player->window = g_new0(SHXClientWindow, 1);

        /* Add a reference to the engine "pump", start it if we're
           the first widget */
        HXPlayerClass* klass;
        klass = HX_PLAYER_GET_CLASS(player);

        if(g_engine_ref_count == 0)
        {
#ifdef G_OS_UNIX
            // Create a display for the player
            if(!g_dpy)
            {
                g_dpy = XOpenDisplay(NULL);
            }

            // Query for extensions for event handling purposes within
            // the pump callback.
            gint ignore;
            g_xshm_present = XQueryExtension(g_dpy,
                                             "MIT-SHM",
                                             &ignore,
                                             &g_xshm_event_base,
                                             &ignore);
            
            g_pump_timer_id = gtk_timeout_add(SLEEP_TIME,
                                              hx_player_pump,
                                              NULL);
#endif
        }
        
        g_engine_ref_count++;
    }

    /* Initialize the engine */
    if(!ClientPlayerCreate(&player->player,
                           player->window,
                           player,
                           &g_hxcallbacks))
    {
        /*  XXXRGG: Move this to the top level client once we get
            good error signal handling working. */
        
        gchar* helix_libs = getenv("HELIX_LIBS");
        if(helix_libs)
        {
            g_error(_("Could not create helix engine. Make sure your helix "
                      "libs are installed at: HELIX_LIBS=%s"), helix_libs);
        }
        else
        {            
            g_error(_("Could not create helix engine. You must run:\n"
                    "export HELIX_LIBS=<path to your helix libs>"));
        }
    }
    
    return GTK_WIDGET(player);
}


/**
 * hx_player_open_url:
 * @player: a #HXPlayer
 * @url: the url to open
 *
 * Opens a url
 *
 * @returns: whether the url opened successfully.
 *
 **/
gboolean
hx_player_open_url(HXPlayer*    player,
                   const gchar* url)
{
    bool bResult;
    
    g_return_val_if_fail(HX_IS_PLAYER(player), FALSE);
    g_return_val_if_fail(url != NULL, FALSE);
    g_return_val_if_fail(player->player != NULL, FALSE);

    bResult = ClientPlayerOpenURL(player->player, url, NULL);

    if(player->shuffle)
    {
        hx_player_shuffle(player);
    }

    return (bResult)? TRUE: FALSE;
}

/**
 * hx_player_get_url:
 * @player: a #HXPlayer
 *
 * Returns the currently open url
 *
 * @returns: The url.
 *
 **/
G_CONST_RETURN gchar*
hx_player_get_url(HXPlayer *player)
{
    UInt32 buf_desired, buf_used;
    
    g_return_val_if_fail(player != NULL, NULL);

    g_free(player->last_opened_url_buf);
    player->last_opened_url_buf = NULL;
    
    /* Get the size */
    ClientPlayerGetOpenedURL(player->player, NULL, 0, &buf_desired);
    if(buf_desired == 0)
    {
        return NULL;
    }

    player->last_opened_url_buf = (gchar*)g_try_malloc(buf_desired + 1);
    g_return_val_if_fail(player->last_opened_url_buf, NULL);

    ClientPlayerGetOpenedURL(player->player,
                             player->last_opened_url_buf,
                             buf_desired,
                             &buf_used);

    g_assert(buf_used == buf_desired);

    return player->last_opened_url_buf;
}


/**
 * hx_player_open_url_with_mime_type:
 * @player: a #HXPlayer
 * @url: the url to open
 * @mime_type: the mime type
 *
 * Opens a url, specifying a mime type.
 * XXXRGG: When would I want to do this?
 *
 * @returns: whether the url opened successfully.
 *
 **/
gboolean
hx_player_open_url_with_mime_type(HXPlayer*    player,
                                  const gchar* url,
                                  const gchar* mime_type)
{
    bool bResult;
    
    g_return_val_if_fail(HX_IS_PLAYER(player), FALSE);
    g_return_val_if_fail(url != NULL, FALSE);
    g_return_val_if_fail(mime_type != NULL, FALSE);
    g_return_val_if_fail(player->player != NULL, FALSE);

    bResult = ClientPlayerOpenURL(player->player, url, mime_type);

    if(player->shuffle)
    {
        hx_player_shuffle(player);
    }

    return (bResult)? TRUE: FALSE;
}

/**
 * hx_player_open_file:
 * @player: a #HXPlayer
 * @filename: the full path to the file to open
 *
 * Opens a file. Equivalent to calling hx_player_open_file()
 * with a file:// url
 *
 * @returns: whether the file opened successfully.
 *
 **/
gboolean
hx_player_open_file(HXPlayer*    player,
                    const gchar* filename)
{
    gchar* url;
    gboolean result;
    
    g_return_val_if_fail(HX_IS_PLAYER(player), FALSE);
    g_return_val_if_fail(filename != NULL, FALSE);
    g_return_val_if_fail(player->player != NULL, FALSE);

    url = g_strdup_printf("file://%s", filename);
    
    result = hx_player_open_url(player, url);
    
    g_free(url);

    return result;
}

/**
 * hx_player_get_content_state:
 * @player: a #HXPlayer
 *
 * Opens a file. Equivalent to calling hx_player_open_file()
 * with a "file://" url
 *
 * @returns: #GtkContentStateType
 *
 **/
HXContentStateType
hx_player_get_content_state(HXPlayer* player)
{
    g_return_val_if_fail(HX_IS_PLAYER(player),
                         HX_CONTENT_STATE_NOT_LOADED);
    
    g_return_val_if_fail(player->player != NULL,
                         HX_CONTENT_STATE_NOT_LOADED);

    return (HXContentStateType) ClientPlayerGetContentState(player->player);
}

/**
 * hx_player_play:
 * @player: a #HXPlayer
 *
 * Starts playback of the opened clip
 *
 **/
void
hx_player_play(HXPlayer* player)
{
    g_return_if_fail(HX_IS_PLAYER(player));
    g_return_if_fail(player->player != NULL);
    
    ClientPlayerPlay(player->player);
}

/**
 * hx_player_pause:
 * @player: a #HXPlayer
 *
 * Pauses playback of a clip
 *
 **/
void
hx_player_pause(HXPlayer* player)
{
    g_return_if_fail(HX_IS_PLAYER(player));
    g_return_if_fail(player->player != NULL);

    ClientPlayerPause(player->player);
}

/**
 * hx_player_stop:
 * @player: a #HXPlayer
 *
 * Stops playback of a clip
 *
 **/
void
hx_player_stop(HXPlayer* player)
{
    g_return_if_fail(HX_IS_PLAYER(player));
    g_return_if_fail(player->player != NULL);

    ClientPlayerStop(player->player);
}

/**
 * hx_player_start_seeking:
 * @player: a #HXPlayer
 *
 * Call this function before calling hx_player_set_position()
 *
 **/
void
hx_player_start_seeking(HXPlayer* player)
{
    g_return_if_fail(HX_IS_PLAYER(player));
    g_return_if_fail(player->player != NULL);

    g_signal_emit(G_OBJECT(player), signals[START_SEEKING_SIGNAL], 0);

    ClientPlayerStartSeeking(player->player);
}

/**
 * hx_player_set_position:
 * @player: a #HXPlayer
 * @position: position in file, meausred in seconds
 *
 **/
void
hx_player_set_position(HXPlayer* player,
                       guint     position)
{
    g_return_if_fail(HX_IS_PLAYER(player));
    g_return_if_fail(player->player != NULL);

    g_signal_emit(G_OBJECT(player), signals[SEEK_SIGNAL], 0,
                  position);

    ClientPlayerSetPosition(player->player, position);    
}

/**
 * hx_player_stop_seeking:
 * @player: a #HXPlayer
 *
 * Call when the seeking operation is complete
 *
 **/
void
hx_player_stop_seeking(HXPlayer* player)
{
    g_return_if_fail(HX_IS_PLAYER(player));
    g_return_if_fail(player->player != NULL);

    ClientPlayerStopSeeking(player->player);

    g_signal_emit(G_OBJECT(player), signals[STOP_SEEKING_SIGNAL], 0);
}
    
/**
 * hx_player_get_position:
 * @player: a #HXPlayer
 *
 * Get the current position in the clip, measured in seconds
 *
 * @returns: the current position
 *
 **/
guint
hx_player_get_position(HXPlayer* player)
{
    guint pos;
    g_return_val_if_fail(HX_IS_PLAYER(player), 0);
    g_return_val_if_fail(player->player != NULL, 0);
    
    pos = ClientPlayerGetPosition(player->player);
    
    return pos;
}

/**
 * hx_player_get_length:
 * @player: a #HXPlayer
 *
 * Get the total length of the clip, measured in seconds
 *
 * @returns: the total clip length
 *
 **/
guint
hx_player_get_length(HXPlayer* player)
{
    UInt32 nPos;
    
    g_return_val_if_fail(HX_IS_PLAYER(player), 0);
    g_return_val_if_fail(player->player != NULL, 0);

    nPos = ClientPlayerGetLength(player->player);

    if(nPos == INFINITE_DURATION)
    {
        /* Check for infinite clip duration using
           hx_player_is_infinite_duration. If this function
           ever returns 22:22:22:22, it means the clip is