#define MIME_MAX_BOUNDARY_LEN 70
extern const char *osip_protocol_version;
static int strcat_simple_header (char **_string, size_t * malloc_size,
                                 char **_message, void *ptr_header,
                                 char *header_name, size_t size_of_header,

mdct_info *faad_mdct_init(uint16_t N)
{
    mdct_info *mdct = (mdct_info*)faad_malloc(sizeof(mdct_info));
    assert(N % 8 == 0);
    mdct->N = N;

  /* boot file name */
  if (dhcp->msg_in->file[0]) {
    dhcp->boot_file_name = mem_malloc(strlen(dhcp->msg_in->file) + 1);
    strcpy(dhcp->boot_file_name, dhcp->msg_in->file);
  }

osip_from_init (osip_from_t ** from)
{
  *from = (osip_from_t *) osip_malloc (sizeof (osip_from_t));
  if (*from == NULL)
    return -1;

#ifndef MINISIZE
#if !defined(WIN32) && !defined(_WIN32_WCE)
osip_malloc_func_t *osip_malloc_func = 0;
osip_realloc_func_t *osip_realloc_func = 0;
osip_free_func_t *osip_free_func = 0;

      return -1;
    }
  dest->sip_method = (char *) osip_malloc (p2 - buf + 1);
  osip_strncpy (dest->sip_method, buf, p2 - buf);
  /* The second token is a sip-url or a uri: */

uint32_t get_sample_rate(const uint8_t sr_index);
int8_t can_decode_ot(const uint8_t object_type);
void *faad_malloc(size_t size);
void faad_free(void *b);
//#define PROFILE

osip_message_init (osip_message_t ** sip)
{
  *sip = (osip_message_t *) osip_malloc (sizeof (osip_message_t));
  if (*sip == NULL)
    return -1;

cfft_info *cffti(uint16_t n)
{
    cfft_info *cfft = (cfft_info*)faad_malloc(sizeof(cfft_info));
    cfft->n = n;
    cfft->work = (complex_t*)faad_malloc(n*sizeof(complex_t));

    uint8_t i;
    NeAACDecHandle hDecoder = NULL;
    if ((hDecoder = (NeAACDecHandle)faad_malloc(sizeof(NeAACDecStruct))) == NULL)
        return NULL;
    memset(hDecoder, 0, sizeof(NeAACDecStruct));

{
  struct udp_pcb *pcb;
  pcb = memp_malloc(MEMP_UDP_PCB);
  /* could allocate UDP PCB? */
  if (pcb != NULL) {

        }
        /* Reverse bit reading of SBR data in DRM audio frame */
        revbuffer = (uint8_t*)faad_malloc(buffer_size*sizeof(uint8_t));
        prevbufstart = revbuffer;
        pbufend = &buffer[buffer_size - 1];

{
     RtpSession *session;
     session = (RtpSession *) ortp_malloc (sizeof (RtpSession));
     rtp_session_init (session, mode);
     return session;

osip_uri_init (osip_uri_t ** url)
{
  *url = (osip_uri_t *) osip_malloc (sizeof (osip_uri_t));
  if (*url == NULL)
    return -1;

  if (i != 0)
    return -1;
  h->hname = (char *) osip_malloc (strlen (hname) + 1);
  if (h->hname == NULL)
    {

osip_via_init (osip_via_t ** via)
{
  *via = (osip_via_t *) osip_malloc (sizeof (osip_via_t));
  if (*via == NULL)
    return -1;

osip_body_init (osip_body_t ** body)
{
  *body = (osip_body_t *) osip_malloc (sizeof (osip_body_t));
  if (*body == NULL)
    return -1;

            hDecoder->pred_stat[channel] = NULL;
        }
        hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
        reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
    }

sdp_bandwidth_init (sdp_bandwidth_t ** b)
{
  *b = (sdp_bandwidth_t *) osip_malloc (sizeof (sdp_bandwidth_t));
  if (*b == NULL)
    return -1;

{
  osip_event_t *sipevent;
  sipevent = (osip_event_t *) osip_malloc (sizeof (osip_event_t));
  if (sipevent == NULL)
    return NULL;

     as the first estimate */
  bufsize = strlen (fromstr) + 1;
  buffer = malloc (bufsize);
  if (buffer == NULL)
    {

#endif
/**************************/
/* MALLOC redirections    */
/**************************/
#if !defined(WIN32) && !defined(_WIN32_WCE)

    return -1;
}
void *faad_malloc(size_t size)
{
#if 0 // defined(_WIN32) && !defined(_WIN32_WCE)

  case PBUF_POOL:
    /* allocate head of pbuf chain into p */
      p = memp_malloc(MEMP_PBUF_POOL);
    LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE | 3, ("pbuf_alloc: allocated pbuf %p\n", (void *)p));
    if (p == NULL) {

    int bytes = bits >> 3;
    int remainder = bits & 0x7;
    uint8_t *buffer = (uint8_t*)faad_malloc((bytes+1)*sizeof(uint8_t));
    for (i = 0; i < bytes; i++)
    {