117 lines
3.6 KiB
Plaintext
117 lines
3.6 KiB
Plaintext
== Files ==
|
|
ocarina/include/
|
|
audio.h
|
|
ocarina/lib/
|
|
audio.cpp
|
|
|
|
== Depends ==
|
|
deck library
|
|
|
|
Audio: (lib/audio.cpp)
|
|
This file will introduce an "audio" namespace containing all of the
|
|
functions interacting with gstreamer. This will create a wrapper
|
|
namespace that will be easier to work with than using raw gstreamer
|
|
functions.
|
|
|
|
The audio layer is meant to be an interface used by the front end to
|
|
control most features of the backend library. This means implementing
|
|
next track, previous track, and so on here.
|
|
|
|
Gstreamer options passed to audio :: init() can be found by running
|
|
`gst-inspect-1.0 --help-gst` on the command line.
|
|
|
|
- Internal:
|
|
Set up a message bus to look for end-of-stream and error messages so
|
|
the next song can be played. This function should call the play
|
|
function after loading a track and after checking the "pause after N"
|
|
count.
|
|
|
|
The audio layer will also create an internal playqueue for tracking
|
|
recently played songs.
|
|
|
|
- State:
|
|
The audio layer will store the current trackid to disk, and then save
|
|
the playqueue deck.
|
|
|
|
File << current_track << endl
|
|
deck.write(File);
|
|
|
|
- API:
|
|
void audio :: init(argc, argv);
|
|
Initialize the gstreamer layer and reload the track that was
|
|
last loaded before shutdown. Gstreamer is supposed to remove
|
|
options from the argv array as they are processed, so pass
|
|
pointers to argc and argv to this function.
|
|
|
|
Read in the state file.
|
|
|
|
void audio :: quit();
|
|
Clean up memory allocated by gstreamer.
|
|
Write out the state file.
|
|
|
|
void audio :: play();
|
|
void audio :: pause();
|
|
Change the gstreamer state to either GST_STATE_PLAYING or
|
|
GST_STATE_PAUSED. Do nothing if there is not a track loaded
|
|
in the pipeline. Throw -EAUDIO if there is an error changing
|
|
state.
|
|
|
|
void audio :: seek_to(long);
|
|
Seek to a position X nanoseconds into the track. Throw -EAUDIO
|
|
if there is an error seeking to the requested position. Do
|
|
nothing if there is not a track loaded in the pipeline.
|
|
|
|
Seconds can be converted to nanoseconds by multiplying with
|
|
GST_SECOND.
|
|
|
|
void audio :: stop();
|
|
pause()
|
|
seek_to(0)
|
|
|
|
void audio :: next();
|
|
Call the deck :: next() function to get the next trackid,
|
|
and load that file into the gstreamer pipeline. Do not change
|
|
the state of the pipeline (if nothing is playing yet, don't
|
|
call play()). Throw -EEXIST if there is no track to load
|
|
into the pipeline.
|
|
|
|
When a track is loaded:
|
|
Is it already in the recently played playqueue?
|
|
If yes, remove it from the playqueue.
|
|
Add to the front of the recently played playqueue.
|
|
Reset the current pointer in the playqueue to 0.
|
|
|
|
Write out the state file.
|
|
|
|
void audio :: previous();
|
|
Call the playlist :: previous() function to iterate backwards
|
|
through the recently played playqueue. Load the returned trackid
|
|
without changing the pipeline state.
|
|
|
|
trackid audio :: current_trackid();
|
|
Return the trackid of the currently playing song. If no track
|
|
is loaded throw -EEXIST;
|
|
|
|
unsigned int audio :: position();
|
|
Return the number of seconds that the song has played.
|
|
|
|
unsigned int audio :: duration();
|
|
Return the duration of the current song in seconds.
|
|
|
|
void audio :: pause_after(bool enabled, unsigned int N);
|
|
Pause after N tracks. The first parameter is a bool
|
|
representing if this feature is enabled or not (true == enabled,
|
|
false == disabled).
|
|
|
|
The count will only be decremented when an end-of-stream message
|
|
is received by the gstreamer pipeline, and not when calling
|
|
next().
|
|
|
|
bool audio :: pause_enabled();
|
|
Return true if pausing is enabled, and false if pausing is
|
|
disabled.
|
|
|
|
unsigned int audio :: pause_count();
|
|
Return the number of tracks that will be played before
|
|
playback pauses.
|