datasource.h

彩信浏览器

/*
 * This file is part of Ambulant Player, www.ambulantplayer.org.
 *
 * Copyright (C) 2003-2007 Stichting CWI, 
 * Kruislaan 413, 1098 SJ Amsterdam, The Netherlands.
 *
 * Ambulant Player is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * Ambulant Player 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with Ambulant Player; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

 
#ifndef AMBULANT_NET_DATASOURCE_H
#define AMBULANT_NET_DATASOURCE_H

#include "ambulant/config/config.h"

#include "ambulant/lib/callback.h"
#include "ambulant/lib/refcount.h"
#include "ambulant/lib/event_processor.h"
#include "ambulant/lib/thread.h"
#include "ambulant/common/playable.h"
#include "ambulant/net/url.h"
#include "ambulant/net/databuffer.h"
#ifdef AMBULANT_PLATFORM_UNIX
#include <stdint.h>
#include "ambulant/lib/unix/unix_thread.h"
#endif
#ifdef _MSC_VER
#pragma warning(disable : 4251)
#endif

namespace ambulant {

namespace net {

	
#ifdef AMBULANT_HAS_LONG_LONG
  	typedef long long int timestamp_t; ///< Time value in microseconds.
#else
	typedef INT64 timestamp_t; ///< Time value in microseconds.
#endif
	
/// This struct completely describes an audio format.
/// If name is "" the format is linear samples encoded
/// in host order, and samplerate, channels and bits
/// are meaningful. If name is nonempty it is some encoded
/// format, parameters points to format-specific data
/// and samplerate/channels/bits are not meaningful.
struct audio_format {	
	std::string mime_type; ///< Mimetype of the format, or "audio/unknown"
	std::string name;	///< Name of the format, or empty for linear samples
	void *parameters;	///< For a named format, pointer to parameters
	int samplerate;		///< For linear samples: the samplerate
	int channels;		///< For linear samples: the number of channels
	int bits;			///< For linear samples: the numer of bits per sample.
	
	/// Default constructor: creates unknown audio_format.
	audio_format()
	:   mime_type("audio/unknown"),
		name("unknown"),
		parameters(NULL),
		samplerate(0),
		channels(0),
		bits(0) {};
		
	/// Constructor for linear samples, pass samplerate, number of channels, bits per sample.
	audio_format(int s, int c, int b)
	:   mime_type("audio/unknown"),
		name(""),
		parameters(NULL),
		samplerate(s),
		channels(c),
		bits(b) {};
	
	/// Constructor for named audio_format, optionally pass extra format-dependent info.
	audio_format(const std::string &n, void *p=(void *)0)
	:   mime_type("audio/unknown"),
		name(n),
		parameters(p),
		samplerate(0),
		channels(0),
		bits(0) {};
		
	/// Constructor for named audio_format, optionally pass extra format-dependent info.
	audio_format(const char *n, void *p=(void *)0)
	:   mime_type("audio/unknown"),
		name(n),
		parameters(p),
		samplerate(0),
		channels(0),
		bits(0) {};
};

/// This struct completely describes a video format.
/// If name is "" the format is a sequence of uncompressed images.
/// Parameters may be 0 if the values are not known.
struct video_format {
	
	std::string mime_type;      ///< Mimetype of the format, or "video/unknown"
	std::string name;			///< Name of the format
	void *parameters;			///< For a named format, pointer to parameters
	timestamp_t frameduration;	///< For linear samples: the samplerate
	int width;					/// The width of the video
	int height;					///	The height of the video
	
	/// Default constructor: creates unknown video_format.
	video_format()
	:   mime_type("video/unknown"),
		name("unknown"),
		parameters(NULL),
		frameduration(0),
		width(0),
		height(0) {};
		
	/// Constructor for named video_format.
	video_format(std::string &n, void *p=(void *)0)
	:   mime_type("video/unknown"),
		name(n),
		parameters(p),
		frameduration(0),
		width(0),
		height(0) {};
		
	/// Constructor for named video_format.
	video_format(const char *n, void *p=(void *)0)
	:   mime_type("video/unknown"),
		name(n),
		parameters(p),
		frameduration(0),
		width(0),
		height(0) {};
};

#ifdef __OBJC__
// This is a workaround for a problem when using gcc 3.3 to compile
// ObjC++
;
#endif

// This class describes the range of audio formats supported by a consumer.
// It always contains at least one supported format.
// The design assumes that support for various sample rates, channels and
// bits are independent variables. In addition, an audio_format_choices
// can support both various linear formats and named formats.
class audio_format_choices {
  public:
  
	/// Default constructor: support no formats.
	audio_format_choices();
	
	/// Constructor using a single audio_format.
	audio_format_choices(const audio_format &fmt);
	
	/// Constructor using a linear sample format. 
	audio_format_choices(int samplerate, int channels, int bits);
	
	/// Constructor using a named format.
	audio_format_choices(const std::string &name);
	
	/// Return the best (highest quality) format.
	const audio_format& best() const;
	
	/// Add support for an additional samplerate.
	void add_samplerate(int samplerate);
	
	/// Add support for an additional number of channels.
	void add_channels(int channels);
	
	/// Add support for an addition number of bits per sample.
	void add_bits(int bits);
	
	/// Add support for an additional named format.
	void add_named_format(const std::string &name);
	
	/// Return true if the audio_format argument matches any of the supported formats.
	bool contains(const audio_format& fmt) const;
	
  private:
	audio_format m_best;
	std::set<int> m_samplerate;
	std::set<int> m_channels;
	std::set<int> m_bits;
	std::set<std::string> m_named_formats;
};

struct ts_packet_t { timestamp_t timestamp; void* data; int size; 
	ts_packet_t(timestamp_t t, void* d, int s) 
	  : timestamp(t), data(d), size(s) {}
};
/// The interface to an object that supplies data to a consumer.
/// The consumer calls start() whenever it wants
/// data. This call returns immedeately and later the datasource arranges
/// that the callback is done, when data is available. The consumer then
/// calls size(), get_read_ptr() and end_of_file() to get available data size,
/// pointer and status. Whenever the consumer has consumed some bytes it calls
/// read_done().
class AMBULANTAPI datasource : virtual public ambulant::lib::ref_counted {  	
  public:
	virtual ~datasource() {};

	/// Called by the client to indicate it wants more data.
	/// When the data is available (or end of file reached) exactly one
	/// callback is scheduled through the event_processor.
	virtual void start(ambulant::lib::event_processor *evp, ambulant::lib::event *callback) = 0;
	
	/// Called by the client to indicate it wants no more data.
	virtual void stop() = 0;

	/// Return true if all data has been consumed.
	virtual bool end_of_file() = 0;
	
	/// Return a pointer to the current data.
	/// Should only be called from the callback routine.
	virtual char* get_read_ptr() = 0;
	
	/// Return the number of bytes available at get_read_ptr().
	virtual int size() const = 0;		

	/// Called by the client to signal it has consumed len bytes.
	virtual void readdone(int len) = 0;
};

class AMBULANTAPI pkt_datasource : virtual public ambulant::lib::ref_counted {  	
  public:
	virtual ~pkt_datasource() {};

	/// Called by the client to indicate it wants more data.
	/// When the data is available (or end of file reached) exactly one
	/// callback is scheduled through the event_processor.
	virtual void start(ambulant::lib::event_processor *evp, ambulant::lib::event *callback) = 0;
	
	/// Called by the client to indicate it wants no more data.
	virtual void stop() = 0;

	/// Return true if all data has been consumed.
	virtual bool end_of_file() = 0;
	
	/// Return the next timestamped packet and discard it.
	virtual ts_packet_t get_ts_packet_t() = 0;
};

/// Interface to an object that supplies audio data to a consumer.
/// Audio_datasource extends the datasource protocol with methods to obtain
/// information on the way the audio data is encoded and methods to support
/// temporal clipping of the audio.
class audio_datasource_mixin {
  public:
	virtual ~audio_datasource_mixin() {};
	/// Returns the native format of the audio data.
	virtual audio_format& get_audio_format() = 0;
	/// Tells the datasource to start reading data starting from time t.
	virtual void read_ahead(timestamp_t time) = 0; 
	/// At what timestamp value should the audio playback stop?
	virtual timestamp_t get_clip_end() = 0;
	/// At what timestamp value should audio playback start?	
	virtual timestamp_t get_clip_begin() = 0;
	/// returns m_clip_begin if the datasource took care of clip_begin otherwise it returns 0
	virtual timestamp_t get_start_time() = 0;
	/// Return the duration of the audio data, if known.
	virtual common::duration get_dur() = 0;
};

class audio_datasource : public datasource, public audio_datasource_mixin {
  public:
	virtual ~audio_datasource() {};
};

class pkt_audio_datasource : public pkt_datasource, public audio_datasource_mixin {
  public:
	virtual ~pkt_audio_datasource() {};
};

/// Implementation of audio_datasource that reads raw audio data from a datasource.
class raw_audio_datasource: 
	virtual public audio_datasource,
	virtual public lib::ref_counted_obj
{
  public:
	raw_audio_datasource(datasource* src) : 
  		m_src(src),
		m_fmt(audio_format(0,0,0)),
		m_duration(false,0.0)  {};
  	~raw_audio_datasource() {};
  	

    void start(lib::event_processor *evp, lib::event *callback) { m_src->start(evp,callback); };
	void stop() { m_src->stop(); };  
	void read_ahead(timestamp_t time){};
  	void seek(timestamp_t time){};
    void readdone(int len) { m_src->readdone(len); };
    bool end_of_file() { return m_src->end_of_file(); };
	bool buffer_full() { return false; };
  	timestamp_t get_clip_end() { return -1; };
	timestamp_t get_clip_begin() { return 0; };
	timestamp_t get_start_time() { return 0; };
	char* get_read_ptr() { return m_src->get_read_ptr(); };
	int size() const { return m_src->size(); };   
	audio_format& get_audio_format() { return m_fmt; };

	common::duration get_dur() {	return m_duration; };
  
  private:
	datasource* m_src;
  	audio_format m_fmt;
  	common::duration m_duration;
		
};

/// Interface to an object that supplies video data to a consumer.
// Video_datasource is *not* a subclass of datasource: it does not deliver a stream
// of bytes (like datasource and audio_datasource) but a stream of images.
// It also has an ad-hoc method to determine whether audio is available too, and obtain
// a datasource for that.