Cool_Tools/vgmstream
1
0
Fork 0
mirror of https://github.com/vgmstream/vgmstream.git synced 2024-11-28 08:20:54 +01:00
Code Issues Packages Projects Releases Wiki Activity

Better reformatting of code

Browse Source
This commit is contained in:
Brandon 2015-07-09 19:32:53 -07:00
parent 3d774e7cec
commit e213d35911
3 changed files with 219 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
unix/plugin.cc
View File

@ -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[] =
{
"loop_forever", "1",
"loop_count", "2",
"fade_length", "3",
"fade_delay", "3",
NULL
};
const char *const VgmStreamPlugin::defaults[] = {
"loop_forever", "1", "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_("Fade Length:"), WidgetFloat(vgmstream_cfg.fade_length), {0, 60, 0.1}),
WidgetSpin(N_("Fade Delay:"), WidgetFloat(vgmstream_cfg.fade_delay), {0, 60, 0.1}),
WidgetSpin(N_("Loop Count:"), WidgetInt(vgmstream_cfg.loop_count),
{1, 20, 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},
vgmstream_cfg_load,
vgmstream_cfg_save
};
{widgets}, 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;
STREAMFILE* streamfile = NULL;
VGMSTREAM *vgmstream = 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)
{
int samples_into_fade = current_sample_pos - (stream_samples_amount - fade_samples);
if (samples_into_fade + toget > 0)
{
for (int j = 0; j < toget; j++, samples_into_fade++)
{
if (samples_into_fade > 0)
{
double fadedness = (double)(fade_samples - samples_into_fade) / fade_samples;
if (vgmstream->loop_flag && fade_samples > 0 &&
!vgmstream_cfg.loop_forever) {
int samples_into_fade =
current_sample_pos - (stream_samples_amount - fade_samples);
if (samples_into_fade + toget > 0) {
for (int j = 0; j < toget; j++, samples_into_fade++) {
if (samples_into_fade > 0) {
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
while (samples_to_do >0)
{
// render till seeked sample
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] = "";

18
unix/plugin.h
View File

@ -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"),
about,
& prefs,
N_("VGMStream Decoder"), N_("vgmstream"), about, &prefs,
};
static constexpr auto iinfo = InputInfo()
.with_exts(exts);
static constexpr auto iinfo = InputInfo().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;

52
unix/vfs.cc
View File

@ -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)
{
VFSSTREAMFILE *streamfile = (VFSSTREAMFILE*)malloc(sizeof(VFSSTREAMFILE));
STREAMFILE *open_vfs_by_VFSFILE(VFSFile *file, const char *path) {
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)
{
VFSFile* vfsFile = new VFSFile(path, "rb");
STREAMFILE *open_vfs(const char *path) {
VFSFile *vfsFile = new VFSFile(path, "rb");
if (!vfsFile)
return NULL;