Ivan Andrianov avatar Ivan Andrianov committed 440aaa1 Merge

Merge with default.

Comments (0)

Files changed (17)

 
 project(FFTRANSCODER)
 
-cmake_minimum_required(VERSION 2.8.0)
+cmake_minimum_required(VERSION 2.8.6)
 
 set(CMAKE_MODULE_PATH ${FFTRANSCODER_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
 
-find_package(Qt4 4.7.0 COMPONENTS QtCore QtGui REQUIRED)
+find_package(Qt4 4.8.0 COMPONENTS QtCore QtGui REQUIRED)
 include(${QT_USE_FILE})
+set(CMAKE_AUTOMOC 1)
 
 find_package(PythonInterp 2.7 REQUIRED)
 find_package(PythonLibs 2.7 REQUIRED)

src/codecs/CMakeLists.txt

   transcoder.cpp
 )
 
-set(FFTRANSCODER_CODECS_MOC_SRCS
-  transcoder.h
-)
-
-qt4_wrap_cpp(FFTRANSCODER_CODECS_SRCS_CXX ${FFTRANSCODER_CODECS_MOC_SRCS})
-
 add_library(fftranscoder_codecs SHARED ${FFTRANSCODER_CODECS_SRCS_CXX})
 
 target_link_libraries(fftranscoder_codecs ${QT_QTCORE_LIBRARY})

src/codecs/frame.cpp

  */
 
 #include "frame.h"
-#include "frame_p.h"
+
+#include <QtCore/QScopedArrayPointer>
 
 namespace FFTranscoder
 {
 namespace Codecs
 {
 
+class Frame::Private
+{
+    Q_DISABLE_COPY(Frame::Private)
+
+public:
+    Private(const qint32 * samples, int sampleCount, int channelCount);
+    ~Private();
+
+    QScopedArrayPointer<const qint32> samples;
+    int sampleCount;
+    int channelCount;
+};
+
 Frame::Frame() :
-        d(new FramePrivate(0, 0, 0))
+        d(new Frame::Private(0, 0, 0))
 {
 }
 
 Frame::Frame(const qint32 * samples, int sampleCount, int channelCount) :
-        d(new FramePrivate(samples, sampleCount, channelCount))
+        d(new Frame::Private(samples, sampleCount, channelCount))
 {
 }
 
     return d->channelCount;
 }
 
-FramePrivate::FramePrivate(const qint32 * samples, int sampleCount,
+Frame::Private::Private(const qint32 * samples, int sampleCount,
         int channelCount) :
         samples(samples), sampleCount(sampleCount), channelCount(channelCount)
 {
 }
 
-FramePrivate::~FramePrivate()
+Frame::Private::~Private()
 {
 }
 

src/codecs/frame.h

 #ifndef FFTRANSCODER_CODECS_FRAME_H
 #define FFTRANSCODER_CODECS_FRAME_H
 
-#include <QScopedPointer>
+#include <QtCore/QScopedPointer>
 
 #include "global.h"
 
 namespace Codecs
 {
 
-class FramePrivate;
-
 /**
  * Class representing a frame (an array of samples).
  */
     int channelCount() const;
 
 private:
-    QScopedPointer<FramePrivate> d;
+    class Private;
+    QScopedPointer<Private> d;
 };
 
 }

src/codecs/frame_p.h

-/*
- * Copyright (C) 2012 by Ivan Andrianov
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#ifndef FFTRANSCODER_CODECS_FRAME_P_H
-#define FFTRANSCODER_CODECS_FRAME_P_H
-
-#include <QScopedArrayPointer>
-
-namespace FFTranscoder
-{
-namespace Codecs
-{
-
-class FramePrivate
-{
-    Q_DISABLE_COPY(FramePrivate)
-
-public:
-    FramePrivate(const qint32 * samples, int sampleCount, int channelCount);
-    ~FramePrivate();
-
-    QScopedArrayPointer<const qint32> samples;
-    int sampleCount;
-    int channelCount;
-};
-
-}
-}
-
-#endif // FFTRANSCODER_CODECS_FRAME_P_H

src/codecs/plugins/ffmpegdecoder/CMakeLists.txt

   ffmpegdecoderplugin.cpp
 )
 
-set(FFMPEG_DECODER_MOC_SRCS
-  ffmpegdecoderplugin.h
-)
-
-qt4_wrap_cpp(FFMPEG_DECODER_SRCS_CXX ${FFMPEG_DECODER_MOC_SRCS})
-
 add_library(ffmpeg_decoder MODULE ${FFMPEG_DECODER_SRCS_CXX})
 
 target_link_libraries(ffmpeg_decoder fftranscoder_codecs ${QT_QTCORE_LIBRARY}

src/codecs/plugins/ffmpegdecoder/ffmpegdecoder.cpp

  */
 
 #include "ffmpegdecoder.h"
-#include "ffmpegdecoder_p.h"
 
-bool FFmpegDecoderPrivate::isFirstObject = true;
+extern "C"
+{
+#include <libavformat/avformat.h>
+#include <libavcodec/avcodec.h>
+}
+
+#include <codecs/frame.h>
+
+class FFmpegDecoder::Private
+{
+    Q_DISABLE_COPY(FFmpegDecoder::Private)
+
+public:
+    Private();
+    ~Private();
+
+    void initValues();
+
+    bool openFile();
+    bool findStreamIndex();
+    bool openCodec();
+
+    void setMetaData();
+
+    void setCodecName();
+    void setBitRate();
+
+    void setBytesPerSample();
+    void setSampleRate();
+    void setChannelCount();
+
+    QString getTag(const char * tagName);
+    void setArtistName();
+    void setAlbumName();
+    void setYear();
+    void setTrackName();
+    void setTrackNumber();
+
+    Frame * processFrame();
+
+    static bool isFirstObject;
+
+    QString fileName;
+    AVFormatContext * formatContext;
+    AVCodecContext * codecContext;
+    AVCodec * codec;
+    int streamIndex;
+
+    QString codecName;
+    uint bitRate;
+
+    StreamInfo streamInfo;
+
+    TagBlock tagBlock;
+
+    AVPacket packet;
+    int currentPacketSize;
+    AVFrame frame;
+
+    bool readMetaData;
+    bool readMetaDataSuccessful;
+};
+
+bool FFmpegDecoder::Private::isFirstObject = true;
 
 FFmpegDecoder::FFmpegDecoder(const QString & fileName) :
-        d(new FFmpegDecoderPrivate())
+        d(new FFmpegDecoder::Private())
 {
-    if(FFmpegDecoderPrivate::isFirstObject)
+    if(FFmpegDecoder::Private::isFirstObject)
     {
-        FFmpegDecoderPrivate::isFirstObject = false;
+        FFmpegDecoder::Private::isFirstObject = false;
         av_register_all();
         avformat_network_init();
     }
     return d->processFrame();
 }
 
-FFmpegDecoderPrivate::FFmpegDecoderPrivate()
+FFmpegDecoder::Private::Private()
 {
 }
 
-FFmpegDecoderPrivate::~FFmpegDecoderPrivate()
+FFmpegDecoder::Private::~Private()
 {
 }
 
-void FFmpegDecoderPrivate::initValues()
+void FFmpegDecoder::Private::initValues()
 {
     formatContext = 0;
     codecContext = 0;
     readMetaDataSuccessful = false;
 }
 
-bool FFmpegDecoderPrivate::openFile()
+bool FFmpegDecoder::Private::openFile()
 {
     return avformat_open_input(&formatContext, fileName.toUtf8().data(), 0, 0)
             >= 0 && avformat_find_stream_info(formatContext, 0) >= 0;
 }
 
-bool FFmpegDecoderPrivate::findStreamIndex()
+bool FFmpegDecoder::Private::findStreamIndex()
 {
     for(unsigned int i = 0; i < formatContext->nb_streams; i++)
     {
     return streamIndex >= 0;
 }
 
-bool FFmpegDecoderPrivate::openCodec()
+bool FFmpegDecoder::Private::openCodec()
 {
     AVCodec * codec = avcodec_find_decoder(codecContext->codec_id);
 
     return true;
 }
 
-void FFmpegDecoderPrivate::setMetaData()
+void FFmpegDecoder::Private::setMetaData()
 {
     setCodecName();
     setBitRate();
     readMetaDataSuccessful = true;
 }
 
-void FFmpegDecoderPrivate::setCodecName()
+void FFmpegDecoder::Private::setCodecName()
 {
     if(codec->id == CODEC_ID_AAC)
     {
     }
 }
 
-void FFmpegDecoderPrivate::setBitRate()
+void FFmpegDecoder::Private::setBitRate()
 {
     if(~codec->capabilities & CODEC_CAP_LOSSLESS)
     {
     }
 }
 
-void FFmpegDecoderPrivate::setBytesPerSample()
+void FFmpegDecoder::Private::setBytesPerSample()
 {
     if(codecContext->sample_fmt == AV_SAMPLE_FMT_U8)
     {
     }
 }
 
-void FFmpegDecoderPrivate::setSampleRate()
+void FFmpegDecoder::Private::setSampleRate()
 {
     streamInfo.setSampleRate(codecContext->sample_rate);
 }
 
-void FFmpegDecoderPrivate::setChannelCount()
+void FFmpegDecoder::Private::setChannelCount()
 {
     streamInfo.setChannelCount(codecContext->channels);
 }
 
-QString FFmpegDecoderPrivate::getTag(const char * tagName)
+QString FFmpegDecoder::Private::getTag(const char * tagName)
 {
     AVDictionaryEntry * tag = av_dict_get(formatContext->metadata, tagName, 0,
             AV_DICT_IGNORE_SUFFIX);
     return "";
 }
 
-void FFmpegDecoderPrivate::setArtistName()
+void FFmpegDecoder::Private::setArtistName()
 {
     QString tag = getTag("Artist");
     if(!tag.isEmpty())
     }
 }
 
-void FFmpegDecoderPrivate::setAlbumName()
+void FFmpegDecoder::Private::setAlbumName()
 {
     QString tag = getTag("Album");
     if(!tag.isEmpty())
     }
 }
 
-void FFmpegDecoderPrivate::setYear()
+void FFmpegDecoder::Private::setYear()
 {
     QString tag = getTag("Date");
     if(!tag.isEmpty())
     }
 }
 
-void FFmpegDecoderPrivate::setTrackName()
+void FFmpegDecoder::Private::setTrackName()
 {
     QString tag = getTag("Title");
     if(!tag.isEmpty())
     }
 }
 
-void FFmpegDecoderPrivate::setTrackNumber()
+void FFmpegDecoder::Private::setTrackNumber()
 {
     QString tag = getTag("Track");
     if(!tag.isEmpty())
     }
 }
 
-Frame * FFmpegDecoderPrivate::processFrame()
+Frame * FFmpegDecoder::Private::processFrame()
 {
     int sampleCount = frame.nb_samples;
     int channelCount = codecContext->channels;

src/codecs/plugins/ffmpegdecoder/ffmpegdecoder.h

 #ifndef FFMPEGDECODER_H
 #define FFMPEGDECODER_H
 
-#include <QString>
-#include <QScopedPointer>
+#include <QtCore/QString>
+#include <QtCore/QScopedPointer>
 
 #include <codecs/decoder.h>
 #include <codecs/streaminfo.h>
 }
 }
 
-class FFmpegDecoderPrivate;
-
 using FFTranscoder::Codecs::Decoder;
 using FFTranscoder::Codecs::Frame;
 using FFTranscoder::Codecs::StreamInfo;
     virtual Frame * readFrame();
 
 private:
-    QScopedPointer<FFmpegDecoderPrivate> d;
+    class Private;
+    QScopedPointer<Private> d;
 };
 
 #endif // FFMPEGDECODER_H

src/codecs/plugins/ffmpegdecoder/ffmpegdecoder_p.h

-/*
- * Copyright (C) 2012 by Ivan Andrianov
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#ifndef FFMPEGDECODER_P_H
-#define FFMPEGDECODER_P_H
-
-#include <QString>
-
-extern "C"
-{
-#include <libavformat/avformat.h>
-#include <libavcodec/avcodec.h>
-}
-
-#include <codecs/frame.h>
-#include <codecs/streaminfo.h>
-#include <codecs/tagblock.h>
-
-class FFmpegDecoder;
-
-using FFTranscoder::Codecs::Frame;
-using FFTranscoder::Codecs::TagBlock;
-
-class FFmpegDecoderPrivate
-{
-    Q_DISABLE_COPY(FFmpegDecoderPrivate)
-
-public:
-    FFmpegDecoderPrivate();
-    ~FFmpegDecoderPrivate();
-
-    void initValues();
-
-    bool openFile();
-    bool findStreamIndex();
-    bool openCodec();
-
-    void setMetaData();
-
-    void setCodecName();
-    void setBitRate();
-
-    void setBytesPerSample();
-    void setSampleRate();
-    void setChannelCount();
-
-    QString getTag(const char * tagName);
-    void setArtistName();
-    void setAlbumName();
-    void setYear();
-    void setTrackName();
-    void setTrackNumber();
-
-    Frame * processFrame();
-
-    static bool isFirstObject;
-
-    QString fileName;
-    AVFormatContext * formatContext;
-    AVCodecContext * codecContext;
-    AVCodec * codec;
-    int streamIndex;
-
-    QString codecName;
-    uint bitRate;
-
-    StreamInfo streamInfo;
-
-    TagBlock tagBlock;
-
-    AVPacket packet;
-    int currentPacketSize;
-    AVFrame frame;
-
-    bool readMetaData;
-    bool readMetaDataSuccessful;
-};
-
-#endif // FFMPEGDECODER_P_H

src/codecs/plugins/ffmpegdecoder/ffmpegdecoderplugin.cpp

 
 #include "ffmpegdecoderplugin.h"
 
-#include <QtPlugin>
+#include <QtCore/QtPlugin>
 
 #include "ffmpegdecoder.h"
 #include "global.h"

src/codecs/plugins/ffmpegdecoder/ffmpegdecoderplugin.h

 #ifndef FFMPEGDECODERPLUGIN_H
 #define FFMPEGDECODERPLUGIN_H
 
-#include <QString>
-#include <QObject>
+#include <QtCore/QString>
+#include <QtCore/QObject>
 
 #include <codecs/decoderplugin.h>
 

src/codecs/plugins/flacencoder/CMakeLists.txt

   flacencoderplugin.cpp
 )
 
-set(FLAC_ENCODER_MOC_SRCS
-  flacencoderplugin.h
-)
-
-qt4_wrap_cpp(FLAC_ENCODER_SRCS_CXX ${FLAC_ENCODER_MOC_SRCS})
-
 add_library(flac_encoder MODULE ${FLAC_ENCODER_SRCS_CXX})
 
 target_link_libraries(flac_encoder fftranscoder_codecs ${QT_QTCORE_LIBRARY}

src/codecs/plugins/flacencoder/flacencoder.cpp

  */
 
 #include "flacencoder.h"
-#include "flacencoder_p.h"
 
 #include <codecs/frame.h>
 
+#include <FLAC/stream_encoder.h>
+#include <FLAC/metadata.h>
+
+class FLACEncoder::Private
+{
+    Q_DISABLE_COPY(FLACEncoder::Private)
+
+public:
+    Private();
+    ~Private();
+
+    void initValues();
+
+    bool createEncoder();
+    bool createMetaData();
+    bool initEncoder();
+
+    bool writeTag(const char * tagName, const char * tagValue);
+    bool writeStringTag(const char * tagName, const QString & tagValue);
+    bool writeIntTag(const char * tagName, uint tagValue);
+    bool writeArtistName();
+    bool writeAlbumName();
+    bool writeYear();
+    bool writeTrackName();
+    bool writeTrackNumber();
+
+    QString fileName;
+
+    StreamInfo streamInfo;
+
+    TagBlock tagBlock;
+
+    FLAC__StreamEncoder * encoder;
+    FLAC__StreamMetadata * metaData;
+
+    bool isMetaDataWritten;
+    bool isMetaDataWrittenSuccessfully;
+};
+
 FLACEncoder::FLACEncoder(const QString & fileName) :
-        d(new FLACEncoderPrivate())
+        d(new FLACEncoder::Private())
 {
     d->fileName = fileName;
     d->initValues();
     return false;
 }
 
-FLACEncoderPrivate::FLACEncoderPrivate()
+FLACEncoder::Private::Private()
 {
 }
 
-FLACEncoderPrivate::~FLACEncoderPrivate()
+FLACEncoder::Private::~Private()
 {
 }
 
-void FLACEncoderPrivate::initValues()
+void FLACEncoder::Private::initValues()
 {
     streamInfo = StreamInfo(2, 44100, 2);
 
     isMetaDataWrittenSuccessfully = false;
 }
 
-bool FLACEncoderPrivate::createEncoder()
+bool FLACEncoder::Private::createEncoder()
 {
     encoder = FLAC__stream_encoder_new();
     return encoder
             && FLAC__stream_encoder_set_compression_level(encoder, 8);
 }
 
-bool FLACEncoderPrivate::createMetaData()
+bool FLACEncoder::Private::createMetaData()
 {
     metaData = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
     return metaData && writeArtistName() && writeAlbumName() && writeYear()
             && FLAC__stream_encoder_set_metadata(encoder, &metaData, 1);
 }
 
-bool FLACEncoderPrivate::initEncoder()
+bool FLACEncoder::Private::initEncoder()
 {
     return FLAC__stream_encoder_init_file(encoder, fileName.toUtf8().data(), 0,
             0) == FLAC__STREAM_ENCODER_INIT_STATUS_OK;
 }
 
-bool FLACEncoderPrivate::writeTag(const char * tagName, const char * tagValue)
+bool FLACEncoder::Private::writeTag(const char * tagName, const char * tagValue)
 {
     FLAC__StreamMetadata_VorbisComment_Entry entry;
     return FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(
                     entry, false);
 }
 
-bool FLACEncoderPrivate::writeStringTag(const char * tagName,
+bool FLACEncoder::Private::writeStringTag(const char * tagName,
         const QString & tagValue)
 {
     if(!tagValue.isEmpty())
     return true;
 }
 
-bool FLACEncoderPrivate::writeIntTag(const char * tagName, uint tagValue)
+bool FLACEncoder::Private::writeIntTag(const char * tagName, uint tagValue)
 {
     if(tagValue > 0)
     {
     return true;
 }
 
-bool FLACEncoderPrivate::writeArtistName()
+bool FLACEncoder::Private::writeArtistName()
 {
     return writeStringTag("ARTIST", tagBlock.artistName());
 }
 
-bool FLACEncoderPrivate::writeAlbumName()
+bool FLACEncoder::Private::writeAlbumName()
 {
     return writeStringTag("ALBUM", tagBlock.albumName());
 }
 
-bool FLACEncoderPrivate::writeYear()
+bool FLACEncoder::Private::writeYear()
 {
     return writeIntTag("DATE", tagBlock.year());
 }
 
-bool FLACEncoderPrivate::writeTrackName()
+bool FLACEncoder::Private::writeTrackName()
 {
     return writeStringTag("TITLE", tagBlock.trackName());
 }
 
-bool FLACEncoderPrivate::writeTrackNumber()
+bool FLACEncoder::Private::writeTrackNumber()
 {
     return writeIntTag("TRACKNUMBER", tagBlock.trackNumber());
 }

src/codecs/plugins/flacencoder/flacencoder.h

 #ifndef FLACENCODER_H
 #define FLACENCODER_H
 
-#include <QString>
-#include <QScopedPointer>
+#include <QtCore/QString>
+#include <QtCore/QScopedPointer>
 
 #include <codecs/encoder.h>
 #include <codecs/streaminfo.h>
 }
 }
 
-class FLACEncoderPrivate;
-
 using FFTranscoder::Codecs::Encoder;
 using FFTranscoder::Codecs::Frame;
 using FFTranscoder::Codecs::StreamInfo;
     virtual bool flush();
 
 private:
-    QScopedPointer<FLACEncoderPrivate> d;
+    class Private;
+    QScopedPointer<Private> d;
 };
 
 #endif // FLACENCODER_H

src/codecs/plugins/flacencoder/flacencoder_p.h

-/*
- * Copyright (C) 2012 by Ivan Andrianov
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#ifndef FLACENCODER_P_H
-#define FLACENCODER_P_H
-
-#include <QString>
-
-#include <FLAC/stream_encoder.h>
-#include <FLAC/metadata.h>
-
-#include <codecs/tagblock.h>
-
-using FFTranscoder::Codecs::TagBlock;
-
-class FLACEncoder;
-
-class FLACEncoderPrivate
-{
-    Q_DISABLE_COPY(FLACEncoderPrivate)
-
-public:
-    FLACEncoderPrivate();
-    ~FLACEncoderPrivate();
-
-    void initValues();
-
-    bool createEncoder();
-    bool createMetaData();
-    bool initEncoder();
-
-    bool writeTag(const char * tagName, const char * tagValue);
-    bool writeStringTag(const char * tagName, const QString & tagValue);
-    bool writeIntTag(const char * tagName, uint tagValue);
-    bool writeArtistName();
-    bool writeAlbumName();
-    bool writeYear();
-    bool writeTrackName();
-    bool writeTrackNumber();
-
-    QString fileName;
-
-    StreamInfo streamInfo;
-
-    TagBlock tagBlock;
-
-    FLAC__StreamEncoder * encoder;
-    FLAC__StreamMetadata * metaData;
-
-    bool isMetaDataWritten;
-    bool isMetaDataWrittenSuccessfully;
-};
-
-#endif // FLACENCODER_P_H

src/codecs/plugins/flacencoder/flacencoderplugin.cpp

 
 #include "flacencoderplugin.h"
 
-#include <QtPlugin>
+#include <QtCore/QtPlugin>
 
 #include "flacencoder.h"
 #include "global.h"

src/codecs/plugins/flacencoder/flacencoderplugin.h

 #ifndef FLACENCODERPLUGIN_H
 #define FLACENCODERPLUGIN_H
 
-#include <QString>
-#include <QObject>
+#include <QtCore/QString>
+#include <QtCore/QObject>
 
 #include <codecs/encoderplugin.h>
 
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.