// Load from file
FXuval FXGZFileStream::readBuffer(FXuval){
register FXival n; int zerror;
if(dir!=FXStreamLoad){fxerror("FXGZFileStream::readBuffer: wrong stream direction.\n");}
FXASSERT(begptr<=rdptr);
FXASSERT(rdptr<=wrptr);
FXASSERT(wrptr<=endptr);
if(rdptr<wrptr){memmove(begptr,rdptr,wrptr-rdptr);}
wrptr=begptr+(wrptr-rdptr);
rdptr=begptr;
while(wrptr<endptr){
// n=file.readBlock(z->buffer,BUFFERSIZE);
// if(n<=0) break;
// z->stream.next_in=z->buffer;
// z->stream.avail_in=n;
if(z->stream.avail_in<=0){ // Get more input if buffer is empty
n=file.readBlock(z->buffer,BUFFERSIZE);
if(n<0) break;
z->stream.next_in=z->buffer;
z->stream.avail_in=n;
}
z->stream.next_out=(Bytef*)wrptr;
z->stream.avail_out=endptr-wrptr;
zerror=inflate(&z->stream,Z_NO_FLUSH);
// if(zerror!=Z_OK) break;
if(zerror<0) break; // break on error condition
wrptr=(FXuchar*)z->stream.next_out;
if(zerror==Z_STREAM_END) break;
}
return wrptr-rdptr;
}
// Save to a file
FXuval FXBZFileStream::writeBuffer(FXuval){
register FXival m,n; int bzerror;
if(dir!=FXStreamSave){fxerror("FXBZFileStream::writeBuffer: wrong stream direction.\n");}
FXASSERT(begptr<=rdptr);
FXASSERT(rdptr<=wrptr);
FXASSERT(wrptr<=endptr);
while(rdptr<wrptr || ac==BZ_FINISH || ac==BZ_FLUSH){
bz->stream.next_in=(char*)rdptr;
bz->stream.avail_in=wrptr-rdptr;
bz->stream.next_out=bz->buffer;
bz->stream.avail_out=BUFFERSIZE;
bzerror=BZ2_bzCompress(&bz->stream,ac);
// if(bzerror!=BZ_OK) break;
if(bzerror<0) break; // break on error condition
m=bz->stream.next_out-bz->buffer;
n=file.writeBlock(bz->buffer,m);
if(n<m) break;
rdptr=(FXuchar*)bz->stream.next_in;
if(bzerror==BZ_STREAM_END) break; // break from FINISH
if(ac==BZ_FLUSH && bzerror==BZ_RUN_OK) break; // break from FLUSH
}
if(rdptr<wrptr){memmove(begptr,rdptr,wrptr-rdptr);}
wrptr=begptr+(wrptr-rdptr);
rdptr=begptr;
return endptr-wrptr;
}
// Load from file
FXuval FXBZFileStream::readBuffer(FXuval){
register FXival n; int bzerror;
if(dir!=FXStreamLoad){fxerror("FXBZFileStream::readBuffer: wrong stream direction.\n");}
FXASSERT(begptr<=rdptr);
FXASSERT(rdptr<=wrptr);
FXASSERT(wrptr<=endptr);
if(rdptr<wrptr){memmove(begptr,rdptr,wrptr-rdptr);}
wrptr=begptr+(wrptr-rdptr);
rdptr=begptr;
while(wrptr<endptr){
// n=file.readBlock(bz->buffer,BUFFERSIZE);
// if(n<=0) break;
// bz->stream.next_in=bz->buffer;
// bz->stream.avail_in=n;
if(bz->stream.avail_in<=0){ // get more input if buffer is empty
n=file.readBlock(bz->buffer,BUFFERSIZE);
if(n<0) break;
bz->stream.next_in=bz->buffer;
bz->stream.avail_in=n;
}
bz->stream.next_out=(char*)wrptr;
bz->stream.avail_out=endptr-wrptr;
bzerror=BZ2_bzDecompress(&bz->stream);
// if(bzerror!=BZ_OK) break;
if(bzerror<0) break; // break on error condition
wrptr=(FXuchar*)bz->stream.next_out;
if(bzerror==BZ_STREAM_END) break;
}
return wrptr-rdptr;
}
// Save to a file
FXuval FXGZFileStream::writeBuffer(FXuval){
register FXival m,n; int zerror;
if(dir!=FXStreamSave){fxerror("FXGZFileStream::writeBuffer: wrong stream direction.\n");}
FXASSERT(begptr<=rdptr);
FXASSERT(rdptr<=wrptr);
FXASSERT(wrptr<=endptr);
while(rdptr<wrptr || f==Z_FINISH || f==Z_SYNC_FLUSH){
z->stream.next_in=(Bytef*)rdptr;
z->stream.avail_in=wrptr-rdptr;
z->stream.next_out=z->buffer;
z->stream.avail_out=BUFFERSIZE;
zerror=deflate(&z->stream,f);
// if(zerror!=Z_OK) break;
if(zerror<0) break; // break on error condition
m=z->stream.next_out-z->buffer;
n=file.writeBlock(z->buffer,m);
if(n<m) break;
rdptr=(FXuchar*)z->stream.next_in;
if(zerror==Z_STREAM_END) break; // break from FINISH/FLUSH
}
if(rdptr<wrptr){memmove(begptr,rdptr,wrptr-rdptr);}
wrptr=begptr+(wrptr-rdptr);
rdptr=begptr;
return endptr-wrptr;
}
ReadStatus MP4Reader::parse() {
mp4AudioSpecificConfig cfg;
FXuchar* buffer;
FXuint size;
FXint ntracks;
FXASSERT(handle==NULL);
FXASSERT(packet);
handle = mp4ff_open_read(&callback);
if (handle==NULL)
goto error;
ntracks = mp4ff_total_tracks(handle);
if (ntracks<=0)
goto error;
for (FXint i=0;i<ntracks;i++) {
if ((mp4ff_get_decoder_config(handle,i,&buffer,&size)==0) && buffer && size) {
if (NeAACDecAudioSpecificConfig(buffer,size,&cfg)==0) {
af.set(AP_FORMAT_S16,mp4ff_get_sample_rate(handle,i),mp4ff_get_channel_count(handle,i));
af.debug();
if (size>packet->space()) {
GM_DEBUG_PRINT("MP4 config buffer is too big for decoder packet");
free(buffer);
goto error;
}
track=i;
frame=0;
nframes=mp4ff_num_samples(handle,i);
stream_length=mp4ff_get_track_duration(handle,i);
packet->append(buffer,size);
packet->flags|=AAC_FLAG_CONFIG|AAC_FLAG_FRAME;
engine->decoder->post(new ConfigureEvent(af,Codec::AAC));
send_meta();
engine->decoder->post(packet);
packet=NULL;
flags|=FLAG_PARSED;
free(buffer);
return ReadOk;
}
free(buffer);
}
}
error:
packet->unref();
return ReadError;
}
void GMDBTracks::insert(GMTrack & track,FXint & path_index) {
if (__likely(track.index==0)) {
FXASSERT(!track.url.empty());
FXASSERT(path_index>=0);
if (path_index==0) {
path_index = insertPath(FXPath::directory(track.url));
FXASSERT(path_index);
if (!path_index) fxwarning("pid==0 for %s\n",FXPath::directory(track.url).text());
}
/// Artist
FXint album_artist_id = insertArtist(track.getAlbumArtist(default_artist));
FXint artist_id = insertArtist(track.getArtist(default_artist));
FXint composer_id = insertArtist(track.composer);
FXint conductor_id = insertArtist(track.conductor);
FXint album_id = insertAlbum(track,album_artist_id);
FXASSERT(artist_id);
FXASSERT(album_id);
/// Insert Track
insert_track.set(0,path_index);
insert_track.set(1,path_index ? FXPath::name(track.url) : track.url);
insert_track.set(2,track.title.empty() ? FXPath::title(track.url) : track.title);
insert_track.set(3,track.time);
insert_track.set(4,track.no);
insert_track.set(5,track.year);
insert_track.set(6,(track.sampleformat) ? -track.sampleformat : track.bitrate);
insert_track.set(7,album_id);
insert_track.set(8,artist_id);
insert_track.set_null(9,composer_id);
insert_track.set_null(10,conductor_id);
insert_track.set(11,FXThread::time());
insert_track.set(12,track.samplerate);
insert_track.set(13,track.channels);
insert_track.set(14,track.filetype);
track.index = insert_track.insert();
/// Tags
if (track.tags.no())
insertTags(track.index,track.tags);
}
/// Add to playlist
if (playlist) {
insert_playlist_track_by_id.set(0,playlist);
insert_playlist_track_by_id.set(1,track.index);
insert_playlist_track_by_id.set(2,playlist_queue);
insert_playlist_track_by_id.execute();
}
}
void GMNotifyDaemon::init() {
{
DBusMessage * msg = method("GetServerInformation");
FXASSERT(msg);
send(msg,this,ID_NOTIFY_SERVER);
}
{
DBusMessage * msg = method("GetCapabilities");
FXASSERT(msg);
send(msg,this,ID_NOTIFY_CAPABILITIES);
}
}
FXint GMSyncTask::run() {
FXASSERT(database);
try {
dbtracks.init(database,options.album_format_grouping);
setID3v1Encoding();
if (options_sync.remove_all) {
remove_missing();
}
else if (options_sync.import_new) {
if (options_sync.update)
import_and_update();
else
import();
if (options_sync.remove_missing)
remove_missing();
}
else if (options_sync.update) {
update();
}
else if (options_sync.remove_missing) {
remove_missing();
}
GMTag::setID3v1Encoding(nullptr);
}
catch(GMDatabaseException&) {
database->rollbackTask();
return 1;
}
return 0;
}
// Clean up the mess
Adie::~Adie(){
for(int i=0; i<syntaxes.no(); i++) delete syntaxes[i];
FXASSERT(windowlist.no()==0);
delete associations;
delete bigicon;
delete smallicon;
delete newicon;
delete reloadicon;
delete openicon;
delete saveicon;
delete saveasicon;
delete printicon;
delete cuticon;
delete copyicon;
delete pasteicon;
delete deleteicon;
delete undoicon;
delete redoicon;
delete fontsicon;
delete helpicon;
delete quiticon;
delete shiftlefticon;
delete shiftrighticon;
delete searchicon;
delete searchnexticon;
delete searchprevicon;
delete bookseticon;
delete booknexticon;
delete bookprevicon;
delete bookdelicon;
}
// Read at least count bytes into the buffer
FXuval FXFileStream::readBuffer(FXuval){
register FXival m,n;
if(dir!=FXStreamLoad){fxerror("FXFileStream::readBuffer: wrong stream direction.\n");}
FXASSERT(begptr<=rdptr);
FXASSERT(rdptr<=wrptr);
FXASSERT(wrptr<=endptr);
m=wrptr-rdptr;
if(m){memmove(begptr,rdptr,m);}
rdptr=begptr;
wrptr=begptr+m;
n=file.readBlock(wrptr,endptr-wrptr);
if(0<n){
wrptr+=n;
}
return wrptr-rdptr;
}
// Fill the list with face names
void FontSelector::listFontFaces()
{
FXFontDesc* fonts;
FXuint numfonts, f;
int selindex = -1;
familylist->clearItems();
family->setText("");
if (FXFont::listFonts(fonts, numfonts, FXString::null, 0, 0, selected.setwidth, selected.encoding, selected.flags))
{
FXASSERT(0 < numfonts);
for (f = 0; f < numfonts; f++)
{
familylist->appendItem(fonts[f].face, NULL, (void*)(FXuval)fonts[f].flags);
if (strcmp(selected.face, fonts[f].face) == 0)
{
selindex = f;
}
}
if (selindex == -1)
{
selindex = 0;
}
if (0 < familylist->getNumItems())
{
familylist->setCurrentItem(selindex);
familylist->makeItemVisible(selindex);
family->setText(familylist->getItemText(selindex));
strlcpy(selected.face, familylist->getItemText(selindex).text(), sizeof(selected.face)+1);
}
FXFREE(&fonts);
}
}
// Write at least count bytes from the buffer
FXuval FXFileStream::writeBuffer(FXuval){
register FXival m,n;
if(dir!=FXStreamSave){fxerror("FXFileStream::writeBuffer: wrong stream direction.\n");}
FXASSERT(begptr<=rdptr);
FXASSERT(rdptr<=wrptr);
FXASSERT(wrptr<=endptr);
m=wrptr-rdptr;
n=file.writeBlock(rdptr,m);
if(0<n){
m-=n;
if(m){memmove(begptr,rdptr+n,m);}
rdptr=begptr;
wrptr=begptr+m;
}
return endptr-wrptr;
}
// Append simple rule
FXint FXSyntax::append(const FXString& name,const FXString& rex,FXint parent){
register FXint index=rules.no();
FXASSERT(0<=parent && parent<rules.no());
FXSimpleRule *rule=new FXSimpleRule(name,rex,parent,index);
rules.append(rule);
rules[parent]->rules.append(rule);
return index;
}
// Return true if p is ancestor of c
FXbool FXSyntax::isAncestor(FXint p,FXint c) const {
FXASSERT(0<=p && 0<=c);
while(c>0){
c=rules[c]->getParent();
if(c==p) return TRUE;
}
return FALSE;
}
long GMNotifyDaemon::onNotifyReply(FXObject*,FXSelector,void*ptr){
DBusMessage * msg = static_cast<DBusMessage*>(ptr);
FXASSERT(msg);
if (dbus_message_get_type(msg)==DBUS_MESSAGE_TYPE_METHOD_RETURN) {
dbus_message_get_args(msg,NULL,DBUS_TYPE_UINT32,&msgid,DBUS_TYPE_INVALID);
}
return 1;
}
// Append safe bracket rule
FXint FXSyntax::append(const FXString& name,const FXString& brex,const FXString& erex,const FXString& srex,FXint parent){
register FXint index=rules.no();
FXASSERT(0<=parent && parent<rules.no());
FXSafeBracketRule *rule=new FXSafeBracketRule(name,brex,erex,srex,parent,index);
rules.append(rule);
rules[parent]->rules.append(rule);
return index;
}
// Move to position
bool FXFileStream::position(FXlong offset,FXWhence whence){
register FXlong p;
if(dir==FXStreamDead){ fxerror("FXMemoryStream::position: stream is not open.\n"); }
if(code==FXStreamOK){
FXASSERT(FXFromStart==SEEK_SET);
FXASSERT(FXFromCurrent==SEEK_CUR);
FXASSERT(FXFromEnd==SEEK_END);
if(dir==FXStreamSave){
// Flush unwritten data
writeBuffer(0);
// System's view of file pointer lags behind ours
if(whence==FXFromCurrent) offset+=wrptr-rdptr;
// Position file
if((p=file.position(offset,whence))<0){
code=FXStreamFull;
return FALSE;
}
// Update pointers
wrptr=begptr;
rdptr=begptr;
}
else{
// System's view of file pointer ahead of ours
if(whence==FXFromCurrent) offset-=wrptr-rdptr;
// Position file
if((p=file.position(offset,whence))<0){
code=FXStreamEnd;
return false;
}
// Update pointers
wrptr=begptr;
rdptr=begptr;
}
pos=p;
return true;
}
return false;
}
Event * InputThread::wait_for_event() {
Event * event = fifo.pop();
if (event==NULL) {
ap_wait(fifo.handle());
event = fifo.pop();
}
FXASSERT(event);
return event;
}
void FXRbObject::freefunc(FXObject* self){
if(self!=0){
// Unregister, but don't destroy, borrowed references
if(FXRbIsBorrowed(self)){
FXRbUnregisterRubyObj(self);
return;
}
const FXchar* classname=self->getClassName();
FXASSERT(classname!=0);
FXASSERT(strlen(classname)>3);
if(classname[0]=='F' && classname[1]=='X' && classname[2]=='R' && classname[3]=='b'){
delete self;
}
else{
FXRbUnregisterRubyObj(self);
}
}
}
// Construct directory enumerator
FXDir::FXDir(){
// If this fails on your machine, determine what sizeof(SPACE) is
// on your machine and mail it to: [email protected]!
//FXTRACE((150,"sizeof(SPACE)=%ld\n",sizeof(SPACE)));
FXASSERT(sizeof(SPACE)<=sizeof(space));
#ifdef WIN32
((SPACE*)space)->handle=INVALID_HANDLE_VALUE;
#else
((SPACE*)space)->handle=NULL;
#endif
}
static const char *GetSectForKey(const char*key)
{
for (FXint i=0; keynames[i]; i++) {
for (FXint j=0; keynames[i][j]; j++) {
if (strcmp(keynames[i][j],key)==0) { return sectnames[i]; }
}
}
fxerror("FATAL: Section for key \"%s\" not found.\n", key);
FXASSERT(!key);
return NULL;
}
// Initialize semaphore with given count
FXSemaphore::FXSemaphore(FXint count){
#if defined(WIN32)
data[0]=(FXuval)CreateSemaphore(NULL,count,0x7fffffff,NULL);
#elif (defined(__APPLE__) || defined(__minix))
// If this fails on your machine, determine what value of
// sizeof(pthread_cond_t) and sizeof(pthread_mutex_t) is
// supposed to be and mail it to: [email protected]!!
//FXTRACE((150,"sizeof(pthread_cond_t)=%d\n",sizeof(pthread_cond_t)));
//FXTRACE((150,"sizeof(pthread_mutex_t)=%d\n",sizeof(pthread_mutex_t)));
FXASSERT(sizeof(FXuval)*9 >= sizeof(pthread_cond_t));
FXASSERT(sizeof(FXuval)*6 >= sizeof(pthread_mutex_t));
data[0]=count;
pthread_cond_init((pthread_cond_t*)&data[1],NULL);
pthread_mutex_init((pthread_mutex_t*)&data[10],NULL);
#else
// If this fails on your machine, determine what value
// of sizeof(sem_t) is supposed to be on your
// machine and mail it to: [email protected]!!
//FXTRACE((150,"sizeof(sem_t)=%d\n",sizeof(sem_t)));
FXASSERT(sizeof(data)>=sizeof(sem_t));
sem_init((sem_t*)data,0,(unsigned int)count);
#endif
}
FXbool BufferBase::resize(FXival n) {
FXASSERT(n>0);
if(begptr+n!=endptr){
FXuchar *oldbegptr=begptr;
// Resize the buffer
if(!resizeElms(begptr,ROUNDUP(n))) return false;
// Adjust pointers, buffer may have moved
endptr=begptr+n;
wrptr=begptr+(wrptr-oldbegptr);
rdptr=begptr+(rdptr-oldbegptr);
if(wrptr>endptr) wrptr=endptr;
if(rdptr>endptr) rdptr=endptr;
}
return true;
}
FXint GMImportTask::run() {
FXASSERT(database);
try {
dbtracks.init(database,options.album_format_grouping);
setID3v1Encoding();
import();
GMTag::setID3v1Encoding(nullptr);
}
catch(GMDatabaseException&) {
database->rollbackTask();
return 1;
}
return 0;
}
FXbool BufferBase::reserve(FXival n) {
FXASSERT(n>0);
if (n>(endptr-wrptr)) {
if (rdptr>begptr) {
if (rdptr<wrptr) {
memmove(begptr,rdptr,wrptr-rdptr);
wrptr-=(rdptr-begptr);
rdptr=begptr;
}
else {
rdptr=wrptr=begptr;
}
if (n<=endptr-wrptr)
return true;
}
return resize((endptr-begptr)+(n-(endptr-wrptr)));
}
return true;
}
FXbool GMSourceView::listsources() {
GMTreeItem * item=nullptr;
GMTreeItem * dbitem=nullptr;
for (FXint i=0;i<GMPlayerManager::instance()->getNumSources();i++){
GMSource * src = GMPlayerManager::instance()->getSource(i);
FXIcon * icon=icon_for_sourcetype(src->getType());
item = new GMTreeItem(src->getName(),icon,icon,src);
if (src->getType()==SOURCE_DATABASE_FILTER) {
FXASSERT(dbitem);
sourcelist->appendItem(dbitem,item);
dbitem->setExpanded(true);
}
else {
sourcelist->appendItem(nullptr,item);
}
if (src->getType()==SOURCE_DATABASE) dbitem=item;
}
sourcelist->sortItems();
return true;
}
PulseOutput::PulseOutput(OutputContext * ctx) : OutputPlugin(ctx) {
FXASSERT(instance==nullptr);
instance = this;
api.userdata = this;
api.io_new = pa_io_event::create; //pulse_io_new;
api.io_free = pa_io_event::destroy;// pulse_io_free;
api.io_enable = pa_io_event::enable; //pulse_io_enable;
api.io_set_destroy = pa_io_event::set_destroy;//pulse_io_set_destroy;
api.defer_new = pa_defer_event::create; //pulse_defer_new;
api.defer_free = pa_defer_event::destroy; //pulse_defer_free;
api.defer_enable = pa_defer_event::toggle_enabled; //pulse_defer_enable;
api.defer_set_destroy = pa_defer_event::set_destroy; //pulse_defer_set_destroy;
api.time_new = pa_time_event::create; //pulse_time_new;
api.time_restart = pa_time_event::restart; //pulse_time_restart;
api.time_free = pa_time_event::destroy; //pulse_time_free;
api.time_set_destroy = pa_time_event::set_destroy; //pulse_time_set_destroy;
api.quit = pulse_quit;
pa_io_event::recycle = nullptr;
pa_time_event::recycle = nullptr;
pa_defer_event::recycle = nullptr;
}
FXbool PulseOutput::write(const void * b,FXuint nframes){
FXASSERT(stream);
const FXchar * buffer = reinterpret_cast<const FXchar*>(b);
FXuint total = nframes*af.framesize();
while(total) {
if (pa_stream_get_state(stream)!=PA_STREAM_READY)
return false;
size_t nbytes = pa_stream_writable_size(stream);
size_t n = FXMIN(total,nbytes);
if (n==0) {
//fxmessage("size %ld\n",nbytes);
context->wait_plugin_events();
continue;
}
pa_stream_write(stream,buffer,n,nullptr,0,PA_SEEK_RELATIVE);
total-=n;
buffer+=n;
}
return true;
}
void FXRbTreeItem::freefunc(FXTreeItem* self){
if(self!=0){
if(!FXRbIsBorrowed(self)){
if(self->isMemberOf(FXMETACLASS(FXRbTreeItem))){
FXRbTreeItem* treeItem=dynamic_cast<FXRbTreeItem*>(self);
FXASSERT(treeItem);
FXTreeList* treeList=dynamic_cast<FXTreeList*>(treeItem->owner);
if(treeList){
FXRbUnregisterRubyObj(self); // MAYBE
treeList->removeItem(self,TRUE);
}
else{
FXTreeListBox* treeListBox=dynamic_cast<FXTreeListBox*>(treeItem->owner);
if(treeListBox){
treeListBox->removeItem(self);
}
}
}
}
FXRbUnregisterRubyObj(self);
}
}
FXuint MP4Reader::mp4_truncate(void*){
FXASSERT(0);
//InputThread* input = reinterpret_cast<InputThread*>(ptr);
return 0;
}
