externals/pidip/modules pdp_ieee1394.c,NONE,1.1 pdp_mp4audiosource.cpp,NONE,1.1 pdp_mp4audiosync.cpp,NONE,1.1 pdp_mp4config.cpp,NONE,1.1 pdp_mp4live~.cpp,NONE,1.1 pdp_mp4playermedia.cpp,NONE,1.1 pdp_mp4playersession.cpp,NONE,1.1 pdp_mp4player~.cpp,NONE,1.1 pdp_mp4videosource.cpp,NONE,1.1 pdp_mp4videosync.cpp,NONE,1.1 pdp_spotlight.c,NONE,1.1 - Pd-cvs

30 Mar 2004


      Update of /cvsroot/pure-data/externals/pidip/modules
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21968/modules
Added Files:
    pdp_ieee1394.c pdp_mp4audiosource.cpp pdp_mp4audiosync.cpp 
    pdp_mp4config.cpp pdp_mp4live~.cpp pdp_mp4playermedia.cpp 
    pdp_mp4playersession.cpp pdp_mp4player~.cpp 
    pdp_mp4videosource.cpp pdp_mp4videosync.cpp pdp_spotlight.c 
Log Message:
New in PiDiP 0.12.13
--- NEW FILE: pdp_mp4config.cpp ---
/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is MPEG4IP.
 * 
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2000, 2001.  All Rights Reserved.
 * 
 * Contributor(s): 
 *		Dave Mackie		dmackie@cisco.com
 *		Bill May 		wmay@cisco.com
 *
 * Adapted for PD/PDP by Yves Degoyon (ydegoyon@free.fr)
 */
#include "pdp_mp4config.h"
CLiveConfig::CLiveConfig(
    SConfigVariable* variables, 
    config_index_t numVariables, 
    const char* defaultFileName)
: CConfigSet(variables, numVariables, defaultFileName) 
{
    m_appAutomatic = false;
    m_videoEncode = true;
    m_videoMaxWidth = 768;
    m_videoMaxHeight = 576;
    m_videoNeedRgbToYuv = false;
    m_videoMpeg4ConfigLength = 0;
    m_videoMpeg4Config = NULL;
    m_videoMaxVopSize = 128 * 1024;
    m_audioEncode = true;
}
CLiveConfig::~CLiveConfig()
{
    CHECK_AND_FREE(m_videoMpeg4Config);
}
// recalculate derived values
void CLiveConfig::Update() 
{
    UpdateVideo();
    UpdateAudio();
}
void CLiveConfig::UpdateVideo() 
{
    m_videoEncode = true;
CalculateVideoFrameSize();
GenerateMpeg4VideoConfig(this);
}
void CLiveConfig::UpdateFileHistory(const char* fileName)
{
}
void CLiveConfig::CalculateVideoFrameSize()
{
    u_int16_t frameHeight;
    float aspectRatio = GetFloatValue(CONFIG_VIDEO_ASPECT_RATIO);
// crop video to appropriate aspect ratio modulo 16 pixels
    if ((aspectRatio - VIDEO_STD_ASPECT_RATIO) < 0.1) {
    	frameHeight = GetIntegerValue(CONFIG_VIDEO_RAW_HEIGHT);
    } else {
    	frameHeight = (u_int16_t)(
    		(float)GetIntegerValue(CONFIG_VIDEO_RAW_WIDTH) 
    		/ aspectRatio);
if ((frameHeight % 16) != 0) {
    		frameHeight += 16 - (frameHeight % 16);
    	}
if (frameHeight > GetIntegerValue(CONFIG_VIDEO_RAW_HEIGHT)) {
    		// OPTION might be better to insert black lines 
    		// to pad image but for now we crop down
    		frameHeight = GetIntegerValue(CONFIG_VIDEO_RAW_HEIGHT);
    		if ((frameHeight % 16) != 0) {
    			frameHeight -= (frameHeight % 16);
    		}
    	}
    }
m_videoWidth = GetIntegerValue(CONFIG_VIDEO_RAW_WIDTH);
    m_videoHeight = frameHeight;
m_ySize = m_videoWidth * m_videoHeight;
    m_uvSize = m_ySize / 4;
    m_yuvSize = (m_ySize * 3) / 2;
}
void CLiveConfig::UpdateAudio() 
{
    m_audioEncode = true;
}
void CLiveConfig::UpdateRecord()
{
}
bool CLiveConfig::IsOneSource()
{
   return true;
}
bool CLiveConfig::IsCaptureVideoSource()
{
   return false;
}
bool CLiveConfig::IsCaptureAudioSource()
{
   return false;
}
bool CLiveConfig::IsFileVideoSource()
{
   return false;
}
bool CLiveConfig::IsFileAudioSource()
{
   return false;
}
--- NEW FILE: pdp_mp4player~.cpp ---
/*
 *   PiDiP module.
 *   Copyright (c) by Yves Degoyon (ydegoyon@free.fr)
 *
 *   This program 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.
 *
 *   This program 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */
/*  This object is a quicktime stream picker object
 *  A lot of this object code is inspired by the code from mpeg4ip
 *  Copyright (c) 2000, 2001, 2002 Dave Mackie, Bill May & others
 *  The rest is written by Yves Degoyon ( ydegoyon@free.fr )
 */
#include "pdp_mp4player~.h"
static char   *pdp_mp4player_version = "pdp_mp4player~: version 0.1, a mpeg4ip stream decoder ( ydegoyon@free.fr).";
#ifdef __cplusplus
extern "C"
{
#endif
static void pdp_mp4player_audio(t_pdp_mp4player *x, t_floatarg faudio )
{
   if ( ( faudio == 0. ) || ( faudio == 1. ) )
   {
      x->x_audio = (int)faudio;
   }
}
static void pdp_mp4player_overtcp(t_pdp_mp4player *x, t_floatarg fovertcp )
{
   if ( ( fovertcp == 0. ) || ( fovertcp == 1. ) )
   {
     x->x_rtpovertcp = (t_int)fovertcp;
     config.set_config_value(CONFIG_USE_RTP_OVER_RTSP, x->x_rtpovertcp);
     if ( x->x_rtpovertcp )
     {
        post("pdp_mp4player~ : using rtp over rtsp (tcp)" );
     }
     else
     {
        post("pdp_mp4player~ : using rtp mode (udp)" );
     }
   }
}
static void pdp_mp4player_priority(t_pdp_mp4player *x, t_floatarg fpriority )
{
   if ( ( x->x_priority >= MIN_PRIORITY ) && ( x->x_priority <= MAX_PRIORITY ) )
   {
     x->x_priority = (int)fpriority;
   }
}
static void pdp_mp4player_vwidth(t_pdp_mp4player *x, t_floatarg fWidth )
{
   if ( ( (t_int) fWidth <= 0 ) )
   {
     post("pdp_mp4player~ : wrong width : %d", fWidth );
     return;
   }
post( "pdp_mp4player~ : setting width : %d", (t_int) fWidth );
   config.set_config_value( CONFIG_VIDEO_RAW_WIDTH, (t_int) fWidth );
}
static void pdp_mp4player_vheight(t_pdp_mp4player *x, t_floatarg fHeight )
{
   if ( ( (t_int) fHeight <= 0 ) )
   {
     post("pdp_mp4player~ : wrong height : %d", fHeight );
     return;
   }
post( "pdp_mp4player~ : setting height : %d", (t_int) fHeight );
   config.set_config_value( CONFIG_VIDEO_RAW_HEIGHT, (t_int) fHeight );
}
static void pdp_mp4player_disconnect(t_pdp_mp4player *x)
{
   if (!x->x_streaming)
   {
     post("pdp_mp4player~ : close request but no stream is played ... ignored" );
     return;
   }
x->x_streaming = 0;
outlet_float( x->x_outlet_streaming, x->x_streaming );
   x->x_nbframes = 0;
   outlet_float( x->x_outlet_nbframes, x->x_nbframes );
post( "pdp_mp4player~ : deleting session" );
   delete x->x_psession;
   post( "pdp_mp4player~ : deleting semaphore" );
   SDL_DestroySemaphore(x->x_psem);
}
static void *pdp_mp4player_decode(void *tdata)
{
  t_pdp_mp4player *x = (t_pdp_mp4player*)tdata;
  struct sched_param schedprio;
  t_int pmin, pmax;
  struct timespec twait, mwait;
twait.tv_sec = 0;
    twait.tv_nsec = 10000000; // 10 ms
schedprio.sched_priority = 0;
    if ( sched_setscheduler(0, SCHED_OTHER, &schedprio) == -1)
    {
       post("pdp_mp4player~ : couldn't set scheduler for decoding thread.\n");
    }
    if ( setpriority( PRIO_PROCESS, 0, x->x_priority ) < 0 )
    {
       post("pdp_mp4player~ : couldn't set priority to %d for decoding thread.\n", x->x_priority );
    }
    else
    {
       post("pdp_mp4player~ : priority set to %d for thread %d.\n", x->x_priority, x->x_decodechild );
    }
while ( x->x_streaming )
    {
      x->x_decodingstate = x->x_psession->sync_thread(x->x_decodingstate);
      nanosleep( &twait, NULL ); // nothing to read, just wait
    }
post( "pdp_mp4player~ : decoding thread %d exiting....", x->x_decodechild );
    x->x_decodechild = 0;
    pthread_exit(NULL);
}
static void pdp_mp4player_connect(t_pdp_mp4player *x, t_symbol *s)
{
  t_int ret, i;
  char buffer[1024];
  char errmsg[512]; 
  pthread_attr_t decode_child_attr;
if ( x->x_streaming ) 
   {
     post("pdp_mp4player~ : connection request but a connection is pending ... disconnecting" );
     pdp_mp4player_disconnect(x);
   }
if ( x->x_url ) free( x->x_url );
   x->x_url = (char*) malloc( strlen( s->s_name ) + 1 );
   strcpy( x->x_url, s->s_name );
x->x_psem = SDL_CreateSemaphore(0);
   snprintf(buffer, sizeof(buffer), "pdp_mp4player~ - %s", x->x_url);
   x->x_psession = new CPlayerSession(&x->x_queue, x->x_psem, buffer, x);
   if (x->x_psession == NULL) 
   {
     post("pdp_mp4player~ : FATAL : could not create session" );
     return;
   }
ret = parse_name_for_session(x->x_psession, x->x_url, errmsg, sizeof(errmsg), NULL);
   if (ret < 0) 
   {
     post("pdp_mp4player~ : FATAL : wrong url : %s : reason : %s", x->x_url, errmsg );
     delete x->x_psession;
     return;
   }
if (ret > 0) 
   {
     post("pdp_mp4player~ : %s", errmsg );
   }
x->x_psession->set_up_sync_thread();
if (x->x_psession->play_all_media(TRUE) != 0) {
      post("pdp_mp4player~ : FATAL : couldn't play all medias" );
      delete x->x_psession;
      return;
   }
// launch decoding thread
   if ( pthread_attr_init( &decode_child_attr ) < 0 )
   {
      post( "pdp_mp4player~ : could not launch decoding thread" );
      perror( "pthread_attr_init" );
      return;
   }
   if ( pthread_create( &x->x_decodechild, &decode_child_attr, pdp_mp4player_decode, x ) < 0 )
   {
      post( "pdp_mp4player~ : could not launch decoding thread" );
      perror( "pthread_create" );
      return;
   }
post("pdp_mp4player~ : session started" );
   x->x_streaming = 1;
return;
}
/* decode the stream to fill up buffers */
static t_int *pdp_mp4player_perform(t_int *w)
{
  t_float *out1   = (t_float *)(w[1]);       // left audio inlet
  t_float *out2   = (t_float *)(w[2]);       // right audio inlet 
  t_pdp_mp4player *x = (t_pdp_mp4player *)(w[3]);
  int n = (int)(w[4]);                      // number of samples 
  short sampleL, sampleR;
  struct timeval etime;
  t_int sn;
// just read the buffer
    if ( x->x_audioon )
    {
      sn=0;
      n=n*DEFAULT_CHANNELS;
      while (n--) 
      {
        sampleL=x->x_audio_in[ sn++ ];
        *(out1) = ((t_float)sampleL)/32768.0;
        if ( DEFAULT_CHANNELS == 1 )
        {
          *(out2) = *(out1);
        }
        if ( DEFAULT_CHANNELS == 2 )
        {
          sampleR=x->x_audio_in[ sn++ ];
          *(out2) = ((t_float)sampleR)/32768.0;
        }
        out1++;
        out2++;
      }
      x->x_audioin_position-=sn;
      memcpy( &x->x_audio_in[0], &x->x_audio_in[sn], 4*MAX_AUDIO_PACKET_SIZE-sn );
      // post( "pdp_mp4player~ : audio in position : %d", x->x_audioin_position );
      if ( x->x_audioin_position <= sn )
      {
         x->x_audioon = 0;
         // post( "pdp_mp4player~ : audio off" );
      }
    }
    else
    {
      // post("pdp_mp4player~ : no available audio" );
      while (n--)
      {
        *(out1++) = 0.0;
        *(out2++) = 0.0;
      }
    }
// check if the framerate has been exceeded
    if ( gettimeofday(&etime, NULL) == -1)
    {
       post("pdp_mp4player~ : could not read time" );
    }
    if ( etime.tv_sec != x->x_cursec )
    {
       x->x_cursec = etime.tv_sec;
       outlet_float( x->x_outlet_framerate, x->x_secondcount );
       x->x_secondcount = 0;
    }
if ( x->x_newpicture )
    {
      pdp_packet_pass_if_valid(x->x_pdp_out, &x->x_packet0);
// update streaming status
      outlet_float( x->x_outlet_streaming, x->x_streaming );
      x->x_nbframes++;
      x->x_secondcount++;
      outlet_float( x->x_outlet_nbframes, x->x_nbframes );
    }
return (w+5);
}
static void pdp_mp4player_dsp(t_pdp_mp4player *x, t_signal **sp)
{
    dsp_add(pdp_mp4player_perform, 4, sp[0]->s_vec, sp[1]->s_vec, x, sp[0]->s_n);
}
static void pdp_mp4player_free(t_pdp_mp4player *x)
{
  int i;
if ( x->x_streaming )
    {
       pdp_mp4player_disconnect(x);
    }
    post( "pdp_mp4player~ : freeing object" );
    pdp_packet_mark_unused(x->x_packet0);
// remove invalid global ports
    close_plugins();
}
t_class *pdp_mp4player_class;
void *pdp_mp4player_new(void)
{
    int i;
t_pdp_mp4player *x = (t_pdp_mp4player *)pd_new(pdp_mp4player_class);
x->x_pdp_out = outlet_new(&x->x_obj, &s_anything);
x->x_outlet_left = outlet_new(&x->x_obj, &s_signal);
    x->x_outlet_right = outlet_new(&x->x_obj, &s_signal);
x->x_outlet_streaming = outlet_new(&x->x_obj, &s_float);
    x->x_outlet_nbframes = outlet_new(&x->x_obj, &s_float);
    x->x_outlet_framerate = outlet_new(&x->x_obj, &s_float);
x->x_packet0 = -1;
    x->x_nbframes = 0;
    x->x_cursec = 0;
    x->x_secondcount = 0;
    x->x_audioin_position = 0;
    x->x_priority = DEFAULT_PRIORITY;
    x->x_decodechild = 0;
    x->x_newpicture = 0;
memset( &x->x_audio_buf[0], 0x0, 4*MAX_AUDIO_PACKET_SIZE*sizeof(short) );
    memset( &x->x_audio_in[0], 0x0, 4*MAX_AUDIO_PACKET_SIZE*sizeof(short) );
// initialize mpeg4hippies
    initialize_plugins();
    config.read_config_file();
    rtsp_set_error_func(player_library_message);
    rtsp_set_loglevel(config.get_config_value(CONFIG_RTSP_DEBUG));
    rtp_set_error_msg_func(player_library_message);
    rtp_set_loglevel(config.get_config_value(CONFIG_RTP_DEBUG));
    sdp_set_error_func(player_library_message);
    sdp_set_loglevel(config.get_config_value(CONFIG_SDP_DEBUG));
    http_set_error_func(player_library_message);
    http_set_loglevel(config.get_config_value(CONFIG_HTTP_DEBUG));
x->x_rtpovertcp = 0;
    config.set_config_value(CONFIG_USE_RTP_OVER_RTSP, x->x_rtpovertcp);
return (void *)x;
}
void pdp_mp4player_tilde_setup(void)
{
    // post( pdp_mp4player_version );
    pdp_mp4player_class = class_new(gensym("pdp_mp4player~"), (t_newmethod)pdp_mp4player_new,
    	(t_method)pdp_mp4player_free, sizeof(t_pdp_mp4player), 0, A_NULL);
class_addmethod(pdp_mp4player_class, (t_method)pdp_mp4player_dsp, gensym("dsp"), A_NULL);
    class_addmethod(pdp_mp4player_class, (t_method)pdp_mp4player_connect, gensym("connect"), A_SYMBOL, A_NULL);
    class_addmethod(pdp_mp4player_class, (t_method)pdp_mp4player_disconnect, gensym("disconnect"), A_NULL);
    class_addmethod(pdp_mp4player_class, (t_method)pdp_mp4player_audio, gensym("audio"), A_FLOAT, A_NULL);
    class_addmethod(pdp_mp4player_class, (t_method)pdp_mp4player_overtcp, gensym("overtcp"), A_FLOAT, A_NULL);
    class_addmethod(pdp_mp4player_class, (t_method)pdp_mp4player_priority, gensym("priority"), A_FLOAT, A_NULL);
    class_addmethod(pdp_mp4player_class, (t_method)pdp_mp4player_vwidth, gensym("vwidth"), A_DEFFLOAT, A_NULL);
    class_addmethod(pdp_mp4player_class, (t_method)pdp_mp4player_vheight, gensym("vheight"), A_DEFFLOAT, A_NULL);
    class_sethelpsymbol( pdp_mp4player_class, gensym("pdp_mp4player~.pd") );
}
#ifdef __cplusplus
}
#endif
--- NEW FILE: pdp_mp4playersession.cpp ---
/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is MPEG4IP.
 * 
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2000, 2001.  All Rights Reserved.
 * 
 * Contributor(s): 
 *              Bill May        wmay@cisco.com
[...1006 lines suppressed...]
      if (m_video_sync != NULL) 
    m_video_sync->flush_sync_buffers();
      if (m_audio_sync != NULL) 
    m_audio_sync->flush_sync_buffers();
      break;
    }
  }
  return (state);
}
int pdp_sync_thread (void *data)
{
  CPlayerSession *p;
  int state = SYNC_STATE_INIT;
  p = (CPlayerSession *)data;
  do {
   state = p->sync_thread(state);
  } while (state != SYNC_STATE_EXIT);
  return (0);
}
--- NEW FILE: pdp_mp4videosync.cpp ---
/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is MPEG4IP.
 * 
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2000, 2001.  All Rights Reserved.
 * 
 * Contributor(s): 
 *              Bill May        wmay@cisco.com
 *              video aspect ratio by:
 *              Peter Maersk-Moller peter@maersk-moller.net
 *
 * Adapted to PD/PDP by Yves Degoyon (ydegoyon@free.fr)
 */
/*
 * video.cpp - provides codec to video hardware class
 */
#include <string.h>
#include "pdp_mp4videosync.h"
#include "pdp_mp4playersession.h"
#include "player_util.h"
#include "m_pd.h"
#define video_message(loglevel, fmt...) message(loglevel, "videosync", fmt)
CPDPVideoSync::CPDPVideoSync (CPlayerSession *psptr, t_pdp_mp4player *pdp_father) : CVideoSync(psptr)
{
  char buf[32];
m_screen = NULL;
  m_image = NULL;
  m_video_initialized = 0;
  m_config_set = 0;
  m_have_data = 0;
  m_y_buffer[0] = NULL;
  m_u_buffer[0] = NULL;
  m_v_buffer[0] = NULL;
  m_buffer_filled[0] = 0;
  m_play_index = m_fill_index = 0;
  m_decode_waiting = 0;
  m_dont_fill = 0;
  m_paused = 1;
  m_behind_frames = 0;
  m_total_frames = 0;
  m_behind_time = 0;
  m_behind_time_max = 0;
  m_skipped_render = 0;
  m_video_scale = 2;
  m_msec_per_frame = 0;
  m_consec_skipped = 0;
  m_fullscreen = 0;
  m_filled_frames = 0;
  m_double_width = 0;
  m_pixel_width = 0;
  m_pixel_height = 0;
  m_max_width = 0;
  m_max_height = 0;
  m_father = pdp_father;
}
CPDPVideoSync::~CPDPVideoSync (void)
{
  if (m_fullscreen != 0) {
    m_fullscreen = 0;
    do_video_resize();
  }
  if (m_image) {
    m_image = NULL;
  }
  if (m_screen) {
    m_screen = NULL;
  }
  if (m_y_buffer[0] != NULL) {
    free(m_y_buffer[0]);
    m_y_buffer[0] = NULL;
  }
  if (m_u_buffer[0] != NULL) {
    free(m_u_buffer[0]);
    m_u_buffer[0] = NULL;
  }
  if (m_v_buffer[0] != NULL) {
    free(m_v_buffer[0]);
    m_v_buffer[0] = NULL;
  }
}
void CPDPVideoSync::config (int w, int h)
{
  m_width = w;
  m_height = h;
  m_y_buffer[0] = (uint8_t *)malloc(w * h * sizeof(uint8_t));
  m_u_buffer[0] = (uint8_t *)malloc(w/2 * h/2 * sizeof(uint8_t));
  m_v_buffer[0] = (uint8_t *)malloc(w/2 * h/2 * sizeof(uint8_t));
  m_buffer_filled[0] = 0;
  m_config_set = 1;
  post( "pdp_mp4videosync : configuration done : %dx%d", m_width, m_height );
}
int CPDPVideoSync::initialize_video (const char *name)
{
  if (m_video_initialized == 0) {
    if (m_config_set) {
      int ret;
      int video_scale = m_video_scale;
int w = m_width * video_scale / 2;
      if (m_double_width) w *= 2;
      int h = m_height * video_scale / 2;
      m_video_initialized = 1;
      post( "pdp_mp4videosync : video initialized : %dx%d", m_width, m_height );
      return (1);
    } else {
     return (0);
    }
  }
  return (1);
}
int CPDPVideoSync::is_video_ready (uint64_t &disptime)
{
  return 1;
}
void CPDPVideoSync::play_video (void) 
{
}
int64_t CPDPVideoSync::play_video_at (uint64_t current_time, int &have_eof)
{
  uint64_t play_this_at;
  unsigned int ix;
  uint8_t *to, *from;
post( "pdp_mp4videosync : play video at  : %ld", current_time );
return (10);
}
int CPDPVideoSync::get_video_buffer(uint8_t **y,
    			 uint8_t **u,
    			 uint8_t **v)
{
post( "pdp_mp4videosync : get video buffer" );
  *y = m_y_buffer[m_fill_index];
  *u = m_u_buffer[m_fill_index];
  *v = m_v_buffer[m_fill_index];
  return (1);
}
void CPDPVideoSync::filled_video_buffers (uint64_t time)
{
  int ix;
  // post( "pdp_mp4videosync : filled video buffer : %ld", time );
  m_psptr->wake_sync_thread();
}
void CPDPVideoSync::set_video_frame(const uint8_t *y, 
    			    const uint8_t *u, 
    			    const uint8_t *v,
    			    int pixelw_y, 
    			    int pixelw_uv, 
    			    uint64_t time)
{
  // post( "pdp_mp4videosync : set video frame : %dx%d", m_width, m_height );
  m_psptr->wake_sync_thread();
// pass the data to the pdp object
  m_father->x_newpicture = 1;
  return;
}
void CPDPVideoSync::flush_sync_buffers (void)
{
  post( "pdp_mp4videosync : flush sync buffer" );
}
void CPDPVideoSync::flush_decode_buffers (void)
{
  post( "pdp_mp4videosync : flush decode buffer" );
}
static void pdp_video_configure (void *ifptr,
    		      int w,
    		      int h,
    		      int format,
                              double aspect_ratio )
{
  ((CPDPVideoSync *)ifptr)->config(w, h);
}
static int pdp_video_get_buffer (void *ifptr, 
    		       uint8_t **y,
    		       uint8_t **u,
    		       uint8_t **v)
{
  return (((CPDPVideoSync *)ifptr)->get_video_buffer(y, u, v));
}
static void pdp_video_filled_buffer(void *ifptr, uint64_t time)
{
  ((CPDPVideoSync *)ifptr)->filled_video_buffers(time);
}
static void pdp_video_have_frame (void *ifptr,
    		       const uint8_t *y,
    		       const uint8_t *u,
    		       const uint8_t *v,
    		       int m_pixelw_y,
    		       int m_pixelw_uv,
    		       uint64_t time)
{
  CPDPVideoSync *foo = (CPDPVideoSync *)ifptr;
foo->set_video_frame(y, u, v, m_pixelw_y, m_pixelw_uv, time);
}
video_vft_t video_vft = 
{
  message,
  pdp_video_configure,
  pdp_video_get_buffer,
  pdp_video_filled_buffer,
  pdp_video_have_frame,
};
video_vft_t *get_video_vft (void)
{
  return (&video_vft);
}
CPDPVideoSync *pdp_create_video_sync (CPlayerSession *psptr, t_pdp_mp4player *pdp_father) 
{
  return new CPDPVideoSync(psptr, pdp_father);
}
--- NEW FILE: pdp_spotlight.c ---
/*
 *   PiDiP module.
 *   Copyright (c) by Yves Degoyon (ydegoyon@free.fr)
 *
 *   This program 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.
 *
 *   This program 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */
/*  This object is an adaptation of lens effect from effectv
 *  Originally written by Fukuchi Kentaro & others
 *  Pd-fication by Yves Degoyon                                 
 */
#include "pdp.h"
#include "yuv.h"
#include <math.h>
static char   *pdp_spotlight_version = "pdp_spotlight: version 0.1, specially made for cabaret, written by Yves Degoyon (ydegoyon@free.fr)";
typedef struct pdp_spotlight_struct
{
    t_object x_obj;
    t_float x_f;
t_outlet *x_outlet0;
    t_int x_packet0;
    t_int x_packet1;
    t_int x_dropped;
    t_int x_queue_id;
t_int x_vwidth;
    t_int x_vheight;
    t_int x_vsize;
    t_int x_cx;         // coordinates of lens center
    t_int x_cy;         // coordinates of lens center
    t_int x_ssize;      // width of the spotlight
    t_float x_strength; // strength of the light (0<=strength<=1)
t_int x_colorR;   // red component of the color
    t_int x_colorG;   // green component of the color
    t_int x_colorB;   // blue component of the color
} t_pdp_spotlight;
static void pdp_spotlight_ssize(t_pdp_spotlight *x, t_floatarg fssize )
{
    if ( fssize>=0 )
    {
       x->x_ssize = (int)fssize;
    }
}
static void pdp_spotlight_cy(t_pdp_spotlight *x, t_floatarg fcy )
{
    if ( fcy>0 )
    {
       x->x_cy = (int)fcy;
    }
}
static void pdp_spotlight_cx(t_pdp_spotlight *x, t_floatarg fcx )
{
    if ( fcx>0 )
    {
       x->x_cx = (int)fcx;
    }
}
static void pdp_spotlight_r(t_pdp_spotlight *x, t_floatarg fr )
{
   if ( ( fr >= 0 ) && ( fr <= 255 ) )
   {
      x->x_colorR = (int)fr;
   }
}
static void pdp_spotlight_g(t_pdp_spotlight *x, t_floatarg fg )
{
   if ( ( fg >= 0 ) && ( fg <= 255 ) )
   {
      x->x_colorG = (int)fg;
   }
}
static void pdp_spotlight_b(t_pdp_spotlight *x, t_floatarg fb )
{
   if ( ( fb >= 0 ) && ( fb <= 255 ) )
   {
      x->x_colorB = (int)fb;
   }
}
static void pdp_spotlight_strength(t_pdp_spotlight *x, t_floatarg fstrength )
{
   if ( ( fstrength >= 0.0 ) && ( fstrength <= 1.0 ) )
   {
      x->x_strength = fstrength;
   }
}
static void pdp_spotlight_process_yv12(t_pdp_spotlight *x)
{
    t_pdp     *header = pdp_packet_header(x->x_packet0);
    short int *data   = (short int *)pdp_packet_data(x->x_packet0);
    t_pdp     *newheader = pdp_packet_header(x->x_packet1);
    short int *newdata = (short int *)pdp_packet_data(x->x_packet1);
    int       i;
short int *poy, *pou, *pov, *pny, *pnu, *pnv;
    short int pmx, pMx, pmy, pMy;
    int px, py, ray2;
x->x_vwidth = header->info.image.width;
    x->x_vheight = header->info.image.height;
    x->x_vsize = x->x_vwidth*x->x_vheight;
newheader->info.image.encoding = header->info.image.encoding;
    newheader->info.image.width = x->x_vwidth;
    newheader->info.image.height = x->x_vheight;
memcpy(newdata, data, (x->x_vsize + (x->x_vsize>>1))<<1);
poy = data;
    pou = data + x->x_vsize;
    pov = data + x->x_vsize + (x->x_vsize>>2);
    pny = newdata;
    pnu = newdata + x->x_vsize;
    pnv = newdata + x->x_vsize + (x->x_vsize>>2);
    if ( x->x_cy-x->x_ssize < 0 ) 
    {
      pmy=0; 
    }
    else
    {
      pmy=x->x_cy-x->x_ssize; 
    }
    if ( x->x_cy+x->x_ssize > x->x_vheight ) 
    {
      pMy=x->x_vheight-1; 
    }
    else
    {
      pMy=x->x_cy+x->x_ssize; 
    }
    if ( x->x_cx-x->x_ssize < 0 ) 
    {
      pmx=0; 
    }
    else
    {
      pmx=x->x_cx-x->x_ssize; 
    }
    if ( x->x_cx+x->x_ssize > x->x_vwidth ) 
    {
      pMx=x->x_vwidth-1; 
    }
    else
    {
      pMx=x->x_cx+x->x_ssize; 
    }
    ray2 = pow( x->x_ssize, 2 );
    for (py = pmy; py <= pMy ; py++) 
    {
      for (px = pmx; px <= pMx; px++) 
      {
        if ( ( pow( (px-x->x_cx), 2 ) + pow( (py-x->x_cy), 2 ) ) < ray2 )
        {
           *(pny+py*x->x_vwidth+px) = 
              (t_float)(*(pny+py*x->x_vwidth+px))*(1.-x->x_strength) +
                (t_float)(((yuv_RGBtoY( (x->x_colorB << 16) + (x->x_colorG << 8) + x->x_colorR ))<<7))
                                *(x->x_strength);
           *(pnu+(py>>1)*(x->x_vwidth>>1)+(px>>1)) = 
              (t_float)(*(pnu+(py>>1)*(x->x_vwidth>>1)+(px>>1)))*(1.-x->x_strength) +  
                (t_float)(((yuv_RGBtoU( (x->x_colorB << 16) + (x->x_colorG << 8) 
                               + x->x_colorR ))-128)<<8)*(x->x_strength);
           *(pnv+(py>>1)*(x->x_vwidth>>1)+(px>>1)) = 
              (t_float)(*(pnv+(py>>1)*(x->x_vwidth>>1)+(px>>1)))*(1.-x->x_strength) +
                (t_float)(((yuv_RGBtoV( (x->x_colorB << 16) + (x->x_colorG << 8) 
                               + x->x_colorR ))-128)<<8)*(x->x_strength);
        }
      }
    }
return;
}
static void pdp_spotlight_sendpacket(t_pdp_spotlight *x)
{
    /* release the packet */
    pdp_packet_mark_unused(x->x_packet0);
    x->x_packet0 = -1;
/* unregister and propagate if valid dest packet */
    pdp_packet_pass_if_valid(x->x_outlet0, &x->x_packet1);
}
static void pdp_spotlight_process(t_pdp_spotlight *x)
{
   int encoding;
   t_pdp *header = 0;
/* check if image data packets are compatible */
   if ( (header = pdp_packet_header(x->x_packet0))
    && (PDP_IMAGE == header->type)){
/* pdp_spotlight_process inputs and write into active inlet */
    switch(pdp_packet_header(x->x_packet0)->info.image.encoding){
case PDP_IMAGE_YV12:
            x->x_packet1 = pdp_packet_clone_rw(x->x_packet0);
            pdp_queue_add(x, pdp_spotlight_process_yv12, pdp_spotlight_sendpacket, &x->x_queue_id);
        break;
default:
        /* don't know the type, so dont pdp_spotlight_process */
        break;
        
    }
    }
}
static void pdp_spotlight_input_0(t_pdp_spotlight *x, t_symbol *s, t_floatarg f)
{
    /* if this is a register_ro message or register_rw message, register with packet factory */
if (s== gensym("register_rw"))
    {
       x->x_dropped = pdp_packet_convert_ro_or_drop(&x->x_packet0, (int)f, pdp_gensym("image/YCrCb/*") );
    }
if ((s == gensym("process")) && (-1 != x->x_packet0) && (!x->x_dropped))
    {
        /* add the process method and callback to the process queue */
        pdp_spotlight_process(x);
}
}
static void pdp_spotlight_free(t_pdp_spotlight *x)
{
  int i;
pdp_queue_finish(x->x_queue_id);
    pdp_packet_mark_unused(x->x_packet0);
}
t_class *pdp_spotlight_class;
void *pdp_spotlight_new(void)
{
    int i;
t_pdp_spotlight *x = (t_pdp_spotlight *)pd_new(pdp_spotlight_class);
    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("cx"));
    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("cy"));
    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("ssize"));
    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("r"));
    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("g"));
    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("b"));
    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("strength"));
x->x_outlet0 = outlet_new(&x->x_obj, &s_anything);
x->x_packet0 = -1;
    x->x_packet1 = -1;
    x->x_queue_id = -1;
x->x_cx = 70;
    x->x_cy = 70;
    x->x_ssize = 50;
    x->x_colorR = 255;
    x->x_colorG = 255;
    x->x_colorB = 255;
    x->x_strength = 0.5;
return (void *)x;
}
#ifdef __cplusplus
extern "C"
{
#endif
void pdp_spotlight_setup(void)
{
//    post( pdp_spotlight_version );
    pdp_spotlight_class = class_new(gensym("pdp_spotlight"), (t_newmethod)pdp_spotlight_new,
    	(t_method)pdp_spotlight_free, sizeof(t_pdp_spotlight), 0, A_NULL);
class_addmethod(pdp_spotlight_class, (t_method)pdp_spotlight_input_0, gensym("pdp"),  A_SYMBOL, A_DEFFLOAT, A_NULL);
    class_addmethod(pdp_spotlight_class, (t_method)pdp_spotlight_cx, gensym("cx"),  A_FLOAT, A_NULL);
    class_addmethod(pdp_spotlight_class, (t_method)pdp_spotlight_cy, gensym("cy"),  A_FLOAT, A_NULL);
    class_addmethod(pdp_spotlight_class, (t_method)pdp_spotlight_ssize, gensym("ssize"),  A_FLOAT, A_NULL);
    class_addmethod(pdp_spotlight_class, (t_method)pdp_spotlight_r, gensym("r"),  A_FLOAT, A_NULL);
    class_addmethod(pdp_spotlight_class, (t_method)pdp_spotlight_g, gensym("g"),  A_FLOAT, A_NULL);
    class_addmethod(pdp_spotlight_class, (t_method)pdp_spotlight_b, gensym("b"),  A_FLOAT, A_NULL);
    class_addmethod(pdp_spotlight_class, (t_method)pdp_spotlight_strength, gensym("strength"),  A_FLOAT, A_NULL);
    class_sethelpsymbol( pdp_spotlight_class, gensym("pdp_spotlight.pd") );
}
#ifdef __cplusplus
}
#endif
--- NEW FILE: pdp_mp4videosource.cpp ---
/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is MPEG4IP.
 * 
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2000, 2001.  All Rights Reserved.
 * 
 * Contributor(s): 
 *        Dave Mackie        dmackie@cisco.com
 *        Bill May         wmay@cisco.com
 *
 * Adapted for PD/PDP by Yves Degoyon (ydegoyon@free.fr)
 */
#ifndef debug_message
#define debug_message post 
#endif
#include <sys/mman.h>
#include "m_pd.h"
#include "pdp_mp4videosource.h"
#include "video_util_rgb.h"
//#define DEBUG_TIMESTAMPS 1
int CPDPVideoSource::ThreadMain(void)
{
   // just a stub, the threaded mode is not used ( never called )
   return 0;
}
void CPDPVideoSource::DoStart(void)
{
  if (m_source) return;
  if (!Init()) return;
  m_source = true;
}
void CPDPVideoSource::DoStop(void)
{
  if (!m_source) return;
  DoStopVideo();
  m_source = false;
}
bool CPDPVideoSource::Init(void)
{
if (m_pConfig->GetIntegerValue(CONFIG_VIDEO_SIGNAL) == VIDEO_SIGNAL_NTSC) 
    {
      m_videoSrcFrameRate = VIDEO_NTSC_FRAME_RATE;
    } 
    else 
    {
      m_videoSrcFrameRate = VIDEO_PAL_FRAME_RATE;
    }
m_videoMbuf.frames = 2;
    m_cacheTimestamp = false;
    m_videoFrameMap = (struct video_mmap*) malloc(m_videoMbuf.frames * sizeof(struct video_mmap));
    if ( !m_videoFrameMap ) 
    {
      post("pdp_mp4live~ : video source init : failed to allocate enough memory");
      return false;
    }
m_videoFrameMapFrame = (uint64_t *)malloc(m_videoMbuf.frames * sizeof(uint64_t));
    m_videoFrameMapTimestamp = (uint64_t *)malloc(m_videoMbuf.frames * sizeof(Timestamp));
    m_captureHead = 0;
    m_encodeHead = -1;
m_videoFrames = 0;
    m_videoSrcFrameDuration = (Duration)(((float)TimestampTicks / m_videoSrcFrameRate) + 0.5);
    for (int i = 0; i < m_videoMbuf.frames; i++) 
    {
       // initialize frame map
       m_videoFrameMap[i].frame = i;
       m_videoFrameMap[i].width = m_pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_WIDTH);
       m_videoFrameMap[i].height = m_pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_HEIGHT);
       m_videoFrameMap[i].format = VIDEO_PALETTE_YUV420P;
if (i == 0) 
       {
         m_videoCaptureStartTimestamp = GetTimestamp();
       }
       m_lastVideoFrameMapFrameLoaded = m_videoFrameMapFrame[i] = i;
       m_lastVideoFrameMapTimestampLoaded =
       m_videoFrameMapTimestamp[i] = CalculateVideoTimestampFromFrames(i);
    }
m_pConfig->CalculateVideoFrameSize();
InitVideo(
        (m_pConfig->m_videoNeedRgbToYuv ?
            RGBVIDEOFRAME :
            YUVVIDEOFRAME),
        true);
SetVideoSrcSize(
        m_pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_WIDTH),
        m_pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_HEIGHT),
        m_pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_WIDTH),
        true);
m_maxPasses = (u_int8_t)(m_videoSrcFrameRate + 0.5);
return true;
}
int8_t CPDPVideoSource::StartTimeStamp(Timestamp &frameTimestamp)
{
    if (m_cacheTimestamp)
      frameTimestamp = m_videoFrameMapTimestamp[m_captureHead];
    else
      frameTimestamp = GetTimestamp();
int8_t capturedFrame = m_captureHead;
    m_captureHead = (m_captureHead + 1) % m_videoMbuf.frames;
return capturedFrame;
}
bool CPDPVideoSource::EndTimeStamp(int8_t frameNumber)
{
  Timestamp calc = GetTimestamp();
if (calc > m_videoSrcFrameDuration + m_lastVideoFrameMapTimestampLoaded) {
#ifdef DEBUG_TIMESTAMPS
    debug_message("pdp_mp4live~ : video frame delay past end of buffer - time is %llu should be %llu",
          calc,
          m_videoSrcFrameDuration + m_lastVideoFrameMapTimestampLoaded);
#endif
    m_videoCaptureStartTimestamp = calc;
    m_videoFrameMapFrame[frameNumber] = 0;
    m_videoFrameMapTimestamp[frameNumber] = calc;
  } else {
    m_videoFrameMapFrame[frameNumber] = m_lastVideoFrameMapFrameLoaded + 1;
    m_videoFrameMapTimestamp[frameNumber] =
      CalculateVideoTimestampFromFrames(m_videoFrameMapFrame[frameNumber]);
  }
m_lastVideoFrameMapFrameLoaded = m_videoFrameMapFrame[frameNumber];
  m_lastVideoFrameMapTimestampLoaded = m_videoFrameMapTimestamp[frameNumber];
  return true;
}
void CPDPVideoSource::ProcessVideo(u_int8_t *pY, u_int8_t *pU, u_int8_t *pV)
{
    // for efficiency, process ~1 second before returning to check for commands
  Timestamp frameTimestamp;
    for (int pass = 0; pass < m_maxPasses; pass++) {
// get next frame from video capture device
        m_encodeHead = StartTimeStamp(frameTimestamp);
        if (m_encodeHead == -1) {
            continue;
        }
ProcessVideoYUVFrame(
            pY, 
            pU, 
            pV,
            m_videoSrcWidth,
            m_videoSrcWidth >> 1,
            frameTimestamp);
// release video frame buffer back to video capture device
        if (EndTimeStamp(m_encodeHead)) {
            m_encodeHead = (m_encodeHead + 1) % m_videoMbuf.frames;
        } else {
            debug_message("pdp_mp4live~ : couldn't release capture buffer!");
        }
    }
}
--- NEW FILE: pdp_mp4live~.cpp ---
/*
 *   PiDiP module.
 *   Copyright (c) by Yves Degoyon (ydegoyon@free.fr )
 *
 *   This program 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.
 *
 *   This program 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */
/*  This object is a mpeg4ip streaming object towards a Darwin or Quicktime streaming server
 *  A lot of this object code is inspired by the code from mpeg4ip
 *  Copyright (c) 2000, 2001, 2002 Dave Mackie, Bill May & others
 *  The rest is written by Yves Degoyon ( ydegoyon@free.fr )                             
 */
#include "pdp.h"
#include <math.h>
#include <time.h>
#include <sys/time.h>
/* mpeg4ip includes taken from the source tree ( not exported ) */
#include <mp4.h>
#define  DECLARE_CONFIG_VARIABLES
#include "config_set.h"
#undef CONFIG_BOOL
#define CONFIG_BOOL(var, name, defval) \
 { &(var), (name), CONFIG_TYPE_BOOL, (defval), (defval) }
#undef CONFIG_FLOAT
#define CONFIG_FLOAT(var, name, defval) \
 { &(var), (name), CONFIG_TYPE_FLOAT,(float) (defval), (float) (defval) }
#undef CONFIG_INT
#define CONFIG_INT(var, name, defval) \
 { &(var), (name), CONFIG_TYPE_INTEGER,(config_integer_t) (defval), (config_integer_t)(defval) }
#undef CONFIG_STRING
#define CONFIG_STRING(var, name, defval) \
 { &(var), (name), CONFIG_TYPE_STRING, (defval), (defval) }
#include "pdp_mp4config.h"
#undef   DECLARE_CONFIG_VARIABLES
#ifndef debug_message
#define debug_message post 
#endif
#include "rtp_transmitter.h"
#include "pdp_mp4videosource.h"
#include "pdp_mp4audiosource.h"
#define VIDEO_BUFFER_SIZE (1024*1024)
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
#define AUDIO_PACKET_SIZE (2*1024) /* using aac encoding */
static char   *pdp_mp4live_version = "pdp_mp4live~: version 0.1, an mpeg4ip video streaming object ( ydegoyon@free.fr )";
typedef struct pdp_mp4live_struct
{
    t_object x_obj;
    t_float x_f;
t_int x_packet0;
    t_int x_dropped;
    t_int x_queue_id;
t_int x_vwidth;
    t_int x_vheight;
    t_int x_vsize;
t_outlet *x_outlet_streaming;  // indicates the status of streaming
    t_outlet *x_outlet_nbframes;   // number of frames emitted
    t_outlet *x_outlet_framerate;  // current frame rate
t_int x_streaming;   // streaming flag
    t_int x_nbframes;    // number of frames emitted
    t_int x_framerate;   // framerate
t_int x_cursec;   // current second
    t_int x_secondcount; // number of frames emitted in the current second
/* audio structures */
    short x_audio_buf[2*MAX_AUDIO_PACKET_SIZE]; /* buffer for incoming audio */
    short x_audio_enc_buf[2*MAX_AUDIO_PACKET_SIZE]; /* buffer for audio to be encoded */
    uint8_t x_audio_out[4*MAX_AUDIO_PACKET_SIZE]; /* buffer for encoded audio */
    t_int x_audioin_position; // writing position for incoming audio
    t_int x_audio_per_frame;  // number of audio samples to transmit for each frame
/* mpeg4ip data */
    CLiveConfig *x_mp4Config;
    CRtpTransmitter *x_rtpTransmitter;
    CPDPVideoSource *x_videosource;
    CPDPAudioSource *x_audiosource;
} t_pdp_mp4live;
#ifdef __cplusplus
extern "C"
{
#endif
static void pdp_mp4live_add_sink(t_pdp_mp4live *x, CMediaSink* pSink)
{
   if (x->x_videosource)
   {
      x->x_videosource->AddSink(pSink);
   }
   if (x->x_audiosource)
   {
      x->x_audiosource->AddSink(pSink);
   }
}
static void pdp_mp4live_remove_sink(t_pdp_mp4live *x, CMediaSink* pSink)
{
   if (x->x_videosource)
   {
      x->x_videosource->RemoveSink(pSink);
   }
   if (x->x_audiosource)
   {
      x->x_audiosource->RemoveSink(pSink);
   }
}
static void pdp_mp4live_disconnect(t_pdp_mp4live *x)
{
 t_int ret, i;
if (!x->x_streaming)
   {
     post("pdp_mp4live~ : disconnect request but not connected ... ignored" );
     return;
   }
if (x->x_audiosource) 
   {
     x->x_audiosource->DoStop();
     delete x->x_audiosource;
     x->x_audiosource = NULL;
   }
if (x->x_videosource) 
   {
     x->x_videosource->DoStop();
     delete x->x_videosource;
     x->x_videosource = NULL;
   }
if (x->x_rtpTransmitter) 
   {
     pdp_mp4live_remove_sink(x, x->x_rtpTransmitter);
     x->x_rtpTransmitter->StopThread();
     delete x->x_rtpTransmitter;
     x->x_rtpTransmitter = NULL;
   }
x->x_streaming = 0;
   outlet_float( x->x_outlet_streaming, x->x_streaming );
   x->x_nbframes = 0;
   outlet_float( x->x_outlet_nbframes, x->x_nbframes );
   x->x_framerate = 0;
   outlet_float( x->x_outlet_framerate, x->x_framerate );
}
static void pdp_mp4live_connect(t_pdp_mp4live *x )
{
  t_int ret, i;
if (x->x_streaming)
   {
     post("pdp_mp4live~ : connect request but already connected ... ignored" );
     return;
   }
post("pdp_mp4live~ : creating video source");
   if ( x->x_videosource == NULL )
   {
      x->x_videosource = new CPDPVideoSource();
      x->x_videosource->SetConfig(x->x_mp4Config);
   }
post("pdp_mp4live~ : creating audio source");
   if ( x->x_audiosource == NULL )
   {
       x->x_audiosource = new CPDPAudioSource(x->x_mp4Config);
   }
post("pdp_mp4live~ : creating rtp transmitter");
   x->x_rtpTransmitter = new CRtpTransmitter(x->x_mp4Config);
   x->x_rtpTransmitter->StartThread();
post("pdp_mp4live~ : creating audio destination");
   x->x_rtpTransmitter->CreateAudioRtpDestination(0,
                      x->x_mp4Config->GetStringValue(CONFIG_RTP_AUDIO_DEST_ADDRESS),
                      x->x_mp4Config->GetIntegerValue(CONFIG_RTP_AUDIO_DEST_PORT),
                      0);
post("pdp_mp4live~ : creating video destination");
   x->x_rtpTransmitter->CreateVideoRtpDestination(0,
                     x->x_mp4Config->GetStringValue(CONFIG_RTP_DEST_ADDRESS),
                     x->x_mp4Config->GetIntegerValue(CONFIG_RTP_VIDEO_DEST_PORT),
                     0);
post("pdp_mp4live~ : starting rtp");
   if ( x->x_rtpTransmitter )
   {
      pdp_mp4live_add_sink(x, x->x_rtpTransmitter);
      x->x_rtpTransmitter->Start();
   }
if (x->x_videosource) 
   {
      post("pdp_mp4live~ : starting video source");
      x->x_videosource->DoStart();
      post("pdp_mp4live~ : generating key frame");
      x->x_videosource->GenerateKeyFrame();
   }
if (x->x_audiosource) 
   {
      post("pdp_mp4live~ : starting audio source");
      x->x_audiosource->DoStart();
   }
x->x_streaming = 1;
   outlet_float( x->x_outlet_streaming, x->x_streaming );
   x->x_nbframes = 0;
   outlet_float( x->x_outlet_nbframes, x->x_nbframes );
   x->x_framerate = 0;
   outlet_float( x->x_outlet_framerate, x->x_framerate );
}
static void pdp_mp4live_ipaddr(t_pdp_mp4live *x, t_symbol *sIpAddr )
{
  t_int a, b, c, d;
if ( !strcmp( sIpAddr->s_name, "" ) )
   {
     post("pdp_mp4live~ : wrong ip address" );
     return;
   }
if ( sscanf( sIpAddr->s_name, "%d.%d.%d.%d", &a, &b, &c, &d ) < 4 )
   {
     post("pdp_mp4live~ : wrong ip address : %s", sIpAddr->s_name );
     return;
   }
post( "pdp_mp4live~ : setting ip address: %s", sIpAddr->s_name );
   x->x_mp4Config->SetStringValue( CONFIG_RTP_DEST_ADDRESS, sIpAddr->s_name );
   x->x_mp4Config->SetStringValue( CONFIG_RTP_AUDIO_DEST_ADDRESS, sIpAddr->s_name );
}
static void pdp_mp4live_aport(t_pdp_mp4live *x, t_floatarg fAudioPort )
{
   if ( ( (t_int) fAudioPort <= 0 ) || ( (t_int) fAudioPort > 65535 ) )
   {
     post("pdp_mp4live~ : wrong audio port : %d", fAudioPort );
     return;
   }
post( "pdp_mp4live~ : setting audio port: %d", (t_int) fAudioPort );
   x->x_mp4Config->SetIntegerValue( CONFIG_RTP_AUDIO_DEST_PORT, (t_int) fAudioPort );
}
static void pdp_mp4live_vport(t_pdp_mp4live *x, t_floatarg fVideoPort )
{
   if ( ( (t_int) fVideoPort <= 0 ) || ( (t_int) fVideoPort > 65535 ) )
   {
     post("pdp_mp4live~ : wrong video port : %d", fVideoPort );
     return;
   }
post( "pdp_mp4live~ : setting video port: %d", (t_int) fVideoPort );
   x->x_mp4Config->SetIntegerValue( CONFIG_RTP_VIDEO_DEST_PORT, (t_int) fVideoPort );
}
static void pdp_mp4live_ttl(t_pdp_mp4live *x, t_floatarg fTtl )
{
   if ( ( (t_int) fTtl <= 0 ) || ( (t_int) fTtl > 255 ) )
   {
     post("pdp_mp4live~ : wrong ttl : %d", fTtl );
     return;
   }
post( "pdp_mp4live~ : setting ttl : %d", (t_int) fTtl );
   x->x_mp4Config->SetIntegerValue( CONFIG_RTP_MCAST_TTL, (t_int) fTtl );
}
static void pdp_mp4live_vwidth(t_pdp_mp4live *x, t_floatarg fWidth )
{
   if ( ( (t_int) fWidth <= 0 ) )
   {
     post("pdp_mp4live~ : wrong width : %d", fWidth );
     return;
   }
post( "pdp_mp4live~ : setting width : %d", (t_int) fWidth );
   x->x_mp4Config->SetIntegerValue( CONFIG_VIDEO_RAW_WIDTH, (t_int) fWidth );
}
static void pdp_mp4live_vheight(t_pdp_mp4live *x, t_floatarg fHeight )
{
   if ( ( (t_int) fHeight <= 0 ) )
   {
     post("pdp_mp4live~ : wrong height : %d", fHeight );
     return;
   }
post( "pdp_mp4live~ : setting height : %d", (t_int) fHeight );
   x->x_mp4Config->SetIntegerValue( CONFIG_VIDEO_RAW_HEIGHT, (t_int) fHeight );
}
static void pdp_mp4live_framerate(t_pdp_mp4live *x, t_floatarg fFrameRate )
{
   if ( ( (t_int) fFrameRate <= 0 ) )
   {
     post("pdp_mp4live~ : wrong framerate : %d", fFrameRate );
     return;
   }
post( "pdp_mp4live~ : setting framerate : %d", (t_int) fFrameRate );
   x->x_mp4Config->SetFloatValue( CONFIG_VIDEO_FRAME_RATE, (t_float) fFrameRate );
}
static void pdp_mp4live_vbitrate(t_pdp_mp4live *x, t_floatarg fVBitrate )
{
   if ( ( (t_int) fVBitrate <= 0 ) )
   {
     post("pdp_mp4live~ : wrong video bit rate : %d", fVBitrate );
     return;
   }
post( "pdp_mp4live~ : setting video bit rate : %d", (t_int) fVBitrate );
   x->x_mp4Config->SetIntegerValue( CONFIG_VIDEO_BIT_RATE, (t_int) fVBitrate );
}
static void pdp_mp4live_samplerate(t_pdp_mp4live *x, t_floatarg fSampleRate )
{
   if ( ( (t_int) fSampleRate != 44100 ) &&
        ( (t_int) fSampleRate != 22050 ) &&
        ( (t_int) fSampleRate != 11025 ) &&
        ( (t_int) fSampleRate != 8000 )
        )
   {
     post("pdp_mp4live~ : wrong samplerate : %d", fSampleRate );
     return;
   }
post( "pdp_mp4live~ : setting samplerate : %d", (t_int) fSampleRate );
   x->x_mp4Config->SetIntegerValue( CONFIG_AUDIO_SAMPLE_RATE, (t_int) fSampleRate );
}
static void pdp_mp4live_abitrate(t_pdp_mp4live *x, t_floatarg fABitrate )
{
   if ( ( (t_int) fABitrate <= 0 ) )
   {
     post("pdp_mp4live~ : wrong audio bit rate : %d", fABitrate );
     return;
   }
post( "pdp_mp4live~ : setting audio bit rate : %d", (t_int) fABitrate );
   x->x_mp4Config->SetIntegerValue( CONFIG_AUDIO_BIT_RATE_KBPS, (t_int) fABitrate );
   x->x_mp4Config->SetIntegerValue( CONFIG_AUDIO_BIT_RATE, ((t_int) fABitrate)*1000 );
}
static void pdp_mp4live_sdp(t_pdp_mp4live *x, t_symbol *sSdpFile )
{
  t_int ret;
post( "pdp_mp4live~ : setting sdp filename : %s", (char *) sSdpFile->s_name );
   x->x_mp4Config->SetStringValue( CONFIG_SDP_FILE_NAME, (char *) sSdpFile->s_name );
post( "pdp_mp4live~ : writing sdp file : %s", (char *) sSdpFile->s_name );
   if ( ( ret = GenerateSdpFile( x->x_mp4Config ) ) )
   {
     post( "pdp_mp4live~ : written sdp file : %s", (char *) sSdpFile->s_name );
   }
   else
   {
     post( "pdp_mp4live~ : could not write sdp file : %s", 
            (char *) sSdpFile->s_name );
   }
}
static void pdp_mp4live_process_yv12(t_pdp_mp4live *x)
{
    t_pdp     *header = pdp_packet_header(x->x_packet0);
    u_int8_t  *data   = (uint8_t *)pdp_packet_data(x->x_packet0);
    u_int8_t  *pY, *pU, *pV;
    struct timeval etime;
/* allocate all ressources */
    if ( ((int)header->info.image.width != x->x_vwidth) ||
         ((int)header->info.image.height != x->x_vheight) )
    {
        x->x_vwidth = header->info.image.width;
        x->x_vheight = header->info.image.height;
        x->x_vsize = x->x_vwidth*x->x_vheight;
    }
if ( x->x_streaming )
    {
         pY = data;
         pU = data+x->x_vsize;
         pV = data+x->x_vsize+(x->x_vsize>>2);
x->x_videosource->ProcessVideo( pY, pV, pU );
/* update frames counter */
if ( gettimeofday(&etime, NULL) == -1)
         {
            post("pdp_ffmpeg~ : could not read time" );
         }
         if ( etime.tv_sec != x->x_cursec )
         {
            x->x_cursec = etime.tv_sec;
            x->x_framerate = x->x_secondcount;
            x->x_secondcount = 0;
         }
         x->x_nbframes++;
         x->x_secondcount++;
/* send an audio frame */
         if ( x->x_audioin_position > x->x_audio_per_frame )
         {
            x->x_audiosource->ProcessAudio( (u_int8_t*)x->x_audio_buf, 
                           (u_int32_t)x->x_audio_per_frame*sizeof(short) );
/* output resampled raw samples */
            memcpy( x->x_audio_buf, x->x_audio_buf+x->x_audio_per_frame, 
                    x->x_audioin_position-x->x_audio_per_frame ); 
            x->x_audioin_position-=x->x_audio_per_frame;
         }
    }
    return;
}
static void pdp_mp4live_killpacket(t_pdp_mp4live *x)
{
    /* delete source packet */
    pdp_packet_mark_unused(x->x_packet0);
    x->x_packet0 = -1;
}
/* store audio data in PCM format and stream it */
static t_int *pdp_mp4live_perform(t_int *w)
{
  t_float *in1   = (t_float *)(w[1]);       // left audio inlet
  t_float *in2   = (t_float *)(w[2]);       // right audio inlet 
  t_pdp_mp4live *x = (t_pdp_mp4live *)(w[3]);
  int n = (int)(w[4]);                      // number of samples 
  t_float fsample;
  t_int   isample, i;
// just fills the buffer ( a pcm buffer )
    while (n--)
    {
       fsample=*(in1++); 
       if (fsample > 1.0) { fsample = 1.0; }
       if (fsample < -1.0) { fsample = -1.0; }
       isample=(short) (32767.0 * fsample);
       *(x->x_audio_buf+x->x_audioin_position)=isample;
       x->x_audioin_position=(x->x_audioin_position+1)%(2*MAX_AUDIO_PACKET_SIZE); 
       if ( x->x_audioin_position == 2*MAX_AUDIO_PACKET_SIZE-1 ) 
       {
          // post( "pdp_mp4live~ : reaching end of audio buffer" );
       }
       fsample=*(in2++); 
       if (fsample > 1.0) { fsample = 1.0; }
       if (fsample < -1.0) { fsample = -1.0; }
       isample=(short) (32767.0 * fsample);
       *(x->x_audio_buf+x->x_audioin_position)=isample;
       x->x_audioin_position=(x->x_audioin_position+1)%(2*MAX_AUDIO_PACKET_SIZE); 
       if ( x->x_audioin_position == 2*MAX_AUDIO_PACKET_SIZE-1 ) 
       {
          // post( "pdp_mp4live~ : reaching end of audio buffer" );
       }
    }
return (w+5);
}
static void pdp_mp4live_dsp(t_pdp_mp4live *x, t_signal **sp)
{
    dsp_add(pdp_mp4live_perform, 4, sp[0]->s_vec, sp[1]->s_vec, x, sp[0]->s_n);
}
static void pdp_mp4live_process(t_pdp_mp4live *x)
{
   int encoding;
   t_pdp *header = 0;
/* check if image data packets are compatible */
   if ( (header = pdp_packet_header(x->x_packet0))
    && (PDP_BITMAP == header->type)){
/* pdp_mp4live_process inputs and write into active inlet */
    switch(pdp_packet_header(x->x_packet0)->info.image.encoding)
        {
case PDP_BITMAP_YV12:
            pdp_queue_add(x, (void*) pdp_mp4live_process_yv12, (void*) pdp_mp4live_killpacket, &x->x_queue_id);
            outlet_float( x->x_outlet_nbframes, x->x_nbframes );
            outlet_float( x->x_outlet_framerate, x->x_framerate );
        break;
default:
        /* don't know the type, so dont pdp_mp4live_process */
            post( "pdp_mp4live~ : hey!! i don't know about that type of image : %d", 
                  pdp_packet_header(x->x_packet0)->info.image.encoding );
        break;
        
    }
    }
}
static void pdp_mp4live_input_0(t_pdp_mp4live *x, t_symbol *s, t_floatarg f)
{
/* if this is a register_ro message or register_rw message, register with packet factory */
if (s== gensym("register_rw"))
    {
       x->x_dropped = pdp_packet_convert_ro_or_drop(&x->x_packet0, (int)f, pdp_gensym("bitmap/yv12/*") );
    }
if ((s == gensym("process")) && (-1 != x->x_packet0) && (!x->x_dropped))
    {
        /* add the process method and callback to the process queue */
        pdp_mp4live_process(x);
    }
}
static void pdp_mp4live_free(t_pdp_mp4live *x)
{
  int i;
pdp_queue_finish(x->x_queue_id);
    pdp_packet_mark_unused(x->x_packet0);
}
t_class *pdp_mp4live_class;
void *pdp_mp4live_new(void)
{
    int i;
t_pdp_mp4live *x = (t_pdp_mp4live *)pd_new(pdp_mp4live_class);
    inlet_new (&x->x_obj, &x->x_obj.ob_pd, gensym ("signal"), gensym ("signal"));
x->x_outlet_streaming = outlet_new(&x->x_obj, &s_float);
    x->x_outlet_nbframes = outlet_new(&x->x_obj, &s_float);
    x->x_outlet_framerate = outlet_new(&x->x_obj, &s_float);
x->x_packet0 = -1;
    x->x_queue_id = -1;
    x->x_nbframes = 0;
    x->x_framerate = 0;
    x->x_secondcount = 0;
    x->x_audioin_position = 0;
x->x_mp4Config = new CLiveConfig(PdpConfigVariables,
                     sizeof(PdpConfigVariables) / sizeof(SConfigVariable),
                     "none");
    if ( x->x_mp4Config == NULL )
    {
       post( "pdp_mp4live~ : couldn't allocate default config" );
       return NULL;
    }
x->x_mp4Config->InitializeIndexes();
x->x_mp4Config->Update();
// update sample rate with the actual sample rate
    x->x_mp4Config->SetIntegerValue( CONFIG_AUDIO_SAMPLE_RATE, (t_int) sys_getsr() );
x->x_videosource = NULL;
    x->x_audiosource = NULL;
x->x_audio_per_frame = AUDIO_PACKET_SIZE;
return (void *)x;
}
void pdp_mp4live_tilde_setup(void)
{
    // post( pdp_mp4live_version );
    pdp_mp4live_class = class_new(gensym("pdp_mp4live~"), (t_newmethod)pdp_mp4live_new,
    	(t_method)pdp_mp4live_free, sizeof(t_pdp_mp4live), 0, A_NULL);
CLASS_MAINSIGNALIN(pdp_mp4live_class, t_pdp_mp4live, x_f );
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_input_0, gensym("pdp"), A_SYMBOL, A_DEFFLOAT, A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_dsp, gensym("dsp"), A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_connect, gensym("connect"), A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_ipaddr, gensym("ipaddr"), A_SYMBOL, A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_aport, gensym("audioport"), A_DEFFLOAT, A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_vport, gensym("videoport"), A_DEFFLOAT, A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_ttl, gensym("ttl"), A_DEFFLOAT, A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_vwidth, gensym("vwidth"), A_DEFFLOAT, A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_vheight, gensym("vheight"), A_DEFFLOAT, A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_framerate, gensym("framerate"), A_DEFFLOAT, A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_vbitrate, gensym("vbitrate"), A_DEFFLOAT, A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_samplerate, gensym("samplerate"), A_DEFFLOAT, A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_abitrate, gensym("abitrate"), A_DEFFLOAT, A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_disconnect, gensym("disconnect"), A_NULL);
    class_addmethod(pdp_mp4live_class, (t_method)pdp_mp4live_sdp, gensym("sdp"), A_SYMBOL, A_NULL);
    class_sethelpsymbol( pdp_mp4live_class, gensym("pdp_mp4live~.pd") );
}
#ifdef __cplusplus
}
#endif
--- NEW FILE: pdp_mp4audiosync.cpp ---
/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is MPEG4IP.
 * 
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2000, 2001.  All Rights Reserved.
 * 
 * Contributor(s): 
 *              Bill May        wmay@cisco.com
 *
 * Adapted to PD/PDP by Yves Degoyon (ydegoyon@free.fr)
 */
/*
 * audio.cpp provides an interface (CPDPAudioSync) between the codec and
 * the SDL audio APIs.
 */
#include <stdlib.h>
#include <string.h>
#include "pdp_mp4playersession.h"
#include "pdp_mp4audiosync.h"
#include "player_util.h"
#include "our_config_file.h"
#include "m_pd.h"
#define audio_message(loglevel, fmt...) message(loglevel, "audiosync", fmt)
static void pdp_audio_callback (void *userdata, Uint8 *stream, int len)
{
  CPDPAudioSync *a = (CPDPAudioSync *)userdata;
  a->audio_callback(stream, len);
}
CPDPAudioSync::CPDPAudioSync (CPlayerSession *psptr, t_pdp_mp4player *pdp_father) : CAudioSync(psptr)
{
  m_fill_index = m_play_index = 0;
  for (int ix = 0; ix < DECODE_BUFFERS_MAX; ix++) {
    m_buffer_filled[ix] = 0;
    m_sample_buffer[ix] = NULL;
  }
  m_buffer_size = 0;
  m_config_set = 0;
  m_audio_initialized = 0;
  m_audio_paused = 1;
  m_resync_required = 0;
  m_dont_fill = 0;
  m_consec_no_buffers = 0;
  m_audio_waiting_buffer = 0;
  m_skipped_buffers = 0;
  m_didnt_fill_buffers = 0;
  m_play_time = 0         ;
  m_buffer_latency = 0;
  m_first_time = 1;
  m_first_filled = 1;
  m_buffer_offset_on = 0;
  m_buffer_ts = 0;
  m_load_audio_do_next_resync = 0;
  m_convert_buffer = NULL;
  m_father = pdp_father;
}
CPDPAudioSync::~CPDPAudioSync (void)
{
  for (int ix = 0; ix < DECODE_BUFFERS_MAX; ix++) {
    if (m_sample_buffer[ix] != NULL)
      free(m_sample_buffer[ix]);
    m_sample_buffer[ix] = NULL;
  }
  CHECK_AND_FREE(m_convert_buffer);
  audio_message(LOG_NOTICE, 
    	"Audio sync skipped %u buffers", 
    	m_skipped_buffers);
  audio_message(LOG_NOTICE, "didn't fill %u buffers", m_didnt_fill_buffers);
}
void CPDPAudioSync::set_config (int freq, 
    		     int channels, 
    		     int format, 
    		     uint32_t sample_size) 
{
  if (m_config_set != 0) 
    return;
if (format == AUDIO_U8 || format == AUDIO_S8)
    m_bytes_per_sample = 1;
  else
    m_bytes_per_sample = 2;
if (sample_size == 0) {
    int temp;
    temp = freq;
    while ((temp & 0x1) == 0) temp >>= 1;
    sample_size = temp;
    while (sample_size < 1024) sample_size *= 2;
    while (((sample_size * 1000) % freq) != 0) sample_size *= 2;
  }
m_buffer_size = channels * sample_size * m_bytes_per_sample;
for (int ix = 0; ix < DECODE_BUFFERS_MAX; ix++) {
    m_buffer_filled[ix] = 0;
    m_sample_buffer[ix] = (uint8_t *)malloc(2 * m_buffer_size);
  }
  m_freq = freq;
  m_channels = channels;
  m_format = format;
  if (m_format == AUDIO_U8) {
    m_silence = 0x80;
  } else {
    m_silence = 0x00;
  }
  m_config_set = 1;
  m_msec_per_frame = (sample_size * 1000) / m_freq;
  audio_message(LOG_DEBUG, "buffer size %d msec per frame %d", m_buffer_size, m_msec_per_frame);
};
uint8_t *CPDPAudioSync::get_audio_buffer (void)
{
  int ret;
  int locked = 0;
  if (m_dont_fill == 1) {
    return (NULL);
  }
if (m_audio_initialized != 0) {
    locked = 1;
  }
  ret = m_buffer_filled[m_fill_index];
  if (ret == 1) {
    m_audio_waiting_buffer = 1;
    m_audio_waiting_buffer = 0;
    if (m_dont_fill != 0) {
      return (NULL);
    }
    locked = 0;
    if (m_audio_initialized != 0) {
      locked = 1;
    }
    ret = m_buffer_filled[m_fill_index];
    if (locked)
    if (ret == 1) {
      post("pdp_mp4audiosync : no buffer");
      return (NULL);
    }
  }
  return (m_sample_buffer[m_fill_index]);
}
void CPDPAudioSync::load_audio_buffer (uint8_t *from, 
    			       uint32_t bytes, 
    			       uint64_t ts, 
    			       int resync)
{
  uint8_t *to;
  uint32_t copied;
  copied = 0;
  if (m_buffer_offset_on == 0) {
    int64_t diff = ts - m_buffer_ts;
if (m_buffer_ts != 0 && diff > 1) {
      m_load_audio_do_next_resync = 1;
      audio_message(LOG_DEBUG, "timeslot doesn't match - %llu %llu",
    	    ts, m_buffer_ts);
    }
    m_buffer_ts = ts;
  } else {
    int64_t check;
    check = ts - m_loaded_next_ts;
    if (check > m_msec_per_frame) {
      audio_message(LOG_DEBUG, "potential resync at ts "U64" should be ts "U64,
    	    ts, m_loaded_next_ts);
      uint32_t left;
      left = m_buffer_size - m_buffer_offset_on;
      to = get_audio_buffer();
      memset(to + m_buffer_offset_on, 0, left);
      filled_audio_buffer(m_buffer_ts, 0);
      m_buffer_offset_on = 0;
      m_load_audio_do_next_resync = 1;
      m_buffer_ts = ts;
    }
  }
  m_loaded_next_ts = bytes * M_64;
  m_loaded_next_ts /= m_bytes_per_sample;
  m_loaded_next_ts /= m_freq;
  m_loaded_next_ts += ts;
while ( bytes > 0) {
    to = get_audio_buffer();
    if (to == NULL) {
      return;
    }
    int copy;
    uint32_t left;
left = m_buffer_size - m_buffer_offset_on;
    copy = MIN(left, bytes);
    memcpy(to + m_buffer_offset_on, from, copy);
    bytes -= copy;
    copied += copy;
    from += copy;
    m_buffer_offset_on += copy;
    if (m_buffer_offset_on >= m_buffer_size) {
      m_buffer_offset_on = 0;
      filled_audio_buffer(m_buffer_ts, resync | m_load_audio_do_next_resync);
      m_buffer_ts += m_msec_per_frame;
      resync = 0;
      m_load_audio_do_next_resync = 0;
    }
  }
  return;
}
void CPDPAudioSync::filled_audio_buffer (uint64_t ts, int resync)
{
  uint32_t fill_index;
  int locked;
  // m_dont_fill will be set when we have a pause
  if (m_dont_fill == 1) {
    return;
  }
  //  resync = 0;
  fill_index = m_fill_index;
  m_fill_index++;
  m_fill_index %= DECODE_BUFFERS_MAX;
locked = 0;
  if (m_audio_initialized != 0) {
    locked = 1;
  }
  if (m_first_filled != 0) {
    m_first_filled = 0;
    resync = 0;
    m_resync_required = 0;
  } else {
    int64_t diff;
    diff = ts - m_last_fill_timestamp;
    if (diff - m_msec_per_frame > m_msec_per_frame) {
      // have a hole here - don't want to resync
      if (diff > ((m_msec_per_frame + 1) * 4)) {
    resync = 1;
      } else {
    // try to fill the holes
    m_last_fill_timestamp += m_msec_per_frame + 1; // fill plus extra
    int64_t ts_diff;
    do {
      uint8_t *retbuffer;
      // Get and swap buffers.
      retbuffer = get_audio_buffer();
      if (retbuffer == NULL) {
        return;
      }
      if (retbuffer != m_sample_buffer[m_fill_index]) {
        audio_message(LOG_ERR, "retbuffer not fill index in audio sync");
        return;
      }
      locked = 0;
      if (m_audio_initialized != 0) {
        locked = 1;
      }
      m_sample_buffer[m_fill_index] = m_sample_buffer[fill_index];
      m_sample_buffer[fill_index] = retbuffer;
      memset(retbuffer, m_silence, m_buffer_size);
      m_buffer_time[fill_index] = m_last_fill_timestamp;
      m_buffer_filled[fill_index] = 1;
      m_samples_loaded += m_buffer_size;
      fill_index++;
      fill_index %= DECODE_BUFFERS_MAX;
      m_fill_index++;
      m_fill_index %= DECODE_BUFFERS_MAX;
      audio_message(LOG_NOTICE, "Filling timestamp %llu with silence",
    		m_last_fill_timestamp);
      m_last_fill_timestamp += m_msec_per_frame + 1; // fill plus extra
      ts_diff = ts - m_last_fill_timestamp;
      audio_message(LOG_DEBUG, "diff is %lld", ts_diff);
    } while (ts_diff > 0);
    locked = 0;
    if (m_audio_initialized != 0) {
      locked = 1;
    }
      }
    } else {
      if (m_last_fill_timestamp == ts) {
    audio_message(LOG_NOTICE, "Repeat timestamp with audio %llu", ts);
    return;
      }
    }
  }
  m_last_fill_timestamp = ts;
  m_buffer_filled[fill_index] = 1;
  m_samples_loaded += m_buffer_size;
  m_buffer_time[fill_index] = ts;
  if (resync) {
    m_resync_required = 1;
    m_resync_buffer = fill_index;
#ifdef DEBUG_AUDIO_FILL
    audio_message(LOG_DEBUG, "Resync from filled_audio_buffer");
#endif
  }
// Check this - we might not want to do this unless we're resyncing
  if (resync) m_psptr->wake_sync_thread();
#ifdef DEBUG_AUDIO_FILL
  audio_message(LOG_DEBUG, "Filling " LLU " %u %u", ts, fill_index, m_samples_loaded);
#endif
}
void CPDPAudioSync::set_eof(void) 
{ 
  uint8_t *to;
  if (m_buffer_offset_on != 0) {
    to = get_audio_buffer();
    if (to != NULL) {
      uint32_t left;
      left = m_buffer_size - m_buffer_offset_on;
      memset(to + m_buffer_offset_on, 0, left);
      m_buffer_offset_on = 0;
      filled_audio_buffer(m_buffer_ts, 0);
      m_buffer_ts += m_msec_per_frame;
    }
  }
  CAudioSync::set_eof();
}
int CPDPAudioSync::initialize_audio (int have_video) 
{
  return (1);
}
int CPDPAudioSync::is_audio_ready (uint64_t &disptime)
{
  disptime = m_buffer_time[m_play_index];
  return (m_dont_fill == 0 && m_buffer_filled[m_play_index] == 1);
}
uint64_t CPDPAudioSync::check_audio_sync (uint64_t current_time, int &have_eof)
{
  return (0);
}
void CPDPAudioSync::audio_callback (Uint8 *stream, int ilen)
{
  int freed_buffer = 0;
  uint32_t bufferBytes = (uint32_t)ilen;
  uint64_t this_time;
  int delay = 0;
  int playtime;
}
void CPDPAudioSync::play_audio (void)
{
  m_first_time = 1;
  m_audio_paused = 0;
  m_play_sample_index = 0;
}
void CPDPAudioSync::flush_sync_buffers (void)
{
  clear_eof();
  m_dont_fill = 1;
  if (m_audio_waiting_buffer) {
    m_audio_waiting_buffer = 0;
  }
}
void CPDPAudioSync::flush_decode_buffers (void)
{
  int locked = 0;
  if (m_audio_initialized != 0) {
    locked = 1;
  }
  m_dont_fill = 0;
  m_first_filled = 1;
  for (int ix = 0; ix < DECODE_BUFFERS_MAX; ix++) {
    m_buffer_filled[ix] = 0;
  }
  m_buffer_offset_on = 0;
  m_play_index = m_fill_index = 0;
  m_audio_paused = 1;
  m_resync_buffer = 0;
  m_samples_loaded = 0;
}
void CPDPAudioSync::set_volume (int volume)
{
  m_volume = (volume * SDL_MIX_MAXVOLUME)/100;
}
void CPDPAudioSync::audio_convert_data (void *from, uint32_t samples)
{
  if (m_obtained.format == AUDIO_U8 || m_obtained.format == AUDIO_S8) {
    // bytewise - easy
    int8_t *src, *dst;
    src = (int8_t *) from;
    dst = (int8_t *) m_convert_buffer;
    if (m_channels == 2) {
      // we got 1, wanted 2
      for (uint32_t ix = 0; ix < samples; ix++) {
    int16_t sum = *src++;
    sum += *src++;
    sum /= 2;
    if (sum < -128) sum = -128;
    else if (sum > 128) sum = 128;
    *dst++ = sum & 0xff;
      }
    } else {
      // we got 2, wanted 1
      for (uint32_t ix = 0; ix < samples; ix++) {
    *dst++ = *src;
    *dst++ = *src++;
      }
    }
  } else {
    int16_t *src, *dst;
    src = (int16_t *) from;
    dst = (int16_t *) m_convert_buffer;
    samples /= 2;
    if (m_channels == 1) {
      // 1 channel to 2
      for (uint32_t ix = 0; ix < samples; ix++) {
    *dst++ = *src;
    *dst++ = *src;
    src++;
      }
    } else {
      // 2 channels to 1
      for (uint32_t ix = 0; ix < samples; ix++) {
    int32_t sum = *src++;
    sum += *src++;
    sum /= 2;
    if (sum < -32768) sum = -32768;
    else if (sum > 32767) sum = 32767;
    *dst++ = sum & 0xffff;
      }
    }
}
}
static void pdp_audio_config (void *ifptr, int freq, 
    		    int chans, int format, uint32_t max_buffer_size)
{
  ((CPDPAudioSync *)ifptr)->set_config(freq,
    			    chans,
    			    format,
    			    max_buffer_size);
}
static uint8_t *pdp_get_audio_buffer (void *ifptr)
{
  return ((CPDPAudioSync *)ifptr)->get_audio_buffer();
}
static void pdp_filled_audio_buffer (void *ifptr,
    			   uint64_t ts,
    			   int resync_req)
{
  ((CPDPAudioSync *)ifptr)->filled_audio_buffer(ts, 
    				     resync_req);
}
static void pdp_load_audio_buffer (void *ifptr, 
    			     uint8_t *from, 
    			     uint32_t bytes, 
    			     uint64_t ts, 
    			     int resync)
{
  ((CPDPAudioSync *)ifptr)->load_audio_buffer(from,
    				      bytes,
    				      ts, 
    				      resync);
}
audio_vft_t audio_vft = {
  message,
  pdp_audio_config,
  pdp_get_audio_buffer,
  pdp_filled_audio_buffer,
  pdp_load_audio_buffer
};
audio_vft_t *get_audio_vft (void)
{
  return &audio_vft;
}
CPDPAudioSync *pdp_create_audio_sync (CPlayerSession *psptr, t_pdp_mp4player *pdp_father)
{
  return new CPDPAudioSync(psptr, pdp_father);
}
int do_we_have_audio (void) 
{
  return 1;
}
--- NEW FILE: pdp_ieee1394.c ---
/*
 *   PiDiP module.
 *   Copyright (c) by Yves Degoyon (ydegoyon@free.fr)
 *
 *   This program 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.
 *
 *   This program 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */
/*  This object is a ieee1394 video input object for OSX, using QuickTime
 *  Some code is inspired by pix_video from Gem
 *  Written by Yves Degoyon
 */
#include "pdp_config.h"
#include "pdp.h"
#include "pdp_llconv.h"
#include "pdp_imageproc.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sched.h>
#include <pthread.h>
#include <Carbon/Carbon.h>
#include <Quicktime/QuickTime.h>
#include <Quicktime/QuickTimeComponents.h>
#define DEFAULT_WIDTH 320
#define DEFAULT_HEIGHT 240
typedef struct pdp_ieee1394_struct
{
  t_object x_obj;
  t_float x_f;
t_outlet *x_outlet0;
bool x_initialized;
  bool x_auto_open;
t_int        x_packet;
  t_pdp*       x_header;
  short int    *x_data;
  unsigned char *x_sdata; // static data to hold the grabbed images
unsigned int x_width;
  unsigned int x_height;
  unsigned int x_size;
  int          x_channel;
  pthread_t    x_thread_id;
  int          x_continue_thread;
  unsigned int x_framerate;
  int          x_frame_ready;
  t_int        x_quality;
SeqGrabComponent x_sg;   
  SGChannel        x_vc;  
  short            x_pixelDepth;
  Rect             x_srcRect;  
  GWorldPtr        x_srcGWorld;
  PixMapHandle     x_pixMap;  
  Ptr              x_baseAddr;
  long             x_rowBytes;
} t_pdp_ieee1394;
static void pdp_ieee1394_close(t_pdp_ieee1394 *x)
{
  void *dummy;
/* terminate thread if there is one */
    if(x->x_continue_thread)
    {
    x->x_continue_thread = 0;
    // pthread_join (x->x_thread_id, &dummy);
    }
// free sequence grabber
    // if (x->x_vc) 
    // {
    //   if (SGDisposeChannel(x->x_sg, x->x_vc)) 
    //   {
    //     post("pdp_ieee1394: unable to dispose video channel");
    //   }
    //   x->x_vc = NULL;
    //   post("pdp_ieee1394: disposed video channel");
    // }
    // if (x->x_sg) 
    // {
    //   if (CloseComponent(x->x_sg)) 
    //   {
    //     post("pdp_ieee1394: unable to free sequence grabber.");
    //   }
    //   x->x_sg = NULL;
    //   post("pdp_ieee1394: freed sequence grabber.");
    // }
    // if (x->x_srcGWorld) 
    // {
    //     DisposeGWorld(x->x_srcGWorld);
    //     post("pdp_ieee1394: disposed world.");
    //     x->x_srcGWorld = NULL;
    // }
}
static void pdp_ieee1394_capture_frame(t_pdp_ieee1394* x)
{
  OSErr       err;
err = SGIdle(x->x_sg);
    if (err != noErr)
    {
      post("pdp_ieee1394: SGIdle failed.");
      x->x_frame_ready = 0;
    } 
    else 
    {
      x->x_frame_ready = 1;
    }
}
static void *pdp_ieee1394_thread(void *voidx)
{
  t_pdp_ieee1394 *x = ((t_pdp_ieee1394 *)voidx);
/* capture with a double buffering scheme */
    while (true)
    {
      if (x->x_continue_thread)
      {
    /* schedule capture command for next frame */
    pdp_ieee1394_capture_frame(x);
      }
      else
      {
        sleep(1);
      }
    }
x->x_thread_id = 0;
    return 0;
}
static void pdp_ieee1394_reset(t_pdp_ieee1394 *x)
{
  OSErr anErr;
if ( !x->x_initialized )
  {
    post("pdp_ieee1394: trying to reset but the sequence grabber is not initialized");
    return;
  }
post("pdp_ieee1394: resetting....");
switch (x->x_quality)
  {
    case 0:
        anErr = SGSetChannelPlayFlags(x->x_vc, channelPlayNormal);
        post("pdp_ieee1394: set sequence grabber to : normal quality");
        break;
    case 1:
        anErr = SGSetChannelPlayFlags(x->x_vc, channelPlayHighQuality);
        post("pdp_ieee1394: set sequence grabber to : high quality");
        break;
    case 2:
        anErr = SGSetChannelPlayFlags(x->x_vc, channelPlayFast);
        post("pdp_ieee1394: set sequence grabber to : fast quality");
        break;
    case 3:
        anErr = SGSetChannelPlayFlags(x->x_vc, channelPlayAllData);
        post("pdp_ieee1394: set sequence grabber to : play all data");
        break;
    }
post("pdp_ieee1394: done.");
}
static void pdp_ieee1394_quality(t_pdp_ieee1394 *x, t_floatarg fquality)
{
  if ( ( (t_int)fquality < 0 ) || ( (t_int)fquality > 3 ) )
  {
     post("pdp_ieee1394: wrong quality %d", (t_int)fquality );
     return;
  }
  else
  {
     x->x_quality = (t_int)fquality;
  }
}
static void pdp_ieee1394_free(t_pdp_ieee1394 *x)
{
    pdp_ieee1394_close(x);
}
static t_int pdp_ieee1394_init_grabber(t_pdp_ieee1394 *x)
{
  OSErr anErr;
  x->x_srcRect.top = 0;
  x->x_srcRect.left = 0;
  x->x_srcRect.bottom = x->x_height;
  x->x_srcRect.right = x->x_width;
x->x_sg = OpenDefaultComponent(SeqGrabComponentType, 0);
  if(x->x_sg==NULL)
  {
    post("pdp_ieee1394: could not open default component");
    return -1;
  }    
  else
  {
    post("pdp_ieee1394: opened default component");
  }
anErr = SGInitialize(x->x_sg);
  if(anErr!=noErr)
  {
    post("pdp_ieee1394: could not initialize sequence grabber");
    return -1;
  }
  else
  {
    post("pdp_ieee1394: initialized sequence grabber");
  }
anErr = SGSetDataRef(x->x_sg, 0, 0, seqGrabDontMakeMovie);
  if (anErr != noErr)
  {
    post("pdp_ieee1394: couldn't set data ref");
    return -1;
  }
  else
  {
    post("pdp_ieee1394: set data ref ok.");
  }
anErr = SGNewChannel(x->x_sg, VideoMediaType, &x->x_vc);
  if(anErr!=noErr)
  {
    post("pdp_ieee1394: could not create new sequence grabber channnel");
    return -1;
  }
  else
  {
    post("pdp_ieee1394: created new sequence grabber channnel.");
  }
anErr = SGSetChannelBounds(x->x_vc, &x->x_srcRect);
  if(anErr!=noErr)
  {
    post("pdp_ieee1394: could not set sequence grabber ChannelBounds ");
    return -1;
  }
  else
  {
    post("pdp_ieee1394: set sequence grabber ChannelBounds");
  }
anErr = SGSetChannelUsage(x->x_vc, seqGrabPreview);
  if(anErr!=noErr)
  {
    post("pdp_ieee1394: could not set sequence grabber ChannelUsage ");
    return -1;
  }
  else
  {
    post("pdp_ieee1394: set sequence grabber ChannelUsage");
  }
switch (x->x_quality)
  {
    case 0:
        anErr = SGSetChannelPlayFlags(x->x_vc, channelPlayNormal);
        post("pdp_ieee1394: set sequence grabber to : normal quality");
        break;
    case 1:
        anErr = SGSetChannelPlayFlags(x->x_vc, channelPlayHighQuality);
        post("pdp_ieee1394: set sequence grabber to : high quality");
        break;
    case 2:
        anErr = SGSetChannelPlayFlags(x->x_vc, channelPlayFast);
        post("pdp_ieee1394: set sequence grabber to : fast quality");
        break;
    case 3:
        anErr = SGSetChannelPlayFlags(x->x_vc, channelPlayAllData);
        post("pdp_ieee1394: set sequence grabber to : play all data");
        break;
  }
anErr = QTNewGWorldFromPtr (&x->x_srcGWorld,
                              k422YpCbCr8CodecType,
                              &x->x_srcRect,
                              NULL,
                              NULL,
                              0,
                              x->x_sdata,
                              x->x_width*2);
  if (anErr!= noErr)
  {
    post ("pdp_ieee1394: QTNewGWorldFromPtr returned %d", anErr);
    return -1;
  }
if (NULL == x->x_srcGWorld)
  {
    post ("pdp_ieee1394: could not allocate off screen");
    return -1;
  }
  SGSetGWorld(x->x_sg,(CGrafPtr)x->x_srcGWorld, NULL);
  SGStartPreview(x->x_sg);
return 0;
}
static void pdp_ieee1394_open(t_pdp_ieee1394 *x)
{
x->x_initialized = true;
    x->x_continue_thread = 1;
/* create thread */
    if ( x->x_thread_id == 0 )
    {
      if ( pdp_ieee1394_init_grabber( x ) != 0 )
      {
        post("pdp_ieee1394: grabber initialization failed");
        return;
      }
      x->x_frame_ready = 0;
      pthread_create(&x->x_thread_id, 0, pdp_ieee1394_thread, x);
    }
}
static void pdp_ieee1394_bang(t_pdp_ieee1394 *x)
{
  unsigned char *pQ;
  short int *pY, *pU, *pV;
  t_int px, py;
if (!(x->x_continue_thread))
    {
      post("pdp_ieee1394: not initialized.");
if (x->x_auto_open)
      {
        post("pdp_ieee1394: attempting auto open");
        pdp_ieee1394_open(x);
        if (!(x->x_initialized))
        {
          post("pdp_ieee1394: auto open failed");
          return;
        }
      }
      else return;
    }
/* do nothing if there is no frame ready */
    if (!x->x_frame_ready) return;
x->x_packet = pdp_packet_new_image_YCrCb(x->x_width, x->x_height);
    x->x_header = pdp_packet_header(x->x_packet);
if (!x->x_header) 
    {
      post("pdp_ieee1394: FATAL: can't allocate packet");
      return;
    }
x->x_data = (short int *) pdp_packet_data(x->x_packet);
    memset( x->x_data, 0x0, (x->x_size+(x->x_size>>1))<<1 );
    pQ = x->x_sdata;
    pY = x->x_data;
    pV = x->x_data+x->x_size;
    pU = x->x_data+x->x_size+(x->x_size>>2);
    for ( py=0; py<(t_int)x->x_height; py++ )
    {
      for ( px=0; px<(t_int)x->x_width; px++ )
      {
        *(pY+py*x->x_width+px) = (*(pQ+1+2*(py*x->x_width+px)))<<7;
        if ( px%2 == 0 )
        {
          *(pU+((py>>1)*(x->x_width>>1)+(px>>1))) = (*(pQ+2*(py*x->x_width+px))-128)<<8;
        }
        if ( px%2 == 1 )
        {
          *(pV+((py>>1)*(x->x_width>>1)+(px>>1))) = (*(pQ+2*(py*x->x_width+px))-128)<<8;
        }
      }
    }
pdp_packet_pass_if_valid(x->x_outlet0, &x->x_packet);
x->x_frame_ready = 0;
}
t_class *pdp_ieee1394_class;
void *pdp_ieee1394_new(t_floatarg fwidth, t_floatarg fheight)
{
  t_pdp_ieee1394 *x = (t_pdp_ieee1394 *)pd_new(pdp_ieee1394_class);
x->x_outlet0 = outlet_new(&x->x_obj, &s_anything);
    x->x_initialized = false;
x->x_auto_open = true;
x->x_continue_thread = 0;
if (fwidth > 0.)
    {
      x->x_width = (int)fwidth;
    }
    else
    {
      x->x_width = DEFAULT_WIDTH;
    }
if (fheight > 0.)
    {
      x->x_height = (int)fheight;
    }
    else
    {
      x->x_height = DEFAULT_WIDTH;
    }
    x->x_size = x->x_width*x->x_height;
    x->x_sdata = (unsigned char*) getbytes( (x->x_size+(x->x_size>>1))<<1 );
    if ( !x->x_sdata )
    {
      post ("pdp_ieee1394: FATAL : couldn't allocate static data.");
      return NULL;
    }
x->x_quality = 1;
    x->x_thread_id = 0;
return (void *)x;
}
#ifdef __cplusplus
extern "C"
{
#endif
void pdp_ieee1394_setup(void)
{
    pdp_ieee1394_class = class_new(gensym("pdp_ieee1394"), (t_newmethod)pdp_ieee1394_new,
    	(t_method)pdp_ieee1394_free, sizeof(t_pdp_ieee1394), 0, A_DEFFLOAT, A_DEFFLOAT, A_NULL);
class_addmethod(pdp_ieee1394_class, (t_method)pdp_ieee1394_bang, gensym("bang"), A_NULL);
    class_addmethod(pdp_ieee1394_class, (t_method)pdp_ieee1394_close, gensym("close"), A_NULL);
    class_addmethod(pdp_ieee1394_class, (t_method)pdp_ieee1394_open, gensym("open"), A_NULL);
    class_addmethod(pdp_ieee1394_class, (t_method)pdp_ieee1394_reset, gensym("reset"), A_NULL);
    class_addmethod(pdp_ieee1394_class, (t_method)pdp_ieee1394_quality, gensym("quality"), A_DEFFLOAT, A_NULL);
}
#ifdef __cplusplus
}
#endif
--- NEW FILE: pdp_mp4audiosource.cpp ---
/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is MPEG4IP.
 * 
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2000-2002.  All Rights Reserved.
 * 
 * Contributor(s): 
 *		Dave Mackie		dmackie@cisco.com
 *		Bill May 		wmay@cisco.com
 *
 * Adapted for PD/PDP by Yves Degoyon (ydegoyon@free.fr)
 */
#include "m_pd.h"
#ifndef debug_message
#define debug_message post
#endif
#include "pdp_mp4audiosource.h"
//#define DEBUG_TIMESTAMPS 1
CPDPAudioSource::CPDPAudioSource(CLiveConfig *pConfig) : CMediaSource() 
{
  SetConfig(pConfig);
m_pcmFrameBuffer = NULL;
  m_prevTimestamp = 0;
  m_timestampOverflowArray = NULL;
  m_timestampOverflowArrayIndex = 0;
  m_audioOssMaxBufferSize = 0;
}
int CPDPAudioSource::ThreadMain(void) 
{
  // just a stub, we don't use the threaded mode
  return 0;
}
void CPDPAudioSource::DoStart()
{
  if (m_source) {
    return;
  }
if (!Init()) {
    return;
  }
m_source = true;
}
void CPDPAudioSource::DoStop()
{
  if (!m_source) {
    return;
  }
CMediaSource::DoStopAudio();
CHECK_AND_FREE(m_timestampOverflowArray);
  free(m_pcmFrameBuffer);
  m_pcmFrameBuffer = NULL;
m_source = false;
}
bool CPDPAudioSource::Init(void)
{
  bool rc = InitAudio(true);
  if (!rc) {
    return false;
  }
m_channelsConfigured = m_pConfig->GetIntegerValue(CONFIG_AUDIO_CHANNELS);
debug_message("pdp_mp4live~ : init audio : (m_audioDstChannels=%d m_audioDstSampleRate=%d )", 
                           m_audioDstChannels, m_audioDstSampleRate);
rc = SetAudioSrc(PCMAUDIOFRAME,
                   m_channelsConfigured,
                   m_pConfig->GetIntegerValue(CONFIG_AUDIO_SAMPLE_RATE));
if (!rc) {
    return false;
  }
debug_message("pdp_mp4live~ : set audio src : (m_audioDstSamplesPerFrame=%d m_audioSrcChannels=%d)", 
                           m_audioDstSamplesPerFrame, m_audioSrcChannels);
// for live capture we can match the source to the destination
  m_audioSrcSamplesPerFrame = m_audioDstSamplesPerFrame;
  m_pcmFrameSize = 
    m_audioSrcSamplesPerFrame * m_audioSrcChannels * sizeof(u_int16_t);
if (m_audioOssMaxBufferSize > 0) {
    size_t array_size;
    m_audioOssMaxBufferFrames = m_audioOssMaxBufferSize / m_pcmFrameSize;
    array_size = m_audioOssMaxBufferFrames * sizeof(*m_timestampOverflowArray);
    m_timestampOverflowArray = (Timestamp *)malloc(array_size);
    memset(m_timestampOverflowArray, 0, array_size);
  }
m_pcmFrameBuffer = (u_int8_t*)malloc(m_pcmFrameSize);
  if (!m_pcmFrameBuffer) {
    goto init_failure;
  }
// maximum number of passes in ProcessAudio, approx 1 sec.
  m_maxPasses = m_audioSrcSampleRate / m_audioSrcSamplesPerFrame;
debug_message("pdp_mp4live~ : audio source initialization done : ( frame size=%d )", m_pcmFrameSize );
return true;
init_failure:
  debug_message("pdp_mp4live~ : audio initialization failed");
free(m_pcmFrameBuffer);
  m_pcmFrameBuffer = NULL;
return false;
}
void CPDPAudioSource::ProcessAudio(u_int8_t* pcmBuffer, u_int32_t pcmBufferSize)
{
  audio_buf_info info;
  Timestamp currentTime = GetTimestamp();
  Timestamp timestamp;
if ( pcmBufferSize > m_pcmFrameSize )
    {
       debug_message( "pdp_mp4live~ : too many audio samples : %d should be %d",
                      pcmBufferSize, m_pcmFrameSize );
       memcpy( m_pcmFrameBuffer, pcmBuffer, m_pcmFrameSize );
    }
    else if ( pcmBufferSize < m_pcmFrameSize )
    {
       debug_message( "pdp_mp4live~ : too little audio samples : %d should be %d",
                      pcmBufferSize, m_pcmFrameSize );
       memcpy( m_pcmFrameBuffer, pcmBuffer, pcmBufferSize );
    }
    else
    {
       memcpy( m_pcmFrameBuffer, pcmBuffer, pcmBufferSize );
    }
if (info.bytes == m_audioOssMaxBufferSize) {
      // means the audio buffer is full, and not capturing
      // we want to make the timestamp based on the previous one
      // When we hit this case, we start using the m_timestampOverflowArray
      // This will give us a timestamp for when the array is full.
      // 
      // In other words, if we have a full audio buffer (ie: it's not loading
      // any more), we start storing the current timestamp into the array.
      // This will let us "catch up", and have a somewhat accurate timestamp
      // when we loop around
      // 
      // wmay - I'm not convinced that this actually works - if the buffer
      // cleans up, we'll ignore m_timestampOverflowArray
      if (m_timestampOverflowArray != NULL && 
      m_timestampOverflowArray[m_timestampOverflowArrayIndex] != 0) {
    timestamp = m_timestampOverflowArray[m_timestampOverflowArrayIndex];
      } else {
    timestamp = m_prevTimestamp + SrcSamplesToTicks(m_audioSrcSamplesPerFrame);
      }
if (m_timestampOverflowArray != NULL)
    m_timestampOverflowArray[m_timestampOverflowArrayIndex] = currentTime;
debug_message("pdp_mp4live~ : audio buffer full !");
} else {
      // buffer is not full - so, we make the timestamp based on the number
      // of bytes in the buffer that we read.
      timestamp = currentTime - SrcSamplesToTicks(SrcBytesToSamples(info.bytes));
      if (m_timestampOverflowArray != NULL)
    m_timestampOverflowArray[m_timestampOverflowArrayIndex] = 0;
    }
#ifdef DEBUG_TIMESTAMPS
    debug_message("pdp_mp4live~ : info.bytes=%d t=%llu timestamp=%llu delta=%llu",
                  info.bytes, currentTime, timestamp, timestamp - m_prevTimestamp);
#endif
m_prevTimestamp = timestamp;
    if (m_timestampOverflowArray != NULL) {
      m_timestampOverflowArrayIndex = (m_timestampOverflowArrayIndex + 1) % 
    m_audioOssMaxBufferFrames;
    }
ProcessAudioFrame(m_pcmFrameBuffer, m_pcmFrameSize, timestamp, false);
}
--- NEW FILE: pdp_mp4playermedia.cpp ---
/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is MPEG4IP.
 * 
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2000, 2001.  All Rights Reserved.
 * 
 * Contributor(s): 
 *              Bill May        wmay@cisco.com
[...1990 lines suppressed...]
    double secs;
    secs = last_div;
    secs /= 1000.0;
    secs += total_secs;
fps = frames_decoded;
    fps /= secs;
    bps = UINT64_TO_DOUBLE(bytes_decoded);
    bps *= 8.0 / secs;
    media_message(LOG_NOTICE, "%s - bytes "U64", seconds %g, fps %g bps "U64,
    	  m_is_video ? "video" : "audio", 
    	  bytes_decoded, secs, 
    	  fps, bytes_decoded * 8 / total_secs);
  }
  if (m_plugin) {
    m_plugin->c_close(m_plugin_data);
    m_plugin_data = NULL;
  }
  return (0);
}