Ticket #2152: patch-freebox-udp.diff

File patch-freebox-udp.diff, 28.3 KB (added by mythtv@…, 19 years ago)

The patch

  • libs/libmythtv/freeboxsignalmonitor.cpp

     
    22
    33// MythTV headers
    44#include "mpegstreamdata.h"
     5#include "freeboxfeederwrapper.h"
    56#include "freeboxsignalmonitor.h"
    67#include "rtspcomms.h"
    78
    … …  
    3435      dtvMonitorRunning(false)
    3536{
    3637    bool isLocked = false;
    37     if (GetChannel()->GetRTSP()->Init())
     38    FreeboxChannelInfo chaninfo = GetChannel()->GetCurrentChanInfo();
     39    if (chaninfo.isValid())
    3840    {
    39         FreeboxChannelInfo chaninfo = GetChannel()->GetCurrentChanInfo();
    40         isLocked = (chaninfo.isValid() &&
    41                     GetChannel()->GetRTSP()->Open(chaninfo.m_url));
     41        isLocked = GetChannel()->GetFeeder()->Init(chaninfo.m_url);
     42        if (isLocked)
     43            isLocked = GetChannel()->GetFeeder()->Open();
    4244    }
    4345
    4446    QMutexLocker locker(&statusLock);
    … …  
    5153 */
    5254FreeboxSignalMonitor::~FreeboxSignalMonitor()
    5355{
    54     GetChannel()->GetRTSP()->RemoveListener(this);
     56    GetChannel()->GetFeeder()->RemoveListener(this);
    5557    Stop();
    5658}
    5759
    … …  
    6365void FreeboxSignalMonitor::deleteLater(void)
    6466{
    6567    disconnect(); // disconnect signals we may be sending...
    66     GetChannel()->GetRTSP()->RemoveListener(this);
     68    GetChannel()->GetFeeder()->RemoveListener(this);
    6769    Stop();
    6870    DTVSignalMonitor::deleteLater();
    6971}
    … …  
    7476void FreeboxSignalMonitor::Stop(void)
    7577{
    7678    DBG_SM("Stop", "begin");
    77     GetChannel()->GetRTSP()->RemoveListener(this);
     79    GetChannel()->GetFeeder()->RemoveListener(this);
    7880    SignalMonitor::Stop();
    7981    if (dtvMonitorRunning)
    8082    {
    81         GetChannel()->GetRTSP()->Stop();
     83        GetChannel()->GetFeeder()->Stop();
    8284        dtvMonitorRunning = false;
    8385        pthread_join(table_monitor_thread, NULL);
    8486    }
    … …  
    101103
    102104    GetStreamData()->AddListeningPID(0);
    103105
    104     GetChannel()->GetRTSP()->AddListener(this);
    105     GetChannel()->GetRTSP()->Run();
    106     GetChannel()->GetRTSP()->RemoveListener(this);
     106    GetChannel()->GetFeeder()->AddListener(this);
     107    GetChannel()->GetFeeder()->Run();
     108    GetChannel()->GetFeeder()->RemoveListener(this);
    107109
    108110    dtvMonitorRunning = false;
    109111    DBG_SM("Run", "end");
    110112}
    111113
    112114void FreeboxSignalMonitor::AddData(
    113     unsigned char *data, unsigned dataSize, struct timeval)
     115    unsigned char *data, unsigned dataSize)
    114116{
    115117    GetStreamData()->ProcessData(data, dataSize);
    116118}

  • libs/libmythtv/freeboxfeederudp.cpp

     
     1/** -*- Mode: c++ -*-
     2 *  FreeboxFeederUdp
     3 *  Copyright (c) 2006 by Mickaël Remars
     4 *  Distributed as part of MythTV under GPL v2 and later.
     5 */
     6
     7#include "freeboxfeederudp.h"
     8
     9#include "../libavformat/avformat.h"
     10#include "freeboxmediasink.h"
     11#include "mythcontext.h"
     12#include "tspacket.h"
     13
     14#define LOC QString("FBFeedUdp:")
     15#define LOC_ERR QString("FBFeedUdp, Error:")
     16
     17
     18FreeboxFeederUdp::FreeboxFeederUdp() :
     19    url_context(0),
     20    network_buffer(0),
     21    _stream_fd(-1),
     22    _lock(false),
     23    _abort(0),
     24    _running(false)
     25{
     26    QMutexLocker locker(&avcodeclock);
     27    av_register_all();
     28}
     29
     30FreeboxFeederUdp::~FreeboxFeederUdp()
     31{
     32}
     33
     34bool FreeboxFeederUdp::CanHandle(const QString &url) const
     35{
     36    return url.startsWith("udp://", false);
     37}
     38
     39bool FreeboxFeederUdp::Init(void)
     40{
     41    // Nothing to init
     42    return true;
     43}
     44
     45void FreeboxFeederUdp::Deinit(void)
     46{
     47    // Nothing to deinit
     48}
     49
     50bool FreeboxFeederUdp::Open(const QString &url)
     51{
     52    VERBOSE(VB_RECORD, LOC << "Open(" << url << ")");
     53
     54    avcodeclock.lock();
     55    assert(url_context==NULL);
     56    int err = url_open(&url_context, url, URL_RDONLY);
     57    avcodeclock.unlock();
     58
     59    if (err < 0)
     60    {
     61        VERBOSE(VB_IMPORTANT, LOC_ERR +
     62                "failed to open the avformat URLContext" + ENO);
     63        return false;
     64    }
     65
     66    assert(_stream_fd<0);
     67    _stream_fd = udp_get_file_handle(url_context);
     68    if (_stream_fd < 0)
     69    {
     70        VERBOSE(VB_IMPORTANT, LOC_ERR +
     71                "failed to get the URLContext's file descriptor" + ENO);
     72        return false;
     73    }
     74   
     75    return true;
     76}
     77
     78bool FreeboxFeederUdp::IsOpen(void) const
     79{
     80    return _stream_fd>=0;
     81}
     82
     83void FreeboxFeederUdp::Close(void)
     84{
     85    if (url_context)
     86    {
     87        url_close(url_context);
     88        url_context = 0;
     89        _stream_fd = -1;
     90    }
     91}
     92
     93void FreeboxFeederUdp::Run(void)
     94{
     95    VERBOSE(VB_RECORD, LOC + "Run() -- begin");
     96    _lock.lock();
     97    _running = true;
     98    _abort   = 0;
     99    _lock.unlock();
     100
     101    VERBOSE(VB_RECORD, LOC + "Run() -- loop begin");
     102    DoEventLoop();
     103    VERBOSE(VB_RECORD, LOC + "Run() -- loop end");
     104
     105    _lock.lock();
     106    _running = false;
     107    _cond.wakeAll();
     108    _lock.unlock();
     109    VERBOSE(VB_RECORD, LOC + "Run() -- end");
     110}
     111
     112void FreeboxFeederUdp::DoEventLoop(void)
     113{
     114    struct timeval tv;
     115    fd_set rdset;
     116    ssize_t bytes_read;
     117    ssize_t unprocessed_bytes = 0;
     118    unsigned char _buffer[TSPacket::SIZE * 50];
     119    int _buffer_size = TSPacket::SIZE * 50;
     120    bzero(_buffer, _buffer_size);
     121
     122    while (!_abort)
     123    {
     124        tv.tv_sec = 5;
     125        tv.tv_usec = 0;
     126        FD_ZERO(&rdset);
     127        FD_SET(_stream_fd, &rdset);
     128
     129        // wait until we can read something
     130        switch (select(_stream_fd + 1, &rdset, NULL, NULL, &tv))
     131        {
     132            case -1:
     133                if (errno == EINTR)
     134                    continue;
     135
     136                VERBOSE(VB_IMPORTANT, LOC_ERR + "select error" + ENO);
     137                continue;
     138
     139            case 0:
     140                VERBOSE(VB_RECORD, LOC_ERR + "select timeout");
     141                continue;
     142
     143            default: break;
     144        }
     145
     146        bytes_read = url_read(url_context, _buffer + unprocessed_bytes,
     147                              _buffer_size - unprocessed_bytes);
     148
     149        if (bytes_read < 0 && errno != EAGAIN)
     150        {
     151            VERBOSE(VB_IMPORTANT, LOC_ERR +
     152                    "failed to read from the URLContext" + ENO);
     153            continue;
     154        }
     155        else if (bytes_read == 0)
     156            continue;
     157
     158        bytes_read += unprocessed_bytes;
     159        unprocessed_bytes = ProcessData(_buffer, bytes_read);
     160        if (unprocessed_bytes > 0)
     161        {
     162            ssize_t ts_remainder = unprocessed_bytes % TSPacket::SIZE;
     163            if (ts_remainder > 0)
     164                unprocessed_bytes += ts_remainder;
     165
     166            memmove(_buffer, &(_buffer[_buffer_size - unprocessed_bytes]),
     167                    unprocessed_bytes);
     168        }
     169    }
     170}
     171
     172ssize_t FreeboxFeederUdp::ProcessData(unsigned char *buf, ssize_t len)
     173{
     174    QMutexLocker locker(&_lock);
     175    std::vector<RTSPListener*>::iterator it = _listeners.begin();
     176    for (; it != _listeners.end(); ++it)
     177        (*it)->AddData(buf, len);
     178    return 0;
     179}
     180
     181void FreeboxFeederUdp::Stop(void)
     182{
     183    VERBOSE(VB_RECORD, LOC + "Stop() -- begin");
     184    QMutexLocker locker(&_lock);
     185    _abort = 0xFF;
     186
     187    while (_running)
     188        _cond.wait(&_lock, 500);
     189    VERBOSE(VB_RECORD, LOC + "Stop() -- end");
     190}
     191
     192void FreeboxFeederUdp::AddListener(RTSPListener *item)
     193{
     194    VERBOSE(VB_RECORD, LOC + "AddListener("<<item<<") -- begin");
     195    if (!item)
     196    {
     197        VERBOSE(VB_RECORD, LOC + "AddListener("<<item<<") -- end 0");
     198        return;
     199    }
     200
     201    QMutexLocker locker(&_lock);
     202    std::vector<RTSPListener*>::iterator it =
     203        find(_listeners.begin(), _listeners.end(), item);
     204    if (it == _listeners.end()) // avoid duplicates
     205        _listeners.push_back(item);
     206
     207    VERBOSE(VB_RECORD, LOC + "AddListener("<<item<<") -- end 1");
     208}
     209
     210void FreeboxFeederUdp::RemoveListener(RTSPListener *item)
     211{
     212    VERBOSE(VB_RECORD, LOC + "RemoveListener("<<item<<") -- begin");
     213    QMutexLocker locker(&_lock);
     214    std::vector<RTSPListener*>::iterator it =
     215        find(_listeners.begin(), _listeners.end(), item);
     216
     217    if (it == _listeners.end())
     218    {
     219        VERBOSE(VB_RECORD, LOC + "RemoveListener("<<item<<") -- end (not found)");
     220        return;
     221    }
     222
     223    // remove from local list..
     224    *it = *_listeners.rbegin();
     225    _listeners.resize(_listeners.size() - 1);
     226    VERBOSE(VB_RECORD, LOC + "RemoveListener("<<item<<") -- end (ok, removed)");
     227}

  • libs/libmythtv/freeboxchannel.h

     
    1212
    1313#include <qmutex.h>
    1414
    15 class RTSPComms;
     15class FreeboxFeederWrapper;
    1616
    1717class FreeboxChannel : public ChannelBase
    1818{
    … …  
    3232    FreeboxChannelInfo GetCurrentChanInfo(void) const
    3333        { return GetChanInfo(curchannelname); }
    3434
    35     RTSPComms       *GetRTSP(void)       { return m_rtsp; }
    36     const RTSPComms *GetRTSP(void) const { return m_rtsp; }
     35    FreeboxFeederWrapper       *GetFeeder(void)       { return m_feeder; }
     36    const FreeboxFeederWrapper *GetFeeder(void) const { return m_feeder; }
    3737   
    3838  private:
    3939    FreeboxChannelInfo GetChanInfo(const QString& channum,
    … …  
    4141
    4242    QString               m_videodev;
    4343    fbox_chan_map_t       m_freeboxchannels;
    44     RTSPComms            *m_rtsp;
     44    FreeboxFeederWrapper *m_feeder;
    4545    mutable QMutex        m_lock;
    4646
    4747  private:

  • libs/libmythtv/libmythtv.pro

     
    398398        HEADERS += freeboxchannel.h            freeboxchannelfetcher.h
    399399        HEADERS += freeboxsignalmonitor.h      rtspcomms.h
    400400        HEADERS += freeboxchannelinfo.h
     401        HEADERS += freeboxfeeder.h
     402        HEADERS += freeboxfeederrtsp.h
     403        HEADERS += freeboxfeederudp.h
     404        HEADERS += freeboxfeederwrapper.h
    401405
    402406        SOURCES += freeboxrecorder.cpp         freeboxmediasink.cpp
    403407        SOURCES += freeboxchannel.cpp          freeboxchannelfetcher.cpp
    404408        SOURCES += freeboxsignalmonitor.cpp    rtspcomms.cpp
     409        SOURCES += freeboxfeederrtsp.cpp
     410        SOURCES += freeboxfeederudp.cpp
     411        SOURCES += freeboxfeederwrapper.cpp
    405412
    406413        DEFINES += USING_FREEBOX
    407414    }

  • libs/libmythtv/freeboxchannel.cpp

     
    1111#include "libmyth/mythcontext.h"
    1212#include "libmyth/mythdbcon.h"
    1313#include "libmythtv/freeboxchannelfetcher.h"
    14 #include "libmythtv/rtspcomms.h"
     14#include "libmythtv/freeboxfeederwrapper.h"
    1515
    1616#define LOC QString("FBChan(%1): ").arg(GetCardID())
    1717#define LOC_ERR QString("FBChan(%1), Error: ").arg(GetCardID())
    … …  
    2020                               const QString &videodev)
    2121    : ChannelBase(parent),
    2222      m_videodev(QDeepCopy<QString>(videodev)),
    23       m_rtsp(new RTSPComms()),
     23      m_feeder(new FreeboxFeederWrapper()),
    2424      m_lock(true)
    2525{
    2626    VERBOSE(VB_CHANNEL, LOC + "ctor");
    … …  
    2929FreeboxChannel::~FreeboxChannel()
    3030{
    3131    VERBOSE(VB_CHANNEL, LOC + "dtor -- begin");
    32     if (m_rtsp)
     32    if (m_feeder)
    3333    {
    34         delete m_rtsp;
    35         m_rtsp = NULL;
     34        delete m_feeder;
     35        m_feeder = NULL;
    3636    }
    3737    VERBOSE(VB_CHANNEL, LOC + "dtor -- end");
    3838}

  • libs/libmythtv/freeboxmediasink.cpp

     
    6161}
    6262
    6363void FreeboxMediaSink::afterGettingFrame1(unsigned int   frameSize,
    64                                           struct timeval presentationTime)
     64                                          struct timeval)
    6565{
    6666    lock.lock();
    6767    vector<RTSPListener*>::iterator it = listeners.begin();
    6868    for (; it != listeners.end(); ++it)
    69         (*it)->AddData(fBuffer, frameSize, presentationTime);
     69        (*it)->AddData(fBuffer, frameSize);
    7070    lock.unlock();
    7171
    7272    continuePlaying();

  • libs/libmythtv/freeboxsignalmonitor.h

     
    66#include "dtvsignalmonitor.h"
    77#include "freeboxmediasink.h"
    88
    9 class RTSPComms;
    109class FreeboxChannel;
    1110
     11
    1212class FreeboxSignalMonitor : public DTVSignalMonitor, public RTSPListener
    1313{
    1414    Q_OBJECT
    … …  
    2323
    2424    // implements RTSPListener
    2525    void AddData(unsigned char *data,
    26                  unsigned       dataSize,
    27                  struct timeval);
     26                 unsigned       dataSize);
    2827
    2928  public slots:
    3029    void deleteLater(void);

  • libs/libmythtv/freeboxfeederwrapper.cpp

     
     1/** -*- Mode: c++ -*-
     2 *  FreeboxFeederWrapper
     3 *  Copyright (c) 2006 by Mickaël Remars
     4 *  Distributed as part of MythTV under GPL v2 and later.
     5 */
     6
     7#include "freeboxfeederwrapper.h"
     8
     9#include "freeboxfeeder.h"
     10#include "freeboxfeederrtsp.h"
     11#include "freeboxfeederudp.h"
     12#include "mythcontext.h"
     13
     14#define LOC QString("FBFeed: ")
     15#define LOC_ERR QString("FBFeed, Error: ")
     16
     17
     18FreeboxFeederWrapper::FreeboxFeederWrapper() :
     19    _feeder(NULL)
     20{
     21}
     22
     23FreeboxFeederWrapper::~FreeboxFeederWrapper()
     24{
     25    delete _feeder;
     26}
     27
     28bool FreeboxFeederWrapper::Init(const QString &url)
     29{
     30    VERBOSE(VB_RECORD, LOC + "Init() -- begin");
     31    QMutexLocker locker(&_lock);
     32    if (_feeder && _feeder->CanHandle(url))
     33    {
     34        _url = url;
     35        VERBOSE(VB_RECORD, LOC + "Init() -- end 0");
     36        return true;
     37    }
     38
     39    FreeboxFeeder *feeder = NULL;
     40    if (url.startsWith("rtsp://", false))
     41    {
     42        feeder = new FreeboxFeederRtsp();
     43    }
     44    else if (url.startsWith("udp://", false))
     45    {
     46        feeder = new FreeboxFeederUdp();
     47    }
     48    else
     49    {
     50        VERBOSE(VB_RECORD, LOC_ERR + QString("Init() -- unhandled url (%1)")
     51            .arg(url));
     52    }
     53    bool result = feeder && feeder->Init();
     54    delete _feeder;
     55    _url = url;
     56    _feeder = feeder;
     57   
     58    VERBOSE(VB_RECORD, LOC + "Init() -- adding listeners");
     59    std::vector<RTSPListener*>::iterator it = _listeners.begin();
     60    for (; it != _listeners.end(); ++it)
     61        _feeder->AddListener(*it);
     62   
     63    VERBOSE(VB_RECORD, LOC + "Init() -- end 1");
     64    return result;
     65}
     66
     67void FreeboxFeederWrapper::Deinit(void)
     68{
     69    VERBOSE(VB_RECORD, LOC + "Deinit() -- begin");
     70    QMutexLocker locker(&_lock);
     71    assert(_feeder!=NULL);
     72    _feeder->Deinit();
     73    delete _feeder;
     74    _feeder = NULL;
     75    _url = QString();
     76    VERBOSE(VB_RECORD, LOC + "Deinit() -- end");
     77}
     78
     79bool FreeboxFeederWrapper::Open()
     80{
     81    VERBOSE(VB_RECORD, LOC + "Open() -- begin");
     82    assert(_feeder!=NULL);
     83    bool result = _feeder->Open(_url);
     84    VERBOSE(VB_RECORD, LOC + "Open() -- end");
     85    return result;
     86}
     87
     88bool FreeboxFeederWrapper::IsOpen(void) const
     89{
     90    VERBOSE(VB_RECORD, LOC + "IsOpen() -- begin");
     91    assert(_feeder!=NULL);
     92    bool result = _feeder->IsOpen();
     93    VERBOSE(VB_RECORD, LOC + "IsOpen() -- end");
     94    return result;
     95}
     96
     97void FreeboxFeederWrapper::Close(void)
     98{
     99    VERBOSE(VB_RECORD, LOC + "Close() -- begin");
     100    assert(_feeder!=NULL);
     101    _feeder->Close();
     102    VERBOSE(VB_RECORD, LOC + "Close() -- end");
     103}
     104
     105void FreeboxFeederWrapper::Run(void)
     106{
     107    VERBOSE(VB_RECORD, LOC + "Run() -- begin");
     108    assert(_feeder!=NULL);
     109    _feeder->Run();
     110    VERBOSE(VB_RECORD, LOC + "Run() -- end");
     111}
     112
     113void FreeboxFeederWrapper::Stop(void)
     114{
     115    VERBOSE(VB_RECORD, LOC + "Stop() -- begin");
     116    assert(_feeder!=NULL);
     117    _feeder->Stop();
     118    VERBOSE(VB_RECORD, LOC + "Stop() -- end");
     119}
     120
     121void FreeboxFeederWrapper::AddListener(RTSPListener *item)
     122{
     123    VERBOSE(VB_RECORD, LOC + "AddListener("<<item<<") -- begin");
     124    if (!item)
     125    {
     126        VERBOSE(VB_RECORD, LOC + "AddListener("<<item<<") -- end 0");
     127        return;
     128    }
     129
     130    QMutexLocker locker(&_lock);
     131    std::vector<RTSPListener*>::iterator it =
     132        find(_listeners.begin(), _listeners.end(), item);
     133    if (it == _listeners.end()) // avoid duplicates
     134    {
     135        _listeners.push_back(item);
     136        if(_feeder) _feeder->AddListener(item);
     137    }
     138
     139    VERBOSE(VB_RECORD, LOC + "AddListener("<<item<<") -- end 1");
     140}
     141
     142void FreeboxFeederWrapper::RemoveListener(RTSPListener *item)
     143{
     144    VERBOSE(VB_RECORD, LOC + "RemoveListener("<<item<<") -- begin");
     145    QMutexLocker locker(&_lock);
     146    std::vector<RTSPListener*>::iterator it =
     147        find(_listeners.begin(), _listeners.end(), item);
     148
     149    if (it == _listeners.end())
     150    {
     151        VERBOSE(VB_RECORD, LOC + "RemoveListener("<<item<<") -- end (not found)");
     152        return;
     153    }
     154
     155    // remove from local list..
     156    *it = *_listeners.rbegin();
     157    _listeners.resize(_listeners.size() - 1);
     158    if(_feeder) _feeder->RemoveListener(item);
     159    VERBOSE(VB_RECORD, LOC + "RemoveListener("<<item<<") -- end (ok, removed)");
     160}

  • libs/libmythtv/freeboxfeederrtsp.h

     
     1/** -*- Mode: c++ -*-
     2 *  FreeboxFeederRtsp
     3 *  Copyright (c) 2006 by Mickaël Remars
     4 *  Distributed as part of MythTV under GPL v2 and later.
     5 */
     6
     7#ifndef FREEBOXFEEDERRTSP_H
     8#define FREEBOXFEEDERRTSP_H
     9
     10#include "freeboxfeeder.h"
     11#include "rtspcomms.h"
     12
     13
     14class FreeboxFeederRtsp : public FreeboxFeeder
     15{
     16  public:
     17    FreeboxFeederRtsp();
     18    virtual ~FreeboxFeederRtsp();
     19
     20  public:
     21    bool CanHandle(const QString &url) const;
     22    bool Init(void);
     23    void Deinit(void);
     24
     25    bool Open(const QString &url);
     26    bool IsOpen(void) const;
     27    void Close(void);
     28
     29    void Run(void);
     30    void Stop(void);
     31
     32    void AddListener(RTSPListener*);
     33    void RemoveListener(RTSPListener*);
     34
     35  private:
     36    RTSPComms m_rtsp;
     37
     38  private:
     39    /// avoid default copy operator
     40    FreeboxFeederRtsp& operator=(const FreeboxFeederRtsp&);
     41    /// avoid default copy constructor
     42    FreeboxFeederRtsp(const FreeboxFeederRtsp&);
     43};
     44
     45#endif // FREEBOXFEEDERRTSP_H

  • libs/libmythtv/freeboxrecorder.cpp

     
    88#include "mpegstreamdata.h"
    99#include "tspacket.h"
    1010#include "freeboxchannel.h"
     11#include "freeboxfeederwrapper.h"
    1112#include "freeboxrecorder.h"
    12 #include "rtspcomms.h"
    1313
    1414#define LOC QString("FBRec: ")
    1515#define LOC_ERR QString("FBRec, Error: ")
    … …  
    2323    _channel(channel),
    2424    _stream_data(NULL)
    2525{
    26     _channel->GetRTSP()->AddListener(this);
     26    _channel->GetFeeder()->AddListener(this);
    2727}
    2828
    2929FreeboxRecorder::~FreeboxRecorder()
    3030{
    3131    StopRecording();
    32     _channel->GetRTSP()->RemoveListener(this);
     32    _channel->GetFeeder()->RemoveListener(this);
    3333}
    3434
    3535bool FreeboxRecorder::Open(void)
    3636{
    3737    VERBOSE(VB_RECORD, LOC + "Open() -- begin");
    3838
    39     if (_channel->GetRTSP()->IsOpen())
    40         _channel->GetRTSP()->Close();
     39    if (_channel->GetFeeder()->IsOpen())
     40        _channel->GetFeeder()->Close();
    4141
    4242    FreeboxChannelInfo chaninfo = _channel->GetCurrentChanInfo();
    4343    if (!chaninfo.isValid())
    … …  
    4646    }
    4747    else
    4848    {
    49         _error = !(_channel->GetRTSP()->Init());
     49        _error = !(_channel->GetFeeder()->Init(chaninfo.m_url));
    5050        if (!_error)
    51             _error = !(_channel->GetRTSP()->Open(chaninfo.m_url));
     51            _error = !(_channel->GetFeeder()->Open());
    5252    }
    5353
    5454    VERBOSE(VB_RECORD, LOC + "Open() -- end err("<<_error<<")");
    … …  
    5858void FreeboxRecorder::Close(void)
    5959{
    6060    VERBOSE(VB_RECORD, LOC + "Close() -- begin");
    61     _channel->GetRTSP()->Stop();
    62     _channel->GetRTSP()->Close();
     61    _channel->GetFeeder()->Stop();
     62    _channel->GetFeeder()->Close();
    6363    VERBOSE(VB_RECORD, LOC + "Close() -- end");
    6464}
    6565
    … …  
    6767{
    6868    VERBOSE(VB_RECORD, LOC + "Pause() -- begin");
    6969    DTVRecorder::Pause(clear);
    70     _channel->GetRTSP()->Stop();
    71     _channel->GetRTSP()->Close();
     70    _channel->GetFeeder()->Stop();
     71    _channel->GetFeeder()->Close();
    7272    VERBOSE(VB_RECORD, LOC + "Pause() -- end");
    7373}
    7474
    7575void FreeboxRecorder::Unpause(void)
    7676{
    7777    VERBOSE(VB_RECORD, LOC + "Unpause() -- begin");
    78     if (_recording && !_channel->GetRTSP()->IsOpen())
     78    if (_recording && !_channel->GetFeeder()->IsOpen())
    7979        Open();
    8080    DTVRecorder::Unpause();
    8181    VERBOSE(VB_RECORD, LOC + "Unpause() -- end");
    … …  
    9999        if (PauseAndWait())
    100100            continue;
    101101
    102         if (!_channel->GetRTSP()->IsOpen())
     102        if (!_channel->GetFeeder()->IsOpen())
    103103        {
    104104            usleep(5000);
    105105            continue;
    106106        }
    107107
    108108        // Go into main RTSP loop, feeding data to AddData
    109         _channel->GetRTSP()->Run();
     109        _channel->GetFeeder()->Run();
    110110    }
    111111
    112112    // Finish up...
    … …  
    122122{
    123123    VERBOSE(VB_RECORD, LOC + "StopRecording() -- begin");
    124124    Pause();
    125     _channel->GetRTSP()->Close();
     125    _channel->GetFeeder()->Close();
    126126
    127127    _request_recording = false;
    128128    while (_recording)
    … …  
    153153// AddData : feed data from RTSP flow to mythtv
    154154// ===================================================
    155155void FreeboxRecorder::AddData(unsigned char *data,
    156                               unsigned       dataSize,
    157                               struct timeval)
     156                              unsigned       dataSize)
    158157{
    159158    unsigned int readIndex = 0;
    160159

  • libs/libmythtv/freeboxfeederudp.h

     
     1/** -*- Mode: c++ -*-
     2 *  FreeboxFeederUdp
     3 *  Copyright (c) 2006 by Mickaël Remars
     4 *  Distributed as part of MythTV under GPL v2 and later.
     5 */
     6
     7#ifndef FREEBOXFEEDERUDP_H
     8#define FREEBOXFEEDERUDP_H
     9
     10// C++ headers
     11#include <vector>
     12
     13// Qt headers
     14#include <qwaitcondition.h>
     15#include <qmutex.h>
     16
     17// MythTV headers
     18#include "freeboxfeeder.h"
     19
     20struct URLContext;
     21
     22
     23class FreeboxFeederUdp : public FreeboxFeeder
     24{
     25  public:
     26    FreeboxFeederUdp();
     27    virtual ~FreeboxFeederUdp();
     28
     29  public:
     30    bool CanHandle(const QString& url) const;
     31    bool Init(void);
     32    void Deinit(void);
     33
     34    bool Open(const QString &url);
     35    bool IsOpen(void) const;
     36    void Close(void);
     37
     38    void Run(void);
     39    void Stop(void);
     40
     41    void AddListener(RTSPListener*);
     42    void RemoveListener(RTSPListener*);
     43
     44  private:
     45    void DoEventLoop();
     46    ssize_t ProcessData(unsigned char *buf, ssize_t len);
     47
     48  private:
     49    // UDP support (using libavformat)
     50    URLContext     *url_context;
     51    unsigned char  *network_buffer;
     52    int             _stream_fd;
     53   
     54    std::vector<RTSPListener*> _listeners;
     55    QWaitCondition  _cond;       ///< Condition  used to coordinate threads
     56    mutable QMutex  _lock;       ///< Lock  used to coordinate threads
     57    char            _abort;
     58    bool            _running;
     59
     60  private:
     61    /// avoid default copy operator
     62    FreeboxFeederUdp& operator=(const FreeboxFeederUdp&);
     63    /// avoid default copy constructor
     64    FreeboxFeederUdp(const FreeboxFeederUdp&);
     65};
     66
     67#endif // FREEBOXFEEDERUDP_H

  • libs/libmythtv/freeboxmediasink.h

     
    1919  public:
    2020    /// Callback function to add MPEG2 TS data
    2121    virtual void AddData(unsigned char *data,
    22                          unsigned int   dataSize,
    23                          struct timeval presentationTime) = 0;
     22                         unsigned int   dataSize) = 0;
    2423  protected:
    2524    virtual ~RTSPListener() {}
    2625};

  • libs/libmythtv/freeboxrecorder.h

     
    4747
    4848    // implements RTSPListener
    4949    void AddData(unsigned char *data,
    50                  unsigned int   dataSize,
    51                  struct timeval presentationTime);
     50                 unsigned int   dataSize);
    5251
    5352    // implements MPEGSingleProgramStreamListener
    5453    void HandleSingleProgramPAT(ProgramAssociationTable *pat);

  • libs/libmythtv/freeboxfeeder.h

     
     1/** -*- Mode: c++ -*-
     2 *  FreeboxFeeder
     3 *  Copyright (c) 2006 by Mickaël Remars
     4 *  Distributed as part of MythTV under GPL v2 and later.
     5 */
     6
     7#ifndef FREEBOXFEEDER_H
     8#define FREEBOXFEEDER_H
     9
     10#include <qstring.h>
     11
     12class RTSPListener;
     13
     14
     15class FreeboxFeeder
     16{
     17  public:
     18    virtual ~FreeboxFeeder() {}
     19   
     20    virtual bool CanHandle(const QString &url) const = 0;
     21    virtual bool Init(void) = 0;
     22    virtual void Deinit(void) = 0;
     23
     24    virtual bool Open(const QString &url) = 0;
     25    virtual bool IsOpen(void) const = 0;
     26    virtual void Close(void) = 0;
     27
     28    virtual void Run(void) = 0;
     29    virtual void Stop(void) = 0;
     30
     31    virtual void AddListener(RTSPListener*) = 0;
     32    virtual void RemoveListener(RTSPListener*) = 0;
     33};
     34
     35#endif//FREEBOXFEEDER_H
     36

  • libs/libmythtv/freeboxfeederrtsp.cpp

     
     1/** -*- Mode: c++ -*-
     2 *  FreeboxFeederRtsp
     3 *  Copyright (c) 2006 by Mickaël Remars
     4 *  Distributed as part of MythTV under GPL v2 and later.
     5 */
     6
     7#include "freeboxfeederrtsp.h"
     8
     9FreeboxFeederRtsp::FreeboxFeederRtsp()
     10{
     11}
     12
     13FreeboxFeederRtsp::~FreeboxFeederRtsp()
     14{
     15}
     16
     17bool FreeboxFeederRtsp::CanHandle(const QString &url) const
     18{
     19    return url.startsWith("rtsp://", false);
     20}
     21
     22bool FreeboxFeederRtsp::Init(void)
     23{
     24    return m_rtsp.Init();
     25}
     26
     27void FreeboxFeederRtsp::Deinit(void)
     28{
     29    m_rtsp.Deinit();
     30}
     31
     32bool FreeboxFeederRtsp::Open(const QString &url)
     33{
     34    return m_rtsp.Open(url);
     35}
     36
     37bool FreeboxFeederRtsp::IsOpen(void) const
     38{
     39    return m_rtsp.IsOpen();
     40}
     41
     42void FreeboxFeederRtsp::Close(void)
     43{
     44    m_rtsp.Close();
     45}
     46
     47void FreeboxFeederRtsp::Run(void)
     48{
     49    m_rtsp.Run();
     50}
     51
     52void FreeboxFeederRtsp::Stop(void)
     53{
     54    m_rtsp.Stop();
     55}
     56
     57void FreeboxFeederRtsp::AddListener(RTSPListener *listener)
     58{
     59    m_rtsp.AddListener(listener);
     60}
     61
     62void FreeboxFeederRtsp::RemoveListener(RTSPListener *listener)
     63{
     64    m_rtsp.RemoveListener(listener);
     65}

  • libs/libmythtv/freeboxfeederwrapper.h

     
     1/** -*- Mode: c++ -*-
     2 *  FreeboxFeederWrapper
     3 *  Copyright (c) 2006 by Mickaël Remars
     4 *  Distributed as part of MythTV under GPL v2 and later.
     5 */
     6
     7#ifndef FREEBOXFEEDERWRAPPER_H
     8#define FREEBOXFEEDERWRAPPER_H
     9
     10#include <qmutex.h>
     11#include <qstring.h>
     12#include <vector>
     13
     14class FreeboxFeeder;
     15class RTSPListener;
     16
     17
     18class FreeboxFeederWrapper
     19{
     20  public:
     21    FreeboxFeederWrapper();
     22    ~FreeboxFeederWrapper();
     23
     24  public:
     25    bool Init(const QString &url);
     26    void Deinit(void);
     27
     28    bool Open(void);
     29    bool IsOpen(void) const;
     30    void Close(void);
     31
     32    void Run(void);
     33    void Stop(void);
     34
     35    void AddListener(RTSPListener*);
     36    void RemoveListener(RTSPListener*);
     37   
     38  private:
     39    FreeboxFeeder *_feeder;
     40    QString        _url;
     41    mutable QMutex  _lock; ///< Lock  used to coordinate threads
     42    std::vector<RTSPListener*> _listeners;
     43
     44  private:
     45    /// avoid default copy operator
     46    FreeboxFeederWrapper& operator=(const FreeboxFeederWrapper&);
     47    /// avoid default copy constructor
     48    FreeboxFeederWrapper(const FreeboxFeederWrapper&);
     49};
     50
     51#endif//FREEBOXFEEDERWRAPPER_H