Mercurialgmyth / file revision
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | revisions | annotate | diff | raw
gmyth-stream/libgnomevfs2/modules/gmythstream-method.c
author renatofilho
Thu Apr 12 22:16:55 2007 +0100 (2007-04-12)
branchtrunk
changeset 539 c67cec9e6073
parent 538 05e6ab23f892
child 540 d6f9b0417346
permissions -rw-r--r--
[svn r544] fixed args parse 
     1 /*

     2  * @author Artur Duque de Souza <souza.artur@indt.org.br>

     3  *

     4  * This program is free software; you can redistribute it and/or modify

     5  * it under the terms of the GNU Lesser General Public License as published by

     6  * the Free Software Foundation; either version 2 of the License, or

     7  * (at your option) any later version.

     8  *

     9  * This program is distributed in the hope that it will be useful,

    10  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12  * GNU General Public License for more details.

    13  *

    14  m * You should have received a copy of the GNU Lesser General Public License

    15  * along with this program; if not, write to the Free Software

    16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    17  */

    18 

    19 #ifdef HAVE_CONFIG_H

    20 #include <config.h>

    21 #endif

    22 

    23 #include <sys/socket.h> /* for socket(), connect(), send(), and recv() */

    24 #include <arpa/inet.h>  /* for sockaddr_in and inet_addr() */

    25 #include <stdlib.h>     /* for atoi() and exit() */

    26 #include <string.h>     /* for memset() */

    27 #include <unistd.h>     /* for close() */

    28 #include <errno.h>

    29 

    30 #include <glib.h>

    31 #include <glib/gprintf.h>

    32 #include <glib/gstdio.h>

    33 #include <gmyth-stream-client.h>

    34 

    35 #include <libgnomevfs/gnome-vfs-module.h>

    36 #include <libgnomevfs/gnome-vfs-utils.h>

    37 

    38 #define BUFFER_SIZE 4096

    39 

    40 typedef struct {

    41     gint port;

    42     gchar* hostname;

    43 

    44     GMythStreamClient *stream;

    45     gint fd;

    46 } gmsHandle;

    47 

    48 typedef struct {

    49     gchar *file_name;

    50     gchar *mux;

    51     gchar *vcodec;

    52     guint vbitrate;

    53     gdouble fps;

    54     gchar *acodec;

    55     guint abitrate;

    56     guint width;

    57     guint height;

    58     guint port;

    59     gchar *opt;

    60 } UriArgs;

    61 

    62 

    63 static gmsHandle* gmsHandle_new(GnomeVFSURI *uri);

    64 

    65 static GnomeVFSResult

    66 do_open (GnomeVFSMethod        *method,

    67 	 GnomeVFSMethodHandle **method_handle,

    68 	 GnomeVFSURI           *uri,

    69 	 GnomeVFSOpenMode       mode,

    70 	 GnomeVFSContext       *context);

    71 

    72 static GnomeVFSResult

    73 do_read (GnomeVFSMethod       *method,

    74 	 GnomeVFSMethodHandle *method_handle,

    75 	 gpointer              buffer,

    76 	 GnomeVFSFileSize      bytes,

    77 	 GnomeVFSFileSize     *bytes_read,

    78 	 GnomeVFSContext      *context);

    79 

    80 static GnomeVFSResult

    81 do_close (GnomeVFSMethod * method,

    82           GnomeVFSMethodHandle * method_handle,

    83           GnomeVFSContext * context);

    84 

    85 static GnomeVFSResult

    86 do_get_file_info (GnomeVFSMethod * method,

    87 		  GnomeVFSURI * uri,

    88 		  GnomeVFSFileInfo * file_info,

    89 		  GnomeVFSFileInfoOptions options,

    90 		  GnomeVFSContext * context);

    91 

    92 

    93 static GnomeVFSResult

    94 do_get_file_info_from_handle (GnomeVFSMethod 		*method,

    95                               GnomeVFSMethodHandle 	*method_handle,

    96                               GnomeVFSFileInfo 		*file_info,

    97                               GnomeVFSFileInfoOptions    options,

    98                               GnomeVFSContext 		*context);

    99 

   100 

   101 static gboolean

   102 do_is_local (GnomeVFSMethod * method, const GnomeVFSURI * uri);

   103 

   104 

   105 static gmsHandle* gmsHandle_new(GnomeVFSURI *uri)

   106 {

   107     gmsHandle* handler = (gmsHandle*)g_malloc0(sizeof(gmsHandle));

   108 

   109     handler->hostname = (gchar*)gnome_vfs_uri_get_host_name(uri);

   110     handler->port = gnome_vfs_uri_get_host_port(uri);

   111     handler->stream = gmyth_stream_client_new ();

   112 

   113     return handler;

   114 }

   115 

   116 static GnomeVFSMethod method = {

   117     sizeof (GnomeVFSMethod),

   118     do_open,                       /* open */

   119     NULL,                          /* create */

   120     do_close,                      /* close */

   121     do_read,                       /* read */

   122     NULL,                          /* write */

   123     NULL,                          /* seek */

   124     NULL,                          /* tell */

   125     NULL,                          /* truncate_handle */

   126     NULL,                          /* open_directory */

   127     NULL,                          /* close_directory */

   128     NULL,                          /* read_directory */

   129     do_get_file_info,              /* get_file_info */

   130     do_get_file_info_from_handle,  /* get_file_info_from_handle */

   131     do_is_local,                   /* is_local */

   132     NULL,                          /* make_directory */

   133     NULL,                          /* remove_directory */

   134     NULL,                          /* move */

   135     NULL,                          /* unlink */

   136     NULL,                          /* check_same_fs */

   137     NULL,                          /* set_file_info */

   138     NULL,                          /* truncate */

   139     NULL,                          /* find_directory */

   140     NULL,                          /* create_symbolic_link */

   141     NULL,                          /* monitor_add */

   142     NULL,                          /* monitor_cancel */

   143     NULL                           /* file_control */

   144 };

   145 

   146 GnomeVFSMethod *

   147 vfs_module_init (const char *method_name, const char *args)

   148 {

   149     return &method;

   150 }

   151 

   152 void

   153 vfs_module_shutdown (GnomeVFSMethod* method)

   154 {

   155     return;

   156 }

   157 

   158 static UriArgs *

   159 _uri_parse_args (const GnomeVFSURI *uri)

   160 {

   161 

   162     gchar *file;

   163     UriArgs *info = g_new0 (UriArgs, 1);

   164 	GSList *args = NULL;

   165 	gchar *c;

   166 	GString *entry;

   167 	gboolean open = FALSE;

   168 	gchar **prop;

   169     GSList* walk;

   170 	gchar *uri_str = gnome_vfs_uri_to_string (uri,

   171 			GNOME_VFS_URI_HIDE_USER_NAME |

   172 			GNOME_VFS_URI_HIDE_PASSWORD |

   173 			GNOME_VFS_URI_HIDE_HOST_NAME |

   174 			GNOME_VFS_URI_HIDE_HOST_PORT |

   175 			GNOME_VFS_URI_HIDE_TOPLEVEL_METHOD);

   176 

   177 	file = gnome_vfs_unescape_string (uri_str, "");

   178 	c = file;

   179 	//skip "/"

   180 	entry = g_string_new ("");

   181 	c = c + 1;

   182 	do {

   183 		if ((*c == '\"') || (*c == '\'')) {

   184 			open = !open;

   185 		}

   186 

   187 		if (((*c == '?') || (c + 1 == '\0')) && !open) {

   188 			args = g_slist_append (args, g_strdup (entry->str));

   189 			entry = g_string_assign (entry, "");

   190 		} else {

   191 			if (*c == '#')

   192 				g_string_append (entry, "//");

   193 			else

   194 				g_string_append_c (entry, *c);

   195 		}

   196 		c = c + 1;

   197 	} while (*c != '\0');

   198 

   199 	g_string_free (entry, TRUE);

   200 

   201     for (walk = args; walk != NULL; walk = walk->next)

   202     {

   203 		gchar *arg = (gchar *) walk->data;

   204         prop = g_strsplit(arg, "=", 2);

   205 

   206         if (g_strv_length (prop) == 2) {

   207 			if (strcmp (prop[0], "file") == 0) {

   208 				info->file_name = g_strdup (prop[1]);

   209 			} else if (strcmp (prop[0], "mux") == 0) {

   210                 info->mux = g_strdup (prop[1]);

   211             } else if (strcmp (prop[0], "vcodec") == 0) {

   212                 info->vcodec = g_strdup (prop[1]);

   213             } else if (strcmp (prop[0], "vbitrate") == 0) {

   214                 info->vbitrate = atoi (prop[1]);

   215             } else if (strcmp (prop[0], "fps") == 0) {

   216                 info->fps = g_strtod (prop[1], NULL);

   217             } else if (strcmp (prop[0], "acodec") == 0) {

   218                 info->acodec = g_strdup (prop[1]);

   219             } else if (strcmp (prop[0], "abitrate") == 0) {

   220                 info->abitrate = atoi (prop[1]);

   221             } else if (strcmp (prop[0], "width") == 0) {

   222                 info->width = atoi (prop[1]);

   223             } else if (strcmp (prop[0], "height") == 0) {

   224                 info->height = atoi (prop[1]);

   225             } else if (strcmp (prop[0], "opt") == 0) {

   226                 g_debug("DENTRO DE OPT: %s", arg);

   227                 //char* v = _parse_opt(walk);

   228                 info->opt = g_strdup (arg);

   229             }

   230         }

   231         g_strfreev (prop);

   232 		g_free (arg);

   233     }

   234     g_free (file);

   235 	g_slist_free (args);

   236     return info;

   237 }

   238 

   239 static GnomeVFSResult

   240 do_open (GnomeVFSMethod        *method,

   241 	 GnomeVFSMethodHandle **method_handle,

   242 	 GnomeVFSURI           *uri,

   243 	 GnomeVFSOpenMode       mode,

   244 	 GnomeVFSContext       *context)

   245 {

   246     gmsHandle *handle = gmsHandle_new(uri);

   247     UriArgs *args;

   248 

   249     if (!gmyth_stream_client_connect (handle->stream,

   250                                       gnome_vfs_uri_get_host_name  (uri),

   251                                       gnome_vfs_uri_get_host_port  (uri))) {

   252 

   253         return GNOME_VFS_ERROR_INVALID_FILENAME;

   254     }

   255 

   256     args = _uri_parse_args (uri);

   257 

   258     gint ret = gmyth_stream_client_open_stream (handle->stream,

   259                                                 args->file_name,

   260                                                 args->mux,

   261                                                 args->vcodec,

   262                                                 args->vbitrate,

   263                                                 args->fps,

   264                                                 args->acodec,

   265                                                 args->abitrate,

   266                                                 args->width,

   267                                                 args->height,

   268                                                 args->opt);

   269 

   270     g_free (args);

   271 

   272     if (ret == -1) {

   273         gmyth_stream_client_disconnect (handle->stream);

   274         return GNOME_VFS_ERROR_INVALID_FILENAME;

   275     }

   276 

   277     handle->fd = gmyth_stream_client_play_stream (handle->stream);

   278 

   279     if (handle->fd == -1) {

   280         gmyth_stream_client_disconnect (handle->stream);

   281         return GNOME_VFS_ERROR_INVALID_FILENAME;

   282     }

   283 

   284     *method_handle = (GnomeVFSMethodHandle *) handle;

   285     return GNOME_VFS_OK;

   286 }

   287 

   288 static GnomeVFSResult

   289 do_read (GnomeVFSMethod       *method,

   290 	 GnomeVFSMethodHandle *method_handle,

   291 	 gpointer              buffer,

   292 	 GnomeVFSFileSize      bytes,

   293 	 GnomeVFSFileSize     *bytes_read,

   294 	 GnomeVFSContext      *context)

   295 {

   296 

   297     gint64 total_read = 0;

   298     gmsHandle *handle = (gmsHandle *) method_handle;

   299 

   300     total_read = recv(handle->fd, buffer, BUFFER_SIZE, 0);

   301     *bytes_read = (GnomeVFSFileSize) total_read;

   302 

   303     if (total_read < 0) return GNOME_VFS_ERROR_INTERNAL;

   304     else return GNOME_VFS_OK;

   305 

   306 }

   307 

   308 static GnomeVFSResult

   309 do_close (GnomeVFSMethod * method,

   310           GnomeVFSMethodHandle * method_handle,

   311           GnomeVFSContext * context)

   312 {

   313     gmsHandle *handle = (gmsHandle *) method_handle;

   314 

   315     gmyth_stream_client_close_stream (handle->stream);

   316     gmyth_stream_client_disconnect (handle->stream);

   317 

   318     g_free(handle);

   319     return GNOME_VFS_OK;

   320 }

   321 

   322 

   323 static GnomeVFSResult

   324 do_get_file_info (GnomeVFSMethod * method,

   325 		  GnomeVFSURI * uri,

   326 		  GnomeVFSFileInfo * file_info,

   327 		  GnomeVFSFileInfoOptions options,

   328 		  GnomeVFSContext * context)

   329 {

   330     file_info->valid_fields = GNOME_VFS_FILE_INFO_FIELDS_TYPE |

   331         GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS;

   332 

   333     file_info->type = GNOME_VFS_FILE_TYPE_SOCKET;

   334 

   335     file_info->permissions = GNOME_VFS_PERM_USER_READ |

   336         GNOME_VFS_PERM_OTHER_READ |

   337         GNOME_VFS_PERM_GROUP_READ;

   338 

   339     return GNOME_VFS_OK;

   340 }

   341 

   342 

   343 static GnomeVFSResult

   344 do_get_file_info_from_handle (GnomeVFSMethod 		*method,

   345                               GnomeVFSMethodHandle 	*method_handle,

   346                               GnomeVFSFileInfo 		*file_info,

   347                               GnomeVFSFileInfoOptions    options,

   348                               GnomeVFSContext 		*context)

   349 {

   350     file_info->valid_fields = GNOME_VFS_FILE_INFO_FIELDS_TYPE |

   351         GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS;

   352 

   353     file_info->type = GNOME_VFS_FILE_TYPE_SOCKET;

   354 

   355     file_info->permissions = GNOME_VFS_PERM_USER_READ |

   356         GNOME_VFS_PERM_OTHER_READ |

   357         GNOME_VFS_PERM_GROUP_READ;

   358 

   359     return GNOME_VFS_OK;

   360 }

   361 

   362 

   363 static gboolean

   364 do_is_local (GnomeVFSMethod * method, const GnomeVFSURI * uri)

   365 {

   366     return FALSE;

   367 }
gmyth