Codename Pineapple

Home page | Mailing list | Docs

Last updated: Sat Feb 3 05:01:11 2007

Asterisk developer's documentation :: Codename Pineapple

channels

chan_nbs.c File Reference

Detailed Description

Network broadcast sound support channel driver.

Author:
Mark Spencer <markster@digium.com>

Definition in file chan_nbs.c.

#include "asterisk.h"
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <nbs.h>
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/logger.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/options.h"
#include "asterisk/utils.h"

Include dependency graph for chan_nbs.c:

Go to the source code of this file.

Data Structures

struct  nbs_pvt

Functions

 AST_MODULE_INFO_STANDARD (ASTERISK_GPL_KEY,"Network Broadcast Sound Support")
static int load_module (void)
static struct nbs_pvt * nbs_alloc (void *data)
static int nbs_call (struct ast_channel *ast, char *dest, int timeout)
static void nbs_destroy (struct nbs_pvt *p)
static int nbs_hangup (struct ast_channel *ast)
static struct ast_channel * nbs_new (struct nbs_pvt *i, int state)
static struct ast_channel * nbs_request (const char *type, int format, void *data, int *cause)
static struct ast_frame * nbs_xread (struct ast_channel *ast)
static int nbs_xwrite (struct ast_channel *ast, struct ast_frame *frame)
static int unload_module (void)

Variables

static char context [AST_MAX_EXTENSION] = "default"
static const struct ast_channel_tech nbs_tech
static int prefformat = AST_FORMAT_SLINEAR
static const char tdesc [] = "Network Broadcast Sound Driver"
static char type [] = "NBS"

Function Documentation

AST_MODULE_INFO_STANDARD (  ASTERISK_GPL_KEY  ,
"Network Broadcast Sound Support" 
) 
 

static int load_module (  void   )  [static]
 

Definition at line 293 of file chan_nbs.c.

References ast_channel_register(), ast_log(), LOG_ERROR, and nbs_tech.

00294 {
00295    /* Make sure we can register our channel type */
00296    if (ast_channel_register(&nbs_tech)) {
00297       ast_log(LOG_ERROR, "Unable to register channel class %s\n", type);
00298       return -1;
00299    }
00300    return 0;
00301 }

static struct nbs_pvt* nbs_alloc (  void *  data  )  [static]
 

Definition at line 128 of file chan_nbs.c.

References ast_log(), ast_strlen_zero(), free, LOG_WARNING, malloc, and nbs_pvt::stream.

Referenced by nbs_request().

00129 {
00130    struct nbs_pvt *p;
00131    int flags = 0;
00132    char stream[256];
00133    char *opts;
00134 
00135    ast_copy_string(stream, data, sizeof(stream));
00136    if ((opts = strchr(stream, ':'))) {
00137       *opts = '\0';
00138       opts++;
00139    } else
00140       opts = "";
00141    p = malloc(sizeof(struct nbs_pvt));
00142    if (p) {
00143       memset(p, 0, sizeof(struct nbs_pvt));
00144       if (!ast_strlen_zero(opts)) {
00145          if (strchr(opts, 'm'))
00146             flags |= NBS_FLAG_MUTE;
00147          if (strchr(opts, 'o'))
00148             flags |= NBS_FLAG_OVERSPEAK;
00149          if (strchr(opts, 'e'))
00150             flags |= NBS_FLAG_EMERGENCY;
00151          if (strchr(opts, 'O'))
00152             flags |= NBS_FLAG_OVERRIDE;
00153       } else
00154          flags = NBS_FLAG_OVERSPEAK;
00155       
00156       ast_copy_string(p->stream, stream, sizeof(p->stream));
00157       p->nbs = nbs_newstream("asterisk", stream, flags);
00158       if (!p->nbs) {
00159          ast_log(LOG_WARNING, "Unable to allocate new NBS stream '%s' with flags %d\n", stream, flags);
00160          free(p);
00161          p = NULL;
00162       } else {
00163          /* Set for 8000 hz mono, 640 samples */
00164          nbs_setbitrate(p->nbs, 8000);
00165          nbs_setchannels(p->nbs, 1);
00166          nbs_setblocksize(p->nbs, 640);
00167          nbs_setblocking(p->nbs, 0);
00168       }
00169    }
00170    return p;
00171 }

static int nbs_call (  struct ast_channel *  ast,
char *  dest,
int  timeout
)  [static]
 

Definition at line 93 of file chan_nbs.c.

References ast_channel::_state, AST_CONTROL_ANSWER, AST_CONTROL_CONGESTION, ast_log(), ast_queue_control(), ast_setstate(), AST_STATE_DOWN, AST_STATE_RESERVED, AST_STATE_RINGING, LOG_DEBUG, LOG_WARNING, nbs_pvt::nbs, option_debug, and ast_channel::tech_pvt.

00094 {
00095    struct nbs_pvt *p;
00096 
00097    p = ast->tech_pvt;
00098 
00099    if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
00100       ast_log(LOG_WARNING, "nbs_call called on %s, neither down nor reserved\n", ast->name);
00101       return -1;
00102    }
00103    /* When we call, it just works, really, there's no destination...  Just
00104       ring the phone and wait for someone to answer */
00105    if (option_debug)
00106       ast_log(LOG_DEBUG, "Calling %s on %s\n", dest, ast->name);
00107 
00108    /* If we can't connect, return congestion */
00109    if (nbs_connect(p->nbs)) {
00110       ast_log(LOG_WARNING, "NBS Connection failed on %s\n", ast->name);
00111       ast_queue_control(ast, AST_CONTROL_CONGESTION);
00112    } else {
00113       ast_setstate(ast, AST_STATE_RINGING);
00114       ast_queue_control(ast, AST_CONTROL_ANSWER);
00115    }
00116 
00117    return 0;
00118 }

static void nbs_destroy (  struct nbs_pvt *  p  )  [static]
 

Definition at line 120 of file chan_nbs.c.

References ast_module_user_remove, free, nbs_pvt::nbs, and nbs_pvt::u.

Referenced by nbs_hangup(), and nbs_request().

00121 {
00122    if (p->nbs)
00123       nbs_delstream(p->nbs);
00124    ast_module_user_remove(p->u);
00125    free(p);
00126 }

static int nbs_hangup (  struct ast_channel *  ast  )  [static]
 

Definition at line 173 of file chan_nbs.c.

References ast_log(), ast_setstate(), AST_STATE_DOWN, LOG_DEBUG, LOG_WARNING, nbs_destroy(), option_debug, and ast_channel::tech_pvt.

00174 {
00175    struct nbs_pvt *p;
00176    p = ast->tech_pvt;
00177    if (option_debug)
00178       ast_log(LOG_DEBUG, "nbs_hangup(%s)\n", ast->name);
00179    if (!ast->tech_pvt) {
00180       ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
00181       return 0;
00182    }
00183    nbs_destroy(p);
00184    ast->tech_pvt = NULL;
00185    ast_setstate(ast, AST_STATE_DOWN);
00186    return 0;
00187 }

static struct ast_channel* nbs_new (  struct nbs_pvt *  i,
int  state
)  [static]
 

Definition at line 233 of file chan_nbs.c.

References ast_channel_alloc(), ast_hangup(), ast_log(), ast_module_user_add, ast_pbx_start(), AST_STATE_DOWN, AST_STATE_RING, ast_string_field_set, ast_channel::context, ast_channel::exten, ast_channel::fds, language, LOG_WARNING, ast_channel::nativeformats, nbs_pvt::nbs, nbs_tech, nbs_pvt::owner, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel::readformat, ast_channel::rings, nbs_pvt::stream, ast_channel::tech, ast_channel::tech_pvt, nbs_pvt::u, and ast_channel::writeformat.

Referenced by nbs_request().

00234 {
00235    struct ast_channel *tmp;
00236    tmp = ast_channel_alloc(1, state, 0, 0, "NBS/%s", i->stream);
00237    if (tmp) {
00238       tmp->tech = &nbs_tech;
00239       tmp->fds[0] = nbs_fd(i->nbs);
00240       tmp->nativeformats = prefformat;
00241       tmp->rawreadformat = prefformat;
00242       tmp->rawwriteformat = prefformat;
00243       tmp->writeformat = prefformat;
00244       tmp->readformat = prefformat;
00245       if (state == AST_STATE_RING)
00246          tmp->rings = 1;
00247       tmp->tech_pvt = i;
00248       ast_copy_string(tmp->context, context, sizeof(tmp->context));
00249       ast_copy_string(tmp->exten, "s",  sizeof(tmp->exten));
00250       ast_string_field_set(tmp, language, "");
00251       i->owner = tmp;
00252       i->u = ast_module_user_add(tmp);
00253       if (state != AST_STATE_DOWN) {
00254          if (ast_pbx_start(tmp)) {
00255             ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
00256             ast_hangup(tmp);
00257          }
00258       }
00259    } else
00260       ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
00261    return tmp;
00262 }

static struct ast_channel * nbs_request (  const char *  type,
int  format,
void *  data,
int *  cause
)  [static]
 

Definition at line 265 of file chan_nbs.c.

References AST_FORMAT_SLINEAR, ast_log(), AST_STATE_DOWN, LOG_NOTICE, nbs_alloc(), nbs_destroy(), and nbs_new().

00266 {
00267    int oldformat;
00268    struct nbs_pvt *p;
00269    struct ast_channel *tmp = NULL;
00270    
00271    oldformat = format;
00272    format &= (AST_FORMAT_SLINEAR);
00273    if (!format) {
00274       ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format '%d'\n", oldformat);
00275       return NULL;
00276    }
00277    p = nbs_alloc(data);
00278    if (p) {
00279       tmp = nbs_new(p, AST_STATE_DOWN);
00280       if (!tmp)
00281          nbs_destroy(p);
00282    }
00283    return tmp;
00284 }

static struct ast_frame * nbs_xread (  struct ast_channel *  ast  )  [static]
 

Definition at line 189 of file chan_nbs.c.

References ast_log(), ast_frame::data, ast_frame::datalen, ast_frame::delivery, nbs_pvt::fr, LOG_DEBUG, ast_frame::mallocd, ast_frame::offset, option_debug, ast_frame::samples, ast_frame::src, and ast_channel::tech_pvt.

00190 {
00191    struct nbs_pvt *p = ast->tech_pvt;
00192    
00193 
00194    /* Some nice norms */
00195    p->fr.datalen = 0;
00196    p->fr.samples = 0;
00197    p->fr.data =  NULL;
00198    p->fr.src = type;
00199    p->fr.offset = 0;
00200    p->fr.mallocd=0;
00201    p->fr.delivery.tv_sec = 0;
00202    p->fr.delivery.tv_usec = 0;
00203 
00204    if (option_debug)
00205       ast_log(LOG_DEBUG, "Returning null frame on %s\n", ast->name);
00206 
00207    return &p->fr;
00208 }

static int nbs_xwrite (  struct ast_channel *  ast,
struct ast_frame *  frame
)  [static]
 

Definition at line 210 of file chan_nbs.c.

References ast_channel::_state, AST_FORMAT_SLINEAR, AST_FRAME_IMAGE, AST_FRAME_VOICE, ast_log(), AST_STATE_UP, ast_frame::data, ast_frame::datalen, ast_frame::frametype, LOG_WARNING, nbs_pvt::nbs, ast_frame::subclass, and ast_channel::tech_pvt.

00211 {
00212    struct nbs_pvt *p = ast->tech_pvt;
00213    /* Write a frame of (presumably voice) data */
00214    if (frame->frametype != AST_FRAME_VOICE) {
00215       if (frame->frametype != AST_FRAME_IMAGE)
00216          ast_log(LOG_WARNING, "Don't know what to do with  frame type '%d'\n", frame->frametype);
00217       return 0;
00218    }
00219    if (!(frame->subclass &
00220       (AST_FORMAT_SLINEAR))) {
00221       ast_log(LOG_WARNING, "Cannot handle frames in %d format\n", frame->subclass);
00222       return 0;
00223    }
00224    if (ast->_state != AST_STATE_UP) {
00225       /* Don't try tos end audio on-hook */
00226       return 0;
00227    }
00228    if (nbs_write(p->nbs, frame->data, frame->datalen / 2) < 0) 
00229       return -1;
00230    return 0;
00231 }

static int unload_module (  void   )  [static]
 

Definition at line 286 of file chan_nbs.c.

References ast_channel_unregister(), and nbs_tech.

00287 {
00288    /* First, take us out of the channel loop */
00289    ast_channel_unregister(&nbs_tech);
00290    return 0;
00291 }

Variable Documentation

char context[AST_MAX_EXTENSION] = "default" [static]
 

Definition at line 62 of file chan_nbs.c.

const struct ast_channel_tech nbs_tech [static]
 

Definition at line 82 of file chan_nbs.c.

Referenced by load_module(), nbs_new(), and unload_module().

int prefformat = AST_FORMAT_SLINEAR [static]
 

Definition at line 60 of file chan_nbs.c.

const char tdesc[] = "Network Broadcast Sound Driver" [static]
 

Definition at line 57 of file chan_nbs.c.

char type[] = "NBS" [static]
 

Definition at line 63 of file chan_nbs.c.

Asterisk is a trademark for Digium, inc.. | Edvina.net | Asterisk.org | This documentation was generated with Doxygen