home *** CD-ROM | disk | FTP | other *** search
/ Amiga Dream 59 / CDDream59.ISO / BeOs / Sound / Intel / PPBeDevKit.ZIP / PLAYERPR.TAR / PlayerPRO / Source / Be-DriverClass.cpp next >
C/C++ Source or Header  |  1998-12-26  |  7KB  |  330 lines

  1. /********************                        ***********************/
  2. //
  3. //    Player PRO 5.0 -- MAD Class for BeOS -
  4. //
  5. //    Library Version 5.0
  6. //
  7. //    To use with MAD Library for BeOS: CodeWarrior
  8. //
  9. //    Antoine ROSSET
  10. //    16 Tranchees
  11. //    1206 GENEVA
  12. //    SWITZERLAND
  13. //
  14. //    Thank you for your interest in PlayerPRO !
  15. //
  16. //    Special Thanks to:
  17. //
  18. //    Dario Accornero <adario@cs.bu.edu>
  19. //
  20. //    For his BeOS support and help!
  21. //
  22. //    FAX:            (+41 22) 346 11 97
  23. //    PHONE:             (+41 79) 203 74 62
  24. //    Internet:         rossetantoine@bluewin.ch
  25. //
  26. /********************                        ***********************/
  27.  
  28. //    System headers.
  29.  
  30. #include    <Path.h>
  31. #include    <Directory.h>
  32. #include    <List.h>
  33. #include    <string.h>
  34.  
  35. //    Local headers.
  36.  
  37. #define        DRIVERCLASS_MODULE    1
  38. #include    "Be-DriverClass.h"
  39.  
  40. //    Streaming function interfacing with BeOS.
  41.  
  42. static    void trackerStreamPlay(void *theCookie, void *buffer, size_t size, const media_raw_audio_format &format);
  43.  
  44. //    Low-level streaming function from MADLibrary.
  45.  
  46. extern "C" {
  47. Boolean    DirectSave( Ptr                 myPtr,
  48.                     MADDriverSettings    *driverType,
  49.                     MADDriverRec        *intDriver );
  50. }
  51.  
  52. //    Constructors.
  53.  
  54. MADDriverClass::MADDriverClass()
  55. {
  56.     MADDriverSettings    init = CreateDefaultDriver();
  57.     inited = InitLibrary( &init);
  58. }
  59.  
  60. MADDriverClass::MADDriverClass( MADDriverSettings *init)
  61. {
  62.     inited = InitLibrary( init);
  63. }
  64.  
  65. //    Destructor: remove system streamers before disposing of the library.
  66.  
  67. MADDriverClass::~MADDriverClass()
  68. {
  69.     if ( streamPlayer )
  70.     {
  71.         streamPlayer->Stop();
  72.         delete    streamPlayer;
  73.     }
  74.     
  75.     if ( curDriverRec )
  76.     {    
  77.         MADDisposeDriver( curDriverRec );
  78.         MADDisposeLibrary( MADLib);
  79.     }
  80. }
  81.  
  82. //    Driver initialization: optimal values for BeOS.
  83.  
  84. MADDriverSettings    MADDriverClass::CreateDefaultDriver( void )
  85. {
  86.     MADDriverSettings    init;
  87.     init.numChn            = 4;
  88.     init.outPutBits     = 16;
  89.     init.outPutRate        = 44100L << 16L;
  90.     init.outPutMode        = DeluxeStereoOutPut;
  91.     init.driverMode        = BeOSSoundDriver;
  92.     init.repeatMusic    = true;
  93.     init.MicroDelaySize = 0;
  94.     init.surround        = false;
  95.     init.sysMemory        = false;
  96.     init.Reverb            = false;
  97.     init.ReverbSize        = 45;
  98.     init.ReverbStrength    = 60;
  99.     init.TickRemover    = true;
  100.  
  101.     return    init;
  102. }
  103.  
  104. //    Library initialization.
  105.  
  106. bool    MADDriverClass::InitLibrary( MADDriverSettings *init)
  107. {
  108.     //    Reset data members to indicate that initialization isn't complete.
  109.     
  110.     libraryError = noErr;
  111.     inited = false;
  112.     musicPlay = false;
  113.     curDriverRec = NULL;
  114.     curMusic = NULL;
  115.     settings = *init;
  116.     
  117.     //    Init the library: default plugins folder is "add-ons".
  118.  
  119.     if ( (libraryError = MADInitLibrary( "add-ons", init->sysMemory, &MADLib)) != noErr )
  120.     {
  121.         #if    DRIVERCLASS_DEBUG
  122.         debugger( "Cannot initialize library." );
  123.         #else
  124.         return    false;
  125.         #endif
  126.     }
  127.     
  128.     //    Init the driver.
  129.     
  130.     if ( (libraryError = MADCreateDriver( init, MADLib, &curDriverRec )) != noErr )
  131.     {
  132.         #if    DRIVERCLASS_DEBUG
  133.         debugger( "Cannot create driver." );
  134.         #else
  135.         return    false;
  136.         #endif
  137.     }
  138.  
  139.     //    Init system streamers.
  140.     
  141.     media_raw_audio_format format;
  142.     
  143.     format.frame_rate = ((float) init->outPutRate / (float) 0x0000FFFF);
  144.     format.channel_count = 2;            // Always stereo !
  145.     format.format = B_AUDIO_FLOAT;        // Always float !
  146.     format.byte_order = 1;
  147.     format.buffer_size = (curDriverRec->BufSize * sizeof( float)) / (init->outPutBits / 8);
  148.     
  149.     streamPlayer = new BSoundPlayer( &format, "PP_player", trackerStreamPlay, NULL, this); 
  150.     
  151.     streamPlayer->SetHasData( true);
  152.     streamPlayer->Start();
  153.     
  154.     return true;
  155. }
  156.  
  157. //    Load a music file into memory and optionally play it.
  158.  
  159. bool    MADDriverClass::LoadMusic( entry_ref* ref, OSType type, bool playIt )
  160. {
  161.     //    Safety check.
  162.     if ( !inited )
  163.         return    false;
  164.     
  165.     //    Try to import the file.
  166.         
  167.     BEntry        fileEntry( ref );
  168.     BPath        filePath;
  169.     fileEntry.GetPath( &filePath );
  170.     char        plugName[5];
  171.     
  172.     libraryError = MADMusicIdentifyCString( MADLib, plugName, (Ptr)filePath.Path());
  173.     if( libraryError == noErr)
  174.     {
  175.         libraryError = MADLoadMusicFileCString( MADLib, &curMusic, plugName, (Ptr)filePath.Path() );
  176.         if( libraryError == noErr)
  177.         {
  178.             MADAttachDriverToMusic( curDriverRec, curMusic );
  179.             if ( playIt ) StartMusic();
  180.         }
  181.     }
  182.     
  183.     if( libraryError) return false;
  184.     else return true;
  185. }
  186.  
  187. //    Start playing current music.
  188.  
  189. void    MADDriverClass::StartMusic( void )
  190. {
  191.     //    Safety check.
  192.     
  193.     if ( !inited )
  194.         return;
  195.     
  196.     if ( MADStartDriver( curDriverRec ) )
  197.     {
  198.         #if    DRIVERCLASS_DEBUG
  199.         debugger( "Error in MADStartDriver()" );
  200.         #endif
  201.     }
  202.     MADPlayMusic( curDriverRec );
  203.     musicPlay = true;
  204. }
  205.  
  206. //    Pause/play music.
  207.  
  208. void    MADDriverClass::PauseMusic( void )
  209. {
  210.     //    Safety check.
  211.     
  212.     if ( !inited )
  213.         return;
  214.  
  215.     if ( musicPlay )
  216.     {
  217.         //    Music is playing: halt it without resetting it.
  218.         
  219.         MADStopMusic( curDriverRec );
  220.         MADStopDriver( curDriverRec );
  221.         musicPlay = false;
  222.     }
  223.     else
  224.     {
  225.         //    Start driver and music.
  226.         
  227.         MADStartDriver( curDriverRec );
  228.         MADPlayMusic( curDriverRec );
  229.         musicPlay = true;
  230.     }
  231. }
  232.  
  233. //    Stop playing current music and optionally discard it.
  234.  
  235. void    MADDriverClass::StopMusic( bool discardIt )
  236. {
  237.     //    Safety check.
  238.     
  239.     if ( !inited )
  240.         return;
  241.  
  242.     //    Stop music and reset its position.
  243.     
  244.     MADStopMusic( curDriverRec );
  245.     MADReset( curDriverRec );
  246.     MADStopDriver( curDriverRec );
  247.     musicPlay = false;
  248.  
  249.     //    Possibly dispose of current music.
  250.     
  251.     if ( discardIt )
  252.     {
  253.         if ( curMusic )
  254.         {
  255.             MADDisposeMusic( &curMusic );
  256.             curMusic = NULL;
  257.         }
  258.     }
  259. }
  260.  
  261. //    Check if current music is over.
  262. bool    MADDriverClass::MusicEnd( void )
  263. {
  264.     //    Safety checks.
  265.     
  266.     if ( !inited )
  267.         return    false;
  268.     
  269.     if ( !musicPlay )
  270.         return    false;
  271.         
  272.     //    Return library flag.
  273.     
  274.     return    curDriverRec->musicEnd;
  275. }
  276.  
  277. //    Streamer interfacing with the system.
  278. static void    trackerStreamPlay(void *user, void *inbuffer, size_t count, const media_raw_audio_format &format)
  279. {
  280.     char*            buffer = (char*) inbuffer;
  281.     long            i;
  282.     
  283.     
  284.     //    Driver object.
  285.     
  286.     MADDriverClass* curDriver = (MADDriverClass*)user;
  287.     MADDriverRec*    curMADDriver = curDriver->curDriverRec;
  288.     
  289.     //    If playing is disabled, do not alter the current buffer.
  290.     
  291.     if ( !curDriver->musicPlay ) return;
  292.     
  293.     //    Check buffer size.
  294.  
  295.     if ( count/sizeof( float) != curMADDriver->BufSize / (curMADDriver->DriverSettings.outPutBits / 8))
  296.     {
  297.         #if    DRIVERCLASS_DEBUG
  298.         debugger("count error");
  299.         #else
  300.         return;
  301.         #endif
  302.     }
  303.     
  304.     DirectSave( curMADDriver->IntDataPtr, &curMADDriver->DriverSettings, curMADDriver );
  305.     
  306.     switch( format.format)
  307.     {
  308.         case B_AUDIO_FLOAT:
  309.             float     *floatbuffer = (float*) buffer;
  310.             
  311.             switch( curMADDriver->DriverSettings.outPutBits)
  312.             {
  313.                 case 16:
  314.                     short    *shortbuffer = (short*) curMADDriver->IntDataPtr;
  315.                     for( i = 0; i < count/sizeof( float); i++) floatbuffer[ i] = ( (float) shortbuffer[ i] * 1.0) / 32767.0;
  316.                 break;
  317.                 
  318.                 case 8:
  319.                     Byte    *charbuffer = (Byte*) curMADDriver->IntDataPtr;
  320.                     for( i = 0; i < count/sizeof( float); i++) floatbuffer[ i] = ( ((float) charbuffer[ i]- 0x80) * 1.0) / 127.0;
  321.                 break;
  322.             }
  323.         break;
  324.         
  325.         default:
  326.             return;        // SUPPORTS ONLY the float format! BeOS driver works in float.
  327.         break;
  328.     }
  329. }
  330.