int main(int argc, char **argv)
{
if ( argc == 2 )
{
const char *filename = argv[1];
xmlDoc *doc = NULL;
xmlNode *root = NULL;
// zaladowanie pliku
if ( !filename )
{
GOC_ERROR("Podano wartosn NULL");
return -1;
}
if ( !goc_isFileExists(filename) )
{
GOC_BERROR("Plik [%s] nie istnieje", filename);
return -1;
}
doc = xmlReadFile( filename, NULL, 0 );
if ( !doc )
{
GOC_BERROR("Nieudane parsowanie pliku [%s]", filename);
return -1;
}
root = xmlDocGetRootElement( doc );
if ( !root )
{
GOC_ERROR("Nieudane pozyskanie galezi root");
return -1;
}
{
StKlasa* k = fobDeserialize( (fobElement*)root );
fobSerialize( (fobElement*)k, stdout );
}
}
else
{
StKlasa* k = fobAlloc(cn_Klasa);
k->name = goc_stringCopy(k->name, "Nazwa");
k->plist = goc_tableAdd(k->plist, &k->nlist, sizeof(char*));
k->plist[k->nlist-1] = goc_stringCopy(NULL, "alfa");
k->plist = goc_tableAdd(k->plist, &k->nlist, sizeof(char*));
k->plist[k->nlist-1] = goc_stringCopy(NULL, "beta");
fobSerialize( (fobElement*)k, stdout );
}
return 0;
}
static enum MixerCode alsaMixerSelectCard(struct MixerSystem* system, int mixerId) {
enum MixerCode code;
snd_mixer_elem_t* mixerElem = NULL;
AlsaMixerCard* card = (AlsaMixerCard*)system->active;
if ( !card ) {
if ( card == system->mixerCard->pElement[mixerId] ) {
return MIXER_CODE_OK;
}
alsaMixerCardClose(system);
}
code = commonMixerSelectCard(system, mixerId);
if ( code != MIXER_CODE_OK ) {
GOC_DEBUG("Cannot select card by commonMixerSelectCard");
return code;
}
card = (AlsaMixerCard*)system->active;
GOC_CHEOP_DEBUG(snd_mixer_open( &card->sndmixer, 0 ) == 0, return MIXER_CODE_CANNOT_OPEN_CARD);
GOC_CHEOP_DEBUG(snd_mixer_attach( card->sndmixer, card->physicalName ) == 0, return MIXER_CODE_CANNOT_OPEN_CARD);
GOC_CHEOP_DEBUG(snd_mixer_selem_register( card->sndmixer, NULL, NULL ) == 0, return MIXER_CODE_CANNOT_OPEN_CARD);
GOC_CHEOP_DEBUG(snd_mixer_load( card->sndmixer ) == 0, return MIXER_CODE_CANNOT_OPEN_CARD);
mixerElem = snd_mixer_first_elem( card->sndmixer );
while ( mixerElem ) {
AlsaMixerElement* pMixerElement = alsaMixerElementAlloc();
for (int channel = 0; channel <= SND_MIXER_SCHN_LAST; channel++ ) {
if ( snd_mixer_selem_has_playback_channel(mixerElem, channel)
&& snd_mixer_selem_get_playback_volume_range(mixerElem, &pMixerElement->rangemin, &pMixerElement->rangemax) == 0
&& snd_mixer_selem_get_playback_volume(mixerElem, channel, &pMixerElement->volume) == 0 ) {
pMixerElement->name = goc_stringCopy(NULL, snd_mixer_selem_get_name(mixerElem));
pMixerElement->type = MIXER_ELEMENT_PLAYBACK;
pMixerElement->sndelement = mixerElem;
card->mixerElement = goc_arrayAdd( card->mixerElement, pMixerElement );
break;
} else if ( snd_mixer_selem_has_capture_channel(mixerElem, channel)
&& snd_mixer_selem_get_capture_volume_range(mixerElem, &pMixerElement->rangemin, &pMixerElement->rangemax) == 0
&& snd_mixer_selem_get_capture_volume(mixerElem, channel, &pMixerElement->volume) == 0 ) {
pMixerElement->name = goc_stringCopy(NULL, snd_mixer_selem_get_name(mixerElem));
pMixerElement->type = MIXER_ELEMENT_CAPTURE;
pMixerElement->sndelement = mixerElem;
card->mixerElement = goc_arrayAdd( card->mixerElement, pMixerElement );
break;
}
}
mixerElem = snd_mixer_elem_next( mixerElem );
}
return MIXER_CODE_OK;
}
// listuj katalog i dodawaj pliki w nim zawarte, ktróre s± mp3
static void listAddFolder(const char *fullname)
{
DIR *dir = opendir( fullname );
struct dirent *ent;
if ( dir == NULL )
return;
while ( (ent = readdir( dir )) != NULL )
{
char *buf = NULL;
if ( goc_stringEquals( ent->d_name, ".." ) )
continue;
if ( goc_stringEquals( ent->d_name, "." ) )
continue;
buf = goc_stringCopy( buf, fullname );
if ( fullname[strlen(fullname)-1] != '/' )
buf = goc_stringAdd( buf, "/" );
buf = goc_stringAdd( buf, ent->d_name );
if ( goc_isFolder( buf ) )
listAddFolder( buf );
else
checkAddFile( buf );
buf = goc_stringFree( buf );
}
closedir( dir );
}
static int hotKeySelectFolder(
GOC_HANDLER uchwyt, GOC_MSG wiesc, void *pBuf, unsigned int nBuf)
{
char *element = goc_stringCopy(NULL, goc_filelistGetFolder(uchwyt));
element = goc_stringAdd(element, "/");
element = goc_stringAdd(element, goc_listGetUnderCursor(uchwyt));
if ( goc_isFileExists( element ) )
{
if ( goc_isFolder( element ) )
{
listAddFolder( element );
}
else
{ // a wiec to plik
checkAddFile( element );
}
char *tmp = goc_stringAdd(goc_stringCopy(NULL, "Dodano: "), element);
goc_labelSetText(nStatus, tmp, 0);
tmp = goc_stringFree(tmp);
goc_systemSendMsg(nStatus, GOC_MSG_PAINT, 0, 0);
}
}
/*
* Wygenerowanie wnêtrza metody alloc dla podanego noda
*/
int generateAllocBody(xmlNode *child, xmlNode *method, FILE *file)
{
char *classname = NULL;
classname = goc_stringCopy(classname, getAttr(child, "name"));
fprintf(file, "\tSt%s* tmp = NULL;\n", classname);
fprintf(file, "\ttmp = malloc(sizeof(St%s));\n", classname);
fprintf(file, "\tmemset(tmp, 0, sizeof(St%s));\n", classname);
fprintf(file, "\treturn tmp;\n");
classname = goc_stringFree(classname);
return 0;
}
int goc_labelAddLine(GOC_HANDLER u, const char *Tekst)
{
GOC_StLabel *napis = (GOC_StLabel*)u;
if ( !Tekst )
return GOC_ERR_OK; // ??
napis->tekst = goc_tableAdd(napis->tekst, &napis->nText, sizeof(GOC_StColorLine));
napis->tekst[napis->nText-1].line = goc_stringCopy(NULL, Tekst);
napis->tekst[napis->nText-1].color = napis->color;
napis->tekst[napis->nText-1].flag = napis->flag;
if ( napis->flag & GOC_EFLAGA_SHOWN )
goc_systemSendMsg(u, GOC_MSG_PAINT, 0, 0);
return GOC_ERR_OK;
}
// ustawienie w kolumnie tekstu w pierwszej wolnej pozycji, jesli nie znajdzie
// zostanie dodana nowa kolumna
int goc_listSetColumnText(GOC_HANDLER u, const char *tekst, int kolumna)
{
GOC_StList* lista = (GOC_StList*)u;
GOC_COLUMN *k = NULL;
int i;
if ( lista->flag & GOC_LISTFLAG_EXTERNAL )
return GOC_ERR_REFUSE;
if ( kolumna >= lista->nKolumna )
return GOC_ERR_REFUSE;
k = lista->pKolumna[kolumna];
for ( i=0; i<k->nText; i++ )
{
if ( k->pText[i] == NULL )
{
k->pText[i] = goc_stringCopy(k->pText[i], tekst);
return GOC_ERR_OK;
}
}
return goc_listAddColumnText(u, tekst, kolumna);
}
int goc_systemSetTimer(GOC_HANDLER uchwyt, const char *id)
{
if ( nHandler == 0 )
{
// wystartuj czasomierz
struct itimerval tv;
struct sigaction sa;
memset( &sa, 0, sizeof( struct sigaction ) );
sa.sa_handler = &alarmTick;
sigaction(SIGALRM, &sa, 0);
memset( &tv, 0, sizeof( struct itimerval ) );
tv.it_value.tv_usec = 100;
tv.it_interval.tv_usec = milisec * 1000;
setitimer(ITIMER_REAL, &tv, 0);
}
pHandler = goc_tableAdd(pHandler, &nHandler, sizeof(GOC_HANDLER));
pHandler[nHandler-1] = uchwyt;
nHandler--;
pId = goc_tableAdd(pId, &nHandler, sizeof(char *));
pId[nHandler-1] = goc_stringCopy(NULL, id);
return GOC_ERR_OK;
}
int doAction(unsigned int action, const void *param)
{
GOC_BDEBUG("Call action %d", action);
int old;
switch ( action )
{
case ACTION_AUMIX_PLUS: // Increase volume
mixerChangeVolume(mixer, 1, NULL);
break;
case ACTION_AUMIX_MINUS: // Decrease volume
mixerChangeVolume(mixer, -1, NULL);
break;
case ACTION_AUMIX_NEXTDEV:
next_aumix_port();
break;
case ACTION_AUMIX_PREVDEV:
break;
case ACTION_AUMIX_CURRDEV: {
MixerElement* active = NULL;
mixerGetSelectedElement(mixer, &active);
*(int*)param = (int)active->volume;
break;
}
case ACTION_AUMIX_CURRNAME: {
MixerElement* active = NULL;
mixerGetSelectedElement(mixer, &active);
*(char**)param = active->name;
break;
}
case ACTION_NEXT:
old = mode;
// zatrzymaj granie
if ( mode == MODE_PLAY )
{
mode = MODE_STOP;
pthread_mutex_lock(&mutexPlay);
}
// zmieñ piosenkê
TRY_OPEN( playlistNext );
mode = old;
if ( filename )
{
// pu¶æ granie dalej
if ( mode == MODE_PLAY )
pthread_mutex_unlock(&mutexPlay);
}
else
mode = MODE_STOP;
return 0;
case ACTION_PREV:
old = mode;
// zatrzymaj granie
if ( mode == MODE_PLAY )
{
mode = MODE_NEXT;
pthread_mutex_lock(&mutexPlay);
}
// zmieñ piosenkê
TRY_OPEN( playlistPrev );
mode = old;
if ( filename )
{
// pu¶æ granie dalej
if ( mode == MODE_PLAY )
pthread_mutex_unlock(&mutexPlay);
}
else
mode = MODE_STOP;
return 0;
case ACTION_PAUSE:
if ( mode == MODE_PLAY )
{
// zatrzymaj granie
mode = MODE_PAUSE;
pthread_mutex_lock(&mutexPlay);
}
else
{
// je¶li wcze¶niej nie wybrano piosenki, wybierz
if ( filename == NULL )
TRY_OPEN( playlistNext );
if ( filename )
{
// pu¶æ granie dalej
mode = MODE_PLAY;
pthread_mutex_unlock(&mutexPlay);
}
}
return 0;
case ACTION_PLAY:
if ( mode == MODE_PLAY )
{
// zatrzymaj granie
mode = MODE_STOP;
pthread_mutex_lock(&mutexPlay);
}
// zmieñ piosenkê
if ( param != NULL ) {
openAudioFile((const char*)param); //TODO: -1
} else {
openAudioFile(filename); //TODO: -1
}
if ( filename )
{
mode = MODE_PLAY;
// pu¶æ granie dalej
pthread_mutex_unlock(&mutexPlay);
}
else
{
mode = MODE_STOP;
}
return 0;
case ACTION_START:
pthread_mutex_init(&threadMutex, NULL);
pthread_mutex_init(&mutexPlay, NULL);
pthread_mutex_lock(&mutexPlay);
TRY_OPEN( playlistNext );
if ( filename )
{
mode = MODE_PLAY;
pthread_mutex_unlock(&mutexPlay);
}
else
{
mode = MODE_STOP;
}
pthread_create(&threadPlay, NULL, &playFile, NULL);
return 0;
case ACTION_QUIT:
printf("Quit and clean thread.\n");
fflush( stdout );
// zatrzymaj granie
if ( mode != MODE_STOP )
{
mode = MODE_STOP;
pthread_mutex_lock(&mutexPlay);
mode = MODE_QUIT;
pthread_mutex_unlock(&mutexPlay);
}
else
{
mode = MODE_QUIT;
pthread_mutex_unlock(&mutexPlay);
}
pthread_mutex_destroy(&threadMutex);
pthread_mutex_destroy(&mutexPlay);
pthread_join( threadPlay, NULL );
return 0;
case ACTION_STOP:
if ( mode == MODE_PLAY )
{
// zatrzymaj granie
mode = MODE_STOP;
pthread_mutex_lock(&mutexPlay);
}
else
{
if ( filename )
// odtwórz od pocz±tku
openAudioFile(filename); // TODO: -1
else
// znajd¼ plik do otworzenia
TRY_OPEN(playlistNext);
if ( filename )
{
// pu¶æ granie dalej
mode = MODE_PLAY;
pthread_mutex_unlock(&mutexPlay);
}
else
{
mode = MODE_STOP;
}
}
return 0;
case ACTION_INFO:
{
FileInfo* fileInfo = (FileInfo*)param;
fileInfo->filename = goc_stringCopy(fileInfo->filename, filename);
finfoInfo(filename, fileInfo);
return 0;
}
default:
return ERR_UNKNOWN_ACTION;
}
return 0;
}
int main(int argc, char** argv)
{
// zak³ada siê, ¿e ramka zawiera próbkê, w której
// jest d¼wiêk beat-u i cisza do nastêpnego beatu
//
//
// ramka
//char *pFrame;
// licznik
int i;
// goc_termInit();
printf(GOC_STRING_WHITE);
// Procedury inicjuj±ce
GOC_DEBUG("Initializing libao");
ao_initialize();
GOC_DEBUG("Initializing libao Device");
aodriverid = ao_default_driver_id();
if ( aodriverid == -1 )
return -1;
openOutputDevice();
params = allocParameters();
if ( argc > 1 )
{
if ( interpretArgs(argc, argv, params) < 0 )
endProgram(-1);
}
GOC_DEBUG("Allocating buffer");
generateBeat(params, BEAT_BASE);
generateBeat(params, BEAT_ACCENT);
generateBeat(params, BEAT_INTER);
generateBeat(params, BEAT_QUIET);
// pFrame = malloc(nFrame);
// memset(pFrame, 0, nFrame);
GOC_BINFO("Tempo: %d Rate: %d Channels: %d Bits: %d",
params->tempo, SAMPLE_RATE, SAMPLE_CHANNELS, SAMPLE_BITS);
// GOC_BDEBUG("Allocated %d at 0x%X", nFrame, (unsigned int)pFrame);
if ( params->flags & FLAG_PRINTCOUNT )
{
goc_clearscreen();
goc_gotoxy(1,1);
}
printf("Playing ... \n");
if ( params->pattern )
printf("Use pattern: %s\n", params->pattern);
fflush(stdout);
{
// to nie do koñca jest liczba ramek - to jest liczba
// podstawowych beatów jakie maj± zostaæ zagrane - nie
// s± liczone beat-y po¶rednie
int nFrames;
int imeasure = 0;
int iinter;
int patternPosition = 0;
int patternLen = 0;
char *prevString = goc_stringCopy(NULL, "");
char playedPattern = '.';
if ( params->pattern )
{
patternLen = strlen(params->pattern);
}
if ( params->tacts )
// na podstawie liczby podanych taktów
nFrames = params->tacts * params->measure;
else
// na podstawie podanego czasu
nFrames = params->tempo * params->pdur / 60;
NEXTPATTERN();
// goc_saveXY();
for (i=0; i<nFrames; i++)
{
if ( imeasure )
{
if ( params->flags & FLAG_PRINTCOUNT )
{
goc_gotoxy(1, 5);
printf("%s%s%s%d%s", GOC_STRING_YELLOW, prevString, GOC_STRING_BWHITE, imeasure + 1, GOC_STRING_YELLOW);
prevString = goc_stringAddInt(prevString, imeasure+1);
prevString = goc_stringAdd(prevString, " .. ");
fflush(stdout);
}
if ( playedPattern == '.' )
ao_play(aodev, params->pBeat[BEAT_BASE].pFrame, params->pBeat[BEAT_BASE].nFrame);
else
ao_play(aodev, params->pBeat[BEAT_QUIET].pFrame, params->pBeat[BEAT_QUIET].nFrame);
NEXTPATTERN();
}
else
{
if ( params->flags & FLAG_PRINTCOUNT )
{
goc_gotoxy(1, 5);
printf("%s%s", GOC_STRING_YELLOW, prevString);
goc_gotoxy(1, 5);
printf("%s%d%s", GOC_STRING_BWHITE, imeasure + 1, GOC_STRING_YELLOW);
prevString = goc_stringFree(prevString);
prevString = goc_stringAddInt(prevString, imeasure+1);
prevString = goc_stringAdd(prevString, " .. ");
fflush(stdout);
}
if ( playedPattern == '.' )
ao_play(aodev, params->pBeat[BEAT_ACCENT].pFrame, params->pBeat[BEAT_ACCENT].nFrame);
else
ao_play(aodev, params->pBeat[BEAT_QUIET].pFrame, params->pBeat[BEAT_QUIET].nFrame);
NEXTPATTERN();
}
if ( (iinter = params->inter) )
{
while ( iinter-- )
{
if ( params->flags & FLAG_PRINTCOUNT )
{
goc_gotoxy(1, 5);
printf("%s%s%si%s", GOC_STRING_YELLOW, prevString, GOC_STRING_WHITE, GOC_STRING_YELLOW);
prevString = goc_stringAdd(prevString, "i .. ");
fflush(stdout);
}
if ( playedPattern == '.' )
ao_play(aodev, params->pBeat[BEAT_INTER].pFrame, params->pBeat[BEAT_INTER].nFrame);
else
ao_play(aodev, params->pBeat[BEAT_QUIET].pFrame, params->pBeat[BEAT_QUIET].nFrame);
NEXTPATTERN();
}
}
imeasure++;
imeasure %= params->measure;
}
if ( params->flags & FLAG_PRINTCOUNT )
{
goc_gotoxy(1, 5);
printf("%s%s", GOC_STRING_YELLOW, prevString);
}
prevString = goc_stringFree(prevString);
}
printf("%s\nFinish\n", GOC_STRING_WHITE);
if ( params->tacts )
{
GOC_BINFO("Played %d frames in %d tacts", i, params->tacts);
}
else
{
GOC_BINFO("Played %d frames in %d seconds", i, params->pdur);
}
endProgram(0);
return 0;
}
int argString(char** argv, int pos, int argc, char** string)
{
*string = goc_stringCopy(NULL, argv[pos+1]);
return 2;
}
int goc_listSetTitle(GOC_HANDLER u, const char *tekst)
{
GOC_StList *lista = (GOC_StList*)u;
lista->pTytul = goc_stringCopy(lista->pTytul, tekst);
return GOC_ERR_OK;
}
/*
* Odmowa wykonania polecenia, jezeli ustawione dane sa zewnetrzne.
*/
static int listAddRow(GOC_HANDLER u, GOC_LISTROW *wiersz)
{
GOC_StList* lista = (GOC_StList*)u;
GOC_COLUMN *k = NULL;
int i;
if ( lista->flag & GOC_LISTFLAG_EXTERNAL )
return GOC_ERR_REFUSE;
// jesli nie ma to stworz nowa kolumne
if ( lista->nKolumna == 0 )
goc_listAddColumn(u, goc_elementGetWidth(u));
// ustal pozcje na podstawie sortowania lub jako ostatni element
if ( wiersz->nRow == -1 )
{
if ( lista->flag & GOC_LISTFLAG_SORT )
{
k = lista->pKolumna[0];
for (i=0; i<k->nText; i++)
{
if ( strcmp(wiersz->pText[0], k->pText[i])<0 )
break;
}
wiersz->nRow = i;
}
else
{
wiersz->nRow = lista->pKolumna[0]->nText;
}
}
// czy nie wykracza ponad dodanie
if ( wiersz->nRow > lista->pKolumna[0]->nText )
return GOC_ERR_REFUSE;
// dodawanie danych wiersza do kolumn
for ( i=0; i<lista->nKolumna; i++ )
{
k = lista->pKolumna[i];
k->pText = goc_tableInsert(k->pText, &(k->nText), sizeof(char*),
wiersz->nRow);
if ( i < wiersz->nText )
{
k->pText[wiersz->nRow] = goc_stringCopy(NULL,
wiersz->pText[i]);
}
else
{
k->pText[wiersz->nRow] = NULL;
}
}
return GOC_ERR_OK;
// return goc_listAddColumnText(u, tekst, 0);
/* GOC_StList* lista = (GOC_StList*)u;
char *pBuf = NULL;
GOC_COLUMN *kolumna = NULL;
if ( lista->flag & GOC_LISTFLAG_EXTERNAL )
return GOC_ERR_REFUSE;
if ( lista->nKolumna == 0 )
goc_listAddColumn(u, lista->width);
kolumna = lista->pKolumna[0];
pBuf = goc_stringCopy(pBuf, tekst);
kolumna->pText = goc_tableAdd( kolumna->pText, &(kolumna->nText),
sizeof(char*) );
kolumna->pText[kolumna->nText-1] = pBuf;
// goc_systemSendMsg(u, GOC_MSG_PAINT, 0, 0);
return GOC_ERR_OK;*/
}
