← Back to branch summary

~ubuntu-branches/ubuntu/maverick/ultrastar-ng/maverick

« back to all changes in this revision

Viewing changes to src/main.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Miriam Ruiz, Miriam Ruiz, Mario Bonino, Jon Dowland, Ansgar Burchardt
  • Date: 2008-06-07 16:43:18 UTC
  • mfrom: (4.1.1 lenny)
  • Revision ID: james.westby@ubuntu.com-20080607164318-4cnzizck1tp8mrwp
Tags: 0.2.1-1
http://bugs.debian.org/453132
http://bugs.debian.org/478634
[ Miriam Ruiz ]
* New Upstream Release (Closes: #453132)
* Removed unneeded patches
* Added packages to build deps:
  + libtool
  + portaudio19-dev | portaudio-dev
  + libboost-dev, libboost-thread-dev, libboost-serialization-dev
  + libboost-program-options-dev, libboost-regex-dev
* Moved shared objects to private directory: /usr/lib/ultraster-ng
* Added rpath to binaries to search for shared objects in the private dir
* Uses ultrastar-ng-gstreamer as default, instead of ultrastar-ng-xine,
  since there are significantly less issues with GStreamer.
* Added patch to fix upstream desktop file
* Added -Wl,-as-needed to LDFLAGS
* Replaced fftw3-dev by libfftw3-dev in build dependencies.
* Standards-Version upgraded to 3.7.3

[ Mario Bonino ]
* Fixed data/Makefile.am to install .desktop file and icon

[ Jon Dowland ]
* add Homepage: control field to source stanza
* fix a bashism in debian/rules (Closes: #478634)

[ Ansgar Burchardt ]
* debian/control: Change XS-Vcs-* to Vcs-*
* Remove Homepage semi-field from description

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/main.cpp
1
1
#include "../config.h"
2
2
 
 
3
#include <audio.hpp>
3
4
#include <screen.h>
4
5
#include <screen_intro.h>
5
6
#include <screen_songs.h>
6
7
#include <screen_sing.h>
7
8
#include <screen_practice.h>
 
9
#include <screen_score.h>
 
10
#include <screen_configuration.h>
8
11
#include <video_driver.h>
9
 
unsigned int width=800;
10
 
unsigned int height=600;
11
 
unsigned int fullscreen=0;
 
12
#include <boost/format.hpp>
 
13
#include <boost/program_options.hpp>
 
14
#include <boost/thread.hpp>
 
15
#include <cstdlib>
 
16
#include <set>
 
17
#include <string>
 
18
#include <vector>
12
19
 
13
 
SDL_Event event;
14
20
SDL_Surface * screenSDL;
15
 
CScreenManager *screenManager;
16
 
CVideoDriver *videoDriver;
17
 
 
18
 
bool capture = true;
19
 
 
20
 
void checkEvents( void )
21
 
{
22
 
        while(SDL_PollEvent( &event ) == 1) {
23
 
                screenManager->getCurrentScreen()->manageEvent(event);
 
21
 
 
22
static void checkEvents_SDL(CScreenManager& sm) {
 
23
        static bool esc = false;
 
24
        SDL_Event event;
 
25
        while(SDL_PollEvent(&event) == 1) {
24
26
                switch(event.type) {
25
 
                        case SDL_QUIT:
26
 
                                screenManager->finished();
27
 
                                break;
28
 
                case SDL_KEYDOWN:
 
27
                  case SDL_QUIT:
 
28
                        sm.finished();
 
29
                        break;
 
30
                  case SDL_KEYUP:
 
31
                        if (event.key.keysym.sym == SDLK_ESCAPE) esc = false;
 
32
                        break;
 
33
                  case SDL_KEYDOWN:
29
34
                        int keypressed  = event.key.keysym.sym;
30
35
                        SDLMod modifier = event.key.keysym.mod;
31
 
                        if( keypressed == SDLK_f && modifier&KMOD_ALT ) {
 
36
                        // Workaround for key repeat on escape
 
37
                        if (keypressed == SDLK_ESCAPE) {
 
38
                                if (esc) return;
 
39
                                esc = true;
 
40
                        }
 
41
                        if (keypressed == SDLK_RETURN && modifier & KMOD_ALT ) {
32
42
                                SDL_WM_ToggleFullScreen(screenSDL);
33
 
                                break;
 
43
                                sm.setFullscreenStatus(!sm.getFullscreenStatus());
 
44
                                continue; // Already handled here...
34
45
                        }
 
46
                        break;
35
47
                }
 
48
                sm.getCurrentScreen()->manageEvent(event);
36
49
        }
37
50
}
38
51
 
39
 
void init( void )
40
 
{
41
 
        if( SDL_Init(SDL_INIT_VIDEO) ==  -1 ) {
42
 
                fprintf(stderr,"SDL_Init Error\n");
43
 
                SDL_Quit();
44
 
                exit(EXIT_FAILURE);
45
 
        }
46
 
        
 
52
static void init_SDL(CScreenManager& sm, CVideoDriver& vd, unsigned int width, unsigned int height) {
 
53
        std::atexit(SDL_Quit);
 
54
        if( SDL_Init(SDL_INIT_VIDEO) ==  -1 ) throw std::runtime_error("SDL_Init failed");
47
55
        SDL_WM_SetCaption(PACKAGE" - "VERSION, "WM_DEFAULT");
48
 
 
49
 
        screenSDL = videoDriver->init( width, height, fullscreen );
50
 
 
 
56
        screenSDL = vd.init(width, height, sm.getFullscreenStatus());
 
57
        if (!screenSDL) throw std::runtime_error("Cannot initialize screen");
51
58
        SDL_ShowCursor(SDL_DISABLE);
52
59
        SDL_EnableUNICODE(SDL_ENABLE);
53
 
        SDL_EnableKeyRepeat(125, 125);
54
 
}
55
 
 
56
 
int thread_func(void *)
57
 
{
58
 
        while( !screenManager->isFinished() ) {
59
 
                screenManager->getRecord()->compute();
60
 
        }
61
 
        return 1;
62
 
}
63
 
 
64
 
void usage( char * progname )
65
 
{
66
 
        fprintf(stdout,"Usage: %s [OPTIONS] [SONG_DIRECTORY]\n", progname);
67
 
        fprintf(stdout,"Options:\n");
68
 
        fprintf(stdout,"\n");
69
 
        fprintf(stdout," -W, --width (default: 640)  set window width\n");
70
 
        fprintf(stdout," -H, --height (default: 480) set window height\n");
71
 
        fprintf(stdout," -t, --theme                 set theme (theme name or absolute path to the\n");
72
 
        fprintf(stdout,"                             theme)\n");
73
 
        fprintf(stdout," -c, --no-capture            disable sound capture thread\n");
74
 
        fprintf(stdout," -f, --fullscreen            enable fullscreen video output\n");
75
 
        fprintf(stdout," -d, --difficulty            set difficulty level\n");
76
 
        fprintf(stdout,"                             (0: easy, 1:medium, 2:hard (default))\n");
77
 
        fprintf(stdout," -h, --help                  display this text and exit\n");
78
 
        fprintf(stdout," -v, --version               display version number and exit\n");
79
 
        exit(EXIT_SUCCESS);
80
 
}
81
 
 
82
 
int main( int argc, char ** argv )
83
 
{
84
 
        char * songs_directory = NULL;
85
 
        char * theme_name      = NULL;
86
 
        CScreen * screen       = NULL;
87
 
        int ch                 = 0;
88
 
        SDL_Thread *thread     = NULL;
89
 
        unsigned int difficulty= 2;
90
 
 
91
 
        static struct option long_options[] =
92
 
                {
93
 
                {"width",required_argument,NULL,'W'},
94
 
                {"height",required_argument,NULL,'H'},
95
 
                {"theme",required_argument,NULL,'t'},
96
 
                {"help",no_argument,NULL,'h'},
97
 
                {"no-capture",no_argument,NULL,'c'},
98
 
                {"version",no_argument,NULL,'v'},
99
 
                {"difficulty",required_argument,NULL,'d'},
100
 
                {"fullscreen",no_argument,NULL,'f'},
101
 
                {0, 0, 0, 0}
102
 
        };
103
 
 
104
 
        while ((ch = getopt_long(argc, argv, "t:W:H:hcfd:v", long_options, NULL)) != -1) {
105
 
                switch(ch) {
106
 
                        case 't':
107
 
                                theme_name = optarg;
108
 
                                break;
109
 
                        case 'W':
110
 
                                width=atoi(optarg);
111
 
                                break;
112
 
                        case 'H':
113
 
                                height=atoi(optarg);
114
 
                                break;
115
 
                        case 'h':
116
 
                                usage(argv[0]);
117
 
                                break;
118
 
                        case 'c':
119
 
                                capture=false;
120
 
                                break;
121
 
                        case 'f':
122
 
                                fullscreen = 1;
123
 
                                break;
124
 
                        case 'd':
125
 
                                difficulty = atoi(optarg);
126
 
                                break;
127
 
                        case 'v':
128
 
                                fprintf(stdout,"%s %s\n",PACKAGE, VERSION);
129
 
                                exit(EXIT_SUCCESS);
130
 
                                break;
131
 
                }
132
 
        }
133
 
 
134
 
        if( optind == argc ) {
135
 
                // Using default songs directory
136
 
                const char default_songs_directory[] = DATA_DIR "/songs";
137
 
                fprintf(stdout,"Using %s as default songs directory\n",default_songs_directory);
138
 
                songs_directory = new char[strlen(default_songs_directory)+2];
139
 
                sprintf(songs_directory,"%s/",default_songs_directory); // safe sprintf
140
 
        } else {
141
 
                // Add the trailing slash
142
 
                songs_directory = new char[strlen(argv[optind])+2];
143
 
                sprintf(songs_directory,"%s/",argv[optind]); // safe sprintf
144
 
        }
145
 
 
146
 
        videoDriver = new CVideoDriver();
147
 
 
148
 
        init();
149
 
 
150
 
        if( theme_name != NULL )
151
 
                screenManager = new CScreenManager( width, height , songs_directory , theme_name );
152
 
        else
153
 
                screenManager = new CScreenManager( width, height , songs_directory );
154
 
 
155
 
        screenManager->setSDLScreen(screenSDL);
156
 
        screenManager->setAudio( new CAudio() );
157
 
        screenManager->setRecord( new CRecord() );
158
 
        screenManager->setVideoDriver( videoDriver );
159
 
        screenManager->setDifficulty( difficulty );
160
 
        
161
 
        screen = new CScreenIntro("Intro");
162
 
        screenManager->addScreen(screen);
163
 
        screen = new CScreenSongs("Songs");
164
 
        screenManager->addScreen(screen);
165
 
        screen = new CScreenSing("Sing");
166
 
        screenManager->addScreen(screen);
167
 
        screen = new CScreenPractice("Practice");
168
 
        screenManager->addScreen(screen);
169
 
 
170
 
        screenManager->activateScreen("Intro");
171
 
 
172
 
        if( capture )
173
 
                thread = SDL_CreateThread(thread_func, NULL);
174
 
 
175
 
        while( !screenManager->isFinished() ) {
176
 
                checkEvents();
177
 
                videoDriver->blank();
178
 
                screenManager->getCurrentScreen()->draw();
179
 
                videoDriver->swap();
180
 
                SDL_Delay(50);
181
 
        }
182
 
 
183
 
        if( capture )
184
 
                SDL_WaitThread(thread, NULL);
185
 
 
186
 
        delete videoDriver;
187
 
        delete screenManager;
188
 
        delete[] songs_directory;
189
 
 
190
 
        SDL_Quit();
191
 
        return EXIT_SUCCESS;
192
 
}
 
60
        SDL_EnableKeyRepeat(80, 80);
 
61
}
 
62
 
 
63
int main(int argc, char** argv) {
 
64
        std::srand(std::time(NULL)); // Seed rand (used for choosing random songs)
 
65
        bool fullscreen = false;
 
66
        unsigned int width, height;
 
67
        std::string theme;
 
68
        std::set<std::string> songdirs;
 
69
        std::string cdev;
 
70
        std::size_t crate;
 
71
        {
 
72
                std::vector<std::string> songdirstmp;
 
73
                namespace po = boost::program_options;
 
74
                po::options_description desc("Available options");
 
75
                desc.add_options()
 
76
                  ("help,h", "you are viewing it")
 
77
                  ("theme,t", po::value<std::string>(&theme)->default_value("lima"), "set theme (name or absolute path)")
 
78
                  ("songdir,s", po::value<std::vector<std::string> >(&songdirstmp)->composing(), "additional song folders to scan\n  -s none to disable built-in defaults")
 
79
                  ("fs,f", "enable full screen mode")
 
80
                  ("width,W", po::value<unsigned int>(&width)->default_value(800), "set horizontal resolution")
 
81
                  ("height,H", po::value<unsigned int>(&height)->default_value(600), "set vertical resolution")
 
82
                  ("cdev", po::value<std::string>(&cdev), "set capture device (disable autodetection)\n  --cdev dev[:settings]\n  --cdev help for list of devices")
 
83
                  ("crate", po::value<std::size_t>(&crate)->default_value(48000), "set capture frequency\n  44100 and 48000 Hz are optimal")
 
84
                  ("version,v", "display version number");
 
85
                po::variables_map vm;
 
86
                try {
 
87
                        po::store(po::parse_command_line(argc, argv, desc), vm);
 
88
                        po::notify(vm);
 
89
                } catch (std::exception& e) {
 
90
                        std::cout << desc << std::endl;
 
91
                        std::cout << "ERROR: " << e.what() << std::endl;
 
92
                        return 1;
 
93
                }
 
94
                if (vm.count("help")) {
 
95
                        std::cout << desc << std::endl;
 
96
                        return 0;
 
97
                }
 
98
                if (cdev == "help") {
 
99
                        da::record::devlist_t l = da::record::devices();
 
100
                        std::cout << "Recording devices:" << std::endl;
 
101
                        for (da::record::devlist_t::const_iterator it = l.begin(); it != l.end(); ++it) {
 
102
                                std::cout << boost::format("  %1% %|10t|%2%\n") % it->name() % it->desc();
 
103
                        }
 
104
                        return 0;
 
105
                }
 
106
                if (vm.count("version")) {
 
107
                        std::cout << PACKAGE << ' ' << VERSION << std::endl;
 
108
                        return 0;
 
109
                }
 
110
                if (vm.count("fs")) fullscreen = true;
 
111
                // Copy songdirstmp into songdirs
 
112
                bool defaultdirs = true;
 
113
                for (std::vector<std::string>::const_iterator it = songdirstmp.begin(); it != songdirstmp.end(); ++it) {
 
114
                        std::string str = *it;
 
115
                        if (str == "none") { defaultdirs = false; continue; }
 
116
                        if (*str.rbegin() != '/') str += '/';
 
117
                        songdirs.insert(str);
 
118
                }
 
119
                if (defaultdirs) {
 
120
                        songdirs.insert(DATA_DIR "songs/");
 
121
                        {
 
122
                                char const* home = getenv("HOME");
 
123
                                if (home) songdirs.insert(std::string(home) + "/.ultrastar/songs/");
 
124
                        }
 
125
                        songdirs.insert("/usr/share/games/ultrastar/songs/");
 
126
                        songdirs.insert("/usr/share/games/ultrastar-ng/songs/");
 
127
                        songdirs.insert("/usr/share/ultrastar/songs/");
 
128
                        songdirs.insert("/usr/share/ultrastar-ng/songs/");
 
129
                        songdirs.insert("/usr/local/share/games/ultrastar/songs/");
 
130
                        songdirs.insert("/usr/local/share/games/ultrastar-ng/songs/");
 
131
                        songdirs.insert("/usr/local/share/ultrastar/songs/");
 
132
                        songdirs.insert("/usr/local/share/ultrastar-ng/songs/");
 
133
                }
 
134
        }
 
135
        try {
 
136
                // Initialize everything
 
137
                CScreenManager sm(width, height, theme);
 
138
                sm.setFullscreenStatus(fullscreen);
 
139
                CVideoDriver vd;
 
140
                init_SDL(sm, vd, width, height);
 
141
                sm.setSDLScreen(screenSDL);
 
142
                sm.setAudio(new CAudio());
 
143
                sm.setVideoDriver(&vd);
 
144
                sm.addScreen(new CScreenIntro("Intro", width, height));
 
145
                sm.addScreen(new CScreenSongs("Songs", width, height, songdirs));
 
146
                Capture capture(cdev, crate);
 
147
                sm.addScreen(new CScreenSing("Sing", width, height, capture.analyzer()));
 
148
                sm.addScreen(new CScreenPractice("Practice", width, height, capture.analyzer()));
 
149
                sm.addScreen(new CScreenScore("Score", width, height));
 
150
                sm.addScreen(new CScreenConfiguration("Configuration", width, height));
 
151
                sm.activateScreen("Intro");
 
152
                // Main loop
 
153
                while (!sm.isFinished()) {
 
154
                        checkEvents_SDL(sm);
 
155
                        vd.blank();
 
156
                        sm.getCurrentScreen()->draw();
 
157
                        vd.swap();
 
158
                        boost::thread::yield();
 
159
                }
 
160
        } catch (std::exception& e) {
 
161
                std::cout << "FATAL ERROR: " << e.what() << std::endl;
 
162
        }
 
163
}
 
164