开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
pda_callbacks.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：39k
源码类别：

midi

开发平台：

Unix_Linux

pda_callbacks.c：源码内容
  1. /*****************************************************************************
  2.  * pda_callbacks.c : Callbacks for the pda Linux Gtk+ plugin.
  3.  *****************************************************************************
  4.  * Copyright (C) 2000, 2001 the VideoLAN team
  5.  * $Id: e1abc08bb1c0422bdcbabd31024c5db980da7fc1 $
  6.  *
  7.  * Authors: Jean-Paul Saman <jpsaman _at_ videolan _dot_ org>
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22.  *****************************************************************************/
  24. /*****************************************************************************
  25.  * Preamble
  26.  *****************************************************************************/
  27. #include <sys/types.h>                                              /* off_t */
  29. #ifdef HAVE_CONFIG_H
  30. # include "config.h"
  31. #endif
  33. #include <vlc_common.h>
  34. #include <vlc_input.h>
  35. #include <vlc_interface.h>
  36. #include <vlc_playlist.h>
  37. #include <vlc_vout.h>
  39. #include <dirent.h>
  40. #include <sys/stat.h>
  41. #include <unistd.h>
  42. #include <pwd.h>
  43. #include <grp.h>
  45. #include <gtk/gtk.h>
  47. #include "pda_callbacks.h"
  48. #include "pda_interface.h"
  49. #include "pda_support.h"
  50. #include "pda.h"
  52. #define VLC_MAX_MRL     256
  54. static char *get_file_perms(struct stat st);
  56. /*****************************************************************************
  57.  * Useful function to retrieve p_intf
  58.  ****************************************************************************/
  59. void * __GtkGetIntf( GtkWidget * widget )
  60. {
  61.     void *p_data;
  63.     if( GTK_IS_MENU_ITEM( widget ) )
  64.     {
  65.         /* Look for a GTK_MENU */
  66.         while( widget->parent && !GTK_IS_MENU( widget ) )
  67.         {
  68.             widget = widget->parent;
  69.         }
  71.         /* Maybe this one has the data */
  72.         p_data = gtk_object_get_data( GTK_OBJECT( widget ), "p_intf" );
  73.         if( p_data )
  74.         {
  75.             return p_data;
  76.         }
  78.         /* Otherwise, the parent widget has it */
  79.         widget = gtk_menu_get_attach_widget( GTK_MENU( widget ) );
  80.     }
  82.     /* We look for the top widget */
  83.     widget = gtk_widget_get_toplevel( GTK_WIDGET( widget ) );
  85.     p_data = gtk_object_get_data( GTK_OBJECT( widget ), "p_intf" );
  87.     return p_data;
  88. }
  90. static void PlaylistAddItem(GtkWidget *widget, gchar *name, char **ppsz_options, int i_size)
  91. {
  92.     intf_thread_t *p_intf = GtkGetIntf( widget );
  93.     playlist_t    *p_playlist;
  94.     int           i_id , i_pos=0;
  95.     GtkTreeView   *p_tvplaylist = NULL;
  97.     p_playlist = pl_Hold( p_intf );
  99.     if( p_playlist ==  NULL)
  100.     {   /* Bail out when VLC's playlist object is not found. */
  101.         return;
  102.     }
  104.     /* Add to playlist object. */
  105.     p_tvplaylist = (GtkTreeView *) lookup_widget( GTK_WIDGET(widget), "tvPlaylist");
  106.     if (p_tvplaylist)
  107.     {
  108.         GtkTreeModel *p_play_model;
  109.         GtkTreeIter   p_play_iter;
  111.         p_play_model = gtk_tree_view_get_model(p_tvplaylist);
  112.  
  113.         if (p_play_model)
  114.         {
  115.             int i;
  117.             /* Add a new row to the playlist treeview model */
  118.             gtk_list_store_append (GTK_LIST_STORE(p_play_model), &p_play_iter);
  119.             gtk_list_store_set (GTK_LIST_STORE(p_play_model), &p_play_iter,
  120.                                     0, name,   /* Add path to it !!! */
  121.                                     1, "no info",
  122.                                     2, playlist_CurrentSize(p_playlist), /* Hidden index. */
  123.                                     -1 );
  125.             /* Add to VLC's playlist */
  126. #if 0
  127.             if (p_intf->p_sys->b_autoplayfile)
  128.             {
  129.                 playlist_Add( p_playlist, (const char*)name, (const char**)ppsz_options, i_size,
  130.                               PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END);
  131.             }
  132.             else
  133. #endif
  134.             {
  135.                 i_id = playlist_AddExt( p_playlist, (const char*)name,
  136.                               (const char*)name,
  137.                               PLAYLIST_APPEND, PLAYLIST_END,
  138.                               (mtime_t) 0,
  139.                               i_size, (const char **) ppsz_options, VLC_INPUT_OPTION_TRUSTED,
  140.                               true, pl_Unlocked );
  141.             }
  143.             /* Cleanup memory */
  144.             for (i=0; i<i_size; i++)
  145.                 free(ppsz_options[i]);
  146.             free(ppsz_options);
  147.         }
  148.     }
  149.     pl_Release( p_intf );
  150. }
  152. void PlaylistRebuildListStore( intf_thread_t *p_intf,
  153.     GtkListStore * p_list, playlist_t * p_playlist )
  154. {
  155.     GtkTreeIter iter;
  156.     int         i_dummy;
  157.     gchar *     ppsz_text[2];
  158. #if 0
  159.     GdkColor    red;
  160.     red.red     = 65535;
  161.     red.blue    = 0;
  162.     red.green   = 0;
  163. #endif
  164.     PL_LOCK;
  165.     for( i_dummy = 0; i_dummy < playlist_CurrentSize(p_playlist) ; i_dummy++ )
  166.     {
  167.         playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i_dummy );
  168.         if( p_item )
  169.         {
  170.             ppsz_text[0] = p_item->p_input->psz_name;
  171.             ppsz_text[1] = "no info";
  172.             gtk_list_store_append (p_list, &iter);
  173.             gtk_list_store_set (p_list, &iter,
  174.                                 0, ppsz_text[0],
  175.                                 1, ppsz_text[1],
  176.                                 2, i_dummy, /* Hidden index */
  177.                                 -1);
  178.         }
  179.     }
  180.     PL_UNLOCK;
  181. }
  183. /*****************************************************************
  184.  * Read directory helper function.
  185.  ****************************************************************/
  186. void ReadDirectory(intf_thread_t *p_intf, GtkListStore *p_list, char *psz_dir )
  187. {
  188.     GtkTreeIter    iter;
  189.     struct dirent **pp_namelist;
  190.     struct passwd *p_pw;
  191.     struct group  *p_grp;
  192.     struct stat    st;
  193.     int n=-1, status=-1;
  195.     msg_Dbg(p_intf, "Changing to dir %s", psz_dir);
  196.     if (psz_dir)
  197.     {
  198.        status = chdir(psz_dir);
  199.        if (status<0)
  200.           msg_Dbg(p_intf, "permision denied" );
  201.     }
  202.     n = scandir(".", &pp_namelist, 0, alphasort);
  204.     if (n<0)
  205.         perror("scandir");
  206.     else
  207.     {
  208.         int i;
  209.         gchar *ppsz_text[4];
  211.         if (lstat("..", &st)==0)
  212.         {
  213.             /* user, group  */
  214.             p_pw  = getpwuid(st.st_uid);
  215.             p_grp = getgrgid(st.st_gid);
  217.             /* XXX : kludge temporaire pour yopy */
  218.             ppsz_text[0] = "..";
  219.             ppsz_text[1] = get_file_perms(st);
  220.             ppsz_text[2] = p_pw->pw_name;
  221.             ppsz_text[3] = p_grp->gr_name;
  223.             /* Add a new row to the model */
  224.             gtk_list_store_append (p_list, &iter);
  225.             gtk_list_store_set (p_list, &iter,
  226.                                 0, ppsz_text[0],
  227.                                 1, ppsz_text[1],
  228.                                 2, st.st_size,
  229.                                 3, ppsz_text[2],
  230.                                 4, ppsz_text[3],
  231.                                 -1);
  233.             free(ppsz_text[1]);
  234.         }
  235.             /* kludge */
  236.         for (i=0; i<n; i++)
  237.         {
  238.             if ((pp_namelist[i]->d_name[0] != '.') &&
  239.                 (lstat(pp_namelist[i]->d_name, &st)==0))
  240.             {
  241.                 /* user, group  */
  242.                 p_pw  = getpwuid(st.st_uid);
  243.                 p_grp = getgrgid(st.st_gid);
  245.                 /* This is a list of strings. */
  246.                 ppsz_text[0] = pp_namelist[i]->d_name;
  247.                 ppsz_text[1] = get_file_perms(st);
  248.                 ppsz_text[2] = p_pw->pw_name;
  249.                 ppsz_text[3] = p_grp->gr_name;
  250. #if 0
  251.                 msg_Dbg(p_intf, "(%d) file: %s permission: %s user: %s group: %s", i, ppsz_text[0], ppsz_text[1], ppsz_text[2], ppsz_text[3] );
  252. #endif
  253.                 gtk_list_store_append (p_list, &iter);
  254.                 gtk_list_store_set (p_list, &iter,
  255.                                     0, ppsz_text[0],
  256.                                     1, ppsz_text[1],
  257.                                     2, st.st_size,
  258.                                     3, ppsz_text[2],
  259.                                     4, ppsz_text[3],
  260.                                     -1);
  262.                 free(ppsz_text[1]);
  263.             }
  264.         }
  265.         free(pp_namelist);
  266.     }
  267. }
  269. static char *get_file_perms(const struct stat st)
  270. {
  271.     char  *psz_perm;
  273.     psz_perm = (char *) malloc(10);
  274.     strncpy( psz_perm, "----------", sizeof("----------"));
  276.     /* determine permission modes */
  277.     if (S_ISLNK(st.st_mode))
  278.         psz_perm[0]= 'l';
  279.     else if (S_ISDIR(st.st_mode))
  280.         psz_perm[0]= 'd';
  281.     else if (S_ISCHR(st.st_mode))
  282.         psz_perm[0]= 'c';
  283.     else if (S_ISBLK(st.st_mode))
  284.         psz_perm[0]= 'b';
  285.     else if (S_ISFIFO(st.st_mode))
  286.         psz_perm[0]= 'f';
  287.     else if (S_ISSOCK(st.st_mode))
  288.         psz_perm[0]= 's';
  289.     else if (S_ISREG(st.st_mode))
  290.         psz_perm[0]= '-';
  291.     else /* Unknown type is an error */
  292.         psz_perm[0]= '?';
  293.     /* Get file permissions */
  294.     /* User */
  295.     if (st.st_mode & S_IRUSR)
  296.         psz_perm[1]= 'r';
  297.     if (st.st_mode & S_IWUSR)
  298.         psz_perm[2]= 'w';
  299.     if (st.st_mode & S_IXUSR)
  300.     {
  301.         if (st.st_mode & S_ISUID)
  302.             psz_perm[3] = 's';
  303.         else
  304.             psz_perm[3]= 'x';
  305.     }
  306.     else if (st.st_mode & S_ISUID)
  307.         psz_perm[3] = 'S';
  308.     /* Group */
  309.     if (st.st_mode & S_IRGRP)
  310.         psz_perm[4]= 'r';
  311.     if (st.st_mode & S_IWGRP)
  312.         psz_perm[5]= 'w';
  313.     if (st.st_mode & S_IXGRP)
  314.     {
  315.         if (st.st_mode & S_ISGID)
  316.             psz_perm[6] = 's';
  317.         else
  318.             psz_perm[6]= 'x';
  319.     }
  320.     else if (st.st_mode & S_ISGID)
  321.         psz_perm[6] = 'S';
  322.     /* Other */
  323.     if (st.st_mode & S_IROTH)
  324.         psz_perm[7]= 'r';
  325.     if (st.st_mode & S_IWOTH)
  326.         psz_perm[8]= 'w';
  327.     if (st.st_mode & S_IXOTH)
  328.     {
  329.         /* 'sticky' bit */
  330.         if (st.st_mode &S_ISVTX)
  331.             psz_perm[9] = 't';
  332.         else
  333.             psz_perm[9]= 'x';
  334.     }
  335.     else if (st.st_mode &S_ISVTX)
  336.         psz_perm[9]= 'T';
  338.     return psz_perm;
  339. }
  341. /*
  342.  * Main interface callbacks
  343.  */
  345. gboolean onPDADeleteEvent(GtkWidget *widget, GdkEvent *event, gpointer user_data)
  346. {
  347.     intf_thread_t *p_intf = GtkGetIntf( widget );
  349.     libvlc_Quit( p_intf->p_libvlc );
  350.     msg_Dbg( p_intf, "about to exit vlc ... signaled" );
  352.     return TRUE;
  353. }
  355. void onRewind(GtkButton *button, gpointer user_data)
  356. {
  357.     intf_thread_t *p_intf = GtkGetIntf( button );
  359.     if (p_intf->p_sys->p_input != NULL)
  360.     {
  361.         var_SetVoid( p_intf->p_sys->p_input, "rate-slower" );
  362.     }
  363. }
  365. void onPause(GtkButton *button, gpointer user_data)
  366. {
  367.     intf_thread_t *p_intf = GtkGetIntf( button );
  369.     if (p_intf->p_sys->p_input != NULL)
  370.     {
  371.         var_SetInteger( p_intf->p_sys->p_input, "state", PAUSE_S );
  372.     }
  373. }
  376. void onPlay(GtkButton *button, gpointer user_data)
  377. {
  378.     intf_thread_t *p_intf = GtkGetIntf( GTK_WIDGET( button ) );
  379.     playlist_t *p_playlist = pl_Hold( p_intf );
  381.     if (p_playlist)
  382.     {
  383.         int s;
  385.         PL_LOCK;
  386.         s = playlist_CurrentSize(p_playlist);
  387.         PL_UNLOCK;
  388.         /* FIXME: This is racy... */
  389.         if (s)
  390.         {
  391.             playlist_Play( p_playlist );
  392.             gdk_window_lower( p_intf->p_sys->p_window->window );
  393.         }
  394.         pl_Release( p_intf );
  395.     }
  396. }
  398. void onStop(GtkButton *button, gpointer user_data)
  399. {
  400.     intf_thread_t *p_intf = GtkGetIntf( GTK_WIDGET( button ) );
  401.     playlist_t *p_playlist = pl_Hold( p_intf );
  402.     if (p_playlist)
  403.     {
  404.         playlist_Stop( p_playlist );
  405.         pl_Release( p_intf );
  406.         gdk_window_raise( p_intf->p_sys->p_window->window );
  407.     }
  408. }
  410. void onForward(GtkButton *button, gpointer user_data)
  411. {
  412.     intf_thread_t *p_intf = GtkGetIntf( button );
  414.     if (p_intf->p_sys->p_input != NULL)
  415.     {
  416.         var_SetVoid( p_intf->p_sys->p_input, "rate-faster" );
  417.     }
  418. }
  421. void onAbout(GtkButton *button, gpointer user_data)
  422. {
  423.     intf_thread_t *p_intf = GtkGetIntf( GTK_WIDGET(button) );
  425.     /* Toggle notebook */
  426.     if (p_intf->p_sys->p_notebook)
  427.     {
  428.         gtk_widget_show( GTK_WIDGET(p_intf->p_sys->p_notebook) );
  429.         gtk_notebook_set_page(p_intf->p_sys->p_notebook,6);
  430.     }
  431. }
  433. gboolean SliderRelease(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
  434. {
  435.     intf_thread_t *p_intf = GtkGetIntf( widget );
  437.     msg_Dbg( p_intf, "SliderButton Release" );
  438.     p_intf->p_sys->b_slider_free = 1;
  440.     return TRUE;
  441. }
  443. gboolean SliderPress(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
  444. {
  445.     intf_thread_t *p_intf = GtkGetIntf( widget );
  447.     msg_Dbg( p_intf, "SliderButton Press" );
  448.     p_intf->p_sys->b_slider_free = 0;
  450.     return FALSE;
  451. }
  453. void SliderMove(GtkRange *range, GtkScrollType scroll, gpointer user_data)
  454. {
  455.     intf_thread_t *p_intf = GtkGetIntf( range );
  456.     msg_Dbg( p_intf, "SliderButton Move" );
  457. }
  460. static void addSelectedToPlaylist(GtkTreeModel *model, GtkTreePath *path,
  461.                            GtkTreeIter *iter, gpointer *userdata)
  462. {
  463.     gchar *psz_filename;
  465.     gtk_tree_model_get(model, iter, 0, &psz_filename, -1);
  467.     PlaylistAddItem(GTK_WIDGET(userdata), psz_filename, 0, 0);
  468. }
  470. void onFileListRow(GtkTreeView *treeview, GtkTreePath *path,
  471.                    GtkTreeViewColumn *column, gpointer user_data)
  472. {
  473.     intf_thread_t *p_intf = GtkGetIntf( GTK_WIDGET(treeview) );
  474.     GtkTreeSelection *p_selection = gtk_tree_view_get_selection(treeview);
  476.     if (gtk_tree_selection_count_selected_rows(p_selection) == 1)
  477.     {
  478.         struct stat   st;
  479.         GtkTreeModel *p_model;
  480.         GtkTreeIter   iter;
  481.         char         *psz_filename;
  483.         /* This might be a directory selection */
  484.         p_model = gtk_tree_view_get_model(treeview);
  485.         if (!p_model)
  486.         {
  487.             msg_Err(p_intf, "PDA: Filelist model contains a NULL pointer" );
  488.             return;
  489.         }
  490.         if (!gtk_tree_model_get_iter(p_model, &iter, path))
  491.         {
  492.             msg_Err( p_intf, "PDA: Could not get iter from model" );
  493.             return;
  494.         }
  496.         gtk_tree_model_get(p_model, &iter, 0, &psz_filename, -1);
  497.         if (stat((char*)psz_filename, &st)==0)
  498.         {
  499.             if (S_ISDIR(st.st_mode))
  500.             {
  501.                 GtkListStore *p_store = NULL;
  503.                 /* Get new directory listing */
  504.                 p_store = gtk_list_store_new (5,
  505.                                            G_TYPE_STRING,
  506.                                            G_TYPE_STRING,
  507.                                            G_TYPE_UINT64,
  508.                                            G_TYPE_STRING,
  509.                                            G_TYPE_STRING);
  510.                 if (p_store)
  511.                 {
  512.                     ReadDirectory(p_intf, p_store, psz_filename);
  514.                     /* Update TreeView with new model */
  515.                     gtk_tree_view_set_model(treeview, (GtkTreeModel*) p_store);
  516.                     g_object_unref(p_store);
  517.                 }
  518.             }
  519.         }
  520.     }
  521. }
  523. void onAddFileToPlaylist(GtkButton *button, gpointer user_data)
  524. {
  525.     GtkTreeView       *p_treeview = NULL;
  527.     p_treeview = (GtkTreeView *) lookup_widget( GTK_WIDGET(button), "tvFileList");
  528.     if (p_treeview)
  529.     {
  530.         GtkTreeSelection *p_selection = gtk_tree_view_get_selection(p_treeview);
  532.         gtk_tree_selection_selected_foreach(p_selection, (GtkTreeSelectionForeachFunc) &addSelectedToPlaylist, (gpointer) p_treeview);
  533.     }
  534. }
  537. void NetworkBuildMRL(GtkEditable *editable, gpointer user_data)
  538. {
  539.     intf_thread_t *p_intf = GtkGetIntf( GTK_WIDGET(editable) );
  540.     GtkSpinButton *p_networkPort = NULL;
  541.     GtkEntry      *p_entryMRL = NULL;
  542.     GtkEntry      *p_networkType = NULL;
  543.     GtkEntry      *p_networkAddress = NULL;
  544.     GtkEntry      *p_networkProtocol = NULL;
  545.     const gchar   *psz_mrlNetworkType;
  546.     const gchar   *psz_mrlAddress;
  547.     const gchar   *psz_mrlProtocol;
  548.     gint           i_mrlPort;
  549.     char           text[VLC_MAX_MRL];
  550.     int            i_pos = 0;
  552.     p_entryMRL = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryMRL" );
  554.     p_networkType     = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryNetworkType" );
  555.     p_networkAddress  = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryNetworkAddress" );
  556.     p_networkPort     = (GtkSpinButton*) lookup_widget( GTK_WIDGET(editable), "entryNetworkPort" );
  557.     p_networkProtocol = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryNetworkProtocolType" );
  559.     psz_mrlNetworkType = gtk_entry_get_text(GTK_ENTRY(p_networkType));
  560.     psz_mrlAddress     = gtk_entry_get_text(GTK_ENTRY(p_networkAddress));
  561.     i_mrlPort          = gtk_spin_button_get_value_as_int(p_networkPort);
  562.     psz_mrlProtocol    = gtk_entry_get_text(GTK_ENTRY(p_networkProtocol));
  564.     /* Build MRL from parts ;-) */
  565.     i_pos = snprintf( &text[0], VLC_MAX_MRL, "%s://", (char*)psz_mrlProtocol);
  566.     if (strncasecmp( (char*)psz_mrlNetworkType, "multicast",9)==0)
  567.     {
  568.         i_pos += snprintf( &text[i_pos], VLC_MAX_MRL - i_pos, "@" );
  569.     }
  570.     i_pos += snprintf( &text[i_pos], VLC_MAX_MRL - i_pos, "%s:%d", (char*)psz_mrlAddress, (int)i_mrlPort );
  572.     if (i_pos >= VLC_MAX_MRL)
  573.     {
  574.         text[VLC_MAX_MRL-1]='';
  575.         msg_Err( p_intf, "Media Resource Locator is truncated to: %s", text);
  576.     }
  578.     gtk_entry_set_text(p_entryMRL,text);
  579. }
  581. void onAddNetworkPlaylist(GtkButton *button, gpointer user_data)
  582. {
  583.     intf_thread_t  *p_intf = GtkGetIntf( button );
  585.     GtkEntry       *p_mrl = NULL;
  586.     GtkCheckButton *p_network_transcode = NULL;
  587.     gboolean        b_network_transcode;
  588.     const gchar    *psz_mrl_name;
  590.     p_mrl = (GtkEntry*) lookup_widget(GTK_WIDGET(button),"entryMRL" );
  591.     psz_mrl_name = gtk_entry_get_text(p_mrl);
  593.     p_network_transcode = (GtkCheckButton*) lookup_widget(GTK_WIDGET(button), "checkNetworkTranscode" );
  594.     b_network_transcode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(p_network_transcode));
  595.     if (b_network_transcode)
  596.     {
  597.         msg_Dbg( p_intf, "Network transcode option selected." );
  598.         onAddTranscodeToPlaylist(button, (gchar *)psz_mrl_name);
  599.     }
  600.     else
  601.     {
  602.         msg_Dbg( p_intf, "Network receiving selected." );
  603.         PlaylistAddItem(GTK_WIDGET(button), (gchar *)psz_mrl_name, 0, 0);
  604.     }
  605. }
  608. void onAddCameraToPlaylist(GtkButton *button, gpointer user_data)
  609. {
  610.     intf_thread_t *p_intf = GtkGetIntf( button );
  612.     GtkSpinButton *entryV4LChannel = NULL;
  613.     GtkSpinButton *entryV4LFrequency = NULL;
  614.     GtkSpinButton *entryV4LSampleRate = NULL;
  615.     GtkSpinButton *entryV4LQuality = NULL;
  616.     GtkSpinButton *entryV4LTuner = NULL;
  617.     gint    i_v4l_channel;
  618.     gint    i_v4l_frequency;
  619.     gint    i_v4l_samplerate;
  620.     gint    i_v4l_quality;
  621.     gint    i_v4l_tuner;
  623.     GtkEntry      *entryV4LVideoDevice = NULL;
  624.     GtkEntry      *entryV4LAudioDevice = NULL;
  625.     GtkEntry      *entryV4LNorm = NULL;
  626.     GtkEntry      *entryV4LSize = NULL;
  627.     GtkEntry      *entryV4LSoundDirection = NULL;
  628.     const gchar   *p_v4l_video_device;
  629.     const gchar   *p_v4l_audio_device;
  630.     const gchar   *p_v4l_norm;
  631.     const gchar   *p_v4l_size;
  632.     const gchar   *p_v4l_sound_direction;
  634.     /* MJPEG only */
  635.     GtkCheckButton *checkV4LMJPEG = NULL;
  636.     GtkSpinButton  *entryV4LDecimation = NULL;
  637.     gboolean        b_v4l_mjpeg;
  638.     gint            i_v4l_decimation;
  639.     /* end MJPEG only */
  641.     GtkCheckButton  *p_check_v4l_transcode = NULL;
  642.     gboolean         b_v4l_transcode;
  643.  
  644.     char **ppsz_options = NULL; /* list of options */
  645.     int  i_options=0;
  646.     char v4l_mrl[6];
  647.     int i_pos;
  648.     int i;
  650.     ppsz_options = (char **) malloc(11 *sizeof(char*));
  651.     if (ppsz_options == NULL)
  652.         return;
  653.     for (i=0; i<11; i++)
  654.     {
  655.         ppsz_options[i] = (char *) malloc(VLC_MAX_MRL);
  656.         if (ppsz_options[i] == NULL)
  657.         {
  658.             for (i-=1; i>=0; i--)
  659.                 free(ppsz_options[i]);
  660.             free(ppsz_options);
  661.             return;
  662.         }
  663.     }
  665.     i_pos = snprintf( &v4l_mrl[0], 6, "v4l");
  666.     v4l_mrl[5]='';
  668.     entryV4LChannel    = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryV4LChannel" );
  669.     entryV4LFrequency  = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryV4LFrequency" );
  670.     entryV4LSampleRate = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryV4LSampleRate" );
  671.     entryV4LQuality    = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryV4LQuality" );
  672.     entryV4LTuner      = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryV4LTuner" );
  674.     entryV4LVideoDevice  = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryV4LVideoDevice" );
  675.     entryV4LAudioDevice  = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryV4LAudioDevice" );
  676.     entryV4LNorm  = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryV4LNorm" );
  677.     entryV4LSize  = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryV4LSize" );
  678.     entryV4LSoundDirection  = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryV4LSoundDirection" );
  680.     i_v4l_channel = gtk_spin_button_get_value_as_int(entryV4LChannel);
  681.     i_v4l_frequency = gtk_spin_button_get_value_as_int(entryV4LFrequency);
  682.     i_v4l_samplerate = gtk_spin_button_get_value_as_int(entryV4LSampleRate);
  683.     i_v4l_quality = gtk_spin_button_get_value_as_int(entryV4LQuality);
  684.     i_v4l_tuner = gtk_spin_button_get_value_as_int(entryV4LTuner);
  686.     p_v4l_video_device = gtk_entry_get_text(GTK_ENTRY(entryV4LVideoDevice));
  687.     p_v4l_audio_device = gtk_entry_get_text(GTK_ENTRY(entryV4LAudioDevice));
  688.     p_v4l_norm = gtk_entry_get_text(GTK_ENTRY(entryV4LNorm));
  689.     p_v4l_size  = gtk_entry_get_text(GTK_ENTRY(entryV4LSize));
  690.     p_v4l_sound_direction = gtk_entry_get_text(GTK_ENTRY(entryV4LSoundDirection));
  692.     i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "%s", (char*)p_v4l_video_device );
  693.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  694.     i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "adev=%s", (char*)p_v4l_audio_device );
  695.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  696.     i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "norm=%s", (char*)p_v4l_norm );
  697.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  698.     i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "size=%s", (char*)p_v4l_size );
  699.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  700.     i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "%s", (char*)p_v4l_sound_direction );
  701.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  703.     i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "channel=%d", (int)i_v4l_channel );
  704.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  705.     i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "frequency=%d", (int)i_v4l_frequency );
  706.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  707.     i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "samplerate=%d", (int)i_v4l_samplerate );
  708.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  709.     i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "quality=%d", (int)i_v4l_quality );
  710.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  711.     i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "tuner=%d", (int)i_v4l_tuner );
  712.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  714.     /* MJPEG only */
  715.     checkV4LMJPEG      = (GtkCheckButton*) lookup_widget( GTK_WIDGET(button), "checkV4LMJPEG" );
  716.     b_v4l_mjpeg = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkV4LMJPEG));
  717.     if (b_v4l_mjpeg)
  718.     {
  719.         entryV4LDecimation = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryV4LDecimation" );
  720.         i_v4l_decimation = gtk_spin_button_get_value_as_int(entryV4LDecimation);
  722.         i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "mjpeg:%d", (int)i_v4l_decimation );
  723.         if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  724.     }
  725.     /* end MJPEG only */
  727.     p_check_v4l_transcode = (GtkCheckButton*) lookup_widget(GTK_WIDGET(button), "checkV4LTranscode" );
  728.     b_v4l_transcode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(p_check_v4l_transcode));
  729.     if (b_v4l_transcode)
  730.     {
  731.         msg_Dbg( p_intf, "Camera transcode option selected." );
  732.         onAddTranscodeToPlaylist(button, (gchar *)v4l_mrl);
  733.     }
  734.     else
  735.     {
  736.         msg_Dbg( p_intf, "Camera reception option selected." );
  737.         PlaylistAddItem(GTK_WIDGET(button), (gchar*) &v4l_mrl, ppsz_options, i_options);
  738.     }
  739. }
  742. gboolean PlaylistEvent(GtkWidget *widget, GdkEvent *event, gpointer user_data)
  743. {
  744.     return FALSE;
  745. }
  748. void onPlaylistColumnsChanged(GtkTreeView *treeview, gpointer user_data)
  749. {
  750. }
  753. gboolean onPlaylistRowSelected(GtkTreeView *treeview, gboolean start_editing, gpointer user_data)
  754. {
  755.     return FALSE;
  756. }
  759. void onPlaylistRow(GtkTreeView *treeview, GtkTreePath *path,
  760.                    GtkTreeViewColumn *column, gpointer user_data)
  761. {
  762.     intf_thread_t *p_intf = GtkGetIntf( GTK_WIDGET(treeview) );
  763.     GtkTreeSelection *p_selection = gtk_tree_view_get_selection(treeview);
  764.     playlist_t * p_playlist = pl_Hold( p_intf );
  766.     if( p_playlist == NULL )
  767.     {
  768.         return; // FALSE;
  769.     }
  771.     if (gtk_tree_selection_count_selected_rows(p_selection) == 1)
  772.     {
  773.         GtkTreeModel *p_model;
  774.         GtkTreeIter   iter;
  775.         int           i_row;
  776.         int           i_skip;
  778.         /* This might be a directory selection */
  779.         p_model = gtk_tree_view_get_model(treeview);
  780.         if (!p_model)
  781.         {
  782.             msg_Err(p_intf, "PDA: Playlist model contains a NULL pointer" );
  783.             pl_Release( p_intf );
  784.             return;
  785.         }
  786.         if (!gtk_tree_model_get_iter(p_model, &iter, path))
  787.         {
  788.             msg_Err( p_intf, "PDA: Playlist could not get iter from model" );
  789.             pl_Release( p_intf );
  790.             return;
  791.         }
  793.         gtk_tree_model_get(p_model, &iter, 2, &i_row, -1);
  794.         i_skip = i_row - p_playlist->i_current_index;
  795.         playlist_Skip( p_playlist, i_skip );
  796.     }
  797.     pl_Release( p_intf );
  798. }
  801. void onUpdatePlaylist(GtkButton *button, gpointer user_data)
  802. {
  803.     intf_thread_t *  p_intf = GtkGetIntf( button );
  804.     playlist_t * p_playlist = pl_Hold( p_intf );
  805.     GtkTreeView *p_tvplaylist = NULL;
  807.     if( p_playlist == NULL )
  808.     {
  809.         return;
  810.     }
  812.     p_tvplaylist = (GtkTreeView*) lookup_widget( GTK_WIDGET(button), "tvPlaylist");
  813.     if (p_tvplaylist)
  814.     {
  815.         GtkListStore *p_model = NULL;
  817.         /* Rebuild the playlist then. */
  818.         p_model = gtk_list_store_new (3,
  819.                     G_TYPE_STRING, /* Filename */
  820.                     G_TYPE_STRING, /* Time */
  821.                     G_TYPE_UINT);  /* Hidden field */
  822.         if (p_model)
  823.         {
  824.             PlaylistRebuildListStore(p_intf, p_model, p_playlist);
  825.             gtk_tree_view_set_model(GTK_TREE_VIEW(p_tvplaylist), GTK_TREE_MODEL(p_model));
  826.             g_object_unref(p_model);
  827.         }
  828.     }
  829.     pl_Release( p_intf );
  830. }
  832. static void deleteItemFromPlaylist(gpointer data, gpointer user_data)
  833. {
  834.     gtk_tree_path_free((GtkTreePath*) data); // removing an item.
  835. }
  837. void onDeletePlaylist(GtkButton *button, gpointer user_data)
  838. {
  839.     intf_thread_t *p_intf = GtkGetIntf( button );
  840.     playlist_t * p_playlist = pl_Hold( p_intf );
  841.     GtkTreeView    *p_tvplaylist;
  843.     /* Delete an arbitrary item from the playlist */
  844.     p_tvplaylist = (GtkTreeView *) lookup_widget( GTK_WIDGET(button), "tvPlaylist" );
  845.     if (p_tvplaylist != NULL)
  846.     {
  847.         GList *p_rows = NULL;
  848.         GList *p_node;
  849.         GtkTreeModel *p_model = NULL;
  850.         GtkListStore *p_store = NULL;
  851.         GtkTreeSelection *p_selection = gtk_tree_view_get_selection(p_tvplaylist);
  853.         p_model = gtk_tree_view_get_model(p_tvplaylist);
  854.         if (p_model)
  855.         {
  856.             p_rows = gtk_tree_selection_get_selected_rows(p_selection, &p_model);
  858.             if( g_list_length( p_rows ) )
  859.             {
  860.                 /* reverse-sort so that we can delete from the furthest
  861.                  * to the closest item to delete...
  862.                  */
  863.                 p_rows = g_list_reverse( p_rows );
  864.             }
  866.             for (p_node=p_rows; p_node!=NULL; p_node = p_node->next)
  867.             {
  868.                 GtkTreeIter iter;
  869.                 GtkTreePath *p_path = NULL;
  871.                 p_path = (GtkTreePath *)p_node->data;
  872.                 if (p_path)
  873.                 {
  874.                     if (gtk_tree_model_get_iter(p_model, &iter, p_path))
  875.                     {
  876.                         gint item;
  878.                         gtk_tree_model_get(p_model, &iter, 2, &item, -1);
  879.                         msg_Err( p_playlist, "PDA delete broken");
  880.                     }
  881.                 }
  882.             }
  883. #if 0
  884.             g_list_foreach (p_rows, (GFunc*)gtk_tree_path_free, NULL);
  885. #endif /* Testing the next line */
  886.             g_list_foreach (p_rows, deleteItemFromPlaylist, NULL);
  887.             g_list_free (p_rows);
  888.         }
  890.         /* Rebuild the playlist then. */
  891.         p_store = gtk_list_store_new (3,
  892.                     G_TYPE_STRING, /* Filename */
  893.                     G_TYPE_STRING, /* Time */
  894.                     G_TYPE_UINT);  /* Hidden field */
  895.         if (p_store)
  896.         {
  897.             PlaylistRebuildListStore(p_intf, p_store, p_playlist);
  898.             gtk_tree_view_set_model(GTK_TREE_VIEW(p_tvplaylist), GTK_TREE_MODEL(p_store));
  899.             g_object_unref(p_store);
  900.         }
  901.     }
  902.     pl_Release( p_intf );
  903. }
  906. void onClearPlaylist(GtkButton *button, gpointer user_data)
  907. {
  908.     intf_thread_t *p_intf = GtkGetIntf( button );
  909.     playlist_t * p_playlist = pl_Hold( p_intf );
  910.     GtkTreeView    *p_tvplaylist;
  911.     int item;
  913.     if( p_playlist == NULL )
  914.     {
  915.         return;
  916.     }
  918.     for(item = playlist_CurrentSize(p_playlist) - 1; item >= 0 ;item-- )
  919.     {
  920.         msg_Err( p_playlist, "fix pda delete" );
  921.     }
  922.     pl_Release( p_intf );
  924.     // Remove all entries from the Playlist widget.
  925.     p_tvplaylist = (GtkTreeView*) lookup_widget( GTK_WIDGET(button), "tvPlaylist");
  926.     if (p_tvplaylist)
  927.     {
  928.         GtkTreeModel *p_play_model;
  930.         p_play_model = gtk_tree_view_get_model(p_tvplaylist);
  931.         if (p_play_model)
  932.         {
  933.             gtk_list_store_clear(GTK_LIST_STORE(p_play_model));
  934.         }
  935.     }
  936. }
  939. void onPreferenceSave(GtkButton *button, gpointer user_data)
  940. {
  941. #if 0
  942.     intf_thread_t *p_intf = GtkGetIntf( button );
  944.     msg_Dbg(p_intf, "Preferences Save" );
  945.     config_SaveConfigFile( p_intf, NULL );
  946. #endif
  947. }
  950. void onPreferenceApply(GtkButton *button, gpointer user_data)
  951. {
  952. #if 0
  953.     intf_thread_t *p_intf = GtkGetIntf( button );
  955.     msg_Dbg(p_intf, "Preferences Apply" );
  956. #endif
  957. }
  960. void onPreferenceCancel(GtkButton *button, gpointer user_data)
  961. {
  962. #if 0
  963.     intf_thread_t *p_intf = GtkGetIntf( button );
  965.     msg_Dbg(p_intf, "Preferences Cancel" );
  966.     config_ResetAll( p_intf );
  967.     /* Cancel interface changes. */
  968.     config_SaveConfigFile( p_intf, NULL );
  969. #endif
  970. }
  973. void onAddTranscodeToPlaylist(GtkButton *button, gpointer user_data)
  974. {
  975.     intf_thread_t *p_intf = GtkGetIntf( button );
  977.     GtkEntry       *p_entryVideoCodec = NULL;
  978.     GtkSpinButton  *p_entryVideoBitrate = NULL;
  979.     GtkSpinButton  *p_entryVideoBitrateTolerance = NULL;
  980.     GtkSpinButton  *p_entryVideoKeyFrameInterval = NULL;
  981.     GtkCheckButton *p_checkVideoDeinterlace = NULL;
  982.     GtkEntry       *p_entryAudioCodec = NULL;
  983.     GtkSpinButton  *p_entryAudioBitrate = NULL;
  984.     const gchar    *p_video_codec;
  985.     gint            i_video_bitrate;
  986.     gint            i_video_bitrate_tolerance;
  987.     gint            i_video_keyframe_interval;
  988.     gboolean        b_video_deinterlace;
  989.     const gchar    *p_audio_codec;
  990.     gint            i_audio_bitrate;
  992.     GtkEntry       *p_entryStdAccess = NULL;
  993.     GtkEntry       *p_entryStdMuxer = NULL;
  994.     GtkEntry       *p_entryStdURL = NULL;
  995.     GtkEntry       *p_entryStdAnnounce = NULL;
  996.     GtkSpinButton  *p_entryStdTTL = NULL;
  997.     GtkCheckButton *p_checkSAP = NULL;
  998.     GtkCheckButton *p_checkSLP = NULL;
  999.     const gchar    *p_std_announce;
  1000.     const gchar    *p_std_access;
  1001.     const gchar    *p_std_muxer;
  1002.     const gchar    *p_std_url;
  1003.     gboolean        b_sap_announce;
  1004.     gboolean        b_slp_announce;
  1005.     gint            i_std_ttl;
  1007.     char **ppsz_options = NULL; /* list of options */
  1008.     int  i_options=0;
  1009.     int  i;
  1011.     gchar mrl[7];
  1012.     int   i_pos;
  1014.     ppsz_options = (char **) malloc(3 *sizeof(char*));
  1015.     if (ppsz_options == NULL)
  1016.         return;
  1017.     for (i=0; i<3; i++)
  1018.     {
  1019.         ppsz_options[i] = (char *) malloc(VLC_MAX_MRL);
  1020.         if (ppsz_options[i] == NULL)
  1021.         {
  1022.             for (i-=1; i>=0; i--)
  1023.                 free(ppsz_options[i]);
  1024.             free(ppsz_options);
  1025.             return;
  1026.         }
  1027.     }
  1029.     /* Update the playlist */
  1030.     playlist_t *p_playlist = pl_Hold( p_intf );
  1031.     if( p_playlist == NULL ) return;
  1032.     pl_Release( p_intf );
  1034.     /* Get all the options. */
  1035.     i_pos = snprintf( &mrl[0], VLC_MAX_MRL, "sout");
  1036.     mrl[6] = '';
  1037.     /* option 1 */
  1038.     i_pos = snprintf( &ppsz_options[i_options][0], VLC_MAX_MRL, "sout='#transcode{");
  1039.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1041.     p_entryVideoCodec   = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryVideoCodec" );
  1042.     p_entryVideoBitrate = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryVideoBitrate" );
  1043.     p_entryVideoBitrateTolerance = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryVideoBitrateTolerance" );
  1044.     p_entryVideoKeyFrameInterval = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryVideoKeyFrameInterval" );
  1045.  
  1046.     p_video_codec = gtk_entry_get_text(GTK_ENTRY(p_entryVideoCodec));
  1047.     i_video_bitrate = gtk_spin_button_get_value_as_int(p_entryVideoBitrate);
  1048.     i_video_bitrate_tolerance = gtk_spin_button_get_value_as_int(p_entryVideoBitrateTolerance);
  1049.     i_video_keyframe_interval = gtk_spin_button_get_value_as_int(p_entryVideoKeyFrameInterval);
  1050.  
  1051.     i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "vcodec=%s,", (char*)p_video_codec );
  1052.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1053.     i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "vb=%d,", (int)i_video_bitrate );
  1054.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1055.     i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "vt=%d,", (int)i_video_bitrate_tolerance );
  1056.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1057.     i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "keyint=%d,", (int)i_video_keyframe_interval );
  1058.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1060.     p_checkVideoDeinterlace = (GtkCheckButton*) lookup_widget( GTK_WIDGET(button), "checkVideoDeinterlace" );
  1061.     b_video_deinterlace = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(p_checkVideoDeinterlace));
  1062.     if (b_video_deinterlace)
  1063.     {
  1064.         i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "deinterlace," );
  1065.         if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1066.     }
  1067.     p_entryAudioCodec   = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryAudioCodec" );
  1068.     p_entryAudioBitrate = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryAudioBitrate" );
  1070.     p_audio_codec = gtk_entry_get_text(GTK_ENTRY(p_entryAudioCodec));
  1071.     i_audio_bitrate = gtk_spin_button_get_value_as_int(p_entryAudioBitrate);
  1073.     i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "acodec=%s,", (char*)p_audio_codec );
  1074.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1075.     i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "ab=%d,", (int)i_audio_bitrate );
  1076.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1077.     i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "channels=1}"/*, (int)i_audio_channels*/ );
  1078.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1080.     /* option 2 */
  1081.     i_pos = 0;
  1082.     i_pos = snprintf( &ppsz_options[i_options++][i_pos], VLC_MAX_MRL - i_pos, "#" );
  1083.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1085.     p_entryStdAccess = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryStdAccess" );
  1086.     p_entryStdMuxer  = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryStdMuxer" );
  1087.     p_entryStdURL = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryStdURL" );
  1088.     p_entryStdAnnounce = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryAnnounceChannel" );
  1089.     p_entryStdTTL = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryStdTTL" );
  1091.     p_std_access = gtk_entry_get_text(GTK_ENTRY(p_entryStdAccess));
  1092.     p_std_muxer = gtk_entry_get_text(GTK_ENTRY(p_entryStdMuxer));
  1093.     p_std_url = gtk_entry_get_text(GTK_ENTRY(p_entryStdURL));
  1094.     p_std_announce = gtk_entry_get_text(GTK_ENTRY(p_entryStdAnnounce));
  1095.     b_sap_announce = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(p_checkSAP));
  1096.     b_slp_announce = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(p_checkSLP));
  1098.     i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "std{access=%s,", (char*)p_std_access);
  1099.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1100.     i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "mux=%s,", (char*)p_std_muxer);
  1101.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1102.     i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "dst=%s", (char*)p_std_url);
  1103.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1105.     if (strncasecmp( (const char*)p_std_access, "udp", 3)==0)
  1106.     {
  1107.         if (b_sap_announce)
  1108.         {
  1109.             i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "sap=%s", (char*)p_std_announce);
  1110.             if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1111.         }
  1112.         if (b_slp_announce)
  1113.         {
  1114.             i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "slp=%s", (char*)p_std_announce);
  1115.             if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1116.         }
  1117.     }
  1119.     i_std_ttl = gtk_spin_button_get_value_as_int(p_entryStdTTL);
  1121.     i_pos += snprintf( &ppsz_options[i_options++][i_pos], VLC_MAX_MRL - i_pos, "ttl=%d}", (int)i_std_ttl);
  1122.     if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '';
  1124.     if (user_data != NULL)
  1125.     {
  1126.       msg_Dbg(p_intf, "Adding transcoding options to playlist item." );
  1127.     }
  1128.     else
  1129.     {
  1130.       msg_Dbg(p_intf, "Adding --sout to playlist." );
  1131.       PlaylistAddItem(GTK_WIDGET(button), (gchar*) &mrl, ppsz_options, i_options);
  1132.     }
  1133. }
  1135. void onEntryStdAccessChanged(GtkEditable *editable, gpointer user_data)
  1136. {
  1137.     intf_thread_t *p_intf = GtkGetIntf( editable );
  1139.     GtkCheckButton *p_checkSAP = NULL;
  1140.     GtkCheckButton *p_checkSLP = NULL;
  1141.     GtkEntry       *p_entryStdAccess = NULL;
  1142.     const gchar    *p_std_access = NULL;
  1143.     gboolean        b_announce = FALSE;
  1145.     p_entryStdAccess = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryStdAccess" );
  1146.     p_checkSAP = (GtkCheckButton*) lookup_widget( GTK_WIDGET(editable), "checkSAP" );
  1147.     p_checkSLP = (GtkCheckButton*) lookup_widget( GTK_WIDGET(editable), "checkSLP" );
  1149.     if ( (p_std_access == NULL) || (p_checkSAP == NULL) || (p_checkSLP == NULL))
  1150.     {
  1151.         msg_Err( p_intf, "Access, SAP and SLP widgets not found." );
  1152.         return;
  1153.     }
  1154.     p_std_access = gtk_entry_get_text(GTK_ENTRY(p_entryStdAccess));
  1156.     b_announce = (strncasecmp( (const char*)p_std_access, "udp", 3) == 0);
  1157.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(p_checkSAP), b_announce);
  1158.     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(p_checkSLP), b_announce);
  1159. }