libmedia/FLVParser.h

   1 // FLVParser.h:  Flash Video file format parser, for Gnash.
   2 //
   3 //   Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18 //
  19
  20
  21 // Information about the FLV format can be found at http://osflash.org/flv
  22
  23 #ifndef GNASH_FLVPARSER_H
  24 #define GNASH_FLVPARSER_H
  25
  26 #include "dsodefs.h"
  27 #include "MediaParser.h" // for inheritance
  28 #include "SimpleBuffer.h"
  29
  30 #include <set>
  31 #include <memory>
  32 #include <map>
  33
  34 #include <boost/thread/mutex.hpp>
  35
  36 namespace gnash {
  37 namespace media {
  38
  39 /// Extra video info found in some FLV embedded streams
  40 //
  41 /// This is basically composed by an header for the audio stream
  42 ///
  43 class ExtraVideoInfoFlv : public VideoInfo::ExtraInfo
  44 {
  45 public:
  46
  47     /// Construct an ExtraVideoInfoFlv
  48     //
  49     /// @param extradata
  50     ///     Video header data. Ownership transferred.
  51     ///
  52     /// @param datasize
  53     ///     Video header data size
  54     ///
  55     /// @todo take a SimpleBuffer by auto_ptr
  56     ///
  57     ExtraVideoInfoFlv(boost::uint8_t* extradata, size_t datasize)
  58         :
  59         data(extradata),
  60         size(datasize)
  61     {
  62     }
  63
  64     /// Video stream header
  65     boost::scoped_array<boost::uint8_t> data;
  66
  67     /// Video stream header size
  68     size_t size;
  69 };
  70
  71 /// Extra audoi info found in some FLV embedded streams
  72 //
  73 /// This is basically composed by an header for the audio stream
  74 ///
  75 class ExtraAudioInfoFlv : public AudioInfo::ExtraInfo
  76 {
  77 public:
  78
  79     /// Construct an ExtraAudioInfoFlv
  80     //
  81     /// @param extradata
  82     ///     Audio header data. Ownership transferred.
  83     ///
  84     /// @param datasize
  85     ///     Audio header data size
  86     ///
  87     /// @todo take a SimpleBuffer by auto_ptr
  88     ///
  89     ExtraAudioInfoFlv(boost::uint8_t* extradata, size_t datasize)
  90         :
  91         data(extradata),
  92         size(datasize)
  93     {
  94     }
  95
  96     /// Audio stream header
  97     boost::scoped_array<boost::uint8_t> data;
  98
  99     /// Audio stream header size
 100     size_t size;
 101 };
 102
 103 /// The FLVParser class parses FLV streams
 104 class DSOEXPORT FLVParser : public MediaParser
 105 {
 106
 107 public:
 108
 109     /// The size of padding for all buffers that might be read by FFMPEG.
 110     //
 111     /// This possibly also applies to other media handlers (gst).
 112     /// Ideally this would be taken from the current Handler, but we don't
 113     /// know about it here.
 114     static const size_t paddingBytes = 8;
 115
 116         /// \brief
 117         /// Create an FLV parser reading input from
 118         /// the given IOChannel
 119         //
 120         /// @param lt
 121         ///     IOChannel to use for input.
 122         ///     Ownership transferred.
 123         ///
 124         FLVParser(std::auto_ptr<IOChannel> lt);
 125
 126         /// Kills the parser...
 127         ~FLVParser();
 128
 129         // see dox in MediaParser.h
 130         virtual bool seek(boost::uint32_t&);
 131
 132         // see dox in MediaParser.h
 133         virtual bool parseNextChunk();
 134
 135         // see dox in MediaParser.h
 136         boost::uint64_t getBytesLoaded() const;
 137
 138         // see dox in MediaParser.h
 139         bool indexingCompleted() const
 140         {
 141                 return _indexingCompleted;
 142         }
 143
 144     /// Retrieve any parsed metadata tags up to a specified timestamp.
 145     //
 146     /// This copies pointers to a SimpleBuffer of AMF data from _metaTags,
 147     /// then removes those pointers from the MetaTags map. Any metadata later
 148     /// than the timestamp is kept until fetchMetaTags is called again (or
 149     /// the dtor is called).
 150     //
 151     /// @param ts   The latest timestamp to retrieve metadata for.
 152     /// @param tags This is filled with shared pointers to metatags in
 153     ///             timestamp order. Ownership of the data is shared. It
 154     ///             is destroyed automatically along with the last owner.
 155     //
 156     virtual void fetchMetaTags(OrderedMetaTags& tags, boost::uint64_t ts);
 157
 158 private:
 159
 160         enum tagType
 161         {
 162                 FLV_AUDIO_TAG = 0x08,
 163                 FLV_VIDEO_TAG = 0x09,
 164                 FLV_META_TAG = 0x12
 165         };
 166
 167         struct FLVTag : public boost::noncopyable
 168         {
 169                 FLVTag(boost::uint8_t* stream)
 170                     :
 171             type(stream[0]),
 172             body_size(getUInt24(stream+1)),
 173             timestamp(getUInt24(stream+4) | (stream[7] << 24) )
 174                 {}
 175
 176                 /// Equals tagType
 177                 boost::uint8_t type;
 178                 boost::uint32_t body_size;
 179                 boost::uint32_t timestamp;
 180         };
 181
 182         struct FLVAudioTag : public boost::noncopyable
 183         {
 184                 FLVAudioTag(const boost::uint8_t& byte)
 185                     :
 186             codec( (byte & 0xf0) >> 4 ),
 187                     samplerate( flv_audio_rates[(byte & 0x0C) >> 2] ),
 188                     samplesize( 1 + ((byte & 0x02) >> 1)),
 189                     stereo( (byte & 0x01) )
 190                 {
 191                 }
 192
 193                 /// Equals audioCodecType
 194                 boost::uint8_t codec;
 195
 196                 boost::uint16_t samplerate;
 197
 198                 /// Size of each sample, in bytes
 199                 boost::uint8_t samplesize;
 200
 201                 bool stereo;
 202
 203     private:
 204
 205         static const boost::uint16_t flv_audio_rates[];
 206
 207     };
 208
 209         enum frameType
 210         {
 211                 FLV_VIDEO_KEYFRAME = 1,
 212                 FLV_VIDEO_INTERLACED = 2,
 213                 FLV_VIDEO_DISPOSABLE = 3
 214         };
 215
 216         struct FLVVideoTag : public boost::noncopyable
 217         {
 218                 FLVVideoTag(const boost::uint8_t& byte)
 219             :
 220             frametype( (byte & 0xf0) >> 4 ),
 221                     codec( byte & 0x0f )
 222                 {}
 223
 224                 /// Equals frameType
 225                 boost::uint8_t frametype;
 226                 /// Equals videoCodecType
 227                 boost::uint8_t codec;
 228         };
 229
 230         /// Parses next tag from the file
 231         //
 232         /// Returns true if something was parsed, false otherwise.
 233         /// Sets _parsingComplete=true on end of file.
 234         ///
 235         bool parseNextTag(bool index_only);
 236
 237         std::auto_ptr<EncodedAudioFrame> parseAudioTag(const FLVTag& flvtag,
 238             const FLVAudioTag& audiotag, boost::uint32_t thisTagPos);
 239
 240     std::auto_ptr<EncodedVideoFrame> parseVideoTag(const FLVTag& flvtag,
 241             const FLVVideoTag& videotag, boost::uint32_t thisTagPos);
 242
 243         void indexAudioTag(const FLVTag& tag, boost::uint32_t thisTagPos);
 244
 245     void indexVideoTag(const FLVTag& tag, const FLVVideoTag& videotag,
 246             boost::uint32_t thisTagPos);
 247
 248         /// Parses the header of the file
 249         bool parseHeader();
 250
 251         /// Reads three bytes in FLV (big endian) byte order.
 252         /// @param in Pointer to read 3 bytes from.
 253         /// @return 24-bit integer.
 254         static boost::uint32_t getUInt24(boost::uint8_t* in);
 255
 256         /// The position where the parsing should continue from.
 257         /// Will be reset on seek, and will be protected by the _streamMutex
 258         boost::uint64_t _lastParsedPosition;
 259
 260         /// Position of next tag to index
 261         boost::uint64_t _nextPosToIndex;
 262
 263         /// Audio frame cursor position
 264         //
 265         /// This is the video frame number that will
 266         /// be referenced by nextVideoFrame and nextVideoFrameTimestamp
 267         ///
 268         size_t _nextAudioFrame;
 269
 270         /// Video frame cursor position
 271         //
 272         /// This is the video frame number that will
 273         /// be referenced by nextVideoFrame and nextVideoFrameTimestamp
 274         ///
 275         size_t _nextVideoFrame;
 276
 277         /// Audio stream is present
 278         bool _audio;
 279
 280         /// Audio stream is present
 281         bool _video;
 282
 283         std::auto_ptr<EncodedAudioFrame>
 284         readAudioFrame(boost::uint32_t dataSize, boost::uint32_t timestamp);
 285
 286         std::auto_ptr<EncodedVideoFrame>
 287         readVideoFrame(boost::uint32_t dataSize, boost::uint32_t timestamp);
 288
 289         /// Position in input stream for each cue point
 290         /// first: timestamp
 291         /// second: position in input stream
 292         typedef std::map<boost::uint64_t, long> CuePointsMap;
 293         CuePointsMap _cuePoints;
 294
 295         bool _indexingCompleted;
 296
 297     MetaTags _metaTags;
 298
 299     boost::mutex _metaTagsMutex;
 300 };
 301
 302 } // end of gnash::media namespace
 303 } // end of gnash namespace
 304
 305 #endif