Better reformatting of code

unix/plugin.cc

@@ -14,37 +14,35 @@ extern "C" {
 
 #include <libaudcore/audio.h>
 
-EXPORT VgmStreamPlugin aud_plugin_instance;
+VgmStreamPlugin aud_plugin_instance;
 Settings vgmstream_cfg;
 VGMSTREAM *vgmstream = NULL;
-#define CFG_ID "vgmstream"  //ID for storing in audacious
+#define CFG_ID "vgmstream" // ID for storing in audacious
 
-const char* const VgmStreamPlugin::defaults[] =
+const char *const VgmStreamPlugin::defaults[] = {
-{
+    "loop_forever", "1",          "loop_count", "2", "fade_length",
-    "loop_forever", "1",
+    "3",            "fade_delay", "3",          NULL};
-    "loop_count",   "2",
-    "fade_length",  "3",
-    "fade_delay",   "3",
-    NULL
-};
 
 const char VgmStreamPlugin::about[] =
     "audacious-vgmstream version: " AUDACIOUSVGMSTREAM_VERSION "\n\n"
     "ported to audacious 3.6 by Brandon Whitehead\n"
     "adopted from audacious 3 port by Thomas Eppers\n"
     "originally written by Todd Jeffreys (http://voidpointer.org/)\n"
-    "vgmstream written by hcs, FastElbja, manakoAT, and bxaimc (http://www.sf.net/projects/vgmstream)";
+    "vgmstream written by hcs, FastElbja, manakoAT, and bxaimc "
+    "(http://www.sf.net/projects/vgmstream)";
 
 const PreferencesWidget VgmStreamPlugin::widgets[] = {
     WidgetLabel(N_("<b>VGMStream Config</b>")),
     WidgetCheck(N_("Loop Forever:"), WidgetBool(vgmstream_cfg.loop_forever)),
-    WidgetSpin(N_("Loop Count:"), WidgetInt(vgmstream_cfg.loop_count), {1, 20, 1}),
+    WidgetSpin(N_("Loop Count:"), WidgetInt(vgmstream_cfg.loop_count),
-    WidgetSpin(N_("Fade Length:"), WidgetFloat(vgmstream_cfg.fade_length), {0, 60, 0.1}),
+               {1, 20, 1}),
-    WidgetSpin(N_("Fade Delay:"), WidgetFloat(vgmstream_cfg.fade_delay), {0, 60, 0.1}),
+    WidgetSpin(N_("Fade Length:"), WidgetFloat(vgmstream_cfg.fade_length),
+               {0, 60, 0.1}),
+    WidgetSpin(N_("Fade Delay:"), WidgetFloat(vgmstream_cfg.fade_delay),
+               {0, 60, 0.1}),
 };
 
-void vgmstream_cfg_load()
+void vgmstream_cfg_load() {
-{
   debugMessage("cfg_load called");
   aud_config_set_defaults(CFG_ID, VgmStreamPlugin::defaults);
   vgmstream_cfg.loop_forever = aud_get_bool(CFG_ID, "loop_forever");
@@ -53,8 +51,7 @@ void vgmstream_cfg_load()
   vgmstream_cfg.fade_delay = aud_get_double(CFG_ID, "fade_delay");
 }
 
-void vgmstream_cfg_save()
+void vgmstream_cfg_save() {
-{
   debugMessage("cfg_save called");
   aud_set_bool(CFG_ID, "loop_forever", vgmstream_cfg.loop_forever);
   aud_set_int(CFG_ID, "loop_count", vgmstream_cfg.loop_count);
@@ -63,34 +60,28 @@ void vgmstream_cfg_save()
 }
 
 const PluginPreferences VgmStreamPlugin::prefs = {
-    {widgets},
+    {widgets}, vgmstream_cfg_load, vgmstream_cfg_save};
-    vgmstream_cfg_load,
-    vgmstream_cfg_save
-};
 
-bool VgmStreamPlugin::init()
+bool VgmStreamPlugin::init() {
-{
   debugMessage("init");
   vgmstream_cfg_load();
   debugMessage("after load cfg");
   return true;
 }
 
-void VgmStreamPlugin::cleanup()
+void VgmStreamPlugin::cleanup() {
-{
   debugMessage("cleanup");
   vgmstream_cfg_save();
 }
 
 // called every time the user adds a new file to playlist
-Tuple VgmStreamPlugin::read_tuple(const char *filename, VFSFile& file)
+Tuple VgmStreamPlugin::read_tuple(const char *filename, VFSFile &file) {
-{
   debugMessage("probe for tuple");
   Tuple tuple;
   int ms;
   int rate;
-    VGMSTREAM* vgmstream  = NULL;
+  VGMSTREAM *vgmstream = NULL;
-    STREAMFILE* streamfile = NULL;
+  STREAMFILE *streamfile = NULL;
 
   streamfile = open_vfs(filename);
   vgmstream = init_vgmstream_from_STREAMFILE(streamfile);
@@ -99,7 +90,10 @@ Tuple VgmStreamPlugin::read_tuple(const char *filename, VFSFile& file)
   rate = vgmstream->sample_rate * 2 * vgmstream->channels;
   tuple.set_int(Tuple::Bitrate, rate);
 
-    ms = get_vgmstream_play_samples(vgmstream_cfg.loop_count, vgmstream_cfg.fade_length, vgmstream_cfg.fade_delay, vgmstream) * 1000LL / vgmstream->sample_rate;
+  ms = get_vgmstream_play_samples(vgmstream_cfg.loop_count,
+                                  vgmstream_cfg.fade_length,
+                                  vgmstream_cfg.fade_delay, vgmstream) *
+       1000LL / vgmstream->sample_rate;
   tuple.set_int(Tuple::Length, ms);
 
   close_streamfile(streamfile);
@@ -108,16 +102,14 @@ Tuple VgmStreamPlugin::read_tuple(const char *filename, VFSFile& file)
   return tuple;
 }
 
-bool VgmStreamPlugin::play(const char * filename, VFSFile& file)
+bool VgmStreamPlugin::play(const char *filename, VFSFile &file) {
-{
   int current_sample_pos = 0;
   int rate;
 
   debugMessage("start play");
-    STREAMFILE* streamfile = open_vfs(filename);
+  STREAMFILE *streamfile = open_vfs(filename);
 
-    if (!streamfile)
+  if (!streamfile) {
-    {
     printf("failed opening %s\n", filename);
     return false;
   }
@@ -125,8 +117,7 @@ bool VgmStreamPlugin::play(const char * filename, VFSFile& file)
   vgmstream = init_vgmstream_from_STREAMFILE(streamfile);
   close_streamfile(streamfile);
 
-    if (!vgmstream || vgmstream->channels <= 0)
+  if (!vgmstream || vgmstream->channels <= 0) {
-    {
     printf("Error::Channels are zero or couldn't init plugin\n");
     if (vgmstream)
       close_vgmstream(vgmstream);
@@ -135,17 +126,19 @@ bool VgmStreamPlugin::play(const char * filename, VFSFile& file)
   }
 
   short buffer[576 * vgmstream->channels];
-    int max_buffer_samples = sizeof(buffer) / sizeof(buffer[0]) / vgmstream->channels;
+  int max_buffer_samples =
+      sizeof(buffer) / sizeof(buffer[0]) / vgmstream->channels;
 
-    int stream_samples_amount = get_vgmstream_play_samples(vgmstream_cfg.loop_count, vgmstream_cfg.fade_length, vgmstream_cfg.fade_delay, vgmstream);
+  int stream_samples_amount = get_vgmstream_play_samples(
+      vgmstream_cfg.loop_count, vgmstream_cfg.fade_length,
+      vgmstream_cfg.fade_delay, vgmstream);
   rate = get_vgmstream_average_bitrate(vgmstream);
 
   set_stream_bitrate(rate);
   open_audio(FMT_S16_LE, vgmstream->sample_rate, 2);
 
   int fade_samples = vgmstream_cfg.fade_length * vgmstream->sample_rate;
-    while (!check_stop())
+  while (!check_stop()) {
-    {
     int toget = max_buffer_samples;
 
     int seek_value = check_seek();
@@ -154,8 +147,7 @@ bool VgmStreamPlugin::play(const char * filename, VFSFile& file)
 
     // If we haven't configured the plugin to play forever
     // or the current song is not loopable.
-        if (!vgmstream_cfg.loop_forever || !vgmstream->loop_flag)
+    if (!vgmstream_cfg.loop_forever || !vgmstream->loop_flag) {
-        {
       if (current_sample_pos >= stream_samples_amount)
         break;
       if (current_sample_pos + toget > stream_samples_amount)
@@ -164,16 +156,15 @@ bool VgmStreamPlugin::play(const char * filename, VFSFile& file)
 
     render_vgmstream(buffer, toget, vgmstream);
 
-        if (vgmstream->loop_flag && fade_samples > 0 && !vgmstream_cfg.loop_forever)
+    if (vgmstream->loop_flag && fade_samples > 0 &&
-        {
+        !vgmstream_cfg.loop_forever) {
-            int samples_into_fade = current_sample_pos - (stream_samples_amount - fade_samples);
+      int samples_into_fade =
-            if (samples_into_fade + toget > 0)
+          current_sample_pos - (stream_samples_amount - fade_samples);
-            {
+      if (samples_into_fade + toget > 0) {
-                for (int j = 0; j < toget; j++, samples_into_fade++)
+        for (int j = 0; j < toget; j++, samples_into_fade++) {
-                {
+          if (samples_into_fade > 0) {
-                    if (samples_into_fade > 0)
+            double fadedness =
-                    {
+                (double)(fade_samples - samples_into_fade) / fade_samples;
-                        double fadedness = (double)(fade_samples - samples_into_fade) / fade_samples;
             for (int k = 0; k < vgmstream->channels; k++)
               buffer[j * vgmstream->channels + k] *= fadedness;
           }
@@ -192,37 +183,33 @@ bool VgmStreamPlugin::play(const char * filename, VFSFile& file)
   return true;
 }
 
-void VgmStreamPlugin::seek(int seek_value, int& current_sample_pos)
+void VgmStreamPlugin::seek(int seek_value, int &current_sample_pos) {
-{
   debugMessage("seeking");
   // compute from ms to samples
-    int seek_needed_samples = (long long)seek_value * vgmstream->sample_rate / 1000L;
+  int seek_needed_samples =
+      (long long)seek_value * vgmstream->sample_rate / 1000L;
   short buffer[576 * vgmstream->channels];
-    int max_buffer_samples = sizeof(buffer) / sizeof(buffer[0]) / vgmstream->channels;
+  int max_buffer_samples =
+      sizeof(buffer) / sizeof(buffer[0]) / vgmstream->channels;
 
   int samples_to_do = 0;
-    if (seek_needed_samples < current_sample_pos)
+  if (seek_needed_samples < current_sample_pos) {
-    {
     // go back in time, reopen file
     debugMessage("reopen file to seek backward");
     reset_vgmstream(vgmstream);
     current_sample_pos = 0;
     samples_to_do = seek_needed_samples;
-    }
+  } else if (current_sample_pos < seek_needed_samples) {
-    else if (current_sample_pos < seek_needed_samples)
-    {
     // go forward in time
     samples_to_do = seek_needed_samples - current_sample_pos;
   }
 
   // do the actual seeking
-    if (samples_to_do >= 0)
+  if (samples_to_do >= 0) {
-    {
     debugMessage("render forward");
 
-        //render till seeked sample
+    // render till seeked sample
-        while (samples_to_do >0)
+    while (samples_to_do > 0) {
-        {
       int seek_samples = std::min(max_buffer_samples, samples_to_do);
       current_sample_pos += seek_samples;
       samples_to_do -= seek_samples;
@@ -232,14 +219,13 @@ void VgmStreamPlugin::seek(int seek_value, int& current_sample_pos)
   }
 }
 
-void debugMessage(const char *str)
+void debugMessage(const char *str) {
-{
 #ifdef DEBUG
   timeval curTime;
   gettimeofday(&curTime, NULL);
   int milli = curTime.tv_usec / 1000;
 
-    char buffer [80];
+  char buffer[80];
   strftime(buffer, 80, "%H:%M:%S", localtime(&curTime.tv_sec));
 
   char currentTime[84] = "";

unix/plugin.h

@@ -7,8 +7,7 @@
 #include <libaudcore/preferences.h>
 #include <libaudcore/runtime.h>
 
-class VgmStreamPlugin : public InputPlugin
+class VgmStreamPlugin : public InputPlugin {
-{
 public:
   static const char *const exts[];
   static const char *const defaults[];
@@ -17,29 +16,24 @@ public:
   static const PluginPreferences prefs;
 
   static constexpr PluginInfo info = {
-		N_("VGMStream Decoder"),
+      N_("VGMStream Decoder"), N_("vgmstream"), about, &prefs,
-		N_("vgmstream"),
-		about,
-    & prefs,
   };
 
-	static constexpr auto iinfo = InputInfo()
+  static constexpr auto iinfo = InputInfo().with_exts(exts);
-		.with_exts(exts);
 
   constexpr VgmStreamPlugin() : InputPlugin(info, iinfo) {}
 
   bool init();
   void cleanup();
-  bool is_our_file(const char *filename, VFSFile &file) {return false;}
+  bool is_our_file(const char *filename, VFSFile &file) { return false; }
   Tuple read_tuple(const char *filename, VFSFile &file);
   bool play(const char *filename, VFSFile &file);
 
 private:
-	void seek(int seek_value, int& current_sample_pos);
+  void seek(int seek_value, int &current_sample_pos);
 };
 
-typedef struct
+typedef struct {
-{
   bool loop_forever;
   int loop_count;
   double fade_length;

unix/vfs.cc

@@ -7,8 +7,7 @@
 #include "plugin.h"
 #include "vfs.h"
 
-typedef struct _VFSSTREAMFILE
+typedef struct _VFSSTREAMFILE {
-{
   STREAMFILE sf;
   VFSFile *vfsFile;
   off_t offset;
@@ -18,12 +17,11 @@ typedef struct _VFSSTREAMFILE
 
 static STREAMFILE *open_vfs_by_VFSFILE(VFSFile *file, const char *path);
 
-static size_t read_vfs(VFSSTREAMFILE *streamfile, uint8_t *dest, off_t offset, size_t length)
+static size_t read_vfs(VFSSTREAMFILE *streamfile, uint8_t *dest, off_t offset,
-{
+                       size_t length) {
   size_t sz;
   // if the offsets don't match, then we need to perform a seek
-  if (streamfile->offset != offset)
+  if (streamfile->offset != offset) {
-  {
     streamfile->vfsFile->fseek(offset, VFS_SEEK_SET);
     streamfile->offset = offset;
   }
@@ -35,46 +33,43 @@ static size_t read_vfs(VFSSTREAMFILE *streamfile, uint8_t *dest, off_t offset, s
   return sz;
 }
 
-static void close_vfs(VFSSTREAMFILE *streamfile)
+static void close_vfs(VFSSTREAMFILE *streamfile) {
-{
   debugMessage("close_vfs");
   free(streamfile->vfsFile);
   free(streamfile);
 }
 
-static size_t get_size_vfs(VFSSTREAMFILE *streamfile)
+static size_t get_size_vfs(VFSSTREAMFILE *streamfile) {
-{
   return streamfile->vfsFile->fsize();
 }
 
-static size_t get_offset_vfs(VFSSTREAMFILE *streamfile)
+static size_t get_offset_vfs(VFSSTREAMFILE *streamfile) {
-{
   return streamfile->offset;
 }
 
-static void get_name_vfs(VFSSTREAMFILE *streamfile, char *buffer, size_t length)
+static void get_name_vfs(VFSSTREAMFILE *streamfile, char *buffer,
-{
+                         size_t length) {
   strncpy(buffer, streamfile->name, length);
-  buffer[length-1] = '\0';
+  buffer[length - 1] = '\0';
 }
 
-static void get_realname_vfs(VFSSTREAMFILE *streamfile, char *buffer, size_t length)
+static void get_realname_vfs(VFSSTREAMFILE *streamfile, char *buffer,
-{
+                             size_t length) {
   strncpy(buffer, streamfile->realname, length);
-    buffer[length-1]='\0';
+  buffer[length - 1] = '\0';
 }
 
-static STREAMFILE *open_vfs_impl(VFSSTREAMFILE *streamfile, const char * const filename, size_t buffersize)
+static STREAMFILE *open_vfs_impl(VFSSTREAMFILE *streamfile,
-{
+                                 const char *const filename,
+                                 size_t buffersize) {
   if (!filename)
     return NULL;
 
   return open_vfs(filename);
 }
 
-STREAMFILE *open_vfs_by_VFSFILE(VFSFile *file, const char *path)
+STREAMFILE *open_vfs_by_VFSFILE(VFSFile *file, const char *path) {
-{
+  VFSSTREAMFILE *streamfile = (VFSSTREAMFILE *)malloc(sizeof(VFSSTREAMFILE));
-  VFSSTREAMFILE *streamfile = (VFSSTREAMFILE*)malloc(sizeof(VFSSTREAMFILE));
   if (!streamfile)
     return NULL;
 
@@ -92,20 +87,19 @@ STREAMFILE *open_vfs_by_VFSFILE(VFSFile *file, const char *path)
   streamfile->vfsFile = file;
   streamfile->offset = 0;
   strncpy(streamfile->name, path, sizeof(streamfile->name));
-  streamfile->name[sizeof(streamfile->name)-1] = '\0';
+  streamfile->name[sizeof(streamfile->name) - 1] = '\0';
   {
-      gchar* realname = g_filename_from_uri(path, NULL, NULL);
+    gchar *realname = g_filename_from_uri(path, NULL, NULL);
     strncpy(streamfile->realname, realname, sizeof(streamfile->realname));
-      streamfile->realname[sizeof(streamfile->realname)-1] = '\0';
+    streamfile->realname[sizeof(streamfile->realname) - 1] = '\0';
     g_free(realname);
   }
 
   return &streamfile->sf;
 }
 
-STREAMFILE *open_vfs(const char *path)
+STREAMFILE *open_vfs(const char *path) {
-{
+  VFSFile *vfsFile = new VFSFile(path, "rb");
-  VFSFile* vfsFile = new VFSFile(path, "rb");
   if (!vfsFile)
     return NULL;