Home |  Recent changes |  Search |  Glossary |  Sitemap |  Login

About |  News |  SIP Resources |  Documentation |  Downloads |  Projects |  SIP Service |  Support          Project shortcuts:  SER |  SERweb |  SEMS

AmAudio.h

Go to the documentation of this file.

/*
 * $Id: AmAudio.h 819 2008-03-19 13:28:06Z sayer $
 *
 * Copyright (C) 2002-2003 Fhg Fokus
 *
 * This file is part of sems, a free SIP media server.
 *
 * sems is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version
 *
 * For a license to use the ser software under conditions
 * other than those described here, or to purchase support for this
 * software, please contact iptel.org by e-mail at the following addresses:
 *    info@iptel.org
 *
 * sems is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License 
 * along with this program; if not, write to the Free Software 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#ifndef _AmAudio_h_
#define _AmAudio_h_

#include "AmThread.h"
#include "amci/amci.h"
#include "AmEventQueue.h"

#include <stdio.h>

#include <memory>
using std::auto_ptr;
#include <string>
using std::string;
#include <map>

#ifdef USE_LIBSAMPLERATE 
#include <samplerate.h>
#endif

#define PCM16_B2S(b) ((b) >> 1)
#define PCM16_S2B(s) ((s) << 1)

class SdpPayload;
class CodecContainer;

class AmAudioEvent: public AmEvent
{
public:
  enum EventType {
        
    noAudio, // Audio class has nothing to play and/or record anymore

    // Audio input & output have been cleared: 
    // !!! sent only from AmSession !!!
    cleared  
  };

  AmAudioEvent(int id):AmEvent(id){}
};


class DblBuffer
{
  unsigned char samples[AUDIO_BUFFER_SIZE * 2];
  int active_buf;

public:
  DblBuffer();
  operator unsigned char*();
  unsigned char* back_buffer();
  void swap();
};

class AmAudio;

class AmAudioFormat
{
public:
  int channels;
  int rate;
  /* frame length in ms (frame based codecs) - unused */
  int frame_length;
  /* frame size in samples */
  int frame_size;
  /* encoded frame size in bytes - unused */
  int frame_encoded_size;

  string sdp_format_parameters;
    
  AmAudioFormat();
  virtual ~AmAudioFormat();

  virtual amci_codec_t*    getCodec();
  void resetCodec();

  long             getHCodec();
  long             getHCodecNoInit() { return h_codec; } // do not initialize

  unsigned int calcBytesToRead(unsigned int needed_samples) const;
  unsigned int bytes2samples(unsigned int) const;

  bool operator == (const AmAudioFormat& r) const;
  bool operator != (const AmAudioFormat& r) const;

protected:
  virtual int getCodecId()=0;

  amci_codec_t*   codec;
  long            h_codec;

  void destroyCodec();
  void initCodec();

private:
  void operator = (const AmAudioFormat& r);
};

class AmAudioSimpleFormat: public AmAudioFormat
{
  int codec_id;

protected:
  virtual int getCodecId() { return codec_id; }

public:
  AmAudioSimpleFormat(int codec_id);
};


class AmAudioRtpFormat: public AmAudioFormat
{
  vector<SdpPayload *> m_payloads;
  int m_currentPayload;
  amci_payload_t *m_currentPayloadP;
  std::map<int, SdpPayload *> m_sdpPayloadByPayload;
  std::map<int, amci_payload_t *> m_payloadPByPayload;
  std::map<int, CodecContainer *> m_codecContainerByPayload;

protected:
  virtual int getCodecId();

public:
  AmAudioRtpFormat(const vector<SdpPayload *>& payloads);
  ~AmAudioRtpFormat();

  int setCurrentPayload(int payload);

  int getCurrentPayload() { return m_currentPayload; };
};

class AmAudio
{
private:
  int rec_time; // in samples
  int max_rec_time;

#ifdef USE_LIBSAMPLERATE 
  SRC_STATE* resample_state;
  float resample_in[PCM16_B2S(AUDIO_BUFFER_SIZE)*2];
  float resample_out[PCM16_B2S(AUDIO_BUFFER_SIZE)];
  size_t resample_buf_samples;
#endif

protected:
  DblBuffer samples;
  
  auto_ptr<AmAudioFormat> fmt;

  AmAudio();
  AmAudio(AmAudioFormat *);


  virtual int read(unsigned int user_ts, unsigned int size) = 0;
  virtual int write(unsigned int user_ts, unsigned int size) = 0;

  void stereo2mono(unsigned char* out_buf,unsigned char* in_buf,unsigned int& size);

  int decode(unsigned int size);
  int encode(unsigned int size);

  unsigned int downMix(unsigned int size);

  unsigned int calcBytesToRead(unsigned int needed_samples) const;

  unsigned int bytes2samples(unsigned int bytes) const;

public:
  //bool begin_talk;

  virtual ~AmAudio();

  virtual void close();

  virtual int get(unsigned int user_ts, unsigned char* buffer, unsigned int nb_samples);

  virtual int put(unsigned int user_ts, unsigned char* buffer, unsigned int size);
  
  unsigned int getFrameSize();

  void setRecordTime(unsigned int ms);
  int  incRecordTime(unsigned int samples);

  void setBufferedOutput(unsigned int buffer_size);

  void setFormat(AmAudioFormat* new_fmt);
};


#endif

// Local Variables:
// mode:C++
// End:

---

Legal Notices |  Privacy Policy

Home |  Recent changes |  Search |  Glossary |  Sitemap |  Login

Copyright (c) 2001-2007 iptel.org. All rights reserved.

Sponsored by FhG FOKUS, iptelorg GmbH, and iptego GmbH