src/vis/libvisual/libvisual.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2004, 2005 Max Howell <max.howell@methylblue.com>       *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  ***************************************************************************/
  10
  11 extern "C"
  12 {
  13     #include <sys/types.h>  //this must be _before_ sys/socket on freebsd
  14     #include <sys/socket.h>
  15     #include <sys/un.h>
  16     #include <unistd.h>
  17 }
  18
  19 #include <cstdlib>
  20 #include <cstring>
  21 #include <iostream>
  22 #include "libvisual.h"
  23
  24
  25 int
  26 main( int argc, char** argv )
  27 {
  28     if( argc <= 1 || std::strcmp( argv[1], "--list" ) == 0 )
  29     {
  30         visual_init( &argc, &argv );
  31
  32         #if 0
  33         VisList *list = visual_actor_get_list();
  34
  35         for( VisListEntry *entry = list->head->next; entry != list->tail; entry = entry->next )
  36         {
  37             VisPluginInfo *info = static_cast<VisActor*>(entry->data)->plugin->ref->info;
  38
  39             std::cout << info->name << '|' << info->about << std::endl;
  40         }
  41         #endif
  42
  43         const char *plugin = 0;
  44
  45         while( (plugin = visual_actor_get_next_by_name( plugin )) )
  46             std::cout << plugin << '\n';
  47
  48         std::exit( 0 );
  49     }
  50     else if( argc == 3 )
  51         Vis::plugin = argv[2];
  52
  53
  54     //connect to socket
  55     const int sockfd = tryConnect( argv[1] );
  56
  57     //register fd/pid combo with Amarok
  58     {
  59         pid_t pid = ::getpid();
  60         char  buf[32] = "REG";
  61         *(pid_t*)&buf[4] = pid;
  62
  63         ::send( sockfd, buf, 4 + sizeof(pid_t), 0 );
  64     }
  65
  66     //init
  67     SDL::init();
  68     Vis::init( argc, argv );
  69
  70
  71     //main loop
  72     // 1. we sleep for a bit, listening for messages from Amarok
  73     // 2. render a frame
  74
  75     timeval tv;
  76     fd_set  fds;
  77     int     nbytes = 0;
  78     uint    render_time = 0;
  79
  80     while( nbytes != -1 && SDL::event_handler() )
  81     {
  82         //set the time to wait
  83         tv.tv_sec  = 0;
  84         tv.tv_usec = render_time > 16 ? 0 : (16 - render_time) * 1000; //60Hz
  85
  86         //get select to watch the right file descriptor
  87         FD_ZERO( &fds );
  88         FD_SET( sockfd, &fds );
  89
  90         ::select( sockfd+1, &fds, 0, 0, &tv );
  91
  92         if( FD_ISSET( sockfd, &fds) ) {
  93             //Amarok sent us some data
  94
  95             char command[16];
  96             ::recv( sockfd, command, 16, 0 );
  97
  98             if( std::strcmp( command, "fullscreen" ) == 0 )
  99                 SDL::toggleFullScreen();
 100         }
 101
 102         //request pcm data
 103         ::send( sockfd, "PCM", 4, 0 );
 104         nbytes = ::recv( sockfd, Vis::pcm_data, 1024 * sizeof( int16_t ), 0 );
 105
 106         render_time = LibVisual::render();
 107     }
 108
 109     ::close( sockfd );
 110
 111     return 0;
 112 }
 113
 114 static int
 115 tryConnect( const char *path )
 116 {
 117     const int fd = ::socket( AF_UNIX, SOCK_STREAM, 0 );
 118
 119     if( fd != -1 )
 120     {
 121         struct sockaddr_un local;
 122
 123         std::strcpy( &local.sun_path[ 0 ], path );
 124         local.sun_family = AF_UNIX;
 125
 126         std::cout << "[Amk] Connecting to: " << path << '\n';
 127
 128         if( connect( fd, (struct sockaddr*)&local, sizeof(local) ) == -1 )
 129         {
 130             ::close( fd );
 131
 132             std::cerr << "[Amk] Could not connect\n";
 133             std::exit( -1 );
 134         }
 135     }
 136
 137     return fd;
 138 }
 139
 140
 141 namespace SDL
 142 {
 143     static inline void
 144     init()
 145     {
 146         if( SDL_Init( SDL_INIT_VIDEO ) )
 147         {
 148             std::cerr << "Could not initialize SDL: " << SDL_GetError() << std::endl;
 149             std::exit( -2 );
 150         }
 151
 152         std::atexit( SDL::quit );
 153     }
 154
 155     static void
 156     quit()
 157     {
 158         //FIXME crashes!
 159         //visual_bin_destroy( Vis::bin );
 160         //visual_quit();
 161
 162         SDL_FreeSurface( screen );
 163         SDL_Quit();
 164     }
 165
 166     static inline void
 167     set_pal()
 168     {
 169         if (Vis::pal)
 170             for( int i = 0; i < 256; i ++ )
 171             {
 172                 SDL::pal[i].r = Vis::pal->colors[i].r;
 173                 SDL::pal[i].g = Vis::pal->colors[i].g;
 174                 SDL::pal[i].b = Vis::pal->colors[i].b;
 175             }
 176
 177         SDL_SetColors( screen, SDL::pal, 0, 256 );
 178     }
 179
 180     static void
 181     create( int width, int height )
 182     {
 183         SDL_FreeSurface( screen );
 184
 185         if( Vis::pluginIsGL )
 186         {
 187             const SDL_VideoInfo *videoinfo = SDL_GetVideoInfo();
 188
 189             if( videoinfo == NULL )
 190             {
 191                 std::cerr << "CRITICAL: Could not get video info\n";
 192                 std::exit( -2 );
 193             }
 194
 195             int
 196             videoflags  = SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE | SDL_RESIZABLE;
 197             videoflags |= videoinfo->hw_available ? SDL_HWSURFACE : SDL_SWSURFACE;
 198
 199             if( videoinfo->blit_hw ) videoflags |= SDL_HWACCEL;
 200
 201             SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
 202
 203             screen = SDL_SetVideoMode( width, height, 16, videoflags );
 204         }
 205         else screen = SDL_SetVideoMode( width, height, Vis::video->bpp * 8, SDL_RESIZABLE );
 206
 207         visual_video_set_buffer( Vis::video, screen->pixels );
 208         visual_video_set_pitch( Vis::video, screen->pitch );
 209     }
 210
 211     static bool
 212     event_handler()
 213     {
 214         SDL_Event event;
 215         VisEventQueue *vevent;
 216
 217         while( SDL_PollEvent( &event ) )
 218         {
 219             vevent = visual_plugin_get_eventqueue( visual_actor_get_plugin( visual_bin_get_actor( Vis::bin ) ) );
 220
 221             switch( event.type )
 222             {
 223             case SDL_KEYUP:
 224                 visual_event_queue_add_keyboard( vevent, (VisKey)event.key.keysym.sym, event.key.keysym.mod, VISUAL_KEY_UP );
 225                 break;
 226
 227             case SDL_KEYDOWN:
 228                 visual_event_queue_add_keyboard (vevent, (VisKey)event.key.keysym.sym, event.key.keysym.mod, VISUAL_KEY_DOWN);
 229
 230                 switch( event.key.keysym.sym )
 231                 {
 232                 //PLUGIN CONTROLS
 233                 case SDLK_F11:
 234                 case SDLK_TAB:
 235                     SDL::toggleFullScreen();
 236                     break;
 237
 238                 case SDLK_ESCAPE:
 239                     if( SDL::isFullScreen() )
 240                         SDL::toggleFullScreen();
 241                     break;
 242
 243                 case SDLK_LEFT:
 244                     Vis::prevActor();
 245                     goto morph;
 246
 247                 case SDLK_RIGHT:
 248                     Vis::nextActor();
 249
 250                 morph:
 251                     SDL::lock();
 252                       visual_bin_set_morph_by_name( Vis::bin, (char*)"alphablend" );
 253                       visual_bin_switch_actor_by_name( Vis::bin, (char*)Vis::plugin );
 254                     SDL::unlock();
 255
 256                     SDL_WM_SetCaption( Vis::plugin, 0 );
 257
 258                     break;
 259
 260                 default:
 261                     ;
 262                 }
 263                 break;
 264
 265             case SDL_VIDEORESIZE:
 266                 Vis::resize( event.resize.w, event.resize.h );
 267                 break;
 268
 269             case SDL_MOUSEMOTION:
 270                 visual_event_queue_add_mousemotion (vevent, event.motion.x, event.motion.y);
 271                 break;
 272
 273             case SDL_MOUSEBUTTONDOWN:
 274                 if (event.button.button == SDL_BUTTON_RIGHT)
 275                 {
 276                     SDL::toggleFullScreen();
 277                     break;
 278                 }
 279                 visual_event_queue_add_mousebutton (vevent, event.button.button, VISUAL_MOUSE_DOWN, 0, 0);
 280                 break;
 281
 282             case SDL_MOUSEBUTTONUP:
 283                 visual_event_queue_add_mousebutton (vevent, event.button.button, VISUAL_MOUSE_UP, 0, 0);
 284                 break;
 285
 286             case SDL_QUIT:
 287                 return false;
 288
 289             default:
 290                 ;
 291             }
 292         }
 293
 294         return true;
 295     }
 296 } //namespace SDL
 297
 298
 299 namespace LibVisual
 300 {
 301     static int
 302     upload_callback( VisInput*, VisAudio *audio, void* )
 303     {
 304         VisBuffer buf;
 305
 306         visual_buffer_init( &buf, pcm_data, 1024, 0 );
 307         visual_audio_samplepool_input( audio->samplepool, &buf, VISUAL_AUDIO_SAMPLE_RATE_44100,
 308             VISUAL_AUDIO_SAMPLE_FORMAT_S16, VISUAL_AUDIO_SAMPLE_CHANNEL_STEREO );
 309
 310         return 0;
 311     }
 312
 313     static void
 314     resize( int width, int height )
 315     {
 316         visual_video_set_dimension( video, width, height );
 317
 318         SDL::create( width, height );
 319
 320         visual_bin_sync( bin, false );
 321     }
 322
 323     static void
 324     init( int &argc, char **&argv )
 325     {
 326         VisVideoDepth depth;
 327
 328         visual_init( &argc, &argv );
 329
 330         bin    = visual_bin_new ();
 331         depth  = visual_video_depth_enum_from_value( 24 );
 332
 333         if( !plugin ) plugin = visual_actor_get_next_by_name( 0 );
 334         if( !plugin ) exit( "Actor plugin not found!" );
 335
 336         visual_bin_set_supported_depth( bin, VISUAL_VIDEO_DEPTH_ALL );
 337
 338         if( NULL == (video = visual_video_new()) )       exit( "Cannot create a video surface" );
 339         if( visual_video_set_depth( video, depth ) < 0 ) exit( "Cannot set video depth" );
 340
 341         visual_video_set_dimension( video, 320, 200 );
 342
 343         if( visual_bin_set_video( bin, video ) ) exit( "Cannot set video" );
 344
 345         visual_bin_connect_by_names( bin, (char*)plugin, 0 );
 346
 347         if( visual_bin_get_depth( bin ) == VISUAL_VIDEO_DEPTH_GL )
 348         {
 349             visual_video_set_depth( video, VISUAL_VIDEO_DEPTH_GL );
 350             pluginIsGL = true;
 351         }
 352
 353         SDL::create( 320, 200 );
 354
 355         SDL_WM_SetCaption( plugin, 0 );
 356
 357         /* Called so the flag is set to false, seen we create the initial environment here */
 358         visual_bin_depth_changed( bin );
 359
 360         VisInput *input = visual_bin_get_input( bin );
 361         if( visual_input_set_callback( input, upload_callback, NULL ) < 0 ) exit( "Cannot set input plugin callback" );
 362
 363         visual_bin_switch_set_style( bin, VISUAL_SWITCH_STYLE_MORPH );
 364         visual_bin_switch_set_automatic( bin, true );
 365         visual_bin_switch_set_steps( bin, 100 );
 366
 367         visual_bin_realize( bin );
 368         visual_bin_sync( bin, false );
 369
 370         std::cout << "[Amk] Libvisual version " << visual_get_version() << '\n';
 371         std::cout << "[Amk] bpp: " << video->bpp << std::endl;
 372         std::cout << "[Amk]  GL: "  << (pluginIsGL ? "true\n" : "false\n");
 373     }
 374
 375     static uint
 376     render()
 377     {
 378         /* On depth change */
 379         if( visual_bin_depth_changed( bin ) )
 380         {
 381             SDL::lock();
 382
 383             pluginIsGL = (visual_bin_get_depth( bin ) == VISUAL_VIDEO_DEPTH_GL);
 384
 385             SDL::create( SDL::screen->w, SDL::screen->h );
 386             visual_bin_sync( bin, true );
 387
 388             SDL::unlock();
 389         }
 390
 391         long ticks = -SDL_GetTicks();
 392
 393         if( pluginIsGL )
 394         {
 395             visual_bin_run( bin );
 396
 397             SDL_GL_SwapBuffers();
 398
 399         } else {
 400
 401             SDL::lock();
 402
 403             visual_video_set_buffer( video, SDL::screen->pixels );
 404             visual_bin_run( bin );
 405
 406             SDL::unlock();
 407
 408             Vis::pal = visual_bin_get_palette( bin );
 409             SDL::set_pal();
 410
 411             SDL_Flip( SDL::screen );
 412         }
 413
 414         ticks += SDL_GetTicks();
 415         return ticks;
 416     }
 417 } //namespace LibVisual