playeripc.cpp

linux下的一款播放器

    attr->nologo = FALSE;
    attr->height = 0;
    attr->loop = FALSE;
    attr->maintainaspect = FALSE;
    attr->numloop = 0;
    attr->prefetch = FALSE;
    attr->region = NULL;
    attr->scriptcallbacks = (HXCallbackFlags)0;
    attr->shuffle = FALSE;
    attr->src = NULL;
    attr->type = NULL;
    attr->width = 0;    
}

static gboolean string_to_bool(const gchar* str)
{
    if((strcasecmp(str, "true") == 0) ||
       (strcmp(str, "1") == 0))
    {
        return TRUE;
    }
    else if((strcasecmp(str, "false") == 0) ||
       (strcmp(str, "0") == 0))
    {
        return FALSE;
    }
    else
    {
        g_warning("Could not convert \"%s\" to boolean\n", str);
    }

    /* Default to false */
    return FALSE;
}


HXCallbackFlags
playeripc_callback_flags_get_from_string(const gchar* str)
{
    static const struct
    {
        const gchar* name;
        HXCallbackFlags flag;
    } lookup[] =
    {
        { "OnAuthorChange",        HX_CALLBACK_ON_AUTHOR_CHANGE            },
        { "OnBuffering",           HX_CALLBACK_ON_BUFFERING                },
        { "OnClipClosed",          HX_CALLBACK_ON_CLIP_CLOSED              },
        { "OnClipOpened",          HX_CALLBACK_ON_CLIP_OPENED              },
        { "OnContacting",          HX_CALLBACK_ON_CONTACTING               },
        { "OnCopyrightChange",     HX_CALLBACK_ON_COPYRIGHT_CHANGE         },
        { "OnErrorMessage",        HX_CALLBACK_ON_ERROR_MESSAGE            },
        { "OnGotoURL",             HX_CALLBACK_ON_GOTO_URL                 },
        { "OnKeyDown",             HX_CALLBACK_ON_KEY_DOWN                 },
        { "OnKeyPress",            HX_CALLBACK_ON_KEY_PRESS                },
        { "OnKeyUp",               HX_CALLBACK_ON_KEY_UP                   },
        { "OnLButtonDown",         HX_CALLBACK_ON_LBUTTON_DOWN             },
        { "OnLButtonUp",           HX_CALLBACK_ON_LBUTTON_UP               },
        { "OnMouseMove",           HX_CALLBACK_ON_MOUSE_MOVE               },
        { "OnMuteChange",          HX_CALLBACK_ON_MUTE_CHANGE              },
        { "OnPlayStateChange",     HX_CALLBACK_ON_PLAY_STATE_CHANGE        },
        { "OnPosLength",           HX_CALLBACK_ON_POS_LENGTH               },
        { "OnPositionChange",      HX_CALLBACK_ON_POSITION_CHANGE          },
        { "OnPostSeek",            HX_CALLBACK_ON_POST_SEEK                },
        { "OnPreFetchComplete",    HX_CALLBACK_ON_PREFETCH_COMPLETE        },
        { "OnPreSeek",             HX_CALLBACK_ON_PRE_SEEK                 },
        { "OnPresentationClosed",  HX_CALLBACK_ON_PRESENTATION_CLOSED      },
        { "OnPresentationOpened",  HX_CALLBACK_ON_PRESENTATION_OPENED      },
        { "OnRButtonDown",         HX_CALLBACK_ON_RBUTTON_DOWN             },
        { "OnRButtonUp",           HX_CALLBACK_ON_RBUTTON_UP               },
        { "OnShowStatus",          HX_CALLBACK_ON_SHOW_STATUS              },
        { "OnStateChange",         HX_CALLBACK_ON_STATE_CHANGE             },
        { "OnTitleChange",         HX_CALLBACK_ON_TITLE_CHANGE             },
        { "OnVolumeChange",        HX_CALLBACK_ON_VOLUME_CHANGE            },
        { "All",                   HX_CALLBACK_ALL                         }
    };                             
    

    gchar** callback_strings;
    gchar** iter;
    HXCallbackFlags callback_flags = (HXCallbackFlags) 0;
    guint i;
    gchar* buf;
    gchar* unquoted_str;

    buf = g_strdup(str);
    unquoted_str = strunquote(hxcommon_strtrim(buf));    
    callback_strings = g_strsplit(unquoted_str, ",", 0);
    iter = callback_strings;
    while(*iter)
    {
        for(i = 0; i < sizeof(lookup) / sizeof(*lookup); i++)
        {
            if(strncasecmp(hxcommon_strtrim(*iter), lookup[i].name, strlen(lookup[i].name)) == 0)
            {
                callback_flags = (HXCallbackFlags)(callback_flags | lookup[i].flag);
            }
        }
        iter++;
    }

    g_strfreev(callback_strings);
    g_free(buf);
    
    return callback_flags;
}

static HXNameFlags
name_flags_get_from_string(const gchar* name)
{
    HXNameFlags flag = HX_NAME_NONE;

    /* XXXRGG: This list may not be complete. Need to
       check Windows player source... */
    if(strcasecmp(name, "PlayControl") == 0)
    {
        flag = HX_NAME_PLAY_CONTROL;
    }
    else if(strcasecmp(name, "PauseControl") == 0)
    {
        flag = HX_NAME_PAUSE_CONTROL;        
    }
    else if(strcasecmp(name, "StopControl") == 0)
    {
        flag = HX_NAME_STOP_CONTROL;
    }

    return flag;
}

/* str is modified */
HXControlFlags
playeripc_control_flags_get_from_string(const gchar* str)
{
    static const struct
    {
        gchar* name;
        HXControlFlags flag;
    } lookup[] =
    {
        { "ControlPanel",    HX_CONTROLS_CONTROL_PANEL      },
        { "FFCtrl",          HX_CONTROLS_FF_CTRL            },
        { "HomeCtrl",        HX_CONTROLS_HOME               },
        { "ImageWindow",     HX_CONTROLS_IMAGE_WINDOW       },
        { "InfoPanel",       HX_CONTROLS_INFO_PANEL         },
        { "InfoVolumePanel", HX_CONTROLS_INFO_VOLUME_PANEL  },
        { "MuteCtrl",        HX_CONTROLS_MUTE_CTRL          },
        { "MuteVolume",      HX_CONTROLS_MUTE_VOLUME        },
        { "PauseButton",     HX_CONTROLS_PAUSE_BUTTON       },
        { "PlayButton",      HX_CONTROLS_PLAY_BUTTON        },
        { "PlayButtonOnly",  HX_CONTROLS_PLAY_BUTTON_ONLY   },
        { "PlayOnlyButton",  HX_CONTROLS_PLAY_BUTTON_ONLY   },
        { "PositionField",   HX_CONTROLS_POSITION_FIELD     },
        { "PositionSlider",  HX_CONTROLS_POSITION_SLIDER    },
        { "RWCtrl",          HX_CONTROLS_RW_CTRL            },
        { "StatusBar",       HX_CONTROLS_STATUS_BAR         },
        { "StatusField",     HX_CONTROLS_STATUS_FIELD       },
        { "StatusPanel",     HX_CONTROLS_STATUS_BAR         },            
        { "StopButton",      HX_CONTROLS_STOP_BUTTON        },
        { "TACCtrl",         HX_CONTROLS_TAC                },
        { "VolumeSlider",    HX_CONTROLS_VOLUME_SLIDER      },
        { "All",             HX_CONTROLS_ALL                }
    };                             
    

    gchar** controls_strings;
    gchar** iter;
    HXControlFlags control_flags = (HXControlFlags) 0;
    guint i;
    gchar* unquoted_str;
    gchar* buf;

    buf = g_strdup(str);
    unquoted_str = strunquote(hxcommon_strtrim(buf));
    controls_strings = g_strsplit(unquoted_str, ",", 0);
    iter = controls_strings;
    while(*iter)
    {
        for(i = 0; i < sizeof(lookup) / sizeof(*lookup); i++)
        {
            if(strncasecmp(hxcommon_strtrim(*iter), lookup[i].name, strlen(lookup[i].name)) == 0)
            {
                control_flags = (HXControlFlags)(control_flags | lookup[i].flag);
                break;
            }
        }
        iter++;
    }

    if((int)control_flags == 0)
    {
        /* We have a controls tag, but it is specifying an unknown control */
        g_warning("Got unknown control: %s", str);
        control_flags = HX_CONTROLS_UNKNOWN;
    }
    
    g_strfreev(controls_strings);
    g_free(buf);
    
    return control_flags;
    
}

static void
window_attributes_get_from_args(HXEmbeddedWindowAttributes *attr, gchar** pairs)
{
    gchar** pairs_iter;

    for(pairs_iter = pairs; *pairs_iter; pairs_iter++)
    {
        gchar* key = NULL;
        gchar* val = NULL;

        key = *pairs_iter;
        val = strchr(key, '=');
        if(!val)
        {
            g_warning("Got unknown key=val \"%s\"", *pairs_iter);
        }
        else
        {
            /* Otherwise we have a valid key and val */
            *val++ = '\0'; // terminate key
            
            key = hxcommon_strtrim(key);
            val = strunquote(hxcommon_strtrim(val));
            
            if     (strcasecmp(key, "autogotourl") == 0)
            {
                attr->autogotourl = string_to_bool(val);
            }
            else if(strcasecmp(key, "autostart") == 0)
            {
                attr->autostart = string_to_bool(val);
            }
            else if(strcasecmp(key, "backgroundcolor") == 0)
            {
                if(attr->backgroundcolor)
                {
                    g_free(attr->backgroundcolor);
                }
                attr->backgroundcolor = g_strdup(val);
            }
            else if(strcasecmp(key, "center") == 0)
            {
                attr->center = string_to_bool(val);                
            }
            else if(strcasecmp(key, "console") == 0)
            {
                if(attr->console)
                {
                    g_free(attr->console);
                }
                attr->console = g_strdup(val);
            }
            else if(strcasecmp(key, "consoleevents") == 0)
            {
                attr->consoleevents = string_to_bool(val);                
            }
            else if(strcasecmp(key, "controls") == 0)
            {
                if(attr->controls_string)
                {
                    g_free(attr->controls_string);
                }
                attr->controls_string = g_strdup(val);
                attr->controls = playeripc_control_flags_get_from_string(val);
            }
            else if(strcasecmp(key, "height") == 0)
            {
                sscanf(val, "%d", &attr->height);
            }
            else if(strcasecmp(key, "loop") == 0)
            {
                attr->loop = string_to_bool(val);
            }
            else if(strcasecmp(key, "maintainaspect") == 0)
            {
                attr->maintainaspect = string_to_bool(val);                
            }
            else if(strcasecmp(key, "name") == 0)
            {
                /* Normally, name is strictly for use with javascript/dom
                   stuff. Some (undocumented) values seem to also change
                   the controls layout. Handle these values here. */
                
                attr->name_flags = name_flags_get_from_string(val);

                if(attr->name)
                {
                    g_free(attr->name);
                }
                attr->name = g_strdup(val);
            }
            else if(strcasecmp(key, "nojava") == 0)
            {
                /* No longer applicable to Mozilla plugins */
            }
            else if(strcasecmp(key, "nologo") == 0)
            {
                attr->nologo = string_to_bool(val);
            }
            else if(strcasecmp(key, "numloop") == 0)
            {
                sscanf(val, "%d", &attr->numloop);
            }
            else if(strcasecmp(key, "prefetch") == 0)
            {
                attr->prefetch = string_to_bool(val);
            }
            else if(strcasecmp(key, "region") == 0)
            {
                /* XXXRGG: Implement me */
                g_warning("REGION attribute unimplemented");
            }
            else if(strcasecmp(key, "scriptcallbacks") == 0)
            {
                attr->scriptcallbacks = playeripc_callback_flags_get_from_string(val);
            }
            else if(strcasecmp(key, "shuffle") == 0)
            {
                attr->shuffle = string_to_bool(val);
            }
            else if(strcasecmp(key, "src") == 0)
            {
                if(attr->src)
                {
                    g_free(attr->src);
                }
                attr->src = g_strdup(val);
            }
            else if(strcasecmp(key, "type") == 0)
            {
                if(attr->type)
                {
                    g_free(attr->type);
                }
                attr->type = g_strdup(val);
            }
            else if(strcasecmp(key, "width") == 0)
            {
                sscanf(val, "%d", &attr->width);
            }
            else if(strcasecmp(key, "nolabels") == 0)
            {
                /* Ignore the nolabels attribute -- it was deprecated in RP5,
                   and not supported in G2. */
            }
            else if(strcasecmp(key, "pluginspage") == 0 ||
                    strcasecmp(key, "pluginurl"  ) == 0 ||
                    strcasecmp(key, "align"      ) == 0 ||
                    strcasecmp(key, "border"     ) == 0 ||
                    strcasecmp(key, "frameborder") == 0 ||
                    strcasecmp(key, "units"      ) == 0 ||
                    strcasecmp(key, "hidden"     ) == 0 ||
                    strcasecmp(key, "hspace"     ) == 0 ||
                    strcasecmp(key, "vspace"     ) == 0 ||
                    strcasecmp(key, "palette"    ) == 0)
            {
                /* These are all attributes that are handled by the browser.
                   We ignore them. */
                
                // XXXRGG: We should actually be using units to handle the
                // conversion of height/width to pixels if units is en.
                // How do we calculate pixels from point size?
            }
            else
            {
                g_warning("Ignoring unknown attribute %s", key);
            }
        }
    }
}

/* Handle all the commands that work on a player object
   (everything but Embed) */
static gboolean
handle_window_command(HXEmbeddedWindow* window, GIOChannel *channel, gint argc, gchar** argv)
{
    gint result = TRUE;

    if (strcmp("SetPlayerUINT32Prop", argv[0]) == 0 && argc == 4)
    {
        gchar* prop;
        guint val;

        prop = argv[2];
        result = sscanf(argv[3], "%d", &val);
                
        if(result)
        {
            result = hxembedded_window_set_uint_property(window, prop, val);
        }

        send_reply(channel, "%d", result? HXR_OK: HXR_FAIL);
    }
    else if (strcmp("SetPlayerStringProp", argv[0]) == 0 && argc == 4)
    {
        gchar* prop;
        gchar* val;

        prop = argv[2];
        val = argv[3];
            
        result = hxembedded_window_set_string_property(window, prop, val);
        send_reply(channel, "%d", result? HXR_OK: HXR_FAIL);
    }
    else if (strcmp("GetPlayerUINT32Prop", argv[0]) == 0 && argc == 3)
    {
        gchar* prop;
        guint val = 0;
            
        prop = argv[2];
            
        result = hxembedded_window_get_uint_property(window, prop, &val);        
        send_reply(channel, "%d, %d", result? HXR_OK: HXR_FAIL, val);
    }
    else if (strcmp("GetPlayerStringProp", argv[0]) == 0 && argc == 3)
    {
        gchar* prop;
        gchar* val = NULL;

        prop = argv[2];
            
        result = hxembedded_window_get_string_property(window, prop, &val, 0);
        if(result)
        {
            send_reply(channel, "%d, \"%s\"", HXR_OK, val);
            g_free(val);
        }
        else
        {
            send_reply(channel, "%d, \"\"", HXR_FAIL);
        }
    }
    else if (strcmp("GetEntryStringProp", argv[0]) == 0 && argc == 4)
    {
        gchar* prop;
        gchar* val = NULL;
        guint index;