packet_decoder.h

Go to the documentation of this file.

class NOVTABLE packet_decoder : public service_base {
protected:
    static bool g_is_our_setup(const GUID & p_owner,t_size p_param1,const void * p_param2,t_size p_param2size) {return false;}

    void open(const GUID & p_owner,bool p_decode,t_size p_param1,const void * p_param2,t_size p_param2size,abort_callback & p_abort) {throw exception_io_data();}
public:


    virtual t_size set_stream_property(const GUID & p_type,t_size p_param1,const void * p_param2,t_size p_param2size) = 0;

    
    virtual void get_info(file_info & p_info) = 0;

    virtual unsigned get_max_frame_dependency()=0;
    virtual double get_max_frame_dependency_time()=0;

    virtual void reset_after_seek()=0;

    virtual void decode(const void * p_buffer,t_size p_bytes,audio_chunk & p_chunk,abort_callback & p_abort)=0;

    virtual bool analyze_first_frame_supported() = 0;  
    virtual void analyze_first_frame(const void * p_buffer,t_size p_bytes,abort_callback & p_abort) = 0;
    
    static void g_open(service_ptr_t<packet_decoder> & p_out,bool p_decode,const GUID & p_owner,t_size p_param1,const void * p_param2,t_size p_param2size,abort_callback & p_abort);

    static const GUID owner_MP4,owner_matroska,owner_MP3,owner_MP2,owner_MP1,owner_MP4_ALAC,owner_ADTS,owner_ADIF, owner_Ogg, owner_MP4_AMR, owner_MP4_AMR_WB, owner_MP4_AC3;

    struct matroska_setup
    {
        const char * codec_id;
        uint32_t sample_rate,sample_rate_output;
        uint32_t channels;
        size_t codec_private_size;
        const void * codec_private;
    };
    //owner_MP4: param1 - codec ID (MP4 audio type), param2 - MP4 codec initialization data
    //owner_MP3: raw MP3/MP2 file, parameters ignored
    //owner_matroska: param2 = matroska_setup struct, param2size size must be equal to sizeof(matroska_setup)


    //these are used to initialize PCM decoder
    static const GUID property_samplerate,property_bitspersample,property_channels,property_byteorder,property_signed,property_channelmask, property_bufferpadding, property_eventlogger, property_checkingintegrity, property_samples_per_frame;
    //property_samplerate : param1 == sample rate in hz
    //property_bitspersample : param1 == bits per sample
    //property_channels : param1 == channel count
    //property_byteorder : if (param1) little_endian; else big_endian;
    //property_signed : if (param1) signed; else unsigned;
    //propery_bufferpadding : param1 == padding of each passed buffer in bytes; retval: decoder's preferred padding
    //property_eventlogger : param2 = event logger ptr, NULL to disable, param2size 0 always
    //property_checkingintegrity : param1 = checking integrity bool flag
    //property_samples_per_frame : param1 = samples per frame
    


    //property_ogg_header : p_param1 = unused, p_param2 = ogg_packet structure, retval: 0 when more headers are wanted, 1 when done parsing headers
    //property_ogg_query_sample_rate : returns sample rate, no parameters
    //property_ogg_packet : p_param1 = unused, p_param2 = ogg_packet strucute
    //property_ogg_qury_preskip : returns preskip samples (Opus)
    static const GUID property_ogg_header, property_ogg_query_sample_rate, property_ogg_packet, property_ogg_query_preskip;

    //property_mp4_esds : p_param2 = MP4 ESDS chunk content as needed by some decoders
    static const GUID property_mp4_esds;

    //property_allow_delayed_output : p_param1 = bool flag indicating whether the decoder than delay outputting audio data at will; essential for Apple AQ decoder
    static const GUID property_allow_delayed_output;
    
    size_t initPadding();
    void setEventLogger(event_logger::ptr logger);
    void setCheckingIntegrity(bool checkingIntegrity);
    void setAllowDelayed( bool bAllow = true );

    FB2K_MAKE_SERVICE_INTERFACE(packet_decoder,service_base);
};

class NOVTABLE packet_decoder_streamparse : public packet_decoder
{
public:
    virtual void decode_ex(const void * p_buffer,t_size p_bytes,t_size & p_bytes_processed,audio_chunk & p_chunk,abort_callback & p_abort) = 0;
    virtual void analyze_first_frame_ex(const void * p_buffer,t_size p_bytes,t_size & p_bytes_processed,abort_callback & p_abort) = 0;

    FB2K_MAKE_SERVICE_INTERFACE(packet_decoder_streamparse,packet_decoder);
};

class NOVTABLE packet_decoder_entry : public service_base
{
public:
    virtual bool is_our_setup(const GUID & p_owner,t_size p_param1,const void * p_param2,t_size p_param2size) = 0;
    virtual void open(service_ptr_t<packet_decoder> & p_out,bool p_decode,const GUID & p_owner,t_size p_param1,const void * p_param2,t_size p_param2size,abort_callback & p_abort) = 0;

    FB2K_MAKE_SERVICE_INTERFACE_ENTRYPOINT(packet_decoder_entry);
};


template<class T>
class packet_decoder_entry_impl_t : public packet_decoder_entry
{
public:
    bool is_our_setup(const GUID & p_owner,t_size p_param1,const void * p_param2,t_size p_param2size) {
        return T::g_is_our_setup(p_owner,p_param1,p_param2,p_param2size);
    }
    void open(service_ptr_t<packet_decoder> & p_out,bool p_decode,const GUID & p_owner,t_size p_param1,const void * p_param2,t_size p_param2size,abort_callback & p_abort) {
        assert(is_our_setup(p_owner,p_param1,p_param2,p_param2size));
        service_ptr_t<T> instance = new service_impl_t<T>();
        instance->open(p_owner,p_decode,p_param1,p_param2,p_param2size,p_abort);
        p_out = instance.get_ptr();
    }
};

template<typename T>
class packet_decoder_factory_t : public service_factory_single_t<packet_decoder_entry_impl_t<T> > {};