sdl_audio.cpp

彩信浏览器

		m_lock.leave();
		unregister_renderer(this);
		m_lock.enter();
	}
	
	if (m_audio_src) {
		m_audio_src->release();
		m_audio_src = NULL;
	}
	
	if (m_transition_engine) {
		delete m_transition_engine;
		m_transition_engine = NULL;
	}
	m_is_playing = false;
	m_lock.leave();
}

void
gui::sdl::sdl_audio_renderer::set_intransition(const lib::transition_info* info) {
 	if (m_transition_engine)
		delete m_transition_engine;
	m_intransition = info;
	m_transition_engine = new smil2::audio_transition_engine();
	m_transition_engine->init(m_event_processor, false, info);
}

void
gui::sdl::sdl_audio_renderer::start_outtransition(const lib::transition_info* info) {
 	if (m_transition_engine)
		delete m_transition_engine;
	m_outtransition = info;
	m_transition_engine = new smil2::audio_transition_engine();
	m_transition_engine->init(m_event_processor, true, info);
}

int
gui::sdl::sdl_audio_renderer::get_data(int bytes_wanted, Uint8 **ptr)
{
	m_lock.enter();
	
	// turned this of because I think here also happends a get_read_ptr when it should not
	//XXXX sometimes we get this one in News when changing video itmes
	
	assert(m_is_playing);
	int rv;
	*ptr = NULL;
	if (m_is_paused||!m_audio_src) { 
		rv = 0;
		m_read_ptr_called = false;
	} else {
		AM_DBG lib::logger::get_logger()->debug("sdl_audio_renderer::get_data: m_audio_src->get_read_ptr(), m_audio_src=0x%x, this=0x%x", (void*) m_audio_src, (void*) this);
		m_read_ptr_called = true;
		rv = m_audio_src->size();
		*ptr = (Uint8 *) m_audio_src->get_read_ptr();
		if (rv) assert(*ptr);
		if (rv > bytes_wanted)
			rv = bytes_wanted;
		// Also set volume(s)
		m_volcount = 0;
		if (m_dest) {
			const common::region_info *info = m_dest->get_info();
			double level = info ? info->get_soundlevel() : 1.0;
			if (m_intransition || m_outtransition) {
				level = m_transition_engine->get_volume(level);
			}
			double leftlevel, rightlevel;
			leftlevel = rightlevel = level;
			if (info) {
				common::sound_alignment align = info->get_soundalign();
				if (align == common::sa_left) {
					rightlevel = 0.0;
				}
				if (align == common::sa_right) {
					leftlevel = 0.0;
				}
			}
			if (leftlevel == 1.0 && rightlevel == 1.0)
				m_volcount = 0;
			else if (leftlevel == rightlevel) {
				m_volcount = 1;
				m_volumes[0] = leftlevel;
			} else {
				m_volcount = 2;
				m_volumes[0] = leftlevel;
				m_volumes[1] = rightlevel;
			}
		}
	}
	m_lock.leave();
	AM_DBG lib::logger::get_logger()->debug("sdl_audio_renderer::get_data(0x%x) return rv=%d, m_volcount=%d, m_volumes=[%f,%f]",this,rv,m_volcount,m_volcount>=1?m_volumes[0]:1,m_volcount==2?m_volumes[1]:m_volcount==1?0:1);
	return rv;
}

void
gui::sdl::sdl_audio_renderer::get_data_done(int size)
{
	m_lock.enter();
	// Acknowledge that we are ready with the data provided to us
	// at the previous callback time
	//AM_DBG if (m_audio_src) lib::logger::get_logger()->debug("sdl_audio_renderer::get_data_done: m_src->readdone(%d), %d more", size, m_audio_src->size()-size);
	//if (size) {
	if (m_audio_src) {

		if (m_read_ptr_called) {
			AM_DBG lib::logger::get_logger()->debug("sdl_audio_renderer::get_data_done: calling m_audio_src->readdone(%d) m_audio_src=0x%x, this = (x%x)", size, (void*) m_audio_src, (void*) this);
			m_audio_src->readdone(size);
			m_read_ptr_called = false;
		}

	}
	bool still_busy;
	still_busy = (size != 0);
	still_busy |= restart_audio_input();
	if (!still_busy) {
		AM_DBG lib::logger::get_logger()->debug("sdl_audio_renderer::playdone: calling m_context->stopped() this = (x%x)",this);
		// We cannot call unregister_renderer from here, because we are called from the
		// SDL callback and already holding the m_global_lock. So, in stead
		// we use the event processor to unregister ourselves later.
		lib::event *e = new readdone_callback(this, &sdl_audio_renderer::stop);
		m_event_processor->add_event(e, 0, ambulant::lib::ep_med);
		if (m_audio_src) {
			m_audio_src->stop();
			m_audio_src->release();
			m_audio_src = NULL;
		}
		m_lock.leave();
		if (m_context) {
			m_context->stopped(m_cookie, 0);
		} else {
			AM_DBG lib::logger::get_logger()->trace("sdl_audio_renderer(0x%x): m_context is  NULL", (void*)this);
		}
		return;
	}
	m_lock.leave();
}

bool
gui::sdl::sdl_audio_renderer::restart_audio_input()
{
	// private method - no need to lock.
	if (!m_audio_src || m_audio_src->end_of_file() || !m_is_playing) {
		// No more data.
		return false;
	}
	if (m_audio_src->size() < s_min_buffer_size_bytes ) {
		// Start reading 
		lib::event *e = new readdone_callback(this, &sdl_audio_renderer::data_avail);
		m_audio_src->start(m_event_processor, e);
	}
	return true;
}

void
gui::sdl::sdl_audio_renderer::data_avail()
{
	m_lock.enter();
	//assert(m_audio_src);
	if (!m_audio_src) {				
		AM_DBG lib::logger::get_logger()->debug("sdl_audio_renderer::data_avail: m_audio_src already deleted");
		m_lock.leave();
		return;
	}
	AM_DBG lib::logger::get_logger()->debug("sdl_audio_renderer::data_avail: %d bytes available", m_audio_src->size());
	
	restart_audio_input();
	
	m_lock.leave();
	AM_DBG lib::logger::get_logger()->debug("sdl_audio_renderer::data_avail: done");
}	

bool
gui::sdl::sdl_audio_renderer::is_paused()
{
	m_lock.enter();
	bool rv;
	rv = m_is_paused;
	m_lock.leave();
	return rv;
}

bool
gui::sdl::sdl_audio_renderer::is_stopped()
{
	m_lock.enter();
	bool rv;
	rv = !m_is_playing;
	m_lock.leave();
	return rv;
}

bool
gui::sdl::sdl_audio_renderer::is_playing()
{
	m_lock.enter();
	bool rv;
	rv = m_is_playing;
	m_lock.leave();
	return rv;
}


void
gui::sdl::sdl_audio_renderer::stop()
{
	m_lock.enter();
	AM_DBG lib::logger::get_logger()->debug("sdl_audio_renderer::stop(0x%x)",(void*)this);
	if (m_is_playing) {
		m_lock.leave();
		unregister_renderer(this);
		// XXX Should we call stopped_callback?
		m_context->stopped(m_cookie, 0);
		m_lock.enter();
	}
	m_is_playing = false;
	if (m_audio_src) {
		m_audio_src->stop();
		m_audio_src->release();
		m_audio_src = NULL;
	}
	m_lock.leave();
}

void
gui::sdl::sdl_audio_renderer::pause(common::pause_display d)
{
	m_lock.enter();
	m_is_paused = true;
	m_lock.leave();
}

void
gui::sdl::sdl_audio_renderer::resume()
{
	m_lock.enter();
	m_is_paused = false;
	m_lock.leave();
}

void
gui::sdl::sdl_audio_renderer::start(double where)
{
	m_lock.enter();
    if (!m_node) abort();
		
	AM_DBG lib::logger::get_logger()->debug("sdl_audio_renderer.start(0x%x)", (void *)this);
	if (m_audio_src) {
	
		if (m_audio_src->get_start_time() != m_audio_src->get_clip_begin())
			lib::logger::get_logger()->trace("sdl_audio_renderer: warning: datasource does not support clipBegin");
			
		lib::event *e = new readdone_callback(this, &sdl_audio_renderer::data_avail);
		AM_DBG lib::logger::get_logger()->debug("sdl_audio_renderer::start(): m_audio_src->start(0x%x, 0x%x) this = (x%x)m_audio_src=0x%x", (void*)m_event_processor, (void*)e, this, (void*)m_audio_src);
		m_audio_src->start(m_event_processor, e);
		m_is_playing = true;
		m_is_paused = false;
		m_lock.leave();
		register_renderer(this);
		if (m_intransition && ! m_transition_engine) {
			m_transition_engine = new smil2::audio_transition_engine();
			m_transition_engine->init(m_event_processor, false, m_intransition);
		}
	} else {
		AM_DBG lib::logger::get_logger()->debug("sdl_audio_renderer.start: no datasource");
		m_lock.leave();
		m_context->stopped(m_cookie, 0);
	}
}

void
gui::sdl::sdl_audio_renderer::seek(double where)
{
	lib::logger::get_logger()->trace("sdl_audio_renderer: seek(%f) not implemented", where);
}

common::duration 
gui::sdl::sdl_audio_renderer::get_dur()
{
	common::duration rv(false, 0.0);
	m_lock.enter();
	if (m_audio_src)
		rv = m_audio_src->get_dur();
	m_lock.leave();
	return rv;
}