flashsupport.c

   1 /*
   2   Adobe Systems Incorporated(r) Source Code License Agreement
   3   Copyright(c) 2006 Adobe Systems Incorporated. All rights reserved.
   4
   5   Please read this Source Code License Agreement carefully before using
   6   the source code.
   7
   8   Adobe Systems Incorporated grants to you a perpetual, worldwide, non-exclusive,
   9   no-charge, royalty-free, irrevocable copyright license, to reproduce,
  10   prepare derivative works of, publicly display, publicly perform, and
  11   distribute this source code and such derivative works in source or
  12   object code form without any attribution requirements.
  13
  14   The name "Adobe Systems Incorporated" must not be used to endorse or promote products
  15   derived from the source code without prior written permission.
  16
  17   You agree to indemnify, hold harmless and defend Adobe Systems Incorporated from and
  18   against any loss, damage, claims or lawsuits, including attorney's
  19   fees that arise or result from your use or distribution of the source
  20   code.
  21
  22   THIS SOURCE CODE IS PROVIDED "AS IS" AND "WITH ALL FAULTS", WITHOUT
  23   ANY TECHNICAL SUPPORT OR ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING,
  24   BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  25   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ALSO, THERE IS NO WARRANTY OF
  26   NON-INFRINGEMENT, TITLE OR QUIET ENJOYMENT. IN NO EVENT SHALL MACROMEDIA
  27   OR ITS SUPPLIERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  28   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  29   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  30   OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  31   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  32   OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOURCE CODE, EVEN IF
  33   ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34 */
  35 ////////////////////////////////////////////////////////////////////////////////////////////////////
  36 //
  37 // File name: flashsupport.c
  38 // Targets: Adobe Flash Player 9.1 beta 2 for Linux (9.0.21.78)
  39 // Last Revision Date: 11/20/2006
  40 //
  41
  42 ////////////////////////////////////////////////////////////////////////////////////////////////////
  43 //
  44 // These are the feature which can be turned on and off. They are all
  45 // optional. The ALSA and Video4Linux support in this file is somewhat
  46 // redundant and reduced in functionality as the Flash Player already has
  47 // ALSA and Video4Linux support built-in. It is provided here for reference only.
  48 // Also, if your system has ALSA support in the kernel there is no need to
  49 // enable OSS here as it will override it.
  50 //
  51
  52 #define OPENSSL
  53 //#define GNUTLS
  54 //#define ALSA
  55 //#define OSS
  56 #define V4L1
  57 //#define PULSEAUDIO
  58 #define JACK
  59
  60 ////////////////////////////////////////////////////////////////////////////////////////////////////
  61 //
  62 // To compile and install flashsupport.c the following components are required:
  63 //
  64 //  - a C compiler (gcc 4.03 is known to be working)
  65 //  - OpenSSL developer package and working user libraries (OpenSSL 0.9.8 is known to be working)
  66 //  - OSS (or ALSA) developer package and working users libraries (Linux 2.6.15 is known to be working)
  67 //  - sudo or root access to install the generated library to /usr/lib
  68 //
  69 // We suggest these steps in a terminal:
  70 //
  71 // > cc -shared -O2 -Wall -Werror -lssl flashsupport.c -o libflashsupport.so
  72 // > ldd libflashplayer.so
  73 // > sudo cp libflashplayer.so /usr/lib
  74 //
  75 // Make sure that 'ldd' can resolve all dynamic libraries. Otherwise the Flash Player
  76 // will silently fail to load and use libflashsupport.so.
  77 //
  78
  79 ////////////////////////////////////////////////////////////////////////////////////////////////////
  80 //
  81 // SHARED SECTION, DO NOT CHANGE!
  82 //
  83 #ifdef cplusplus
  84 extern "C" {
  85 #endif // cplusplus
  86
  87 //
  88 // Imported functions
  89 //
  90
  91     typedef void *(*T_FPI_Mem_Alloc)(int size);     // This function is not thread safe
  92     typedef void (*T_FPI_Mem_Free)(void *ptr); // This function is not thread safe
  93
  94 #if defined(ALSA) || defined(OSS) || defined(PULSEAUDIO) || defined(JACK)
  95     typedef void (*T_FPI_SoundOutput_FillBuffer)(void *ptr, char *buffer, int n_bytes); // This function is thread safe
  96 #endif // defined(ALSA) || defined(OSS)
  97
  98     struct FPI_Functions {
  99         int       fpi_count;
 100         void *fpi_mem_alloc;                            // 1
 101         void *fpi_mem_free;                                     // 2
 102         void *fpi_soundoutput_fillbuffer;       // 3
 103     };
 104
 105 //
 106 // Exported functions
 107 //
 108
 109     void *FPX_Init(void *ptr);
 110
 111     static void FPX_Shutdown(void);
 112
 113 #if defined(OPENSSL) || defined(GNUTLS)
 114     static void *FPX_SSLSocket_Create(int socket_fd);
 115     static int FPX_SSLSocket_Destroy(void *ptr);
 116     static int FPX_SSLSocket_Connect(void *ptr);
 117     static int FPX_SSLSocket_Receive(void *ptr, char *buffer, int n_bytes);
 118     static int FPX_SSLSocket_Send(void *ptr, const char *buffer, int n_bytes);
 119 #endif // defined(OPENSSL) || defined(GNUTLS)
 120
 121 #if defined(ALSA) || defined(OSS) || defined(PULSEAUDIO) || defined(JACK)
 122     static void *FPX_SoundOutput_Open(void);
 123     static int FPX_SoundOutput_Close(void *ptr);
 124     static int FPX_SoundOutput_Latency(void *ptr);
 125 #endif // defined(ALSA) || defined(OSS)
 126
 127 #ifdef V4L1
 128     static void *FPX_VideoInput_Open(void);
 129     static int FPX_VideoInput_Close(void *ptr);
 130     static int FPX_VideoInput_GetFrame(void *ptr, char *data, int width, int height, int pitch_n_bytes);
 131 #endif // V4L1
 132
 133     struct FPX_Functions {
 134         int   fpx_count;
 135         void *fpx_shutdown;                                     // 1
 136         void *fpx_sslsocket_create;                     // 2
 137         void *fpx_sslsocket_destroy;            // 3
 138         void *fpx_sslsocket_connect;            // 4
 139         void *fpx_sslsocket_receive;            // 5
 140         void *fpx_sslsocket_send;                       // 6
 141         void *fpx_soundoutput_open;                     // 7
 142         void *fpx_soundoutput_close;            // 8
 143         void *fpx_soundoutput_latency;          // 9
 144         void *fpx_videoinput_open;                      // 10
 145         void *fpx_videoinput_close;                     // 11
 146         void *fpx_videoinput_getframe;          // 12
 147     };
 148
 149 #ifdef cplusplus
 150 };
 151 #endif // cplusplus
 152 //
 153 // END OF SHARED SECTION
 154 //
 155 ////////////////////////////////////////////////////////////////////////////////////////////////////
 156
 157 #include <memory.h>
 158
 159 #ifdef OPENSSL
 160 #include <openssl/ssl.h>
 161 #elif defined(GNUTLS)
 162 #include <sys/types.h>
 163 #include <sys/socket.h>
 164 #include <arpa/inet.h>
 165 #include <unistd.h>
 166 #include <gnutls/gnutls.h>
 167 #endif // GNUTLS
 168
 169 #if  defined(ALSA) || defined(JACK)
 170 #include <pthread.h>
 171 #include <semaphore.h>
 172 #include <alsa/asoundlib.h>
 173 #elif defined(OSS)
 174 #include <unistd.h>
 175 #include <pthread.h>
 176 #include <linux/soundcard.h>
 177 #include <sys/ioctl.h>
 178 #include <fcntl.h>
 179 #endif // OSS
 180
 181 #ifdef V4L1
 182 #include <unistd.h>
 183 #include <pthread.h>
 184 #include <linux/videodev.h>
 185 #include <sys/ioctl.h>
 186 #include <fcntl.h>
 187 #endif // V4L1
 188
 189 #ifdef PULSEAUDIO
 190 #include <pulse/pulseaudio.h>
 191 #endif
 192
 193 #ifdef JACK
 194 #include <jack/jack.h>
 195 #include <jack/ringbuffer.h>
 196 #include <samplerate.h>
 197 #include <semaphore.h>
 198 #endif
 199
 200 static struct FPX_Functions fpx_functions;
 201
 202 static T_FPI_Mem_Alloc FPI_Mem_Alloc = 0;
 203 static T_FPI_Mem_Free FPI_Mem_Free = 0;
 204
 205 #if defined(ALSA) || defined(OSS) || defined(PULSEAUDIO) || defined(JACK)
 206 static T_FPI_SoundOutput_FillBuffer FPI_SoundOutput_FillBuffer = 0;
 207 #endif // defined(ALSA) || defined(OSS)
 208
 209 void *FPX_Init(void *ptr)
 210 {
 211     struct FPI_Functions *fpi_functions;
 212     if ( !ptr ) return 0;
 213
 214     //
 215     // Setup imported functions
 216     //
 217
 218     fpi_functions = (struct FPI_Functions *)ptr;
 219
 220     if ( fpi_functions->fpi_count >= 1 )    FPI_Mem_Alloc           = fpi_functions->fpi_mem_alloc;                                         // 1
 221     if ( fpi_functions->fpi_count >= 2 )    FPI_Mem_Free            = fpi_functions->fpi_mem_free;                                          // 2
 222
 223 #if defined(ALSA) || defined(OSS) || defined(PULSEAUDIO) || defined(JACK)
 224     if ( fpi_functions->fpi_count >= 3 )    FPI_SoundOutput_FillBuffer= fpi_functions->fpi_soundoutput_fillbuffer;  // 3
 225 #endif // defined(ALSA) || defined(OSS)
 226
 227     //
 228     // Setup exported functions
 229     //
 230
 231     memset(&fpx_functions, 0, sizeof(fpx_functions));
 232
 233     fpx_functions.fpx_shutdown                                      = FPX_Shutdown;                                 // 1
 234
 235 #if defined(OPENSSL) || defined(GNUTLS)
 236     fpx_functions.fpx_sslsocket_create                      = FPX_SSLSocket_Create;                 // 2
 237     fpx_functions.fpx_sslsocket_destroy             = FPX_SSLSocket_Destroy;                // 3
 238     fpx_functions.fpx_sslsocket_connect             = FPX_SSLSocket_Connect;                // 4
 239     fpx_functions.fpx_sslsocket_receive             = FPX_SSLSocket_Receive;                // 5
 240     fpx_functions.fpx_sslsocket_send                        = FPX_SSLSocket_Send;                   // 6
 241 #endif // defined(OPENSSL) || defined(GNUTLS)
 242
 243 #if defined(ALSA) || defined(OSS) || defined(PULSEAUDIO) || defined(JACK)
 244     fpx_functions.fpx_soundoutput_open                      = FPX_SoundOutput_Open;                 // 7
 245     fpx_functions.fpx_soundoutput_close             = FPX_SoundOutput_Close;                // 8
 246     fpx_functions.fpx_soundoutput_latency           = FPX_SoundOutput_Latency;              // 9
 247 #endif // defined(ALSA) || defined(OSS)
 248
 249 #ifdef V4L1
 250     fpx_functions.fpx_videoinput_open                       = FPX_VideoInput_Open;                  // 10
 251     fpx_functions.fpx_videoinput_close                      = FPX_VideoInput_Close;                 // 11
 252     fpx_functions.fpx_videoinput_getframe           = FPX_VideoInput_GetFrame;              // 12
 253 #endif // V4L1
 254
 255     fpx_functions.fpx_count                                         = 14;
 256
 257 #ifdef OPENSSL
 258     SSL_library_init();
 259 #elif defined(GNUTLS)
 260     gnutls_global_init();
 261 #endif // GNUTLS
 262
 263     return (void *)&fpx_functions;
 264 }
 265
 266 static void FPX_Shutdown(void)
 267 {
 268 #ifdef OPENSSL
 269
 270 #elif defined(GNUTLS)
 271     gnutls_global_deinit();
 272 #endif // GNUTLS
 273 }
 274
 275 //
 276 // SSL support functions
 277 //
 278
 279 #ifdef OPENSSL
 280 struct SSL_Instance {
 281     SSL     *ssl;
 282     SSL_CTX *sslCtx;
 283 };
 284
 285 static void *FPX_SSLSocket_Create(int socket_fd)
 286 // return = instance pointer
 287 {
 288     struct SSL_Instance *instance = (struct SSL_Instance *)FPI_Mem_Alloc(sizeof(struct SSL_Instance));
 289     memset(instance,0,sizeof(struct SSL_Instance));
 290
 291     if ( ( instance->sslCtx = SSL_CTX_new( TLSv1_client_method() ) ) == 0 ) goto fail;
 292
 293     if ( ( instance->ssl = SSL_new(instance->sslCtx) ) == 0 ) goto fail;
 294
 295     if ( SSL_set_fd(instance->ssl, socket_fd) < 0 ) goto fail;
 296
 297     return (void *)instance;
 298 fail:
 299     if ( instance->ssl ) {
 300         SSL_shutdown(instance->ssl);
 301     }
 302
 303     if ( instance->sslCtx ) {
 304         SSL_CTX_free(instance->sslCtx);
 305     }
 306
 307     if (FPI_Mem_Free) FPI_Mem_Free(instance);
 308
 309     return 0;
 310 }
 311
 312 static int FPX_SSLSocket_Destroy(void *ptr)
 313 // ptr = instance pointer
 314 // return = 0 on sucess, < 0 on error
 315 {
 316     struct SSL_Instance *instance = (struct SSL_Instance *)ptr;
 317
 318     if ( instance->ssl ) {
 319         SSL_shutdown(instance->ssl);
 320     }
 321
 322     if ( instance->sslCtx ) {
 323         SSL_CTX_free(instance->sslCtx);
 324     }
 325
 326     if (FPI_Mem_Free) FPI_Mem_Free(instance);
 327
 328     return 0;
 329 }
 330
 331 static int FPX_SSLSocket_Connect(void *ptr)
 332 // ptr = instance pointer
 333 // socket_fd = BSD socket fd to be associated with SSL connection
 334 // return = 0 on sucess, < 0 on error
 335 //
 336 // Flash Player will use errno to obtain current status
 337 {
 338     struct SSL_Instance *instance = (struct SSL_Instance *)ptr;
 339     return SSL_connect(instance->ssl);
 340 }
 341
 342 static int FPX_SSLSocket_Receive(void *ptr, char *buffer, int n_bytes)
 343 // ptr = instance pointer
 344 // buffer = raw buffer to place received data into
 345 // n_bytes = length of buffer in bytes
 346 // return = actual bytes received, < 0 on error
 347 //
 348 // Flash Player will use errno to obtain current status
 349 {
 350     struct SSL_Instance *instance = (struct SSL_Instance *)ptr;
 351     return SSL_read(instance->ssl, buffer, n_bytes);
 352 }
 353
 354 static int FPX_SSLSocket_Send(void *ptr, const char *buffer, int n_bytes)
 355 // ptr = instance pointer
 356 // buffer = raw buffer to be sent
 357 // n_bytes = length of input buffer in bytes
 358 // return = actual bytes sent, < 0 on error
 359 //
 360 // Flash Player will use errno to obtain current status
 361 {
 362     struct SSL_Instance *instance = (struct SSL_Instance *)ptr;
 363     return SSL_write(instance->ssl, buffer, n_bytes);
 364 }
 365 #elif defined(GNUTLS)
 366 struct SSL_Instance {
 367     gnutls_session_t                                        session;
 368     gnutls_anon_client_credentials_t        anoncred;
 369 };
 370
 371 static void *FPX_SSLSocket_Create(int socket_fd)
 372 // return = instance pointer
 373 {
 374     const int kx_prio[] = { GNUTLS_KX_ANON_DH, 0 };
 375
 376     struct SSL_Instance *instance = (struct SSL_Instance *)FPI_Mem_Alloc(sizeof(struct SSL_Instance));
 377     memset(instance,0,sizeof(struct SSL_Instance));
 378
 379     if ( gnutls_anon_allocate_client_credentials(&instance->anoncred) < 0 ) goto fail;
 380
 381     if ( gnutls_init(&instance->session, GNUTLS_CLIENT) < 0 ) goto fail;
 382
 383     if ( gnutls_set_default_priority(instance->session) < 0 ) goto fail;
 384
 385     if ( gnutls_kx_set_priority(instance->session, kx_prio) < 0 ) goto fail;
 386
 387     if ( gnutls_credentials_set(instance->session, GNUTLS_CRD_ANON, instance->anoncred) < 0 ) goto fail;
 388
 389     gnutls_transport_set_ptr(instance->session, (gnutls_transport_ptr_t)socket_fd);
 390
 391     return (void *)instance;
 392 fail:
 393
 394     if ( instance->session ) {
 395         gnutls_deinit(instance->session);
 396     }
 397
 398     if ( instance->anoncred ) {
 399         gnutls_anon_free_client_credentials(instance->anoncred);
 400     }
 401
 402     if (FPI_Mem_Free) FPI_Mem_Free(instance);
 403
 404     return 0;
 405 }
 406
 407 static int FPX_SSLSocket_Destroy(void *ptr)
 408 // ptr = instance pointer
 409 // return = 0 on sucess, < 0 on error
 410 {
 411     struct SSL_Instance *instance = (struct SSL_Instance *)FPI_Mem_Alloc(sizeof(struct SSL_Instance));
 412
 413     gnutls_bye(instance->session, GNUTLS_SHUT_RDWR);
 414
 415     gnutls_deinit(instance->session);
 416
 417     gnutls_anon_free_client_credentials(instance->anoncred);
 418
 419     if (FPI_Mem_Free) FPI_Mem_Free(instance);
 420
 421     return 0;
 422 }
 423
 424 static int FPX_SSLSocket_Connect(void *ptr)
 425 // ptr = instance pointer
 426 // socket_fd = BSD socket fd to be associated with SSL connection
 427 // return = 0 on sucess, < 0 on error
 428 //
 429 // Flash Player will use errno to obtain current status
 430 {
 431     struct SSL_Instance *instance = (struct SSL_Instance *)ptr;
 432     return gnutls_handshake(instance->session);
 433 }
 434
 435 static int FPX_SSLSocket_Receive(void *ptr, char *buffer, int n_bytes)
 436 // ptr = instance pointer
 437 // buffer = raw buffer to place received data into
 438 // n_bytes = length of buffer in bytes
 439 // return = actual bytes received, < 0 on error
 440 //
 441 // Flash Player will use errno to obtain current status
 442 {
 443     struct SSL_Instance *instance = (struct SSL_Instance *)ptr;
 444     return gnutls_record_recv(instance->session, buffer, n_bytes);
 445 }
 446
 447 static int FPX_SSLSocket_Send(void *ptr, const char *buffer, int n_bytes)
 448 // ptr = instance pointer
 449 // buffer = raw buffer to be sent
 450 // n_bytes = length of input buffer in bytes
 451 // return = actual bytes sent, < 0 on error
 452 //
 453 // Flash Player will use errno to obtain current status
 454 {
 455     struct SSL_Instance *instance = (struct SSL_Instance *)ptr;
 456     return gnutls_record_send(instance->session, buffer, n_bytes);
 457 }
 458 #endif // GNUTLS
 459
 460 //
 461 // Sound support functions
 462 //
 463 #ifdef ALSA
 464 struct SoundOutput_Instance {
 465     snd_pcm_t *                             handle;
 466     snd_async_handler_t *   async_handler;
 467     sem_t                                   semaphore;
 468     pthread_t                               thread;
 469     char *                                  buffer;
 470     snd_pcm_sframes_t               buffer_size;
 471     snd_pcm_sframes_t               period_size;
 472     snd_pcm_sframes_t               buffer_pos;
 473     char *                                  buffer_ptr;
 474 };
 475
 476 static void *alsa_thread(void *ptr)
 477 {
 478     struct SoundOutput_Instance *instance = (struct SoundOutput_Instance *)ptr;
 479     snd_pcm_sframes_t avail = 0;
 480     int result = 0;
 481     int err = 0;
 482     int state = 0;
 483
 484     for( ; ; ) {
 485
 486         err = sem_wait(&instance->semaphore);
 487         if ( !instance->handle ) {
 488             pthread_exit(0);
 489             return 0;
 490         }
 491
 492         if ( err < 0 ) {
 493             usleep(1);
 494             continue;
 495         }
 496
 497         do {
 498             if ( instance->buffer_pos <= 0 ) {
 499                 FPI_SoundOutput_FillBuffer(ptr, instance->buffer, snd_pcm_frames_to_bytes(instance->handle, instance->period_size));
 500                 instance->buffer_pos = instance->period_size;
 501                 instance->buffer_ptr = instance->buffer;
 502             }
 503             do {
 504                 state = snd_pcm_state(instance->handle);
 505                 if(state != SND_PCM_STATE_RUNNING && state != SND_PCM_STATE_PREPARED) {
 506                     snd_pcm_prepare(instance->handle);
 507                 }
 508                 result = snd_pcm_writei(instance->handle, instance->buffer_ptr, instance->buffer_pos);
 509                 if( result <= 0 ) {
 510                     switch( result ) {
 511                         case    -EPIPE: {
 512                             snd_pcm_prepare(instance->handle);
 513                         } break;
 514                         case    -ESTRPIPE: {
 515                             err = snd_pcm_resume(instance->handle);
 516                             if ( err < 0 ) {
 517                                 snd_pcm_prepare(instance->handle);
 518                             }
 519                         } break;
 520                     }
 521                     break;
 522                 } else {
 523                     instance->buffer_pos -= result;
 524                     instance->buffer_ptr += snd_pcm_frames_to_bytes(instance->handle, result);
 525                 }
 526             } while (instance->buffer_pos);
 527             avail = snd_pcm_avail_update(instance->handle);
 528             if( avail < 0 ) {
 529                 switch( avail ) {
 530                     case    -EPIPE: {
 531                         snd_pcm_prepare(instance->handle);
 532                     } break;
 533                     case    -ESTRPIPE: {
 534                         err = snd_pcm_resume(instance->handle);
 535                         if ( err < 0 ) {
 536                             snd_pcm_prepare(instance->handle);
 537                         }
 538                     } break;
 539                 }
 540                 break;
 541             }
 542
 543         } while(avail >= instance->period_size);
 544     }
 545 }
 546
 547 static void alsa_callback(snd_async_handler_t *ahandler)
 548 {
 549     struct SoundOutput_Instance *instance = (struct SoundOutput_Instance *)snd_async_handler_get_callback_private(ahandler);
 550     // signal mixer thread
 551     sem_post(&instance->semaphore);
 552 }
 553
 554 static void *FPX_SoundOutput_Open()
 555 // return = instance pointer
 556 {
 557     struct SoundOutput_Instance *instance = 0;
 558     snd_pcm_hw_params_t *hwparams = 0;
 559     snd_pcm_sw_params_t *swparams = 0;
 560     snd_pcm_format_t pcm_format;
 561     unsigned int buffer_time = 500000;
 562     unsigned int period_time =  20000;
 563     unsigned int actual_rate;
 564     snd_pcm_uframes_t size;
 565     int direction;
 566     void *retVal = 0;
 567     int err = 0;
 568
 569     if ( !FPI_SoundOutput_FillBuffer )  goto fail;
 570     if ( !FPI_Mem_Alloc ) goto fail;
 571
 572     instance = FPI_Mem_Alloc(sizeof(struct SoundOutput_Instance));
 573     memset(instance,0,sizeof(struct SoundOutput_Instance));
 574
 575     if ( ( err = snd_pcm_open(&instance->handle, "default", SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK) ) < 0) {
 576         if ( ( err = snd_pcm_open(&instance->handle, "plughw:0,0", SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK) ) < 0) {
 577             goto fail;
 578         }
 579     }
 580
 581     snd_pcm_hw_params_alloca(&hwparams);
 582     snd_pcm_sw_params_alloca(&swparams);
 583
 584     if (snd_pcm_hw_params_any(instance->handle, hwparams) < 0) goto fail;
 585
 586     if (snd_pcm_hw_params_set_access(instance->handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) goto fail;
 587
 588     pcm_format = SND_PCM_FORMAT_S16_LE;
 589
 590     if (snd_pcm_hw_params_set_format(instance->handle, hwparams, pcm_format) < 0) goto fail;
 591
 592     if (snd_pcm_hw_params_set_channels(instance->handle, hwparams, 2) < 0) goto fail;
 593
 594     actual_rate = 44100;
 595
 596     if (snd_pcm_hw_params_set_rate_near(instance->handle, hwparams, &actual_rate, 0) < 0) goto fail;
 597
 598     if (actual_rate != 44100) goto fail;
 599
 600     if (snd_pcm_hw_params_set_buffer_time_near(instance->handle, hwparams, &buffer_time, &direction) < 0) goto fail;
 601
 602     if (snd_pcm_hw_params_get_buffer_size(hwparams, &size) < 0) goto fail;
 603
 604     instance->buffer_size = (snd_pcm_sframes_t)size;
 605
 606     if (snd_pcm_hw_params_set_period_time_near(instance->handle, hwparams, &period_time, &direction) < 0) goto fail;
 607
 608     if (snd_pcm_hw_params_get_period_size(hwparams, &size, &direction) < 0) goto fail;
 609
 610     instance->period_size = (snd_pcm_sframes_t)size;
 611
 612     if (snd_pcm_hw_params(instance->handle, hwparams) < 0) goto fail;
 613
 614     if (snd_pcm_sw_params_current(instance->handle, swparams) < 0) goto fail;
 615
 616     if (snd_pcm_sw_params_set_start_threshold(instance->handle, swparams, ((instance->buffer_size-1) / instance->period_size) * instance->period_size) < 0) goto fail;
 617
 618     if (snd_pcm_sw_params_set_stop_threshold(instance->handle, swparams, ~0U) < 0) goto fail;
 619
 620     if (snd_pcm_sw_params_set_avail_min(instance->handle, swparams, instance->period_size) < 0) goto fail;
 621
 622     if (snd_pcm_sw_params_set_xfer_align(instance->handle, swparams, 1) < 0) goto fail;
 623
 624     if (snd_pcm_sw_params(instance->handle, swparams) < 0) goto fail;
 625
 626     if (snd_async_add_pcm_handler(&instance->async_handler, instance->handle, &alsa_callback, instance) < 0) goto fail;
 627
 628     if ( ( instance->buffer = FPI_Mem_Alloc(instance->buffer_size * 2 * 2 * 2) ) == 0 ) goto fail;
 629
 630     if ( pthread_create(&instance->thread, 0, alsa_thread, instance) < 0 ) goto fail;
 631
 632     sem_post(&instance->semaphore);
 633
 634     return instance;
 635
 636 fail:
 637     if ( instance ) {
 638         if ( instance->handle ) {
 639             snd_pcm_drop(instance->handle);
 640             snd_pcm_close(instance->handle);
 641             instance->handle = 0;
 642         }
 643         if ( instance->thread ) {
 644             sem_post(&instance->semaphore);
 645             sem_destroy(&instance->semaphore);
 646             pthread_join(instance->thread,&retVal);
 647         }
 648         if ( instance->buffer ) {
 649             if ( FPI_Mem_Free ) FPI_Mem_Free(instance->buffer);
 650         }
 651         if ( FPI_Mem_Free ) FPI_Mem_Free(instance);
 652     }
 653     return 0;
 654 }
 655
 656 static int FPX_SoundOutput_Close(void *ptr)
 657 // ptr = instance pointer
 658 // return = 0 on success, < 0 on error
 659 {
 660     struct SoundOutput_Instance *instance = (struct SoundOutput_Instance *)ptr;
 661     void *retVal = 0;
 662     if ( instance->handle ) {
 663         snd_pcm_drop(instance->handle);
 664         snd_pcm_close(instance->handle);
 665         instance->handle = 0;
 666     }
 667     if ( instance->thread ) {
 668         sem_post(&instance->semaphore);
 669         sem_destroy(&instance->semaphore);
 670         pthread_join(instance->thread,&retVal);
 671     }
 672     if ( instance->buffer ) {
 673         if ( FPI_Mem_Free ) FPI_Mem_Free(instance->buffer);
 674     }
 675     if ( FPI_Mem_Free ) FPI_Mem_Free(instance);
 676     return 0;
 677 }
 678
 679 static int FPX_SoundOutput_Latency(void *ptr)
 680 // ptr = instance pointer
 681 // return = 0 on success, < 0 on error
 682 {
 683     struct SoundOutput_Instance *instance = (struct SoundOutput_Instance *)ptr;
 684     if ( instance->handle ) {
 685         snd_pcm_sframes_t delay = 0;
 686         snd_pcm_delay(instance->handle, &delay);
 687         if ( snd_pcm_state(instance->handle) == SND_PCM_STATE_RUNNING && delay > 0 ) {
 688             return delay;
 689         } else {
 690             return 0;
 691         }
 692     }
 693     return -1;
 694 }
 695 #elif defined(OSS)
 696 struct SoundOutput_Instance {
 697     int                                             oss_fd;
 698     pthread_t                               thread;
 699     int                                             signal;
 700 };
 701
 702 static void *oss_thread(void *ptr)
 703 {
 704     struct SoundOutput_Instance *instance = (struct SoundOutput_Instance *)ptr;
 705     char buffer[4096];
 706     int len = 0;
 707     int written = 0;
 708     for(;;) {
 709         FPI_SoundOutput_FillBuffer(ptr,buffer,4096);
 710         len = 4096;
 711         while ( len ) {
 712             written = write(instance->oss_fd, buffer, len);
 713             if ( written >= 0 ) {
 714                 len -= written;
 715             }
 716             if ( instance->signal ) {
 717                 pthread_exit(0);
 718             }
 719             if ( written < 0 ) {
 720                 usleep(100);
 721             }
 722         }
 723     }
 724 }
 725
 726 static void *FPX_SoundOutput_Open()
 727 // return = instance pointer
 728 {
 729     struct SoundOutput_Instance *instance = 0;
 730     int format = AFMT_S16_LE;
 731     int stereo = 1;
 732     int speed = 44100;
 733
 734     if ( !FPI_SoundOutput_FillBuffer )  goto fail;
 735     if ( !FPI_Mem_Alloc ) goto fail;
 736
 737     instance = (struct SoundOutput_Instance *)FPI_Mem_Alloc(sizeof(struct SoundOutput_Instance));
 738     memset(instance,0,sizeof(struct SoundOutput_Instance));
 739
 740     if ( ( instance->oss_fd = open("/dev/dsp",O_WRONLY) ) < 0 ) goto fail;
 741
 742     if ( ioctl(instance->oss_fd, SNDCTL_DSP_SETFMT, &format) < 0 ) goto fail;
 743
 744     if ( ioctl(instance->oss_fd, SNDCTL_DSP_STEREO, &stereo) < 0 ) goto fail;
 745
 746     if ( ioctl(instance->oss_fd, SNDCTL_DSP_SPEED, &speed) < 0 ) goto fail;
 747
 748     if ( pthread_create(&instance->thread, 0, oss_thread, instance) < 0 ) goto fail;
 749
 750     return instance;
 751 fail:
 752     if ( instance ) {
 753         if ( FPI_Mem_Free ) FPI_Mem_Free(instance);
 754     }
 755     return 0;
 756 }
 757
 758 static int FPX_SoundOutput_Close(void *ptr)
 759 // ptr = instance pointer
 760 // return = 0 on success, < 0 on error
 761 {
 762     struct SoundOutput_Instance *instance = (struct SoundOutput_Instance *)ptr;
 763     void *retVal = 0;
 764
 765     instance->signal = 1;
 766
 767     if ( instance->oss_fd ) {
 768         ioctl(instance->oss_fd, SNDCTL_DSP_RESET, 0);
 769     }
 770
 771     if ( instance->thread ) {
 772         pthread_join(instance->thread,&retVal);
 773     }
 774
 775     if ( instance->oss_fd ) {
 776         close(instance->oss_fd);
 777     }
 778
 779     if ( FPI_Mem_Free ) FPI_Mem_Free(instance);
 780
 781     return 0;
 782 }
 783
 784 static int FPX_SoundOutput_Latency(void *ptr)
 785 // ptr = instance pointer
 786 // return = 0 on success, < 0 on error
 787 {
 788     struct SoundOutput_Instance *instance = (struct SoundOutput_Instance *)ptr;
 789     if ( instance->oss_fd ) {
 790         int value = 0;
 791         if ( ( value = ioctl(instance->oss_fd,SNDCTL_DSP_GETODELAY,&value) ) == 0 ) {
 792             return value / 4;
 793         }
 794         return 0;
 795     }
 796     return -1;
 797 }
 798 #endif // defined(OSS)
 799
 800 #ifdef PULSEAUDIO
 801
 802 #define BUFSIZE (4096)
 803
 804 struct output_data {
 805     pa_threaded_mainloop *mainloop;
 806     pa_context *context;
 807     pa_stream *stream;
 808     uint8_t buf[BUFSIZE];
 809     pthread_t thread_id;
 810     int first;
 811 };
 812
 813 static void context_state_cb(pa_context *c, void *userdata) {
 814     struct output_data *p = userdata;
 815
 816     assert(c);
 817     assert(p);
 818
 819     p->thread_id = pthread_self();
 820     p->context = c;
 821
 822     switch (pa_context_get_state(c)) {
 823         case PA_CONTEXT_READY:
 824         case PA_CONTEXT_TERMINATED:
 825         case PA_CONTEXT_FAILED:
 826             pa_threaded_mainloop_signal(p->mainloop, 0);
 827             break;
 828
 829         case PA_CONTEXT_UNCONNECTED:
 830         case PA_CONTEXT_CONNECTING:
 831         case PA_CONTEXT_AUTHORIZING:
 832         case PA_CONTEXT_SETTING_NAME:
 833             break;
 834     }
 835 }
 836
 837 static void stream_state_cb(pa_stream *s, void *userdata) {
 838     struct output_data *p = userdata;
 839
 840     assert(s);
 841     assert(p);
 842
 843     p->thread_id = pthread_self();
 844     p->stream = s;
 845
 846     switch (pa_stream_get_state(s)) {
 847
 848         case PA_STREAM_READY:
 849         case PA_STREAM_FAILED:
 850         case PA_STREAM_TERMINATED:
 851             pa_threaded_mainloop_signal(p->mainloop, 0);
 852             break;
 853
 854         case PA_STREAM_UNCONNECTED:
 855         case PA_STREAM_CREATING:
 856             break;
 857     }
 858 }
 859
 860 static void write_data(struct output_data *p) {
 861     size_t length;
 862
 863     assert(p);
 864
 865     /* Wait until timing info is available before we write the second
 866      * and all subsequent blocks */
 867     if (!p->first && !pa_stream_get_timing_info(p->stream))
 868         return;
 869
 870     length = pa_stream_writable_size(p->stream);
 871
 872     while (length > 4) {
 873         size_t l = length;
 874
 875         if (l > BUFSIZE)
 876             l = BUFSIZE;
 877
 878         l &= ~ ((size_t) 3);
 879
 880         FPI_SoundOutput_FillBuffer(p, (char*) p->buf, l);
 881
 882         if (pa_stream_write(p->stream, p->buf, l, NULL, 0, PA_SEEK_RELATIVE) < 0)
 883             break;
 884
 885         length -= l;
 886
 887         if (p->first)
 888             break;
 889     }
 890
 891     /* There's no real handling of errors here. Unfortunately the
 892      * Flash API doesn't export a sane way to do this. With networked
 893      * audio streams and hotplug-capable audio devices the audio
 894      * stream might be killed in the middle of nothing, hence it is
 895      * very unfortunate that we cannot report errors that happen here
 896      * back to Flash. */
 897
 898     p->first = 0; /* So, we write the first block noch, remember that */
 899 }
 900
 901 static void stream_request_cb(pa_stream *s, size_t length, void *userdata) {
 902     struct output_data *p = userdata;
 903
 904     assert(s);
 905     assert(length > 0);
 906     assert(p);
 907
 908     p->thread_id = pthread_self();
 909
 910     /* Write some data */
 911     write_data(p);
 912 }
 913
 914 static void stream_latency_update_cb(pa_stream *s, void *userdata) {
 915     struct output_data *p = userdata;
 916
 917     assert(s);
 918     assert(p);
 919
 920     p->thread_id = pthread_self();
 921
 922     /* Try to write some more, in case we delayed the first write until latency data became available */
 923     write_data(p);
 924 }
 925
 926 static void *FPX_SoundOutput_Open(void) {
 927
 928     static const pa_sample_spec ss = {
 929         .format = PA_SAMPLE_S16LE, /* Hmm, Flash wants LE here, not
 930                                     * NE. This makes porting Flash to
 931                                     * Big-Endian machines unnecessary
 932                                     * difficult. */
 933         .rate = 44100,
 934         .channels = 2
 935     };
 936
 937     struct output_data *p;
 938
 939     /* Unfortunately we cannot report any useful error string back to
 940      * Flash. It would be highly preferable if Flash supported some
 941      * way how we could tell the user what the reason is why audio is
 942      * not working for him. */
 943
 944     if (!(p = FPI_Mem_Alloc(sizeof(struct output_data))))
 945         goto fail;
 946
 947     memset(p, 0, sizeof(*p));
 948     p->first = 1;
 949     p->thread_id = (pthread_t) 0;
 950
 951     /* First, let's create the main loop */
 952     if (!(p->mainloop = pa_threaded_mainloop_new()))
 953         goto fail;
 954
 955     /* Second, initialize the connection context */
 956     if (!(p->context = pa_context_new(pa_threaded_mainloop_get_api(p->mainloop), "Adobe Flash")))
 957         goto fail;
 958
 959     pa_context_set_state_callback(p->context, context_state_cb, p);
 960
 961     if (pa_context_connect(p->context, NULL, 0, NULL) < 0)
 962         goto fail;
 963
 964     /* Now, let's start the background thread */
 965     pa_threaded_mainloop_lock(p->mainloop);
 966
 967     if (pa_threaded_mainloop_start(p->mainloop) < 0)
 968         goto fail;
 969
 970     /* Wait until the context is ready */
 971     pa_threaded_mainloop_wait(p->mainloop);
 972
 973     if (pa_context_get_state(p->context) != PA_CONTEXT_READY)
 974         goto unlock_and_fail;
 975
 976     /* Now, initialize the stream */
 977     if (!(p->stream = pa_stream_new(p->context, "Flash Animation", &ss, NULL)))
 978         goto unlock_and_fail;
 979
 980     pa_stream_set_state_callback(p->stream, stream_state_cb, p);
 981     pa_stream_set_write_callback(p->stream, stream_request_cb, p);
 982     pa_stream_set_latency_update_callback(p->stream, stream_latency_update_cb, p);
 983
 984     if (pa_stream_connect_playback(p->stream, NULL, NULL, PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_AUTO_TIMING_UPDATE, NULL, NULL) < 0)
 985         goto unlock_and_fail;
 986
 987     /* Wait until the stream is ready */
 988     pa_threaded_mainloop_wait(p->mainloop);
 989
 990     if (pa_stream_get_state(p->stream) != PA_STREAM_READY)
 991         goto unlock_and_fail;
 992
 993     pa_threaded_mainloop_unlock(p->mainloop);
 994
 995     return p;
 996
 997 unlock_and_fail:
 998
 999     pa_threaded_mainloop_unlock(p->mainloop);
1000
1001 fail:
1002     if (p)
1003         FPX_SoundOutput_Close(p);
1004
1005     return NULL;
1006 }
1007
1008 static int FPX_SoundOutput_Close(void *ptr) {
1009     struct output_data *p = ptr;
1010
1011     assert(p);
1012
1013     if (p->mainloop)
1014         pa_threaded_mainloop_stop(p->mainloop);
1015
1016     if (p->stream) {
1017         pa_stream_disconnect(p->stream);
1018         pa_stream_unref(p->stream);
1019     }
1020
1021     if (p->context) {
1022         pa_context_disconnect(p->context);
1023         pa_context_unref(p->context);
1024     }
1025
1026     if (p->mainloop)
1027         pa_threaded_mainloop_free(p->mainloop);
1028
1029     if (FPI_Mem_Free)
1030         FPI_Mem_Free(p);
1031
1032     return 0;
1033 }
1034
1035 static int FPX_SoundOutput_Latency(void *ptr) {
1036     struct output_data *p = ptr;
1037     pa_usec_t t = 0;
1038     int negative;
1039     int r;
1040
1041     assert(p);
1042
1043     /* We lock here only if we are not called from our event loop thread */
1044     if (!p->thread_id || !pthread_equal(p->thread_id, pthread_self()))
1045         pa_threaded_mainloop_lock(p->mainloop);
1046
1047     if (pa_stream_get_latency(p->stream, &t, &negative) < 0 || negative)
1048         r = 0;
1049     else
1050         r = (int) (pa_usec_to_bytes(t, pa_stream_get_sample_spec(p->stream)) >> 2);
1051
1052     if (!p->thread_id || !pthread_equal(p->thread_id, pthread_self()))
1053         pa_threaded_mainloop_unlock(p->mainloop);
1054
1055     return r;
1056 }
1057
1058 #endif
1059
1060 #ifdef JACK
1061
1062 struct ALSA_SoundOutput_Instance {
1063     snd_pcm_t *                             handle;
1064     snd_async_handler_t *   async_handler;
1065     sem_t                                   semaphore;
1066     pthread_t                               thread;
1067     char *                                  buffer;
1068     snd_pcm_sframes_t               buffer_size;
1069     snd_pcm_sframes_t               period_size;
1070     snd_pcm_sframes_t               buffer_pos;
1071     char *                                  buffer_ptr;
1072 };
1073
1074 static void *alsa_thread(void *ptr)
1075 {
1076     struct ALSA_SoundOutput_Instance *instance = (struct ALSA_SoundOutput_Instance *)ptr;
1077     snd_pcm_sframes_t avail = 0;
1078     int result = 0;
1079     int err = 0;
1080     int state = 0;
1081
1082     for( ; ; ) {
1083
1084         err = sem_wait(&instance->semaphore);
1085         if ( !instance->handle ) {
1086             pthread_exit(0);
1087             return 0;
1088         }
1089
1090         if ( err < 0 ) {
1091             usleep(1);
1092             continue;
1093         }
1094
1095         do {
1096             if ( instance->buffer_pos <= 0 ) {
1097                 FPI_SoundOutput_FillBuffer(ptr, instance->buffer, snd_pcm_frames_to_bytes(instance->handle, instance->period_size));
1098                 instance->buffer_pos = instance->period_size;
1099                 instance->buffer_ptr = instance->buffer;
1100             }
1101             do {
1102                 state = snd_pcm_state(instance->handle);
1103                 if(state != SND_PCM_STATE_RUNNING && state != SND_PCM_STATE_PREPARED) {
1104                     snd_pcm_prepare(instance->handle);
1105                 }
1106                 result = snd_pcm_writei(instance->handle, instance->buffer_ptr, instance->buffer_pos);
1107                 if( result <= 0 ) {
1108                     switch( result ) {
1109                         case    -EPIPE: {
1110                             snd_pcm_prepare(instance->handle);
1111                         } break;
1112                         case    -ESTRPIPE: {
1113                             err = snd_pcm_resume(instance->handle);
1114                             if ( err < 0 ) {
1115                                 snd_pcm_prepare(instance->handle);
1116                             }
1117                         } break;
1118                     }
1119                     break;
1120                 } else {
1121                     instance->buffer_pos -= result;
1122                     instance->buffer_ptr += snd_pcm_frames_to_bytes(instance->handle, result);
1123                 }
1124             } while (instance->buffer_pos);
1125             avail = snd_pcm_avail_update(instance->handle);
1126             if( avail < 0 ) {
1127                 switch( avail ) {
1128                     case    -EPIPE: {
1129                         snd_pcm_prepare(instance->handle);
1130                     } break;
1131                     case    -ESTRPIPE: {
1132                         err = snd_pcm_resume(instance->handle);
1133                         if ( err < 0 ) {
1134                             snd_pcm_prepare(instance->handle);
1135                         }
1136                     } break;
1137                 }
1138                 break;
1139             }
1140
1141         } while(avail >= instance->period_size);
1142     }
1143 }
1144
1145 static void alsa_callback(snd_async_handler_t *ahandler)
1146 {
1147     struct ALSA_SoundOutput_Instance *instance = (struct ALSA_SoundOutput_Instance *)snd_async_handler_get_callback_private(ahandler);
1148     // signal mixer thread
1149     sem_post(&instance->semaphore);
1150 }
1151
1152 static void *ALSA_FPX_SoundOutput_Open(void)
1153 // return = instance pointer
1154 {
1155     struct ALSA_SoundOutput_Instance *instance = 0;
1156     snd_pcm_hw_params_t *hwparams = 0;
1157     snd_pcm_sw_params_t *swparams = 0;
1158     snd_pcm_format_t pcm_format;
1159     unsigned int buffer_time = 500000;
1160     unsigned int period_time =  20000;
1161     unsigned int actual_rate;
1162     snd_pcm_uframes_t size;
1163     int direction;
1164     void *retVal = 0;
1165     int err = 0;
1166
1167     if ( !FPI_SoundOutput_FillBuffer )  goto fail;
1168     if ( !FPI_Mem_Alloc ) goto fail;
1169
1170     instance = FPI_Mem_Alloc(sizeof(struct ALSA_SoundOutput_Instance));
1171     memset(instance,0,sizeof(struct ALSA_SoundOutput_Instance));
1172
1173     if ( ( err = snd_pcm_open(&instance->handle, "default", SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK) ) < 0) {
1174         if ( ( err = snd_pcm_open(&instance->handle, "plughw:0,0", SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK) ) < 0) {
1175             goto fail;
1176         }
1177     }
1178
1179     snd_pcm_hw_params_alloca(&hwparams);
1180     snd_pcm_sw_params_alloca(&swparams);
1181
1182     if (snd_pcm_hw_params_any(instance->handle, hwparams) < 0) goto fail;
1183
1184     if (snd_pcm_hw_params_set_access(instance->handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) goto fail;
1185
1186     pcm_format = SND_PCM_FORMAT_S16_LE;
1187
1188     if (snd_pcm_hw_params_set_format(instance->handle, hwparams, pcm_format) < 0) goto fail;
1189
1190     if (snd_pcm_hw_params_set_channels(instance->handle, hwparams, 2) < 0) goto fail;
1191
1192     actual_rate = 44100;
1193
1194     if (snd_pcm_hw_params_set_rate_near(instance->handle, hwparams, &actual_rate, 0) < 0) goto fail;
1195
1196     if (actual_rate != 44100) goto fail;
1197
1198     if (snd_pcm_hw_params_set_buffer_time_near(instance->handle, hwparams, &buffer_time, &direction) < 0) goto fail;
1199
1200     if (snd_pcm_hw_params_get_buffer_size(hwparams, &size) < 0) goto fail;
1201
1202     instance->buffer_size = (snd_pcm_sframes_t)size;
1203
1204     if (snd_pcm_hw_params_set_period_time_near(instance->handle, hwparams, &period_time, &direction) < 0) goto fail;
1205
1206     if (snd_pcm_hw_params_get_period_size(hwparams, &size, &direction) < 0) goto fail;
1207
1208     instance->period_size = (snd_pcm_sframes_t)size;
1209
1210     if (snd_pcm_hw_params(instance->handle, hwparams) < 0) goto fail;
1211
1212     if (snd_pcm_sw_params_current(instance->handle, swparams) < 0) goto fail;
1213
1214     if (snd_pcm_sw_params_set_start_threshold(instance->handle, swparams, ((instance->buffer_size-1) / instance->period_size) * instance->period_size) < 0) goto fail;
1215
1216     if (snd_pcm_sw_params_set_stop_threshold(instance->handle, swparams, ~0U) < 0) goto fail;
1217
1218     if (snd_pcm_sw_params_set_avail_min(instance->handle, swparams, instance->period_size) < 0) goto fail;
1219
1220     if (snd_pcm_sw_params_set_xfer_align(instance->handle, swparams, 1) < 0) goto fail;
1221
1222     if (snd_pcm_sw_params(instance->handle, swparams) < 0) goto fail;
1223
1224     if (snd_async_add_pcm_handler(&instance->async_handler, instance->handle, &alsa_callback, instance) < 0) goto fail;
1225
1226     if ( ( instance->buffer = FPI_Mem_Alloc(instance->buffer_size * 2 * 2 * 2) ) == 0 ) goto fail;
1227
1228     if ( pthread_create(&instance->thread, 0, alsa_thread, instance) < 0 ) goto fail;
1229
1230     sem_post(&instance->semaphore);
1231
1232     return instance;
1233
1234 fail:
1235     if ( instance ) {
1236         if ( instance->handle ) {
1237             snd_pcm_drop(instance->handle);
1238             snd_pcm_close(instance->handle);
1239             instance->handle = 0;
1240         }
1241         if ( instance->thread ) {
1242             sem_post(&instance->semaphore);
1243             sem_destroy(&instance->semaphore);
1244             pthread_join(instance->thread,&retVal);
1245         }
1246         if ( instance->buffer ) {
1247             if ( FPI_Mem_Free ) FPI_Mem_Free(instance->buffer);
1248         }
1249         if ( FPI_Mem_Free ) FPI_Mem_Free(instance);
1250     }
1251     return 0;
1252 }
1253
1254 static int ALSA_FPX_SoundOutput_Close(void *ptr)
1255 // ptr = instance pointer
1256 // return = 0 on success, < 0 on error
1257 {
1258     struct ALSA_SoundOutput_Instance *instance = (struct ALSA_SoundOutput_Instance *)ptr;
1259     void *retVal = 0;
1260     if ( instance->handle ) {
1261         snd_pcm_drop(instance->handle);
1262         snd_pcm_close(instance->handle);
1263         instance->handle = 0;
1264     }
1265     if ( instance->thread ) {
1266         sem_post(&instance->semaphore);
1267         sem_destroy(&instance->semaphore);
1268         pthread_join(instance->thread,&retVal);
1269     }
1270     if ( instance->buffer ) {
1271         if ( FPI_Mem_Free ) FPI_Mem_Free(instance->buffer);
1272     }
1273     if ( FPI_Mem_Free ) FPI_Mem_Free(instance);
1274     return 0;
1275 }
1276
1277 static int ALSA_FPX_SoundOutput_Latency(void *ptr)
1278 // ptr = instance pointer
1279 // return = 0 on success, < 0 on error
1280 {
1281     struct ALSA_SoundOutput_Instance *instance = (struct ALSA_SoundOutput_Instance *)ptr;
1282     if ( instance->handle ) {
1283         snd_pcm_sframes_t delay = 0;
1284         snd_pcm_delay(instance->handle, &delay);
1285         if ( snd_pcm_state(instance->handle) == SND_PCM_STATE_RUNNING && delay > 0 ) {
1286             return delay;
1287         } else {
1288             return 0;
1289         }
1290     }
1291     return -1;
1292 }
1293
1294
1295 struct jack_output_data {
1296         jack_client_t *client;
1297         jack_port_t *port_l;
1298         jack_port_t *port_r;
1299         SRC_STATE *src_l;
1300         SRC_STATE *src_r;
1301         int src_error;
1302
1303         jack_ringbuffer_t *buffer;
1304         sem_t semaphore;
1305         volatile int quit;
1306         pthread_t tid;
1307         void *alsa_fallback;
1308 };
1309
1310 static void *jack_flash_thread( void *arg )
1311 {
1312         struct jack_output_data *p = arg;
1313         int jack_rate = jack_get_sample_rate( p->client );
1314         int flash_frames = jack_get_buffer_size( p->client ) * 44100 / jack_rate;
1315
1316         size_t bufsize = 2*flash_frames * sizeof( int16_t );
1317         int16_t *buffer = alloca( bufsize );
1318
1319         while( !p->quit ) {
1320                 sem_wait( &(p->semaphore) );
1321                 FPI_SoundOutput_FillBuffer(p, (char*) buffer, bufsize);
1322                 jack_ringbuffer_write( p->buffer, (char*)buffer, bufsize );
1323         }
1324         return NULL;
1325 }
1326
1327 static int jack_process_cb( jack_nframes_t nframes, void *arg )
1328 {
1329         struct jack_output_data *p = arg;
1330         int i;
1331         int jack_rate = jack_get_sample_rate( p->client );
1332         int flash_frames = nframes * 44100 / jack_rate;
1333
1334         size_t bufsize = 2*flash_frames * sizeof( int16_t );
1335         int16_t *buffer = alloca( bufsize );
1336         float   *float_buf = alloca( flash_frames * sizeof(float) );
1337
1338         float *port_l = jack_port_get_buffer( p->port_l, nframes );
1339         float *port_r = jack_port_get_buffer( p->port_r, nframes );
1340
1341         SRC_DATA sd;
1342
1343         if( jack_ringbuffer_read_space( p->buffer ) < bufsize ) {
1344                 // no data to read. fill ports with zero and return.
1345                 memset( port_l, 0, nframes * sizeof( jack_default_audio_sample_t ) );
1346                 memset( port_r, 0, nframes * sizeof( jack_default_audio_sample_t ) );
1347                 return 0;
1348         }
1349
1350         //FPI_SoundOutput_FillBuffer(p, (char*) buffer, bufsize);
1351         if( jack_ringbuffer_read( p->buffer, (char *)buffer, bufsize ) != bufsize ) {
1352                 printf( "Something is pretty wrong :( \n" );
1353                 return 0;
1354         }
1355         sem_post( &(p->semaphore) );
1356
1357         for( i=0; i<flash_frames; i++ ) {
1358                 float_buf[i] = (float) (buffer[2*i]) / 32768.0;
1359         }
1360
1361         sd.data_in = float_buf;
1362         sd.data_out = port_l;
1363         sd.input_frames = flash_frames;
1364         sd.output_frames = nframes;
1365         sd.end_of_input = 0;
1366 //      sd.src_ratio = (double)flash_frames / (double)nframes;
1367         sd.src_ratio = (double)nframes / (double)flash_frames;
1368
1369         src_process( p->src_l, &sd );
1370
1371
1372         for( i=0; i<flash_frames; i++ ) {
1373                 float_buf[i] = (float) (buffer[2*i+1]) / 32768.0;
1374         }
1375
1376         sd.data_in = float_buf;
1377         sd.data_out = port_r;
1378         sd.input_frames = flash_frames;
1379         sd.output_frames = nframes;
1380         sd.end_of_input = 0;
1381 //      sd.src_ratio = (double)flash_frames / (double)nframes;
1382         sd.src_ratio = (double)nframes / (double)flash_frames;
1383
1384         src_process( p->src_r, &sd );
1385
1386         return 0;
1387 }
1388
1389 static void *FPX_SoundOutput_Open(void) {
1390
1391     struct jack_output_data *p=NULL;
1392     char namebuf[100];
1393     int jack_rate;
1394     int flash_frames;
1395     size_t bufsize;
1396     char *connect_port_1 = getenv( "JACK_FLASH_PORT_1" );
1397     char *connect_port_2 = getenv( "JACK_FLASH_PORT_2" );
1398
1399     /* Unfortunately we cannot report any useful error string back to
1400      * Flash. It would be highly preferable if Flash supported some
1401      * way how we could tell the user what the reason is why audio is
1402      * not working for him. */
1403
1404     if (!(p = FPI_Mem_Alloc(sizeof(struct jack_output_data))))
1405         goto fail;
1406
1407     memset(p, 0, sizeof(*p));
1408
1409     /* First, let's create the main loop */
1410     if (!(p->client = jack_client_open( "flash", JackNoStartServer, NULL ))) {
1411         p->alsa_fallback = ALSA_FPX_SoundOutput_Open();
1412         if( p->alsa_fallback )
1413                 return p;
1414         else
1415                 return 0;
1416     }
1417
1418     p->src_l = src_new(SRC_LINEAR, 1, & (p->src_error));
1419     p->src_r = src_new(SRC_LINEAR, 1, & (p->src_error));
1420
1421     jack_rate = jack_get_sample_rate( p->client );
1422     flash_frames = jack_get_buffer_size( p->client ) * 44100 / jack_rate;
1423     bufsize = 2*flash_frames * sizeof( int16_t );
1424
1425     p->buffer = jack_ringbuffer_create( bufsize * 2 );
1426     sem_init( &(p->semaphore), 0, 2 );
1427
1428     pthread_create( &(p->tid), NULL, jack_flash_thread, p );
1429
1430     /* Second, initialize the connection context */
1431     if (!(p->port_l = jack_port_register( p->client, "out1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0)) )
1432         goto fail;
1433     if (!(p->port_r = jack_port_register( p->client, "out2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0)) )
1434         goto fail;
1435
1436     jack_set_process_callback( p->client, jack_process_cb, p );
1437     jack_activate( p->client );
1438
1439     snprintf( namebuf, 99, "%s:out1", jack_get_client_name( p->client ) );
1440     jack_connect( p->client, namebuf, (connect_port_1 != NULL) ? connect_port_1 : "system:playback_1" );
1441     snprintf( namebuf, 99, "%s:out2", jack_get_client_name( p->client ) );
1442     jack_connect( p->client, namebuf, (connect_port_2 != NULL) ? connect_port_2 : "system:playback_1" );
1443
1444     return p;
1445
1446 fail:
1447     if (p)
1448         FPX_SoundOutput_Close(p);
1449
1450     return NULL;
1451 }
1452
1453 static int FPX_SoundOutput_Close(void *ptr) {
1454     struct jack_output_data *p = ptr;
1455
1456     if( p->alsa_fallback ) {
1457             return ALSA_FPX_SoundOutput_Close( p->alsa_fallback );
1458     }
1459     //assert(p);
1460     if( p->tid ) {
1461             p->quit = 1;
1462             pthread_join( p->tid, NULL );
1463     }
1464
1465     if (p->client) {
1466             jack_deactivate( p->client );
1467             jack_client_close( p->client );
1468     }
1469
1470     return 0;
1471 }
1472
1473 static int FPX_SoundOutput_Latency(void *ptr) {
1474     struct jack_output_data *p = ptr;
1475     if( p->alsa_fallback ) {
1476             return ALSA_FPX_SoundOutput_Latency( p->alsa_fallback );
1477     }
1478
1479         // heh ? jack has no latency :P
1480     return 0;
1481 }
1482 #endif
1483
1484
1485 #ifdef V4L1
1486 struct VideoOutput_Instance {
1487     int                                             v4l_fd;
1488     pthread_t                               thread;
1489     int                                             signal;
1490     char *                                  buffer[2];
1491     int                                             buffercurrent;
1492     int                                             buffersize;
1493     struct video_window     window;
1494     struct video_picture    picture;
1495 };
1496
1497 static void *v4l_thread(void *ptr)
1498 {
1499     struct VideoOutput_Instance *instance = (struct VideoOutput_Instance *)ptr;
1500     int result;
1501     int status;
1502
1503     for(;;) {
1504
1505         result = read(instance->v4l_fd, instance->buffer[instance->buffercurrent], instance->buffersize);
1506         if(result > 0) {
1507         }
1508
1509         if ( result < 0 ) {
1510             usleep(10000);
1511         }
1512
1513         if ( instance->signal ) {
1514             status = 0;
1515             ioctl(instance->v4l_fd, VIDIOCCAPTURE, &status);
1516             pthread_exit(0);
1517         }
1518     }
1519     return NULL;
1520 }
1521
1522 static void *FPX_VideoInput_Open(void)
1523 {
1524     struct VideoOutput_Instance *instance = 0;
1525
1526     if ( !FPI_Mem_Alloc ) goto fail;
1527
1528     instance = (struct VideoOutput_Instance *)FPI_Mem_Alloc(sizeof(struct VideoOutput_Instance));
1529     memset(instance,0,sizeof(struct VideoOutput_Instance));
1530
1531     if ( ( instance->v4l_fd = open("/dev/video", O_RDONLY) ) < 0 ) goto fail;
1532
1533     if ( ioctl(instance->v4l_fd, VIDIOCGPICT, &instance->picture) < 0 ) goto fail;
1534
1535     switch(instance->picture.palette) {
1536         case    VIDEO_PALETTE_YUV420P:
1537             break;
1538         case    VIDEO_PALETTE_RGB24:
1539         case    VIDEO_PALETTE_YUV422P:
1540         case    VIDEO_PALETTE_YUV411P:
1541         case    VIDEO_PALETTE_YUV410P:
1542         case    VIDEO_PALETTE_GREY:
1543         case    VIDEO_PALETTE_HI240:
1544         case    VIDEO_PALETTE_RGB565:
1545         case    VIDEO_PALETTE_RGB32:
1546         case    VIDEO_PALETTE_RGB555:
1547         case    VIDEO_PALETTE_YUV422:
1548         case    VIDEO_PALETTE_YUYV:
1549         case    VIDEO_PALETTE_UYVY:
1550         case    VIDEO_PALETTE_YUV420:
1551         case    VIDEO_PALETTE_YUV411:
1552         case    VIDEO_PALETTE_RAW:
1553         default:
1554             goto fail;
1555     }
1556
1557     if( ioctl(instance->v4l_fd, VIDIOCGWIN, &instance->window) < 0 ) goto fail;
1558
1559     instance->buffer[0] = FPI_Mem_Alloc(instance->window.width * instance->window.height * 2);
1560     instance->buffer[1] = FPI_Mem_Alloc(instance->window.width * instance->window.height * 2);
1561
1562     if ( pthread_create(&instance->thread, 0, v4l_thread, instance) < 0 ) goto fail;
1563
1564     return instance;
1565
1566 fail:
1567     if ( FPI_Mem_Free ) {
1568         if ( instance->buffer[0] ) {
1569             FPI_Mem_Free(instance->buffer[0]);
1570         }
1571         if ( instance->buffer[1] ) {
1572             FPI_Mem_Free(instance->buffer[1]);
1573         }
1574         FPI_Mem_Free(instance);
1575     }
1576     return 0;
1577 }
1578
1579 static int FPX_VideoInput_Close(void *ptr)
1580 {
1581     struct VideoOutput_Instance *instance = (struct VideoOutput_Instance *)ptr;
1582     void *retVal = 0;
1583
1584     instance->signal = 1;
1585
1586     if ( instance->thread ) {
1587         pthread_join(instance->thread,&retVal);
1588     }
1589
1590     if ( instance->v4l_fd ) {
1591         close(instance->v4l_fd);
1592     }
1593
1594     if ( FPI_Mem_Free ) {
1595         if ( instance->buffer[0] ) {
1596             FPI_Mem_Free(instance->buffer[0]);
1597         }
1598         if ( instance->buffer[1] ) {
1599             FPI_Mem_Free(instance->buffer[1]);
1600         }
1601         FPI_Mem_Free(instance);
1602     }
1603
1604     return 0;
1605 }
1606
1607 static int FPX_VideoInput_GetFrame(void *ptr, char *data, int width, int height, int pitch_n_bytes)
1608 {
1609     struct VideoOutput_Instance *instance = (struct VideoOutput_Instance *)ptr;
1610     int ix, iy, ox, oy, ow, oh, dx, dy, Y, U, V, R, G, B;
1611     unsigned char *y, *u, *v;
1612
1613     switch(instance->picture.palette) {
1614         case    VIDEO_PALETTE_YUV420P: {
1615             ow = instance->window.width;
1616             oh = instance->window.height;
1617
1618             dx = (ow<<16) / width;
1619             dy = (oh<<16) / height;
1620
1621             y  = (unsigned char *)instance->buffer[instance->buffercurrent^1];
1622             u  = y + ow * oh;
1623             v  = u + ow * oh / 4;
1624
1625             oy = 0;
1626
1627             for ( iy = 0; iy < height; iy++ ) {
1628
1629                 ox = 0;
1630
1631                 for ( ix = 0; ix < width; ix++ ) {
1632
1633                     Y = ( 149 * ((int)(y[(oy>>16)*(ow  )+(ox>>16)]) - 16) ) / 2;
1634                     U =          (int)(u[(oy>>17)*(ow/2)+(ox>>17)]) - 128;
1635                     V =          (int)(v[(oy>>17)*(ow/2)+(ox>>17)]) - 128;
1636
1637                     R = (Y + V * 102          ) / 64;
1638                     G = (Y - V *  52 - U * 25 ) / 64;
1639                     B = (Y + U * 129          ) / 64;
1640
1641                     R = R < 0 ? 0 : ( R > 255 ? 255 : R );
1642                     G = G < 0 ? 0 : ( G > 255 ? 255 : G );
1643                     B = B < 0 ? 0 : ( B > 255 ? 255 : B );
1644
1645                     data[ix*3+0] = R;
1646                     data[ix*3+1] = G;
1647                     data[ix*3+2] = B;
1648
1649                     ox += dx;
1650                 }
1651
1652                 oy += dy;
1653
1654                 data += pitch_n_bytes;
1655             }
1656         } break;
1657         default:
1658             goto fail;
1659     }
1660
1661     instance->buffercurrent ^= 1;
1662
1663     return 0;
1664
1665 fail:
1666     return -1;
1667 }
1668 #endif // V4L1