diskstream.h

Go to the documentation of this file.

// 
//   Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef __DISKSTREAM_H__
#define __DISKSTREAM_H__

#ifdef HAVE_CONFIG_H
#include "gnashconfig.h"
#endif

#include <string>
#include <iostream> 

#include "amf.h"
#include "buffer.h"
#include "flv.h"
#include "cque.h"
#include "statistics.h"
#include "getclocktime.hpp"
#include "dsodefs.h"
#include <boost/scoped_ptr.hpp>

namespace gnash {

class DSOEXPORT DiskStream {
public:
    typedef enum {
        NO_STATE,
        CREATED,
        CLOSED,
        OPEN,
        PLAY,
        PREVIEW,
        THUMBNAIL,
        PAUSE,
        SEEK,
        UPLOAD,
        MULTICAST,
        DONE
    } state_e;

  typedef enum {
    FILETYPE_NONE,
    FILETYPE_AMF,
    FILETYPE_SWF,
    FILETYPE_HTML,
    FILETYPE_PNG,
    FILETYPE_JPEG,
    FILETYPE_GIF,
    FILETYPE_MP3,
    FILETYPE_MP4,
    FILETYPE_OGG,
    FILETYPE_VORBIS,
    FILETYPE_THEORA,
    FILETYPE_DIRAC,
    FILETYPE_TEXT,
    FILETYPE_FLV,
    FILETYPE_VP6,
    FILETYPE_XML,
    FILETYPE_FLAC,
    FILETYPE_ENCODED,
    FILETYPE_PHP,
  } filetype_e;

    DSOEXPORT DiskStream();
    DSOEXPORT DiskStream(const std::string &filespec);
    DSOEXPORT DiskStream(const std::string &filespec, cygnal::Buffer &buf);
    DSOEXPORT DiskStream(const std::string &filespec, boost::uint8_t *data, size_t size);
    DSOEXPORT DiskStream(const std::string &filespec, int netfd);
    DSOEXPORT ~DiskStream();

    DSOEXPORT void close();

    DSOEXPORT bool open(const std::string &filespec);
    DSOEXPORT bool open(const std::string &filespec, int netfd);
    DSOEXPORT bool open(const std::string &filespec, int netfd, gnash::Statistics  &statistics);

    bool play();
    bool play(bool flag);
    bool play(int netfd, bool flag);
    
    bool preview(const std::string &filespec, int frames);
    
    bool thumbnail(const std::string &filespec, int quantity);
    
    bool pause();
    
    boost::uint8_t * seek(off_t offset);
    
    bool upload(const std::string &filespec);
    
    // Stream a single "real-time" source.
    bool multicast(const std::string &filespec);

    DSOEXPORT boost::uint8_t *loadToMem(size_t filesize, off_t offset);
    DSOEXPORT boost::uint8_t *loadToMem(off_t offset);
    DSOEXPORT boost::uint8_t *loadToMem() { return loadToMem(_offset); };

    DSOEXPORT bool writeToDisk(const std::string &filespec, boost::uint8_t *data, size_t size);
    DSOEXPORT bool writeToDisk(const std::string &filespec, cygnal::Buffer &data);
    DSOEXPORT bool writeToDisk(const std::string &filespec);
    DSOEXPORT bool writeToDisk();

    bool writeToNet(int start, int bytes);

    size_t getPagesize() { return _pagesize; };
    
    void setPagesize(size_t size) { _pagesize = size; };

    DiskStream &operator=(DiskStream *stream);

     void dump();
//    friend std::ostream& operator<< (std::ostream &os, const DiskStream &ds);

    boost::uint8_t *get() { return _dataptr; };
    bool fullyPopulated();
//    bool fullyPopulated() { return ((_seekptr - _filesize) == _dataptr); };
    
    size_t getFileSize() { return _filesize; };

    DiskStream::filetype_e getFileType() { return _filetype; };

    std::string &getFilespec() { return _filespec; }
    void setFilespec(std::string filespec) { _filespec = filespec; }

    struct timespec *getLastAccessTime() { return &_last_access; };

    state_e getState() { return _state; };
    void setState(state_e state) { _state = state; };

    int getFileFd() { return _filefd; };
    int getNetFd() { return _netfd; };
    
#ifdef USE_STATS_CACHE





    struct timespec *getFirstAccessTime() { return &_first_access; };
    size_t getAccessCount() { return _accesses; };
#endif    

    void dump() const { dump(std::cerr); }
    void dump(std::ostream& os) const;

private:
    state_e     _state;
    
    int         _filefd;
    
    int         _netfd;

    std::string _filespec;

    gnash::Statistics  _statistics;

    boost::uint8_t *_dataptr;

    size_t      _max_memload;
    
    boost::uint8_t *_seekptr;

    size_t      _filesize;

    size_t      _pagesize;

    off_t       _offset;

    filetype_e determineFileType();
    filetype_e determineFileType( boost::uint8_t *data);
    filetype_e determineFileType(const std::string &filespec);

    // Get the file stats, so we know how to set the
    // Content-Length in the header.
    bool getFileStats(const std::string &filespec);
    DiskStream::filetype_e _filetype;

    struct timespec _last_access;
    
#ifdef USE_STATS_CACHE
    struct timespec _first_access;      // used for timing how long data stays in the queue.
    size_t          _accesses;
#endif

#ifdef USE_STATS_FILE
    int         _bytes;
#endif

    // The header, tag, and onMetaData from the FLV file.
    boost::shared_ptr<cygnal::Flv>    _flv;
};

inline std::ostream& operator << (std::ostream& os, const DiskStream& ds)
{
        ds.dump(os);
        return os;
}

} // end of cygnal namespace

#endif // __DISKSTREAM_H__

// local Variables:
// mode: C++
// indent-tabs-mode: t
// End: