gstfs.c

   1 /*
   2  *  gstfs - a gstreamer filesystem
   3  */
   4 #include <sys/types.h>
   5 #include <dirent.h>
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <stdlib.h>
   9 #include <fuse.h>
  10 #include <errno.h>
  11 #include <glib.h>
  12 #include <printf.h>
  13 #include <gst/gst.h>
  14 #include "xcode.h"
  15
  16 #define min(a,b) ((a)<(b)?(a):(b))
  17 #define max(a,b) ((a)>(b)?(a):(b))
  18
  19 static GHashTable *file_cache;
  20 static char *get_source_path(const char *filename);
  21
  22 char *source_mount = "ogg";
  23 char *src_ext = "ogg", *dest_ext = "mp3";
  24
  25 // This stuff is stored into a hash table blah blah
  26 struct file_info
  27 {
  28     char *filename;           /* hash key */
  29     char *source_filename;    /* filename in other mount */
  30     size_t len;               /* size of file */
  31     size_t alloc_len;         /* allocated size of buf */
  32     char *buf;                /* completely converted file */
  33 };
  34
  35 struct file_info *new_file_info(const char *filename)
  36 {
  37     struct file_info *fi;
  38
  39     fi = calloc(1, sizeof(struct file_info));
  40     fi->filename = strdup(filename);
  41     fi->source_filename = get_source_path(filename);
  42     return fi;
  43 }
  44
  45 char *replace_ext(char *filename, char *search, char *replace)
  46 {
  47     char *ext = strrchr(filename, '.');
  48     if (ext && strcmp(ext+1, search) == 0)
  49     {
  50         *(ext+1) = 0;
  51         filename = g_strconcat(filename, replace, NULL);
  52     }
  53     return filename;
  54 }
  55
  56 int is_target_type(const char *filename)
  57 {
  58     char *ext = strrchr(filename, '.');
  59     return (ext && strcmp(ext+1, dest_ext) == 0);
  60 }
  61
  62 /*
  63  *  If the path represents a file in the mirror filesystem, then
  64  *  look for it in the cache.  If not, create a new file info.
  65  *
  66  *  If it isn't a mirror file, return NULL.
  67  */
  68 static struct file_info *gstfs_lookup(const char *path)
  69 {
  70     struct file_info *ret;
  71
  72     if (!is_target_type(path))
  73         return NULL;
  74
  75     ret = g_hash_table_lookup(file_cache, path);
  76     if (!ret)
  77     {
  78         ret = new_file_info(path);
  79         if (!ret)
  80             goto out;
  81
  82         g_hash_table_replace(file_cache, ret->filename, ret);
  83     }
  84 out:
  85     return ret;
  86 }
  87
  88 static char *get_source_path(const char *filename)
  89 {
  90     char *source;
  91
  92     printf("filename: %s\n", filename);
  93
  94     source = g_strdup_printf("%s%s", source_mount, filename);
  95     source = replace_ext(source, dest_ext, src_ext);
  96     printf("-> source filename: %s\n", source);
  97     return source;
  98 }
  99
 100 int gstfs_statfs(const char *path, struct statvfs *buf)
 101 {
 102     char *source_path;
 103
 104     source_path = get_source_path(path);
 105     if (statvfs(path, buf))
 106         return -errno;
 107
 108     g_free(source_path);
 109     return 0;
 110 }
 111
 112 int gstfs_getattr(const char *path, struct stat *stbuf)
 113 {
 114     int ret = 0;
 115     char *source_path;
 116     struct file_info *converted;
 117
 118     source_path = get_source_path(path);
 119
 120     printf("in gettattr, foo\n");
 121     if (stat(source_path, stbuf))
 122        ret = -errno;
 123     else if ((converted = gstfs_lookup(path)))
 124     {
 125        stbuf->st_size = converted->len;
 126     }
 127
 128     g_free(source_path);
 129     return ret;
 130 }
 131
 132 static int read_cb(char *buf, size_t size, void *data)
 133 {
 134     struct file_info *info = (struct file_info *) data;
 135
 136     size_t newsz = info->len + size;
 137
 138     if (info->alloc_len < newsz)
 139     {
 140         info->alloc_len = max(info->alloc_len * 2, newsz);
 141         info->buf = realloc(info->buf, info->alloc_len);
 142         if (!info->buf)
 143             return -ENOMEM;
 144     }
 145
 146     memcpy(&info->buf[info->len], buf, size);
 147     info->len += size;
 148     return 0;
 149 }
 150
 151 int gstfs_read(const char *path, char *buf, size_t size, off_t offset,
 152     struct fuse_file_info *fi)
 153 {
 154     struct file_info *info = gstfs_lookup(path);
 155     size_t count;
 156
 157     if (!info)
 158         return -ENOENT;
 159
 160     if (!info->buf)
 161         transcode(info->source_filename, read_cb, info);
 162
 163     if (info->len <= offset)
 164         return 0;
 165
 166     count = min(info->len - offset, size);
 167
 168     memcpy(buf, &info->buf[offset], count);
 169     return count;
 170 }
 171
 172 int gstfs_open(const char *path, struct fuse_file_info *fi)
 173 {
 174     struct file_info *info = gstfs_lookup(path);
 175     if (!info)
 176         return -ENOENT;
 177
 178     return 0;
 179 }
 180
 181 /**
 182  *  readdir - copy all entries from source mount
 183  */
 184 int gstfs_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
 185     off_t offset, struct fuse_file_info *fi)
 186 {
 187     struct dirent *dirent;
 188     DIR *dir;
 189     char *source_path;
 190
 191     source_path = get_source_path(path);
 192     dir = opendir(source_path);
 193
 194     if (!dir)
 195         return -ENOENT;
 196
 197     while ((dirent = readdir(dir)))
 198     {
 199         char *s = g_strdup(dirent->d_name);
 200         s = replace_ext(s, src_ext, dest_ext);
 201         filler(buf, s, NULL, 0);
 202
 203         g_free(s);
 204     }
 205     closedir(dir);
 206
 207     return 0;
 208 }
 209
 210 static struct fuse_operations gstfs_ops = {
 211     .readdir = gstfs_readdir,
 212     .statfs = gstfs_statfs,
 213     .getattr = gstfs_getattr,
 214     .open = gstfs_open,
 215     .read = gstfs_read
 216 };
 217
 218 int main(int argc, char *argv[])
 219 {
 220     gst_init (&argc, &argv);
 221     file_cache = g_hash_table_new(g_str_hash, g_str_equal);
 222
 223     return fuse_main(argc, argv, &gstfs_ops, NULL);
 224 }