calculate_peak_process

Inheritance diagram for calculate_peak_process:

Public Member Functions
	calculate_peak_process (metadb_handle_list_cref items)
void	on_done (HWND p_wnd, bool p_was_aborted)
void	on_init (HWND p_wnd)
void	run (threaded_process_status &p_status, abort_callback &p_abort)
Public Member Functions inherited from threaded_process_callback
	FB2K_MAKE_SERVICE_INTERFACE (threaded_process_callback, service_base)
Public Member Functions inherited from service_base
template<typename outPtr_t >
bool	cast (outPtr_t &outPtr)
virtual int	service_add_ref ()=0 throw ()
virtual bool	service_query (service_ptr_t< service_base > &p_out, const GUID &p_guid)
template<class T >
bool	service_query_t (service_ptr_t< T > &p_out)
virtual int	service_release ()=0 throw ()

Private Attributes
pfc::string8	m_failMsg
const metadb_handle_list	m_items
audio_sample	m_peak

Additional Inherited Members
Public Types inherited from service_base
typedef service_base	t_interface
Protected Member Functions inherited from service_base
	service_base ()
	~service_base ()

Detailed Description

Definition at line 3 of file decode.cpp.

Constructor & Destructor Documentation

calculate_peak_process::calculate_peak_process ( metadb_handle_list_cref  items )

inline

Definition at line 5 of file decode.cpp.

: m_items(items), m_peak() {}

Member Function Documentation

void calculate_peak_process::on_done ( HWND  p_wnd, bool  p_was_aborted  )

inlinevirtual

Called after the worker thread has finished executing.

Reimplemented from threaded_process_callback.

Definition at line 43 of file decode.cpp.

                                                {
        if (!p_was_aborted) {
            if (!m_failMsg.is_empty()) {
                popup_message::g_complain("Peak scan failure", m_failMsg);
            } else {
                pfc::string_formatter result;
                result << "Value: " << m_peak << "\n\n";
                result << "Scanned items:\n";
                for(t_size walk = 0; walk < m_items.get_size(); ++walk) {
                    result << m_items[walk] << "\n";
                }
                popup_message::g_show(result,"Peak scan result");
            }
        }
    }

void calculate_peak_process::on_init ( HWND  p_wnd )

inlinevirtual

Called from the main thread before spawning the worker thread.
Note that you should not access the window handle passed to on_init() in the worker thread later on.

Reimplemented from threaded_process_callback.

Definition at line 6 of file decode.cpp.

{}

void calculate_peak_process::run ( threaded_process_status &  p_status, abort_callback &  p_abort  )

inlinevirtual

Called from the worker thread. Do all the hard work here.

Implements threaded_process_callback.

Definition at line 7 of file decode.cpp.

                                                                          {
        try {
            const t_uint32 decode_flags = input_flag_no_seeking | input_flag_no_looping; // tell the decoders that we won't seek and that we don't want looping on formats that support looping.
            input_helper input;
            for(t_size walk = 0; walk < m_items.get_size(); ++walk) {
                p_abort.check(); // in case the input we're working with fails at doing this
                p_status.set_progress(walk, m_items.get_size());
                p_status.set_progress_secondary(0);
                p_status.set_item_path( m_items[walk]->get_path() );
                input.open(NULL, m_items[walk], decode_flags, p_abort);
                
                double length;
                { // fetch the track length for proper dual progress display;
                    file_info_impl info;
                    // input.open should have preloaded relevant info, no need to query the input itself again.
                    // Regular get_info() may not retrieve freshly loaded info yet at this point (it will start giving the new info when relevant info change callbacks are dispatched); we need to use get_info_async.
                    if (m_items[walk]->get_info_async(info)) length = info.get_length();
                    else length = 0;
                }

                audio_chunk_impl_temporary l_chunk;
                double decoded = 0;
                while(input.run(l_chunk, p_abort)) { // main decode loop
                    m_peak = l_chunk.get_peak(m_peak);
                    if (length > 0) { // don't bother for unknown length tracks
                        decoded += l_chunk.get_duration();
                        if (decoded > length) decoded = length;
                        p_status.set_progress_secondary_float(decoded / length);
                    }
                    p_abort.check(); // in case the input we're working with fails at doing this
                }
            }
        } catch(std::exception const & e) {
            m_failMsg = e.what();
        }
    }

Field Documentation

pfc::string8 calculate_peak_process::m_failMsg

private

Definition at line 60 of file decode.cpp.

const metadb_handle_list calculate_peak_process::m_items

private

Definition at line 61 of file decode.cpp.

audio_sample calculate_peak_process::m_peak

private

Definition at line 59 of file decode.cpp.

---

The documentation for this class was generated from the following file:

• foobar2000/foo_sample/decode.cpp