Ticket #736: decoderlocking.patch

File decoderlocking.patch, 23.6 KB (added by eskil <myth@…>, 15 years ago)

patch file

  • mythplugins/mythmusic/mythmusic/aacdecoder.cpp

    diff --exclude='Makefile*' --exclude='*svn*' --exclude='*pro' --exclude='moc_*.cpp' -ru ../observable/mythplugins/mythmusic/mythmusic/aacdecoder.cpp mythplugins/mythmusic/mythmusic/aacdecoder.cpp
    old new  
    125125                memmove(output_buf, output_buf + sz, output_bytes);
    126126                output_at = output_bytes;
    127127              } else {
    128                 mutex()->unlock();
     128                unlock();
    129129                usleep(500);
    130                 mutex()->lock();
     130                lock();
    131131                done = user_stop;
    132132              }
    133133           
     
    440440void aacDecoder::run()
    441441{
    442442
    443     mutex()->lock();
     443    lock();
    444444
    445445    if (!inited)
    446446    {
    447447      error("aacDecoder: run() called without being init'd");
    448         mutex()->unlock();
     448        unlock();
    449449        return;
    450450    }
    451451
     
    453453
    454454    stat = DecoderEvent::Decoding;
    455455
    456     mutex()->unlock();
     456    unlock();
    457457
    458458    {
    459459        DecoderEvent e((DecoderEvent::Type) stat);
     
    470470
    471471    while (!done && !finish && !user_stop)
    472472    {
    473         mutex()->lock();
     473        lock();
    474474
    475475        ++current_sample;
    476476        if (seekTime >= 0.0)
     
    587587                }
    588588            }
    589589        }
    590         mutex()->unlock();
     590        unlock();
    591591    }
    592592
    593593    flush(TRUE);
    594594
    595     mutex()->lock();
     595    lock();
    596596
    597597    //cerr << "aacDecoder: completed decoding of " << filename << endl;
    598598    if (finish)
     
    604604        stat = DecoderEvent::Stopped;
    605605    }
    606606
    607     mutex()->unlock();
     607    unlock();
    608608
    609609    {
    610610        DecoderEvent e((DecoderEvent::Type) stat);
  • mythplugins/mythmusic/mythmusic/avfdecoder.cpp

    diff --exclude='Makefile*' --exclude='*svn*' --exclude='*pro' --exclude='moc_*.cpp' -ru ../observable/mythplugins/mythmusic/mythmusic/avfdecoder.cpp mythplugins/mythmusic/mythmusic/avfdecoder.cpp
    old new  
    105105                memmove(output_buf, output_buf + sz, output_bytes);
    106106                output_at = output_bytes;
    107107            } else {
    108                 mutex()->unlock();
     108                unlock();
    109109                usleep(500);
    110                 mutex()->lock();
     110                lock();
    111111                done = user_stop;
    112112            }
    113113        }
     
    227227    int mem_len;
    228228    char *s;
    229229
    230     mutex()->lock();
     230    lock();
    231231
    232232    if (!inited)
    233233    {
    234         mutex()->unlock();
     234        unlock();
    235235        return;
    236236    }
    237237
    238238    stat = DecoderEvent::Decoding;
    239239
    240     mutex()->unlock();
     240    unlock();
    241241
    242242    {
    243243        DecoderEvent e((DecoderEvent::Type) stat);
     
    247247    av_read_play(ic);
    248248    while (!done && !finish && !user_stop)
    249249    {
    250         mutex()->lock();
     250        lock();
    251251
    252252        // Look to see if user has requested a seek
    253253        if (seekTime >= 0.0)
     
    267267        if (av_read_frame(ic, pkt) < 0)
    268268        {
    269269            cerr << "avfdecoder.o: read frame failed" << endl;
    270             mutex()->unlock();
     270            unlock();
    271271            finish = TRUE;
    272272            break;
    273273        }
     
    275275        // Get the pointer to the data and its length
    276276        ptr = pkt->data;
    277277        len = pkt->size;
    278         mutex()->unlock();
     278        unlock();
    279279
    280280        while (len > 0 && !done && !finish && !user_stop && seekTime <= 0.0) 
    281281        {
    282             mutex()->lock();
     282            lock();
    283283            // Decode the stream to the output codec
    284284            // Samples is the output buffer
    285285            // data_size is the size in bytes of the frame
     
    289289                                           ptr, len);   
    290290            if (dec_len < 0)
    291291            {
    292                 mutex()->unlock();
     292                unlock();
    293293                break;
    294294            }
    295295
    296296            s = (char *)samples;
    297             mutex()->unlock();
     297            unlock();
    298298
    299299            while (data_size > 0 && !done && !finish && !user_stop &&
    300300                   seekTime <= 0.0)
    301301             {
    302                 mutex()->lock();
     302                lock();
    303303                // Store and check the size
    304304                // It is possible the returned data is larger than
    305305                // the output buffer.  If so, flush the buffer and
     
    326326                if (output())
    327327                    flush();
    328328
    329                 mutex()->unlock();
     329                unlock();
    330330            }
    331331
    332             mutex()->lock();
     332            lock();
    333333            flush();
    334334            ptr += dec_len;
    335335            len -= dec_len;
    336             mutex()->unlock();
     336            unlock();
    337337        }
    338338        av_free_packet(pkt);
    339339    }
     
    347347    else if (user_stop)
    348348        stat = DecoderEvent::Stopped;
    349349
    350     // mutex()->unlock();
     350    // unlock();
    351351
    352352    {
    353353        DecoderEvent e((DecoderEvent::Type) stat);
  • mythplugins/mythmusic/mythmusic/cddecoder.cpp

    diff --exclude='Makefile*' --exclude='*svn*' --exclude='*pro' --exclude='moc_*.cpp' -ru ../observable/mythplugins/mythmusic/mythmusic/cddecoder.cpp mythplugins/mythmusic/mythmusic/cddecoder.cpp
    old new  
    7777                memmove(output_buf, output_buf + sz, output_bytes);
    7878                output_at = output_bytes;
    7979            } else {
    80                 mutex()->unlock();
     80                unlock();
    8181                usleep(500);
    82                 mutex()->lock();
     82                lock();
    8383                done = user_stop;
    8484            }
    8585        }
     
    174174
    175175void CdDecoder::run()
    176176{
    177     mutex()->lock();
     177    lock();
    178178
    179179    if (! inited) {
    180         mutex()->unlock();
     180        unlock();
    181181
    182182        return;
    183183    }
    184184
    185185    stat = DecoderEvent::Decoding;
    186186
    187     mutex()->unlock();
     187    unlock();
    188188
    189189    {
    190190        DecoderEvent e((DecoderEvent::Type) stat);
     
    194194    int16_t *cdbuffer;
    195195
    196196    while (! done && ! finish) {
    197         mutex()->lock();
     197        lock();
    198198        // decode
    199199
    200200        if (seekTime >= 0.0) {
     
    231231            }
    232232        }
    233233
    234         mutex()->unlock();
     234        unlock();
    235235    }
    236236
    237     mutex()->lock();
     237    lock();
    238238
    239239    if (finish)
    240240        stat = DecoderEvent::Finished;
    241241    else if (user_stop)
    242242        stat = DecoderEvent::Stopped;
    243243
    244     mutex()->unlock();
     244    unlock();
    245245
    246246    {
    247247        DecoderEvent e((DecoderEvent::Type) stat);
  • mythplugins/mythmusic/mythmusic/decoder.cpp

    diff --exclude='Makefile*' --exclude='*svn*' --exclude='*pro' --exclude='moc_*.cpp' -ru ../observable/mythplugins/mythmusic/mythmusic/decoder.cpp mythplugins/mythmusic/mythmusic/decoder.cpp
    old new  
    4545
    4646void Decoder::setInput(QIODevice *i)
    4747{
    48     mutex()->lock();
     48    lock();
    4949    in = i;
    50     mutex()->unlock();
     50    unlock();
    5151}
    5252
    5353void Decoder::setOutput(AudioOutput *o)
    5454{
    55     mutex()->lock();
     55    lock();
    5656    out = o;
    57     mutex()->unlock();
     57    unlock();
    5858}
    5959
    6060void Decoder::error(const QString &e)
  • mythplugins/mythmusic/mythmusic/decoder.h

    diff --exclude='Makefile*' --exclude='*svn*' --exclude='*pro' --exclude='moc_*.cpp' -ru ../observable/mythplugins/mythmusic/mythmusic/decoder.h mythplugins/mythmusic/mythmusic/decoder.h
    old new  
    6565    void setOutput(AudioOutput *);
    6666    void setFilename(const QString &newName) { filename = newName; }
    6767
    68     QMutex *mutex() { return &mtx; }
     68        virtual void lock(void) { return mtx.lock(); }
     69        virtual void unlock(void) { return mtx.unlock(); }
     70        virtual bool tryLock(void) { return mtx.tryLock(); }
     71        virtual bool locked(void) { return mtx.locked(); }
     72
    6973    QWaitCondition *cond() { return &cnd; }
    7074
    7175    void setBlockSize(unsigned int sz) { blksize = sz; }
     
    8791
    8892  protected:
    8993    Decoder(DecoderFactory *, QIODevice *, AudioOutput *);
    90 
     94        QMutex* getMutex(void) { return &mtx; }
    9195    void error(const QString &);
    9296
    9397    QString filename;
  • mythplugins/mythmusic/mythmusic/flacdecoder.cpp

    diff --exclude='Makefile*' --exclude='*svn*' --exclude='*pro' --exclude='moc_*.cpp' -ru ../observable/mythplugins/mythmusic/mythmusic/flacdecoder.cpp mythplugins/mythmusic/mythmusic/flacdecoder.cpp
    old new  
    213213                memmove(output_buf, output_buf + sz, output_bytes);
    214214                output_at = output_bytes;
    215215            } else {
    216                 mutex()->unlock();
     216                unlock();
    217217                usleep(500);
    218                 mutex()->lock();
     218                lock();
    219219                done = user_stop;
    220220            }
    221221        }
     
    245245
    246246    if (! input()->isOpen()) {
    247247        if (! input()->open(IO_ReadOnly)) {
    248             error("FlacOgg: Failed to open input. Error " +
     248            error("FlacDecoder: Failed to open input. Error " +
    249249                  QString::number(input()->status()) + ".");
    250250            return FALSE;
    251251        }
     
    301301
    302302void FlacDecoder::run()
    303303{
    304     mutex()->lock();
     304    lock();
    305305
    306306    if (! inited) {
    307         mutex()->unlock();
     307        unlock();
    308308
    309309        return;
    310310    }
    311311
    312312    stat = DecoderEvent::Decoding;
    313313
    314     mutex()->unlock();
     314    unlock();
    315315
    316316    {
    317317        DecoderEvent e((DecoderEvent::Type) stat);
     
    322322    FLAC__SeekableStreamDecoderState decoderstate;
    323323
    324324    while (! done && ! finish) {
    325         mutex()->lock();
     325        lock();
    326326        // decode
    327327
    328328        if (seekTime >= 0.0) {
     
    355355            }
    356356        }
    357357
    358         mutex()->unlock();
     358        unlock();
    359359    }
    360360
    361     mutex()->lock();
     361    lock();
    362362
    363363    if (finish)
    364364        stat = DecoderEvent::Finished;
    365365    else if (user_stop)
    366366        stat = DecoderEvent::Stopped;
    367367
    368     mutex()->unlock();
     368    unlock();
    369369
    370370    {
    371371        DecoderEvent e((DecoderEvent::Type) stat);
  • mythplugins/mythmusic/mythmusic/maddecoder.cpp

    diff --exclude='Makefile*' --exclude='*svn*' --exclude='*pro' --exclude='moc_*.cpp' -ru ../observable/mythplugins/mythmusic/mythmusic/maddecoder.cpp mythplugins/mythmusic/mythmusic/maddecoder.cpp
    old new  
    305305                memmove(output_buf, output_buf + sz, output_bytes);
    306306                output_at = output_bytes;
    307307            } else {
    308                 mutex()->unlock();
     308                unlock();
    309309                usleep(500);
    310                 mutex()->lock();
     310                lock();
    311311                done = user_stop;
    312312            }
    313313        }
     
    316316
    317317void MadDecoder::run()
    318318{
    319     mutex()->lock();
     319    lock();
    320320
    321321    if (! inited) {
    322         mutex()->unlock();
     322        unlock();
    323323        return;
    324324    }
    325325
    326326    stat = DecoderEvent::Decoding;
    327327
    328     mutex()->unlock();
     328    unlock();
    329329
    330330    {
    331331        DecoderEvent e((DecoderEvent::Type) stat);
     
    333333    }
    334334
    335335    while (! done && ! finish && ! derror) {
    336         mutex()->lock();
     336        lock();
    337337
    338338        if (seekTime >= 0.0) {
    339339            long seek_pos = long(seekTime * input()->size() / totalTime);
     
    361361                    eof = true;
    362362                } else if (len < 0) {
    363363                    derror = true;
     364                    unlock();
    364365                    break;
    365366                }
    366367
     
    373374
    374375        seekTime = -1.;
    375376
    376         mutex()->unlock();
     377        unlock();
    377378
    378379        while (! done && ! finish && ! derror) {
    379380            if (mad_frame_decode(&frame, &stream) == -1) {
     
    387388                continue;
    388389            }
    389390
    390             mutex()->lock();
     391            lock();
    391392
    392393            if (seekTime >= 0.) {
    393                 mutex()->unlock();
     394                unlock();
    394395                break;
    395396            }
    396397
    397398            mad_synth_frame(&synth, &frame);
    398399            madOutput();
    399             mutex()->unlock();
     400            unlock();
    400401        }
    401402    }
    402403
    403     mutex()->lock();
     404    lock();
    404405
    405406    if (! user_stop && eof) {
    406407        flush(TRUE);
     
    419420    else if (user_stop)
    420421        stat = DecoderEvent::Stopped;
    421422
    422     mutex()->unlock();
     423    unlock();
    423424
    424425    {
    425426        DecoderEvent e((DecoderEvent::Type) stat);
  • mythplugins/mythmusic/mythmusic/playbackbox.cpp

    old new  
    923923            mainvisual->setVisual(visual_mode);
    924924           
    925925            if (curMeta)
    926                 setTrackOnLCD(curMeta);
     926                updateTrackInfo(curMeta);
    927927        }   
    928928        else
    929929            constructPlaylistTree();
     
    10091009                    volume_status->refresh();
    10101010
    10111011                    if (curMeta)
    1012                         setTrackOnLCD (curMeta);
     1012                        setTrackOnLCD(curMeta);
    10131013                }
    10141014            }
    10151015        }
     
    10391039    QUrl sourceurl(playfile);
    10401040    QString sourcename(playfile);
    10411041
    1042     bool startoutput = false;
    1043 
    10441042    if (!output)
    1045     {
    1046         QString adevice = gContext->GetSetting("AudioDevice");
    1047 
    1048         // TODO: Error checking that device is opened correctly!
    1049         output = AudioOutput::OpenAudio(adevice, 16, 2, 44100,
    1050                                      AUDIOOUTPUT_MUSIC, true );
    1051         output->setBufferSize(outputBufferSize * 1024);
    1052         output->SetBlocking(false);
    1053         output->addListener(this);
    1054         output->addListener(mainvisual);
    1055         output->addVisual(mainvisual);
    1056    
    1057         startoutput = true;
    1058 
    1059     }
     1043        openOutputDevice();
    10601044   
    10611045    if (output->GetPause())
    10621046    {
     
    12091193    // wake up threads
    12101194    if (decoder)
    12111195    {
    1212         decoder->mutex()->lock();
     1196        decoder->lock();
    12131197        decoder->cond()->wakeAll();
    1214         decoder->mutex()->unlock();
     1198        decoder->unlock();
    12151199    }
    12161200
    12171201}
     
    12201204{
    12211205    if (decoder && decoder->running())
    12221206    {
    1223         decoder->mutex()->lock();
     1207        decoder->lock();
    12241208        decoder->stop();
    1225         decoder->mutex()->unlock();
     1209        decoder->unlock();
    12261210    }
    12271211
    12281212    if (decoder)
    12291213    {
    1230         decoder->mutex()->lock();
     1214        decoder->lock();
    12311215        decoder->cond()->wakeAll();
    1232         decoder->mutex()->unlock();
     1216        decoder->unlock();
    12331217    }
    12341218
    12351219    if (decoder)
     
    12381222
    12391223void PlaybackBoxMusic::stop(void)
    12401224{
    1241     if (decoder && decoder->running())
    1242     {
    1243         decoder->mutex()->lock();
    1244         decoder->stop();
    1245         decoder->mutex()->unlock();
    1246     }
    1247 
    1248     // wake up threads
    1249     if (decoder)
    1250     {
    1251         decoder->mutex()->lock();
    1252         decoder->cond()->wakeAll();
    1253         decoder->mutex()->unlock();
    1254     }
    1255 
    1256     if (decoder)
    1257         decoder->wait();
     1225    stopDecoder();
    12581226
    12591227    if (output)
    12601228    {
     
    12651233    mainvisual->setDecoder(0);
    12661234    mainvisual->setOutput(0);
    12671235
    1268     delete input;
    1269     input = 0;
    1270 
    12711236    QString time_string;
    12721237    int maxh = maxTime / 3600;
    12731238    int maxm = (maxTime / 60) % 60;
     
    13791344
    13801345        if (decoder && decoder->running())
    13811346        {
    1382             decoder->mutex()->lock();
     1347            decoder->lock();
    13831348            decoder->seek(pos);
    13841349
    13851350            if (mainvisual)
     
    13891354                mainvisual->mutex()->unlock();
    13901355            }
    13911356
    1392             decoder->mutex()->unlock();
     1357            decoder->unlock();
    13931358        }
    13941359    }
    13951360}
     
    16201585    {
    16211586        case OutputEvent::Playing:
    16221587        {
    1623             setTrackOnLCD(curMeta);
     1588            updateTrackInfo(curMeta);
    16241589            statusString = tr("Playing stream.");
    16251590            break;
    16261591        }
     
    16541619            int maxm = (maxTime / 60) % 60;
    16551620            int maxs = maxTime % 60;
    16561621           
    1657             if (maxh > 0)
    1658                 time_string.sprintf("%d:%02d:%02d / %02d:%02d:%02d", eh, em,
    1659                                     es, maxh, maxm, maxs);
    1660             else
    1661                 time_string.sprintf("%02d:%02d / %02d:%02d", em, es, maxm,
    1662                                     maxs);
     1622            if (maxTime <= 0) {
     1623                if (eh > 0)
     1624                    time_string.sprintf("%d:%02d:%02d", eh, em, es);
     1625                else
     1626                    time_string.sprintf("%02d:%02d", em, es);                   
     1627            } else {
     1628                if (maxh > 0)
     1629                    time_string.sprintf("%d:%02d:%02d / %02d:%02d:%02d", eh, em,
     1630                                        es, maxh, maxm, maxs);
     1631                else
     1632                    time_string.sprintf("%02d:%02d / %02d:%02d", em, es, maxm,
     1633                                        maxs);
     1634            }
    16631635           
    16641636            if (curMeta)
    16651637            {
    16661638                if (class LCD *lcd = LCD::Get())
    16671639                {
    1668                     float percent_heard = ((float)rs /
    1669                                            (float)curMeta->Length()) * 1000.0;
     1640                    float percent_heard = maxTime<=0?0.0:((float)rs /
     1641                                                          (float)curMeta->Length()) * 1000.0;
    16701642                    lcd->setMusicProgress(time_string, percent_heard);
    16711643                }
    16721644            }
     
    17681740            current_visualization_text->SetText("");
    17691741}
    17701742
     1743void PlaybackBoxMusic::updateTrackInfo(Metadata *mdata)
     1744{
     1745    if (title_text)
     1746        title_text->SetText(mdata->FormatTitle());
     1747    if (artist_text)
     1748        artist_text->SetText(mdata->FormatArtist());
     1749    if (album_text)
     1750        album_text->SetText(mdata->Album());
     1751   
     1752    setTrackOnLCD(mdata);
     1753}
     1754
     1755void PlaybackBoxMusic::openOutputDevice(void)
     1756{
     1757    QString adevice = gContext->GetSetting("AudioDevice");
     1758   
     1759    // TODO: Error checking that device is opened correctly!
     1760    output = AudioOutput::OpenAudio(adevice, 16, 2, 44100,
     1761                                    AUDIOOUTPUT_MUSIC, true );
     1762    output->setBufferSize(outputBufferSize * 1024);
     1763    output->SetBlocking(false);
     1764    output->addListener(this);
     1765    output->addListener(mainvisual);
     1766    output->addVisual(mainvisual);   
     1767}
     1768
    17711769void PlaybackBoxMusic::handleTreeListSignals(int node_int, IntVector *attributes)
    17721770{
    17731771    if (attributes->size() < 4)
  • mythplugins/mythmusic/mythmusic/playbackbox.h

    diff --exclude='Makefile*' --exclude='*svn*' --exclude='*pro' --exclude='moc_*.cpp' -ru ../observable/mythplugins/mythmusic/mythmusic/playbackbox.h mythplugins/mythmusic/mythmusic/playbackbox.h
    old new  
    104104    void doUpdatePlaylist(QString whereClause);
    105105    void CycleVisualizer(void);
    106106    void updatePlaylistFromCD(void);
    107     void setTrackOnLCD (Metadata *mdata);
     107    void setTrackOnLCD(Metadata *mdata);
     108    void updateTrackInfo(Metadata *mdata);
     109    void openOutputDevice(void);
    108110    void postUpdate();
    109111    void playFirstTrack();
    110112
  • mythplugins/mythmusic/mythmusic/streaminput.cpp

    diff --exclude='Makefile*' --exclude='*svn*' --exclude='*pro' --exclude='moc_*.cpp' -ru ../observable/mythplugins/mythmusic/mythmusic/streaminput.cpp mythplugins/mythmusic/mythmusic/streaminput.cpp
    old new  
    2121void StreamInput::setup()
    2222{
    2323    if (! url.isValid())
    24         return;
     24        return;
    2525
    2626    QString protocol = url.protocol();
    2727    QString host = url.host();
     
    2929    int port = url.port();
    3030
    3131    if (protocol != "mqp" || host.isNull())
    32         return;
     32        return;
    3333
    3434    if (port == -1)
    35         port = 42666;
     35        port = 42666;
    3636
    3737    request = ".song " + path.utf8() + "\r\n";
    3838
     
    4545
    4646    sock->connectToHost(host, port);
    4747
    48     while (stage != -1 && stage < 4) {
    49         qDebug("processing one event: stage %d %d %ld",
    50                stage, sock->canReadLine(), sock->bytesAvailable());
    51         qApp->processOneEvent();
     48    while (stage != -1 && stage < 4)
     49    {
     50        qDebug("processing one event: stage %d %d %ld",
     51               stage, sock->canReadLine(), sock->bytesAvailable());
     52        qApp->processOneEvent();
    5253    }
    5354
    5455    qDebug("disconnecting from socket");
     
    5758    disconnect(sock, SIGNAL(connected()), this, SLOT(connected()));
    5859    disconnect(sock, SIGNAL(readyRead()), this, SLOT(readyread()));
    5960
    60     if (stage == -1) {
    61         // some sort of error
    62         delete sock;
    63         sock = 0;
     61    if (stage == -1)
     62    {
     63        // some sort of error
     64        delete sock;
     65        sock = 0;
    6466    }
    6567}
    6668
     
    8587
    8688void StreamInput::readyread()
    8789{
    88     if (stage == 2) {
    89     qDebug("readyread... checking response");
    90 
    91     if (! sock->canReadLine()) {
    92         stage = -1;
    93         qDebug("can't read line");
    94         return;
    95     }
    96 
    97     QString line = sock->readLine();
    98     if (line.isEmpty()) {
    99         stage = -1;
    100         qDebug("line is empty");
    101         return;
    102     }
    103 
    104     if (line.left(5) != "*GOOD") {
    105         VERBOSE(VB_IMPORTANT, QString("server error response: %1")
    106                                       .arg(line));
    107         stage = -1;
    108         return;
    109     }
    110 
    111     stage = 3;
    112     } else if (sock->bytesAvailable() > 65536 || sock->atEnd()) {
    113         stage = 4;
     90    if (stage == 2)
     91    {
     92        qDebug("readyread... checking response");
     93       
     94        if (! sock->canReadLine())
     95        {
     96            stage = -1;
     97            qDebug("can't read line");
     98            return;
     99        }
     100       
     101        QString line = sock->readLine();
     102        if (line.isEmpty())
     103        {
     104            stage = -1;
     105            qDebug("line is empty");
     106            return;
     107        }
     108
     109        if (line.left(5) != "*GOOD")
     110        {
     111            VERBOSE(VB_IMPORTANT, QString("server error response: %1")
     112                    .arg(line));
     113            stage = -1;
     114            return;
     115        }
     116       
     117        stage = 3;
     118    }
     119    else if (sock->bytesAvailable() > 65536 || sock->atEnd())
     120    {
     121        stage = 4;
    114122    }
    115123}
    116124
  • mythplugins/mythmusic/mythmusic/vorbisdecoder.cpp

    diff --exclude='Makefile*' --exclude='*svn*' --exclude='*pro' --exclude='moc_*.cpp' -ru ../observable/mythplugins/mythmusic/mythmusic/vorbisdecoder.cpp mythplugins/mythmusic/mythmusic/vorbisdecoder.cpp
    old new  
    120120                memmove(output_buf, output_buf + sz, output_bytes);
    121121                output_at = output_bytes;
    122122            } else {
    123                 mutex()->unlock();
     123                unlock();
    124124                usleep(500);
    125                 mutex()->lock();
     125                lock();
    126126                done = user_stop;
    127127            }
    128128        }
     
    212212
    213213void VorbisDecoder::run()
    214214{
    215     mutex()->lock();
     215    lock();
    216216
    217217    if (! inited) {
    218         mutex()->unlock();
     218        unlock();
    219219
    220220        return;
    221221    }
    222222
    223223    stat = DecoderEvent::Decoding;
    224224
    225     mutex()->unlock();
     225    unlock();
    226226
    227227    {
    228228        DecoderEvent e((DecoderEvent::Type) stat);
     
    232232    int section = 0;
    233233
    234234    while (! done && ! finish) {
    235         mutex()->lock();
     235        lock();
    236236        // decode
    237237
    238238        if (seekTime >= 0.0) {
     
    273273            finish = TRUE;
    274274        }
    275275
    276         mutex()->unlock();
     276        unlock();
    277277    }
    278278
    279     mutex()->lock();
     279    lock();
    280280
    281281    if (finish)
    282282        stat = DecoderEvent::Finished;
    283283    else if (user_stop)
    284284        stat = DecoderEvent::Stopped;
    285285
    286     mutex()->unlock();
     286    unlock();
    287287
    288288    {
    289289        DecoderEvent e((DecoderEvent::Type) stat);