Kwave::MimeData Class Reference

#include <MimeData.h>

Inheritance diagram for Kwave::MimeData:

Collaboration diagram for Kwave::MimeData:

Classes
class	Buffer

Public Member Functions
	MimeData ()
virtual	~MimeData () Q_DECL_OVERRIDE
virtual bool	encode (QWidget *widget, Kwave::MultiTrackReader &src, const Kwave::MetaDataList &meta_data)
virtual void	clear ()

Static Public Member Functions
static sample_index_t	decode (QWidget *widget, const QMimeData *e, Kwave::SignalManager &sig, sample_index_t pos)

Private Attributes
Kwave::MimeData::Buffer	m_buffer

Detailed Description

Definition at line 40 of file MimeData.h.

Constructor & Destructor Documentation

MimeData()

Kwave::MimeData::MimeData

(

)

Constructor

Definition at line 173 of file MimeData.cpp.

    :QMimeData(), m_buffer()
{
}

~MimeData()

Kwave::MimeData::~MimeData ( )

virtual

Destructor

Definition at line 179 of file MimeData.cpp.

{
}

Member Function Documentation

clear()

void Kwave::MimeData::clear ( )

virtual

Clears the content, makes the storage an empty byte array

Definition at line 434 of file MimeData.cpp.

References Kwave::MimeData::Buffer::close(), and m_buffer.

Referenced by Kwave::ClipBoard::copy().

{
    m_buffer.close();
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode()

sample_index_t Kwave::MimeData::decode ( QWidget *  widget, const QMimeData *  e, Kwave::SignalManager &  sig, sample_index_t  pos  )

static

Decodes the encoded byte data of the given mime source and initializes a MultiTrackReader.

Parameters

widget	the widget used for displaying error messages
e	source with encoded mime data
sig	signal that receives the mime data
pos	position within the signal where to insert the data

Returns

number of decoded samples if successful, zero if failed

Definition at line 237 of file MimeData.cpp.

References Kwave::MetaDataList::add(), Kwave::SignalManager::allTracks(), Kwave::CodecManager::canDecode(), Kwave::connect(), Kwave::Decoder::decode(), Kwave::CodecManager::decoder(), Kwave::MultiWriter::flush(), Kwave::ChannelMixer::init(), Kwave::Insert, Kwave::Decoder::metaData(), Kwave::SignalManager::metaData(), Kwave::FileInfo::metaDataType(), Kwave::SignalManager::newSignal(), Kwave::Decoder::open(), Kwave::SignalManager::rate(), Kwave::MetaDataList::remove(), Kwave::MetaDataList::scalePositions(), Kwave::MetaDataList::selectByType(), Kwave::SignalManager::selectedTracks(), Kwave::StreamObject::setAttribute(), Kwave::MetaDataList::shiftRight(), and Kwave::SignalManager::tracks().

Referenced by Kwave::Drag::decode(), and Kwave::ClipBoard::paste().

{
    // decode, use the first format that matches
    sample_index_t decoded_length = 0;
    unsigned int   decoded_tracks = 0;

    // try to find a suitable decoder
    foreach (const QString &format, e->formats()) {
        // skip all non-supported formats
        if (!Kwave::CodecManager::canDecode(format)) continue;

        Kwave::Decoder *decoder = Kwave::CodecManager::decoder(format);
        Q_ASSERT(decoder);
        if (!decoder) return 0;

        QByteArray raw_data = e->data(format);
        QBuffer src(&raw_data);

        // open the mime source and get header information
        bool ok = decoder->open(widget, src);
        if (!ok) {
            delete decoder;
            continue;
        }

        decoded_length = Kwave::FileInfo(decoder->metaData()).length();
        decoded_tracks = Kwave::FileInfo(decoder->metaData()).tracks();
        Q_ASSERT(decoded_length);
        Q_ASSERT(decoded_tracks);
        if (!decoded_length || !decoded_tracks) {
            delete decoder;
            continue;
        }

        // get sample rates of source and destination
        double src_rate = Kwave::FileInfo(decoder->metaData()).rate();
        double dst_rate = sig.rate();

        // if the sample rate has to be converted, adjust the length
        // right border
        if (!qFuzzyCompare(src_rate, dst_rate) && (dst_rate > 1) && sig.tracks())
            decoded_length *= (dst_rate / src_rate);

        sample_index_t left  = pos;
        sample_index_t right = left + decoded_length - 1;
        QList<unsigned int> tracks = sig.selectedTracks();
        if (tracks.isEmpty()) tracks = sig.allTracks();

        // special case: destination is currently empty
        if (!sig.tracks()) {
            // encode into an empty window -> create tracks
            qDebug("Kwave::MimeData::decode(...) -> new signal");
            dst_rate = src_rate;
            sig.newSignal(0,
                src_rate,
                Kwave::FileInfo(decoder->metaData()).bits(),
                decoded_tracks);
            ok = (sig.tracks() == decoded_tracks);
            if (!ok) {
                delete decoder;
                continue;
            }
        }
        const unsigned int dst_tracks = sig.selectedTracks().count();

        // create the final sink
        Kwave::MultiTrackWriter dst(sig, sig.selectedTracks(),
                                    Kwave::Insert, left, right);

        // if the track count does not match, then we need a channel mixer
        Q_ASSERT(ok);
        Kwave::ChannelMixer *mixer = Q_NULLPTR;
        if (ok && (decoded_tracks != dst_tracks)) {
            qDebug("Kwave::MimeData::decode(...) -> mixing channels: %u -> %u",
                   decoded_tracks, dst_tracks);
            mixer = new(std::nothrow)
                Kwave::ChannelMixer(decoded_tracks, dst_tracks);
            Q_ASSERT(mixer);
            ok &= (mixer) && mixer->init();
            Q_ASSERT(ok);
        }
        Q_ASSERT(ok);

        // if the sample rates do not match, then we need a rate converter
        Kwave::StreamObject *rate_converter = Q_NULLPTR;
        if (ok && !qFuzzyCompare(src_rate, dst_rate)) {
            // create a sample rate converter
            qDebug("Kwave::MimeData::decode(...) -> rate conversion: "\
                   "%0.1f -> %0.1f", src_rate, dst_rate);
            rate_converter = new(std::nothrow)
                Kwave::MultiTrackSource<Kwave::RateConverter, true>(
                    dst_tracks, widget);
            Q_ASSERT(rate_converter);
            if (rate_converter)
                rate_converter->setAttribute(SLOT(setRatio(QVariant)),
                                             QVariant(dst_rate / src_rate));
            else
                ok = false;
        }
        Q_ASSERT(ok);

        // set hourglass cursor
        QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

        if (ok && (rate_converter || mixer)) {
            // pass all data through a filter chain
            Kwave::MultiStreamWriter adapter(decoded_tracks);

            // pass the data through a sample rate converter
            // decoder -> adapter -> [mixer] -> [converter] -> dst

            Kwave::StreamObject *last_output = &adapter;

            if (ok && mixer) {
                // connect the channel mixer
                ok = Kwave::connect(
                    *last_output, SIGNAL(output(Kwave::SampleArray)),
                    *mixer,       SLOT(input(Kwave::SampleArray))
                );
                last_output = mixer;
            }

            if (ok && rate_converter) {
                // connect the rate converter
                ok = Kwave::connect(
                    *last_output,    SIGNAL(output(Kwave::SampleArray)),
                    *rate_converter, SLOT(input(Kwave::SampleArray))
                );
                last_output = rate_converter;
            }

            // connect the sink
            if (ok) {
                ok = Kwave::connect(
                    *last_output, SIGNAL(output(Kwave::SampleArray)),
                    dst,          SLOT(input(Kwave::SampleArray))
                );
            }

            // this also starts the conversion automatically
            if (ok)
                ok = decoder->decode(widget, adapter);

            // flush all samples that are still in the adapter
            adapter.flush();

        } else if (ok) {
            // decode directly without any filter
            ok = decoder->decode(widget, dst);
        }

        dst.flush();

        // clean up the filter chain
        if (mixer)          delete mixer;
        if (rate_converter) delete rate_converter;

        // remove hourglass
        QApplication::restoreOverrideCursor();

        // failed :-(
        Q_ASSERT(ok);
        if (!ok) {
            delete decoder;
            decoded_length = 0;
            continue;
        }

        // take care of the meta data, shift all it by "left" and
        // add it to the signal
        Kwave::MetaDataList meta_data = decoder->metaData();

        // adjust meta data position in case of different sample rate
        if (!qFuzzyCompare(src_rate, dst_rate))
            meta_data.scalePositions(dst_rate / src_rate, tracks);

        meta_data.shiftRight(0, left, tracks);

        // remove the file info, this must not be handled here, otherwise
        // this would overwrite the file info of the destination
        meta_data.remove(meta_data.selectByType(
            Kwave::FileInfo::metaDataType()));

        // add the remaining meta data (e.g. labels etc)
        sig.metaData().add(meta_data);

        delete decoder;
        break;
    }

//     qDebug("Kwave::MimeData::decode -> decoded_length=%u", decoded_length);
    return decoded_length;
}

Here is the call graph for this function:

Here is the caller graph for this function:

encode()

bool Kwave::MimeData::encode ( QWidget *  widget, Kwave::MultiTrackReader &  src, const Kwave::MetaDataList &  meta_data  )

virtual

Encodes wave data received from a MultiTrackReader into a byte array that is compatible with the format of a wav file.

Parameters

widget	the widget used as parent for displaying error messages
src	source of the samples
meta_data	information about the signal, sample rate, resolution and other meta data

Returns

true if successful

Definition at line 184 of file MimeData.cpp.

References _, Kwave::MimeData::Buffer::byteArray(), Kwave::MimeData::Buffer::close(), Kwave::Encoder::encode(), Kwave::CodecManager::encoder(), Kwave::MultiTrackReader::first(), Kwave::INF_COMPRESSION, Kwave::MultiTrackReader::last(), m_buffer, Kwave::MimeData::Buffer::mapToByteArray(), Kwave::Compression::NONE, Kwave::MetaDataList::replace(), Kwave::MetaDataList::selectByRange(), Kwave::FileInfo::set(), Kwave::FileInfo::setLength(), Kwave::FileInfo::setTracks(), Kwave::MetaDataList::shiftLeft(), Kwave::MultiTrackSource< SOURCE, INITIALIZE >::tracks(), and Kwave::WAVE_FORMAT_PCM.

Referenced by Kwave::ClipBoard::copy(), and Kwave::Drag::encode().

{
    // use our default encoder
    Kwave::Encoder *encoder = Kwave::CodecManager::encoder(_(WAVE_FORMAT_PCM));
    Q_ASSERT(encoder);
    if (!encoder) return false;

    Q_ASSERT(src.tracks());
    if (!src.tracks()) return false;

    // set hourglass cursor
    QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

    sample_index_t first = src.first();
    sample_index_t last  = src.last();
    Kwave::MetaDataList new_meta_data = meta_data.selectByRange(first, last);

    // move all meta data left, to start at the beginning of the selection
    new_meta_data.shiftLeft(first, first, QList<unsigned int>());

    // fix the length information in the new file info
    // and change to uncompressed mode
    Kwave::FileInfo info(meta_data);
    info.set(Kwave::INF_COMPRESSION, QVariant(Kwave::Compression::NONE));
    info.setLength(last - first + 1);
    info.setTracks(src.tracks());
    new_meta_data.replace(Kwave::MetaDataList(info));

    // encode into the buffer
    m_buffer.close(); // discard old stuff
    encoder->encode(widget, src, m_buffer, new_meta_data);

    delete encoder;

    // set the mime data into this mime data container
    bool succeeded = m_buffer.mapToByteArray();
    if (succeeded) {
        // mmap succeeded
        setData(_(WAVE_FORMAT_PCM), m_buffer.byteArray());
    } else {
        // failed to map memory
        m_buffer.close();
    }

    // remove hourglass
    QApplication::restoreOverrideCursor();

    return succeeded;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_buffer

Kwave::MimeData::Buffer Kwave::MimeData::m_buffer

private

buffer for the mime data (with swap file support)

Definition at line 153 of file MimeData.h.

Referenced by clear(), and encode().

---

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

• libkwave/MimeData.h
• libkwave/MimeData.cpp