hxplayer.cpp

linux下的一款播放器

                                       G_SIGNAL_MATCH_ID,
                                       signals[HXERROR_SIGNAL],
                                       0,    // detail 
                                       NULL, // closure
                                       NULL, // func
                                       NULL  // data
                                       );

    if(error_id == 0 && hxerror_id == 0)
    {
        /* No error signal handlers found -- use g_warning to display instead.
           This is particularly useful for handling errors on startup
           (tbd: might be a better idea to have hx_player_new return a GError) */
        g_warning(_("HXPlayer: Error 0x%08x: \"%s\""), (guint)hxCode, error->message);
    }
    
    /* We allocate a HXError and free it. That's not the way functions
       work, but it's a grey area for signals.*/
    g_signal_emit(G_OBJECT(player), signals[ERROR_SIGNAL], 0, error);

    /* Also emit a signal with all the helix error information in it.
       This is used in the embedded player */
    g_signal_emit(G_OBJECT(player), signals[HXERROR_SIGNAL], 0,
                  (guint)hxCode, (guint)userCode,
                  pErrorString, pUserString, pMoreInfoURL);

    g_free(error);
}

bool
GoToURL(void*       userInfo,
        const char* pURL,
        const char* pTarget,
        bool isPlayerURL)
{
    HXPlayer* player;

    player = HX_PLAYER(userInfo);
    g_return_val_if_fail(player != NULL, false);

    if(isPlayerURL)
    {
        g_signal_emit(G_OBJECT(player), signals[OPEN_WINDOW_SIGNAL], 0, pURL, pTarget);
    }
    else
    {
        g_signal_emit(G_OBJECT(player), signals[GOTO_URL_SIGNAL], 0, pURL, pTarget);
    }

    return true;
}

bool
RequestAuthentication(void*       userInfo,
                      const char* pServer,
                      const char* pRealm,
                      bool        isProxyServer)
{
    HXPlayer* player;

    player = HX_PLAYER(userInfo);
    g_return_val_if_fail(player != NULL, false);

    g_signal_emit(G_OBJECT(player), signals[REQUEST_AUTHENTICATION_SIGNAL], 0,
                  pServer, pRealm, isProxyServer);

    return false;
}

bool
RequestUpgrade(void*       userInfo,
               const char* url,
               UInt32      numOfComponents,
               const char* componentNames[],
               bool        isBlocking)
{
    HXPlayer* player;
    GList* components_list = NULL;
    GList* components_list_iter;
    guint i;
    gboolean duplicate;
    
    player = HX_PLAYER(userInfo);
    g_return_val_if_fail(player != NULL, false);

    /* See comment in OnErrorOccurred */
    ClientPlayerStop(player->player);
    g_signal_emit(G_OBJECT(player), signals[STOP_SIGNAL], 0);
    
    for(i = 0; i < numOfComponents; i++)
    {
        duplicate = FALSE;
        
        /* Check for duplicate components */
        components_list_iter = components_list;
        while(components_list_iter)
        {
            duplicate = strcmp(componentNames[i], (char*)components_list_iter->data) == 0;
            components_list_iter = g_list_next(components_list_iter);
            if(duplicate)
            {
                break;
            }
        }
        
        if(!duplicate)
        {
            /* Add it to the list if there were no duplicates*/
            components_list = g_list_append(components_list, (void*)componentNames[i]);
        }

    }
                                    
    // XXXRGG: This seems to get called for file:// urls where the file
    // doesn't exist. FIXME
    g_signal_emit(G_OBJECT(player), signals[REQUEST_UPGRADE_SIGNAL], 0,
                  url, components_list, (gboolean)isBlocking);
    
    g_list_free(components_list);
                                    
    return false;
}

bool
HasComponent(void*       userInfo,
             const char* componentName)
{
    (void)userInfo;
    (void)componentName;
    
    g_warning("Unhandled request for component %s",
              componentName);
    
    return false;
}

static const HXClientCallbacks g_hxcallbacks =
{
    OnVisualStateChanged,
    OnIdealSizeChanged,
    OnLengthChanged,
    OnTitleChanged,
    OnGroupsChanged,
    OnGroupStarted,
    OnContacting,
    OnBuffering,
    OnContentStateChanged,
    OnContentConcluded,
    OnStatusChanged,
    OnVolumeChanged,
    OnMuteChanged,
    OnClipBandwidthChanged,
    OnErrorOccurred,
    GoToURL,
    RequestAuthentication,
    RequestUpgrade,
    HasComponent,

    NULL, // PrivateCallback1
    NULL, // PrivateCallback2
};

bool
HasFeature( const char* szFeatureName )
{
    gboolean result = FALSE;
    GList* iter;

    iter = g_players_list;
    while(iter && !result)
    {        
        g_signal_emit(G_OBJECT(iter->data),
                      signals[HAS_FEATURE_SIGNAL], 0,
                      (gchar*)szFeatureName, &result);

        iter = g_list_next(iter);
    }
        
    return (result)? true: false;
}

/* These functions are actually defined in hxprefs.cpp */
bool ReadPreference  (const char*          pPrekKey,
                      unsigned char*       pValueBuffer,
                      UInt32               bufferLength,
                      UInt32*              pUsedBufferLength);
bool WritePreference (const char*          pPrekKey,
                      const unsigned char* pValueBuffer,
                      UInt32               bufferLength);
bool DeletePreference(const char*          pPrekKey);


static const HXClientEngineCallbacks g_hxclientengine_callbacks =
{
    ReadPreference,
    WritePreference,
    DeletePreference,
    HasFeature
};

GType
hx_player_get_type(void)
{
    static GType hxplayer_type = 0;

    if (!hxplayer_type)
    {
        static const GTypeInfo hxplayer_info =
        {
            sizeof (HXPlayerClass),
            NULL,           /* base_init */
            NULL,           /* base_finalize */
            (GClassInitFunc) hx_player_class_init,
            NULL,           /* class_finalize */
            NULL,           /* class_data */
            sizeof (HXPlayer),
            0,              /* n_preallocs */
            (GInstanceInitFunc) hx_player_init,
            NULL,           /* value_table */
        };
                                                                                    
        hxplayer_type = g_type_register_static (GTK_TYPE_WIDGET, "HXPlayer",
                                                &hxplayer_info, (GTypeFlags)0);
    }
                                                                                
    return hxplayer_type;   
}

static void
hx_player_class_init(HXPlayerClass* klass)
{
    GObjectClass* gobject_class = G_OBJECT_CLASS(klass);
    GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass);

#ifdef ENABLE_NLS
    /* gettext support */
    bindtextdomain (PACKAGE, LOCALEDIR);

#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
    bind_textdomain_codeset(PACKAGE, "UTF-8");
#endif
#endif

    gobject_class->finalize = hx_player_finalize;
    gobject_class->set_property = hx_player_set_property;
    gobject_class->get_property = hx_player_get_property;

    widget_class->realize = hx_player_realize;
    widget_class->unrealize = hx_player_unrealize;
    widget_class->size_allocate = hx_player_size_allocate; 
    widget_class->expose_event = hx_player_expose; 
    widget_class->motion_notify_event = hx_player_motion_notify_event;
            
    /* Action signals */    
    signals[PLAY_SIGNAL] =
        g_signal_new("play",
                      G_OBJECT_CLASS_TYPE(gobject_class),
                      (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                      G_STRUCT_OFFSET(HXPlayerClass, play),
                      NULL, NULL,
                      g_cclosure_marshal_VOID__VOID,
                      G_TYPE_NONE, 0);  

    signals[STOP_SIGNAL] =
        g_signal_new("stop",
                      G_OBJECT_CLASS_TYPE(gobject_class),
                      (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                      G_STRUCT_OFFSET(HXPlayerClass, stop),
                      NULL, NULL,
                      g_cclosure_marshal_VOID__VOID,
                      G_TYPE_NONE, 0);  

    signals[PAUSE_SIGNAL] =
        g_signal_new("pause",
                      G_OBJECT_CLASS_TYPE(gobject_class),
                      (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                      G_STRUCT_OFFSET(HXPlayerClass, pause),
                      NULL, NULL,
                      g_cclosure_marshal_VOID__VOID,
                      G_TYPE_NONE, 0);  

    signals[CONTACTING_SIGNAL] =
        g_signal_new("contacting",
                      G_OBJECT_CLASS_TYPE(gobject_class),
                      (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                      G_STRUCT_OFFSET(HXPlayerClass, contacting),
                      NULL, NULL,
                      g_cclosure_marshal_VOID__STRING,
                      G_TYPE_NONE, 1, G_TYPE_STRING);

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


    signals[LENGTH_CHANGED_SIGNAL] =
        g_signal_new("length_changed",
                      G_OBJECT_CLASS_TYPE(gobject_class),
                      (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                      G_STRUCT_OFFSET(HXPlayerClass, length_changed),
                      NULL, NULL,
                      g_cclosure_marshal_VOID__UINT,
                      G_TYPE_NONE, 1, G_TYPE_UINT);  

    signals[SEEK_SIGNAL] =
        g_signal_new("seek",
                      G_OBJECT_CLASS_TYPE(gobject_class),
                      (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                      G_STRUCT_OFFSET(HXPlayerClass, seek),
                      NULL, NULL,
                      g_cclosure_marshal_VOID__UINT,
                      G_TYPE_NONE, 1, G_TYPE_UINT);  

    signals[START_SEEKING_SIGNAL] =
        g_signal_new("start_seeking",
                      G_OBJECT_CLASS_TYPE(gobject_class),
                      (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                      G_STRUCT_OFFSET(HXPlayerClass, start_seeking),
                      NULL, NULL,
                      g_cclosure_marshal_VOID__VOID,
                      G_TYPE_NONE, 0);  

    signals[STOP_SEEKING_SIGNAL] =
        g_signal_new("stop_seeking",
                      G_OBJECT_CLASS_TYPE(gobject_class),
                      (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                      G_STRUCT_OFFSET(HXPlayerClass, stop_seeking),
                      NULL, NULL,
                      g_cclosure_marshal_VOID__VOID,
                      G_TYPE_NONE, 0);  
    
    signals[ERROR_SIGNAL] =
        g_signal_new("error",
                      G_OBJECT_CLASS_TYPE(gobject_class),
                      (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                      G_STRUCT_OFFSET(HXPlayerClass, error),
                      NULL, NULL,
                      g_cclosure_marshal_VOID__POINTER,
                      G_TYPE_NONE, 1, G_TYPE_POINTER);  

    signals[HXERROR_SIGNAL] =
        g_signal_new("hxerror",
                      G_OBJECT_CLASS_TYPE(gobject_class),
                      (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                      G_STRUCT_OFFSET(HXPlayerClass, error),
                      NULL, NULL,
                      g_cclosure_user_marshal_VOID__UINT_UINT_STRING_STRING_STRING,
                      G_TYPE_NONE, 5, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);  

    signals[IDEAL_SIZE_CHANGED_SIGNAL] =
        g_signal_new("ideal_size_changed",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, ideal_size_changed),
                     NULL, NULL,
                     g_cclosure_user_marshal_VOID__INT_INT,
                     G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);  

    signals[VOLUME_CHANGED_SIGNAL] =
        g_signal_new("volume_changed",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, volume_changed),
                     NULL, NULL,
                     g_cclosure_marshal_VOID__UINT,
                     G_TYPE_NONE, 1, G_TYPE_UINT);  

    signals[MUTE_CHANGED_SIGNAL] =
        g_signal_new("mute_changed",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, mute_changed),
                     NULL, NULL,
                     g_cclosure_marshal_VOID__BOOLEAN,
                     G_TYPE_NONE, 1, G_TYPE_BOOLEAN);  

    signals[GOTO_URL_SIGNAL] =
        g_signal_new("goto_url",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, goto_url),
                     NULL, NULL,
                     g_cclosure_user_marshal_VOID__STRING_STRING,
                     G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);  

    signals[OPEN_WINDOW_SIGNAL] =
        g_signal_new("open_window",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, open_window),
                     NULL, NULL,
                     g_cclosure_user_marshal_VOID__STRING_STRING,
                     G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);  

    signals[CLIP_BANDWIDTH_CHANGED_SIGNAL] =
        g_signal_new("clip_bandwidth_changed",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, clip_bandwidth_changed),
                     NULL, NULL,
                     g_cclosure_marshal_VOID__INT,
                     G_TYPE_NONE, 1, G_TYPE_INT);  

    signals[REQUEST_UPGRADE_SIGNAL] =
        g_signal_new("request_upgrade",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, request_upgrade),
                     NULL, NULL,
                     g_cclosure_user_marshal_VOID__STRING_POINTER_BOOLEAN,
                     G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN);

    signals[GROUPS_CHANGED_SIGNAL] =
        g_signal_new("groups_changed",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, groups_changed),
                     NULL, NULL,
                     g_cclosure_marshal_VOID__VOID,
                     G_TYPE_NONE, 0);

    signals[GROUP_STARTED_SIGNAL] =
        g_signal_new("group_started",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, group_started),
                     NULL, NULL,
                     g_cclosure_marshal_VOID__UINT,
                     G_TYPE_NONE, 1, G_TYPE_UINT);

    signals[TITLE_CHANGED_SIGNAL] =
        g_signal_new("title_changed",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, title_changed),
                     NULL, NULL,
                     g_cclosure_marshal_VOID__STRING,
                     G_TYPE_NONE, 1, G_TYPE_STRING);

    signals[REQUEST_AUTHENTICATION_SIGNAL] =
        g_signal_new("request_authentication",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, request_authentication),
                     NULL, NULL,
                     g_cclosure_user_marshal_VOID__STRING_STRING_BOOLEAN,
                     G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);

    signals[STATUS_CHANGED_SIGNAL] =
        g_signal_new("status_changed",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, status_changed),
                     NULL, NULL,
                     g_cclosure_marshal_VOID__STRING,
                     G_TYPE_NONE, 1, G_TYPE_STRING);

    signals[CONTENT_CONCLUDED_SIGNAL] =
        g_signal_new("content_concluded",
                     G_OBJECT_CLASS_TYPE(gobject_class),
                     (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
                     G_STRUCT_OFFSET(HXPlayerClass, content_concluded),
                     NULL, NULL,
                     g_cclosure_marshal_VOID__VOID,
                     G_TYPE_NONE, 0);