Fri Jul 24 00:41:59 2009

Asterisk developer's documentation


slinfactory.c File Reference

A machine to gather up arbitrary frames and convert them to raw slinear on demand. More...

#include "asterisk.h"
#include "asterisk/frame.h"
#include "asterisk/slinfactory.h"
#include "asterisk/translate.h"

Go to the source code of this file.

Functions

unsigned int ast_slinfactory_available (const struct ast_slinfactory *sf)
 Retrieve number of samples currently in an slinfactory.
void ast_slinfactory_destroy (struct ast_slinfactory *sf)
 Destroy the contents of a slinfactory.
int ast_slinfactory_feed (struct ast_slinfactory *sf, struct ast_frame *f)
 Feed audio into an slinfactory.
void ast_slinfactory_flush (struct ast_slinfactory *sf)
 Flush the contents of an slinfactory.
void ast_slinfactory_init (struct ast_slinfactory *sf)
 Initialize an slinfactory.
int ast_slinfactory_read (struct ast_slinfactory *sf, short *buf, size_t samples)
 Read samples from an slinfactory.


Detailed Description

A machine to gather up arbitrary frames and convert them to raw slinear on demand.

Author:
Anthony Minessale <anthmct@yahoo.com>

Definition in file slinfactory.c.


Function Documentation

unsigned int ast_slinfactory_available ( const struct ast_slinfactory sf  ) 

Retrieve number of samples currently in an slinfactory.

Returns:
Number of samples in slinfactory

Definition at line 208 of file slinfactory.c.

References ast_slinfactory::size.

Referenced by ast_audiohook_write_frame(), audio_audiohook_write_list(), audiohook_read_frame_both(), and audiohook_read_frame_single().

00209 {
00210    return sf->size;
00211 }

void ast_slinfactory_destroy ( struct ast_slinfactory sf  ) 

Destroy the contents of a slinfactory.

This function will free any memory allocated for the contents of the slinfactory. It does not free the slinfactory itself. If the sf is malloc'd, then it must be explicitly free'd after calling this function.

Returns:
Nothing

Definition at line 59 of file slinfactory.c.

References ast_frfree, AST_LIST_REMOVE_HEAD, ast_translator_free_path(), f, ast_frame::frame_list, and ast_slinfactory::trans.

Referenced by ast_audiohook_destroy().

00060 {
00061    struct ast_frame *f;
00062 
00063    if (sf->trans) {
00064       ast_translator_free_path(sf->trans);
00065       sf->trans = NULL;
00066    }
00067 
00068    while ((f = AST_LIST_REMOVE_HEAD(&sf->queue, frame_list)))
00069       ast_frfree(f);
00070 }

int ast_slinfactory_feed ( struct ast_slinfactory sf,
struct ast_frame f 
)

Feed audio into an slinfactory.

Returns:
Number of frames currently in factory

Definition at line 80 of file slinfactory.c.

References AST_FORMAT_G722, AST_FORMAT_SLINEAR, AST_FORMAT_SLINEAR16, ast_frdup(), ast_frfree, ast_getformatname(), AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log(), ast_translate(), ast_translator_build_path(), ast_translator_free_path(), f, ast_slinfactory::format, ast_frame::frame_list, LOG_WARNING, ast_slinfactory::size, and ast_slinfactory::trans.

Referenced by ast_audiohook_write_frame().

00081 {
00082    struct ast_frame *begin_frame = f, *duped_frame = NULL, *frame_ptr;
00083    unsigned int x;
00084 
00085    /* In some cases, we can be passed a frame which has no data in it, but
00086     * which has a positive number of samples defined. Once such situation is
00087     * when a jitter buffer is in use and the jitter buffer interpolates a frame.
00088     * The frame it produces has data set to NULL, datalen set to 0, and samples
00089     * set to either 160 or 240.
00090     */
00091    if (!f->data.ptr) {
00092       return 0;
00093    }
00094 
00095    if (f->subclass != AST_FORMAT_SLINEAR && f->subclass != AST_FORMAT_SLINEAR16) {
00096       if (sf->trans && f->subclass != sf->format) {
00097          ast_translator_free_path(sf->trans);
00098          sf->trans = NULL;
00099       }
00100 
00101       if (!sf->trans) {
00102          if (!(sf->trans = ast_translator_build_path((f->subclass == AST_FORMAT_G722 ? AST_FORMAT_SLINEAR16 : AST_FORMAT_SLINEAR), f->subclass))) {
00103             ast_log(LOG_WARNING, "Cannot build a path from %s to slin\n", ast_getformatname(f->subclass));
00104             return 0;
00105          }
00106          sf->format = f->subclass;
00107       }
00108 
00109       if (!(begin_frame = ast_translate(sf->trans, f, 0))) 
00110          return 0;
00111       
00112       duped_frame = ast_frdup(begin_frame);
00113 
00114       ast_frfree(begin_frame);
00115 
00116       if (!duped_frame)
00117          return 0;
00118    } else {
00119       if (sf->trans) {
00120          ast_translator_free_path(sf->trans);
00121          sf->trans = NULL;
00122       }
00123       if (!(duped_frame = ast_frdup(f)))
00124          return 0;
00125    }
00126 
00127    x = 0;
00128    AST_LIST_TRAVERSE(&sf->queue, frame_ptr, frame_list)
00129       x++;
00130 
00131    AST_LIST_INSERT_TAIL(&sf->queue, duped_frame, frame_list);
00132 
00133    sf->size += duped_frame->samples;
00134 
00135    return x;
00136 }

void ast_slinfactory_flush ( struct ast_slinfactory sf  ) 

Flush the contents of an slinfactory.

Returns:
Nothing

Definition at line 220 of file slinfactory.c.

References ast_frfree, AST_LIST_REMOVE_HEAD, ast_translator_free_path(), ast_frame::frame_list, ast_slinfactory::hold, ast_slinfactory::holdlen, ast_slinfactory::offset, ast_slinfactory::size, and ast_slinfactory::trans.

Referenced by ast_audiohook_write_frame().

00221 {
00222    struct ast_frame *fr = NULL;
00223 
00224    if (sf->trans) {
00225       ast_translator_free_path(sf->trans);
00226       sf->trans = NULL;
00227    }
00228 
00229    while ((fr = AST_LIST_REMOVE_HEAD(&sf->queue, frame_list)))
00230       ast_frfree(fr);
00231 
00232    sf->size = sf->holdlen = 0;
00233    sf->offset = sf->hold;
00234 
00235    return;
00236 }

void ast_slinfactory_init ( struct ast_slinfactory sf  ) 

Initialize an slinfactory.

Returns:
Nothing

Definition at line 42 of file slinfactory.c.

Referenced by ast_audiohook_init().

00043 {
00044    memset(sf, 0, sizeof(*sf));
00045    sf->offset = sf->hold;
00046 }

int ast_slinfactory_read ( struct ast_slinfactory sf,
short *  buf,
size_t  samples 
)

Read samples from an slinfactory.

Returns:
Number of samples read

Definition at line 147 of file slinfactory.c.

References ast_frfree, AST_LIST_REMOVE_HEAD, AST_SLINFACTORY_MAX_HOLD, ast_frame::data, ast_frame::frame_list, ast_slinfactory::hold, ast_slinfactory::holdlen, ast_frame::offset, ast_slinfactory::offset, ast_frame::ptr, ast_frame::samples, and ast_slinfactory::size.

Referenced by audio_audiohook_write_list(), audiohook_read_frame_both(), and audiohook_read_frame_single().

00148 {
00149    struct ast_frame *frame_ptr;
00150    unsigned int sofar = 0, ineed, remain;
00151    short *frame_data, *offset = buf;
00152 
00153    while (sofar < samples) {
00154       ineed = samples - sofar;
00155 
00156       if (sf->holdlen) {
00157          if (sf->holdlen <= ineed) {
00158             memcpy(offset, sf->hold, sf->holdlen * sizeof(*offset));
00159             sofar += sf->holdlen;
00160             offset += sf->holdlen;
00161             sf->holdlen = 0;
00162             sf->offset = sf->hold;
00163          } else {
00164             remain = sf->holdlen - ineed;
00165             memcpy(offset, sf->offset, ineed * sizeof(*offset));
00166             sofar += ineed;
00167             sf->offset += ineed;
00168             sf->holdlen = remain;
00169          }
00170          continue;
00171       }
00172       
00173       if ((frame_ptr = AST_LIST_REMOVE_HEAD(&sf->queue, frame_list))) {
00174          frame_data = frame_ptr->data.ptr;
00175          
00176          if (frame_ptr->samples <= ineed) {
00177             memcpy(offset, frame_data, frame_ptr->samples * sizeof(*offset));
00178             sofar += frame_ptr->samples;
00179             offset += frame_ptr->samples;
00180          } else {
00181             remain = frame_ptr->samples - ineed;
00182             memcpy(offset, frame_data, ineed * sizeof(*offset));
00183             sofar += ineed;
00184             frame_data += ineed;
00185             if (remain > (AST_SLINFACTORY_MAX_HOLD - sf->holdlen)) {
00186                remain = AST_SLINFACTORY_MAX_HOLD - sf->holdlen;
00187             }
00188             memcpy(sf->hold, frame_data, remain * sizeof(*offset));
00189             sf->holdlen = remain;
00190          }
00191          ast_frfree(frame_ptr);
00192       } else {
00193          break;
00194       }
00195    }
00196 
00197    sf->size -= sofar;
00198    return sofar;
00199 }


Generated on Fri Jul 24 00:41:59 2009 for Asterisk - the Open Source PBX by  doxygen 1.4.7