testauddevice.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:8k
源码类别:

Symbian

开发平台:

C/C++

  1. #/* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #include <stdio.h>
  36. #include <stdlib.h>
  37. #include <string.h>
  38. #ifdef _SYMBIAN
  39. #include <e32math.h>
  40. #endif
  41. #include "hxresult.h"
  42. #include "hxcom.h"
  43. #include "hxausvc.h"
  44. #include "hxengin.h"
  45. #include "ihxpckts.h"   
  46. #include "hxtypes.h"
  47. #include "hxaudev.h"
  48. #include "hxbuffer.h"
  49. extern "C"
  50. {
  51.     
  52. int audioTestEntry(void)
  53. {
  54.     HX_RESULT res = HXR_OK; 
  55.     
  56.     //Create an audio device.
  57.     fprintf( stderr, "Creating an audio device instance....n" ); 
  58.     CHXAudioDevice* pDevice = NULL;
  59.     pDevice = CHXAudioDevice::Create();
  60.     if( !pDevice )
  61.     {
  62.         fprintf( stderr, "couldn't create device. *FAILED*n" );
  63.         sleep(2);
  64.         return 1;
  65.     }
  66.     //Set up the format...
  67.     HXAudioFormat audioFormat;
  68.     audioFormat.uChannels        = 2;     // 1 or 2
  69.     audioFormat.uBitsPerSample   = 16;    // 8 or 16
  70.     audioFormat.ulSamplesPerSec  = 44100; // 11025, 21050, 44100.
  71.     //The block size we will make the number of bytes required for
  72.     //1/10th of a second of audio given the above format. The block
  73.     //size is the amount of data we write to the audio device each
  74.     //time.
  75.     int bytesPerSample    = audioFormat.uChannels*audioFormat.uBitsPerSample/8;  
  76.     int samplesInOneTenth = audioFormat.ulSamplesPerSec/10;
  77.     const int blockSize   = bytesPerSample*samplesInOneTenth;
  78.     audioFormat.uMaxBlockSize = blockSize;
  79.     fprintf( stderr, "Block Size set to %dn", audioFormat.uMaxBlockSize ); 
  80.     //It is OK to fail this as not all audio devices support all
  81.     //formats. If it does fail the client core would choose the next
  82.     //'lower' format until it finds one the device supports. at that
  83.     //point it would use the resampler to downsample the pcm. We won't
  84.     //do that here, just make sure whatever device you are testing
  85.     //support the above format.
  86.     fprintf( stderr, "Checking the format.....n" );
  87.     res = pDevice->CheckFormat( &audioFormat );
  88.     if( res!=HXR_OK )
  89.     {
  90.         fprintf( stderr, "check format *FAILED*.n" );
  91.         sleep(2);
  92.         return 1;
  93.     }
  94.     //open the device.
  95.     fprintf( stderr, "Opening the device....n" ); 
  96.     res = pDevice->Open( &audioFormat, NULL );
  97.     if( FAILED(res) )
  98.     {
  99.         fprintf( stderr, "*FAILED* to open audio device.n" );
  100.         sleep(2);
  101.         return 1;
  102.     }
  103.     //Init the volume. This does not have to be supported by devices.
  104.     if( pDevice->InitVolume(0,100))
  105.         fprintf( stderr, "Device supports volume....n" );
  106.     else
  107.         fprintf( stderr, "Device does not support volume....n" ); 
  108.     //Get and set the volume...
  109.     int curVolume = pDevice->GetVolume();
  110.     fprintf( stderr, "Current volume is %dn", curVolume );
  111.     int newVolume = 90;
  112.     if( curVolume == newVolume )
  113.         newVolume = 950;
  114.         
  115.     fprintf( stderr, "Setting volume to %dn", newVolume );
  116.     pDevice->SetVolume(newVolume);
  117.     if( pDevice->GetVolume() != newVolume )
  118.     {
  119.         fprintf( stderr, "*FAILED* to set volumen" );
  120.         sleep(2);
  121.         return 1;
  122.     }
  123.     //Pause the device until we are ready....
  124.     fprintf( stderr, "Pausing audio devicen" );
  125.     res = pDevice->Pause();
  126.     if( FAILED(res) )
  127.     {
  128.         fprintf( stderr, "*FAILED* to pause device....n" );
  129.         sleep(2);
  130.         return 1;
  131.     }
  132.     
  133.     //try to play some pcm data.....
  134.     //
  135.     // Pump in PCM data here. Make sure we pump it in so fast that the
  136.     // device falls behind so we can do some pause/resume stuff
  137.     // below...
  138.     //
  139.     fprintf( stderr, "Pushing down 5 seconds of PCM...n" ); 
  140.     unsigned char* szBuff = new unsigned char[blockSize];
  141.     HXAudioData   audioData;
  142.     audioData.ulAudioTime=0;
  143.     
  144.     //Fill our 1/10th second buffer 50 times. 5 seconds of total audio.
  145.     INT16 n = 0;
  146.     TReal cur = 0.0;
  147.     TReal xfade = 0.0;
  148.     TInt  dir=1.0;
  149.     
  150.     for( int i=0 ; i<50 ; i++ )
  151.     {
  152.         TReal rad = (2.0*3.1415926)/(float)audioFormat.ulSamplesPerSec * 300.0*(float)i/5 ;
  153.         int byte=0;
  154.         for( int sample=0; sample<audioFormat.ulSamplesPerSec/10; sample++ )
  155.         {
  156.             for( int channel=0; channel<audioFormat.uChannels; channel++ )
  157.             {
  158.                 //Fill each channel with some data
  159.                 TReal amp;
  160.                 Math::Sin(amp, cur); //got the sample.
  161.                 if( audioFormat.uBitsPerSample == 16 )
  162.                 {
  163.                     amp = amp*((1<<15)-1);
  164.                     INT16* pTmp = (INT16*)(szBuff+byte);
  165.                     if( channel == 0 )
  166.                         *pTmp = (INT16)(amp*xfade);
  167.                    else
  168.                        *pTmp = (INT16)(amp*(1-xfade));
  169.                         
  170.                     byte += 2;
  171.                 }
  172.                 else
  173.                 {
  174.                     amp = amp*127+127;
  175.                     szBuff[byte]=(INT8)amp;
  176.                     byte++;
  177.                 }
  178.             }
  179.             cur = cur+rad;
  180.             if( cur>=(2*3.1415926) )
  181.                 cur = 0;
  182.             xfade = xfade + (1.0/(5.0*(float)audioFormat.ulSamplesPerSec))*10*dir;
  183.             if(xfade>1)
  184.             {
  185.                 dir *= -1;
  186.                 xfade=1;
  187.             }
  188.             if(xfade<0)
  189.             {
  190.                 dir *= -1;
  191.                 xfade=0;
  192.             }
  193.             
  194.         }
  195.         
  196.         //write this block of data to the audio device.
  197.         audioData.pData = new CHXBuffer();
  198.         if( !audioData.pData )
  199.         {
  200.             fprintf( stderr, "Out of memory....n" );
  201.             return 1;
  202.         }
  203.         
  204.         audioData.pData->AddRef();
  205.         audioData.pData->Set(szBuff, blockSize);
  206.         res = pDevice->Write(&audioData);
  207.         HX_RELEASE( audioData.pData );
  208.         if( FAILED(res) )
  209.         {
  210.             fprintf( stderr, "*FAILED* to write to the audio devicen" );
  211.             pDevice->Close(TRUE);
  212.             sleep(2);
  213.             return 1;
  214.         }
  215.     }
  216.     HX_VECTOR_DELETE(szBuff);
  217.     fprintf( stderr, "Resuming the device you should hear 5 seconds of sound...n" );
  218.     res = pDevice->Resume();
  219.     if( FAILED(res) )
  220.     {
  221.         fprintf( stderr, "*FAILED* to resume...n" );
  222.         sleep(2);
  223.         return 1;
  224.     }
  225.     
  226. //     ULONG32 ulTime = 0;
  227. //     while( pDevice->NumberOfBlocksRemainingToPlay() )
  228. //     {
  229. //         pDevice->Write(NULL);
  230. //         pDevice->GetCurrentAudioTime(ulTime);
  231. //         fprintf( stderr, "Current Audio time is: %lun", ulTime ); 
  232. //     }
  233.     
  234. //     //Close the device
  235. //     res = pDevice->Close(FALSE);
  236. //     if( FAILED(res) )
  237. //     {
  238. //         fprintf( stderr, "*FAILED* to close the device...n" );
  239. //         sleep(2);
  240. //         return 1;
  241. //     }
  242.     
  243.     fprintf( stderr, "nAudio device unit test *PASSED*. Give yourself a gold starn" ); 
  244.     return 0;
  245. }
  246. };