audio_membuffer(audio_format aud_fmt, float seconds) : audio_data(0),
                                                        aud_info(aud_fmt),
                                                        buf_size(0),
                                                        init_size(0)
 {
     /* Allocs memory for audio recording the specified number of seconds */
     init_size = (unsigned int)((float)aud_info.byte_rate() * seconds <= 0 ? 1 : seconds);
     alloc_mem_(init_size);
 }

		// directsound_audio_stream::create_buffer()
		void directsound_audio_stream::create_buffer(directsound_instance& instance, audio_format const& format) {
			WAVEFORMATEX waveFormat;
			waveFormat.wFormatTag = WAVE_FORMAT_PCM;
			waveFormat.nChannels = format.channels();
			waveFormat.nSamplesPerSec = format.frequency();
			waveFormat.nAvgBytesPerSec = format.bytes_per_second();
			waveFormat.nBlockAlign = static_cast<WORD>(format.bytes_per_frame());
			waveFormat.wBitsPerSample = format.bits_per_sample();
			waveFormat.cbSize = 0;

			DSBUFFERDESC bufferDesc;
			bufferDesc.dwSize = sizeof(DSBUFFERDESC);
			bufferDesc.dwFlags = DSBCAPS_GLOBALFOCUS | DSBCAPS_GETCURRENTPOSITION2;
			bufferDesc.dwReserved = 0;
			bufferDesc.dwBufferBytes = static_cast<DWORD>( BufferSize_seconds.count() * format.bytes_per_second() );
			bufferDesc.guid3DAlgorithm = DS3DALG_DEFAULT;
			bufferDesc.lpwfxFormat = &waveFormat;
			LPDIRECTSOUNDBUFFER ptr = nullptr;
			if( FAILED(instance.ptr()->CreateSoundBuffer(&bufferDesc, &ptr, nullptr)) ) {
				throw directsound_exception{};
			}
			ptr->SetFormat(&waveFormat);
			_buffer = buffer_ptr{ ptr };

			clear_entire_buffer();
			_state = audio_stream_state::ready;
		}

 audio_membuffer( audio_format aud_fmt, unsigned int seconds )
     : audio_data( 0 ), aud_info( aud_fmt ), buf_size( 0 ),
     init_size( 0 )
 {  
     
     //
     // Allocs memory for audio recording
     // the specified number of seconds.
     //
     init_size = aud_info.byte_rate() * seconds;
     alloc_mem_( init_size );
 
 }

        unsigned int samplevalue_max( void )
        {

            if ( aud_info.bits() == 16 )
                return (unsigned int )65535;

            else if ( aud_info.bits() == 8 )
                return (unsigned int)255;

            else 
                return 0;
        }

        unsigned int samples_received( void ) const
        {


            return ( aud_info.samples_in_bytes( bytes_received ));

        }

        unsigned tot_samples_buf( void )
        {


            return aud_info.samples_in_bytes( mb_size );


        }

        unsigned int nsample ( unsigned int nsamp )
        {


            unsigned int svalue;



            if ( aud_info.bits() == 16 )
                svalue = ( unsigned int )  abs( *(( short * ) (main_buffer + aud_info.bytes_in_samples( nsamp ))));
            else if ( aud_info.bits() == 8 )
               svalue = (unsigned int)(( ptrdiff_t ) *(main_buffer + aud_info.bytes_in_samples( nsamp )));

            else 
                svalue = 0;

            return svalue;

        }

        audio_membuffer( void )
            : audio_data( 0 ), aud_info( _AUDIO_DEFAULT_FORMAT ),
            buf_size( 0 ), init_size( 0 )
        {  
            
            //
            // Allocs memory for at least 1 or some seconds
            // of recording.
            //
            init_size = ( unsigned int )
                (( float )aud_info.byte_rate() * _AUDIO_DEFAULT_BUFSECS );


            alloc_mem_( init_size );

        
        }

        unsigned int total_samples( void ) const
        {

            return ( aud_info.samples_in_seconds( fseconds_total() ));

        }

 //returns the float number of seconds
 //that has been recorded
 float fseconds_recorded( void ) const
 { return ( float )(( float ) bytes_received / 
                 ( float ) aud_info.byte_rate()); }

 //returns the float number of seconds
 //that the buffer can record
 float fseconds_total( void ) const
 { return ( float )(( float ) buf_size / 
                 ( float ) aud_info.byte_rate()); }

 //returns the integer number of seconds
 //that the buffer can record
 unsigned int seconds_recorded( void ) const
 { return bytes_received / aud_info.byte_rate(); }

 //returns the integer number of seconds
 //that the buffer can record
 unsigned int seconds_total( void ) const
 { return buf_size / aud_info.byte_rate(); }