Ticket #341: decoder-refactor.2.patch

File decoder-refactor.2.patch, 15.1 KB (added by eskil <myth@…>, 15 years ago)

fixed for style

  • mythplugins/mythmusic/mythmusic/aacdecoder.cpp

     
    614614    deinit();
    615615}
    616616
    617 Metadata* aacDecoder::getMetadata()
     617MetaIO* aacDecoder::doCreateTagger()
    618618{
    619 
    620     Metadata *mdata = new Metadata(filename);
    621     if (mdata->isInDatabase(musiclocation))
    622     {
    623       return mdata;
    624     }
    625    
    626     delete mdata;
    627 
    628     MetaIOMP4* p_tagger = new MetaIOMP4;
    629     if (ignore_id3) {
    630         mdata = p_tagger->readFromFilename(filename);
    631     } else {
    632         mdata = p_tagger->read(filename);
    633     }
    634    
    635     delete p_tagger;
    636 
    637     if (mdata)
    638         mdata->dumpToDatabase(musiclocation);
    639     else
    640       error(QString("aacdecoder.o: Could not read metadata from \"%1\"").arg(filename.local8Bit()));
    641 
    642     return mdata;
    643 }   
    644 
    645 void aacDecoder::commitMetadata(Metadata *mdata)
    646 {
    647     MetaIOMP4* p_tagger = new MetaIOMP4;
    648     p_tagger->write(mdata);
    649     delete p_tagger;
     619    return new MetaIOMP4;
    650620}
    651621
    652622uint32_t aacDecoder::aacRead(char *buffer, uint32_t length)
  • mythplugins/mythmusic/mythmusic/decoder.h

     
    88#include <qptrlist.h>
    99
    1010class Metadata;
     11class MetaIO;
    1112class Decoder;
    1213class DecoderFactory;
    1314
     
    7980    static Decoder *create(const QString &, QIODevice *, AudioOutput *,
    8081                           bool = FALSE);
    8182
    82     virtual Metadata *getMetadata() = 0;
    83     virtual void commitMetadata(Metadata *mdata) = 0;
     83    /** \brief Read the metadata from \p filename directly.
     84       
     85        Creates a \p MetaIO object using \p Decoder::doCreateTagger and uses
     86        the MetaIO object to read the metadata.
     87       
     88        \returns an instance of \p Metadata owned by the caller
     89     */
     90    virtual Metadata *readMetadata(void);
    8491
     92    /** \brief Get the metadata  for \p filename
     93       
     94        First tries to read the metadata from the database. If there
     95        is no database entry, it'll call \p Decoder::readMetadata.
     96
     97                \returns an instance of \p Metadata owned by the caller
     98    */
     99    virtual Metadata *getMetadata(void);
     100
     101    /** \brief Create a \p MetaIO object for the format.
     102
     103        This method should be overwritten by subclasses to return an
     104        instance of the appropriate MetaIO subtype. It is used by \p
     105        Decoder::getMetadata, \p Decoder::readMetadata and \p
     106        Decoder::commitMetadata.
     107       
     108        The default implementation returns a NULL pointer, which
     109        essentially means, that if the decoder does not overrider this
     110        method or all of the users (see previous paragraph), files
     111        that the decoder supports cannot be indexed using metadata in
     112        the file.
     113
     114                Eg. the mp3 decoder (\p MadDecoder) implements this, whereas
     115                the audio CD decoder (\p CdDecoder) does not.
     116
     117                \returns an instance of \p MetaIO owned by the caller
     118     */
     119    virtual MetaIO *doCreateTagger (void);
     120
     121    /** \brief Write the given metadata to the \p filename.
     122       
     123        Creates a \p MetaIO object using \p Decoder::doCreateTagger and
     124        asks the MetaIO object to write the contents of mdata to \p
     125        filename.
     126
     127        \params mdata the metadata to write to the disk
     128     */
     129    virtual void commitMetadata(Metadata *mdata);
     130
    85131    static void SetLocationFormatUseTags(void);
    86132
    87133    QString getFilename(void) { return filename; }
  • mythplugins/mythmusic/mythmusic/cddecoder.h

     
    2626    int getNumCDAudioTracks(void);
    2727
    2828    Metadata *getMetadata(int track);
    29     Metadata *getMetadata();
    30     Metadata *getLastMetadata();
     29    Metadata *getMetadata(void);
     30    Metadata *getLastMetadata(void);
    3131    void commitMetadata(Metadata *mdata);
    3232
    3333  private:
  • mythplugins/mythmusic/mythmusic/decoder.cpp

     
    66
    77#include "decoder.h"
    88#include "constants.h"
     9#include "metadata.h"
     10#include "metaio.h"
    911#include <mythtv/output.h>
    1012#include <mythtv/visual.h>
    1113
     
    8789    listeners.remove(object);
    8890}
    8991
     92Metadata *Decoder::readMetadata(void)
     93{
     94    Metadata *mdata = NULL;
     95    MetaIO* p_tagger = doCreateTagger();
    9096
     97    if (p_tagger)
     98    {
     99        if (ignore_id3)
     100            mdata = p_tagger->readFromFilename(filename);
     101        else
     102            mdata = p_tagger->read(filename);
     103       
     104        delete p_tagger;
     105    }
     106    else
     107    {
     108        if (!mdata)
     109            cerr << "maddecoder.o: Could not read metadata from " << filename.local8Bit() << endl;
     110    }
     111
     112    return mdata;   
     113}
     114
     115Metadata* Decoder::getMetadata(void)
     116{
     117
     118    Metadata *mdata = new Metadata(filename);
     119    if (mdata->isInDatabase(musiclocation))
     120    {
     121      return mdata;
     122    }
     123   
     124    delete mdata;
     125
     126    return readMetadata();
     127}   
     128
     129void Decoder::commitMetadata(Metadata *mdata)
     130{
     131    MetaIO* p_tagger = doCreateTagger();
     132    if (p_tagger)
     133    {
     134        p_tagger->write(mdata);
     135        delete p_tagger;
     136    }
     137}
     138
     139MetaIO *Decoder::doCreateTagger()
     140{
     141    return NULL;
     142}
     143
    91144// static methods
    92145
    93146int Decoder::ignore_id3 = 0;
  • mythplugins/mythmusic/mythmusic/aacdecoder.h

     
    2929    void seek(double);
    3030    void stop();
    3131
    32     Metadata *getMetadata();
    33     void commitMetadata(Metadata *mdata);
     32    MetaIO *doCreateTagger(void);
    3433
    3534    bool     initializeMP4();
    3635    int      getAACTrack(mp4ff_t *infile);
  • mythplugins/mythmusic/mythmusic/vorbisdecoder.cpp

     
    293293    deinit();
    294294}
    295295
    296 Metadata *VorbisDecoder::getMetadata()
     296MetaIO *VorbisDecoder::doCreateTagger()
    297297{
    298     Metadata *mdata = new Metadata(filename);
    299     if (mdata->isInDatabase(musiclocation))
    300     {
    301         return mdata;
    302     }
    303 
    304     delete mdata;
    305 
    306 
    307     MetaIOOggVorbisComment* p_tagger = new MetaIOOggVorbisComment;
    308     if (ignore_id3)
    309         mdata = p_tagger->readFromFilename(filename);
    310     else
    311         mdata = p_tagger->read(filename);
    312 
    313     delete p_tagger;
    314 
    315     if (mdata)
    316         mdata->dumpToDatabase(musiclocation);
    317     else
    318         cerr << "vorbisdecoder.o: Could not read metadata from " << filename.local8Bit() << endl;   
    319 
    320     return mdata;
    321 }   
    322 
    323 void VorbisDecoder::commitMetadata(Metadata *mdata)
    324 {
    325     MetaIOOggVorbisComment* p_tagger = new MetaIOOggVorbisComment;
    326     p_tagger->write(mdata);
    327     delete p_tagger;
     298    return new MetaIOOggVorbisComment;
    328299}
    329300
    330301
  • mythplugins/mythmusic/mythmusic/flacdecoder.h

     
    2222    void doWrite(const FLAC__Frame *frame, const FLAC__int32 * const buffer[]);
    2323    void setFlacMetadata(const FLAC__StreamMetadata *metadata);
    2424
    25     Metadata *getMetadata();
    26     void commitMetadata(Metadata *mdata);
     25    MetaIO *doCreateTagger(void);
    2726
    2827  private:
    2928    void run();
  • mythplugins/mythmusic/mythmusic/avfdecoder.cpp

     
    357357    deinit();
    358358}
    359359
    360 Metadata* avfDecoder::getMetadata()
     360MetaIO* avfDecoder::doCreateTagger()
    361361{
    362     Metadata *mdata = new Metadata(filename);
    363     if (mdata->isInDatabase(musiclocation))
    364     {
    365         return mdata;
    366     }
    367 
    368     delete mdata;
    369 
    370 
    371     MetaIOAVFComment* p_tagger = new MetaIOAVFComment;
    372     if (ignore_id3)
    373         mdata = p_tagger->readFromFilename(filename);
    374     else
    375         mdata = p_tagger->read(filename);
    376    
    377     delete p_tagger;
    378 
    379     if (mdata)
    380         mdata->dumpToDatabase(musiclocation);
    381     else
    382         cerr << "avfdecoder.o: Could not read metadata from " << filename << endl;
    383 
    384     return mdata;
     362    return new MetaIOAVFComment;
    385363}   
    386364
    387 void avfDecoder::commitMetadata(Metadata *mdata)
    388 {
    389     MetaIOAVFComment* p_tagger = new MetaIOAVFComment;
    390     p_tagger->write(mdata);
    391     delete p_tagger;
    392 }
    393 
    394365bool avfDecoderFactory::supports(const QString &source) const
    395366{
    396367    return (source.right(extension().length()).lower() == extension());
  • mythplugins/mythmusic/mythmusic/main.cpp

     
    6565    return decoder;
    6666}
    6767
    68 void CheckFile(const QString &filename)
     68void AddFileToDB(const QString &directory, const QString &filename)
    6969{
    7070    Decoder *decoder = getDecoder(filename);
    7171
    7272    if (decoder)
    7373    {
    7474        Metadata *data = decoder->getMetadata();
    75         if (data)
     75        if (data) {
     76            data->dumpToDatabase(directory);
    7677            delete data;
     78        }
    7779
    7880        delete decoder;
    7981    }
    8082}
    8183
     84// Remove a file from the database
     85void RemoveFileFromDB (const QString &directory, const QString &filename)
     86{
     87    QString name(filename);
     88    name.remove(0, directory.length());
     89    MSqlQuery query(MSqlQuery::InitCon());
     90    query.prepare("DELETE FROM musicmetadata WHERE "
     91                  "filename = :NAME ;");
     92    query.bindValue(":NAME", name.utf8());
     93    query.exec();
     94}
     95
    8296enum MusicFileLocation
    8397{
    8498    kFileSystem,
     
    196210    busy->start();
    197211    BuildFileList(directory, music_files);
    198212    busy->Close();
    199     busy->deleteLater();
    200     busy = NULL;
     213    delete busy;
    201214
    202215    MSqlQuery query(MSqlQuery::InitCon());
    203216    query.exec("SELECT filename "
     
    234247    file_checking = new MythProgressDialog(
    235248        QObject::tr("Updating music database"), music_files.size());
    236249
    237     QRegExp quote_regex("\"");
     250    counter = 0;
    238251    for (iter = music_files.begin(); iter != music_files.end(); iter++)
    239252    {
    240253        if (*iter == kFileSystem)
    241         {
    242             CheckFile(iter.key());
    243         }
     254            AddFileToDB(directory, iter.key());
    244255        else if (*iter == kDatabase)
    245         {
    246             QString name(iter.key());
    247             name.remove(0, directory.length());
     256            RemoveFileFromDB(directory, iter.key ());
    248257
    249             query.prepare("DELETE FROM musicmetadata WHERE "
    250                           "filename = :NAME ;");
    251             query.bindValue(":NAME", name.utf8());
    252             query.exec();
    253         }
    254 
    255258        file_checking->setProgress(++counter);
    256259    }
    257260    file_checking->Close();
  • mythplugins/mythmusic/mythmusic/flacdecoder.cpp

     
    385385        char *field_value;
    386386} Argument_VcField;
    387387
    388 Metadata *FlacDecoder::getMetadata()
     388MetaIO *FlacDecoder::doCreateTagger()
    389389{
    390     Metadata *mdata = new Metadata(filename);
    391     if (mdata->isInDatabase(musiclocation))
    392     {
    393         return mdata;
    394     }
     390    return new MetaIOFLACVorbisComment;
     391}
    395392
    396     delete mdata;
    397393
    398     MetaIOFLACVorbisComment* p_tagger = new MetaIOFLACVorbisComment;
    399     if (ignore_id3)
    400         mdata = p_tagger->readFromFilename(filename);
    401     else
    402         mdata = p_tagger->read(filename);
    403 
    404     delete p_tagger;
    405 
    406     if (mdata)
    407         mdata->dumpToDatabase(musiclocation);
    408     else
    409         cerr << "flacdecoder.o: Could not read metadata from " << filename.local8Bit() << endl;
    410 
    411     return mdata;
    412 }   
    413 
    414 void FlacDecoder::commitMetadata(Metadata *mdata)
    415 {
    416     MetaIOFLACVorbisComment* p_tagger = new MetaIOFLACVorbisComment;
    417     p_tagger->write(mdata);
    418     delete p_tagger;
    419     }
    420 
    421 
    422394bool FlacDecoderFactory::supports(const QString &source) const
    423395{
    424396    return (source.right(extension().length()).lower() == extension());
  • mythplugins/mythmusic/mythmusic/maddecoder.h

     
    2424    static const int maxFrameCheck;
    2525    static const int initialFrameSize;
    2626
    27     Metadata *getMetadata();
    28     void commitMetadata(Metadata *mdata);
     27    MetaIO *doCreateTagger(void);
    2928
    3029private:
    3130    void run();
  • mythplugins/mythmusic/mythmusic/vorbisdecoder.h

     
    1818    void seek(double);
    1919    void stop();
    2020
    21     Metadata *getMetadata();
    22     void commitMetadata(Metadata *mdata);
     21    MetaIO *doCreateTagger(void);
    2322
    2423  private:
    2524    void run();
  • mythplugins/mythmusic/mythmusic/avfdecoder.h

     
    1818    void seek(double);
    1919    void stop();
    2020
    21     Metadata *getMetadata();
    22     void commitMetadata(Metadata *mdata);
     21    MetaIO *doCreateTagger(void);
    2322
    2423  private:
    2524    void run();
  • mythplugins/mythmusic/mythmusic/maddecoder.cpp

     
    512512    return MAD_FLOW_STOP;
    513513}
    514514
    515 Metadata *MadDecoder::getMetadata()
     515MetaIO *MadDecoder::doCreateTagger()
    516516{
    517     Metadata *mdata = new Metadata(filename);
    518     if (mdata->isInDatabase(musiclocation))
    519     {
    520         return mdata;
    521     }
    522 
    523     delete mdata;
    524 
    525 
    526     MetaIOID3v2* p_tagger = new MetaIOID3v2;
    527     if (ignore_id3)
    528         mdata = p_tagger->readFromFilename(filename);
    529     else
    530         mdata = p_tagger->read(filename);
    531 
    532     delete p_tagger;
    533 
    534     if (mdata)
    535         mdata->dumpToDatabase(musiclocation);
    536     else
    537         cerr << "maddecoder.o: Could not read metadata from " << filename.local8Bit() << endl;
    538 
    539     return mdata;
     517    return new MetaIOID3v2;
    540518}
    541519
    542 void MadDecoder::commitMetadata(Metadata *mdata)
    543 {
    544     MetaIOID3v2* p_tagger = new MetaIOID3v2;
    545     p_tagger->write(mdata);
    546     delete p_tagger;
    547 }
    548 
    549520bool MadDecoderFactory::supports(const QString &source) const
    550521{
    551522    bool res = false;