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"

Include dependency graph for slinfactory.c:

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.

• sf The slinfactory to peek into

Returns:

Number of samples in slinfactory

Definition at line 213 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().

{
   return sf->size;
}

void ast_slinfactory_destroy

(

struct ast_slinfactory *

sf

)

Destroy the contents of a slinfactory.

• sf The slinfactory that is no longer needed

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_slinfactory::queue, and ast_slinfactory::trans.

Referenced by ast_audiohook_destroy().

{
   struct ast_frame *f;

   if (sf->trans) {
      ast_translator_free_path(sf->trans);
      sf->trans = NULL;
   }

   while ((f = AST_LIST_REMOVE_HEAD(&sf->queue, frame_list)))
      ast_frfree(f);
}

int ast_slinfactory_feed	(	struct ast_slinfactory *	sf,
		struct ast_frame *	f
	)

Feed audio into an slinfactory.

• sf The slinfactory to feed into
• f Frame containing audio to feed in

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_frisolate(), ast_getformatname(), AST_LIST_INSERT_TAIL, AST_LIST_NEXT, AST_LIST_TRAVERSE, ast_log(), ast_translate(), ast_translator_build_path(), ast_translator_free_path(), ast_frame::data, ast_slinfactory::format, LOG_WARNING, ast_frame::ptr, ast_slinfactory::queue, ast_frame::samples, ast_slinfactory::size, ast_frame::subclass, and ast_slinfactory::trans.

Referenced by ast_audiohook_write_frame().

{
   struct ast_frame *begin_frame = f, *duped_frame = NULL, *frame_ptr;
   unsigned int x = 0;

   /* In some cases, we can be passed a frame which has no data in it, but
    * which has a positive number of samples defined. Once such situation is
    * when a jitter buffer is in use and the jitter buffer interpolates a frame.
    * The frame it produces has data set to NULL, datalen set to 0, and samples
    * set to either 160 or 240.
    */
   if (!f->data.ptr) {
      return 0;
   }

   if (f->subclass != AST_FORMAT_SLINEAR && f->subclass != AST_FORMAT_SLINEAR16) {
      if (sf->trans && f->subclass != sf->format) {
         ast_translator_free_path(sf->trans);
         sf->trans = NULL;
      }

      if (!sf->trans) {
         if (!(sf->trans = ast_translator_build_path((f->subclass == AST_FORMAT_G722 ? AST_FORMAT_SLINEAR16 : AST_FORMAT_SLINEAR), f->subclass))) {
            ast_log(LOG_WARNING, "Cannot build a path from %s to slin\n", ast_getformatname(f->subclass));
            return 0;
         }
         sf->format = f->subclass;
      }

      if (!(begin_frame = ast_translate(sf->trans, f, 0))) {
         return 0;
      }
      
      if (!(duped_frame = ast_frisolate(begin_frame))) {
         return 0;
      }

      if (duped_frame != begin_frame) {
         ast_frfree(begin_frame);
      }
   } else {
      if (sf->trans) {
         ast_translator_free_path(sf->trans);
         sf->trans = NULL;
      }
      if (!(duped_frame = ast_frdup(f)))
         return 0;
   }

   AST_LIST_TRAVERSE(&sf->queue, frame_ptr, frame_list)
      x++;

   /* if the frame was translated, the translator may have returned multiple
      frames, so process each of them
   */
   for (begin_frame = duped_frame; begin_frame; begin_frame = AST_LIST_NEXT(begin_frame, frame_list)) {
      AST_LIST_INSERT_TAIL(&sf->queue, begin_frame, frame_list);
      sf->size += begin_frame->samples;
   }

   return x;
}

void ast_slinfactory_flush

(

struct ast_slinfactory *

sf

)

Flush the contents of an slinfactory.

• sf The slinfactory to flush

Returns:

Nothing

Definition at line 225 of file slinfactory.c.

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

Referenced by ast_audiohook_write_frame().

{
   struct ast_frame *fr = NULL;

   if (sf->trans) {
      ast_translator_free_path(sf->trans);
      sf->trans = NULL;
   }

   while ((fr = AST_LIST_REMOVE_HEAD(&sf->queue, frame_list)))
      ast_frfree(fr);

   sf->size = sf->holdlen = 0;
   sf->offset = sf->hold;

   return;
}

void ast_slinfactory_init

(

struct ast_slinfactory *

sf

)

Initialize an slinfactory.

• sf The slinfactory to initialize

Returns:

Nothing

Definition at line 42 of file slinfactory.c.

References ast_slinfactory::hold, and ast_slinfactory::offset.

Referenced by ast_audiohook_init().

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

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

Read samples from an slinfactory.

• sf The slinfactory to read from
• buf Buffer to put samples into
• samples Number of samples wanted

Returns:

Number of samples read

Definition at line 152 of file slinfactory.c.

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

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

{
   struct ast_frame *frame_ptr;
   unsigned int sofar = 0, ineed, remain;
   short *frame_data, *offset = buf;

   while (sofar < samples) {
      ineed = samples - sofar;

      if (sf->holdlen) {
         if (sf->holdlen <= ineed) {
            memcpy(offset, sf->hold, sf->holdlen * sizeof(*offset));
            sofar += sf->holdlen;
            offset += sf->holdlen;
            sf->holdlen = 0;
            sf->offset = sf->hold;
         } else {
            remain = sf->holdlen - ineed;
            memcpy(offset, sf->offset, ineed * sizeof(*offset));
            sofar += ineed;
            sf->offset += ineed;
            sf->holdlen = remain;
         }
         continue;
      }
      
      if ((frame_ptr = AST_LIST_REMOVE_HEAD(&sf->queue, frame_list))) {
         frame_data = frame_ptr->data.ptr;
         
         if (frame_ptr->samples <= ineed) {
            memcpy(offset, frame_data, frame_ptr->samples * sizeof(*offset));
            sofar += frame_ptr->samples;
            offset += frame_ptr->samples;
         } else {
            remain = frame_ptr->samples - ineed;
            memcpy(offset, frame_data, ineed * sizeof(*offset));
            sofar += ineed;
            frame_data += ineed;
            if (remain > (AST_SLINFACTORY_MAX_HOLD - sf->holdlen)) {
               remain = AST_SLINFACTORY_MAX_HOLD - sf->holdlen;
            }
            memcpy(sf->hold, frame_data, remain * sizeof(*offset));
            sf->holdlen = remain;
         }
         ast_frfree(frame_ptr);
      } else {
         break;
      }
   }

   sf->size -= sofar;
   return sofar;
}