libmedia/MediaHandler.cpp

   1 // MediaHandler.cpp:  Default MediaHandler implementation, 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 #ifdef HAVE_CONFIG_H
  22 #include "gnashconfig.h"
  23 #endif
  24
  25 #include "MediaHandler.h"
  26 #include "FLVParser.h"
  27 #include "IOChannel.h"
  28 #include "AudioDecoderSimple.h"
  29 #include "log.h"
  30
  31 #ifdef DECODING_SPEEX
  32 # include "AudioDecoderSpeex.h"
  33 #endif
  34
  35 namespace gnash {
  36 namespace media {
  37
  38 bool
  39 MediaHandler::isFLV(IOChannel& stream)
  40 {
  41     char head[4] = {0, 0, 0, 0};
  42     stream.seek(0);
  43     size_t actuallyRead = stream.read(head, 3);
  44     stream.seek(0);
  45
  46     if (actuallyRead < 3)
  47     {
  48         throw IOException(_("MediaHandler::isFLV: Could not read 3 bytes "
  49                     "from input stream"));
  50     }
  51
  52     if (!std::equal(head, head + 3, "FLV")) return false;
  53     return true;
  54 }
  55
  56 std::auto_ptr<MediaParser>
  57 MediaHandler::createMediaParser(std::auto_ptr<IOChannel> stream)
  58 {
  59     std::auto_ptr<MediaParser> parser;
  60
  61     try {
  62         if (!isFLV(*stream))
  63         {
  64             log_error(_("MediaHandler::createMediaParser: only FLV input is "
  65                         "supported by this MediaHandler"));
  66             return parser;
  67         }
  68     }
  69     catch (IOException& m) {
  70         log_error(_("Exception while reading from stream: %s"), m.what());
  71         return parser;
  72     }
  73
  74     parser.reset( new FLVParser(stream) );
  75     assert(!stream.get()); // TODO: when ownership will be transferred...
  76
  77     return parser;
  78 }
  79
  80 std::auto_ptr<AudioDecoder>
  81 MediaHandler::createFlashAudioDecoder(const AudioInfo& info)
  82 {
  83     assert (info.type == CODEC_TYPE_FLASH );
  84
  85     audioCodecType codec = static_cast<audioCodecType>(info.codec);
  86     switch (codec)
  87     {
  88         case media::AUDIO_CODEC_ADPCM:
  89         case media::AUDIO_CODEC_RAW:
  90         {
  91             std::auto_ptr<AudioDecoder> ret(new AudioDecoderSimple(info));
  92             return ret;
  93         }
  94
  95 #ifdef DECODING_SPEEX
  96         case AUDIO_CODEC_SPEEX:
  97         {
  98             std::auto_ptr<AudioDecoder> ret(new AudioDecoderSpeex);
  99             return ret;
 100         }
 101 #endif
 102
 103         default:
 104         {
 105             boost::format err = boost::format(
 106                 _("MediaHandler::createFlashAudioDecoder:"
 107                   " no available flash decoders for codec %d (%s)")) %
 108                 (int)codec % codec;
 109             throw MediaException(err.str());
 110         }
 111     }
 112 }
 113
 114 } // namespace media
 115 } // namespace gnash
 116
 117 /// Here follows handler registration code.
 118
 119 #ifdef ENABLE_FFMPEG_MEDIA
 120 #include "ffmpeg/MediaHandlerFfmpeg.h"
 121 #endif
 122 #ifdef ENABLE_GST_MEDIA
 123 #include "gst/MediaHandlerGst.h"
 124 #endif
 125 #ifdef ENABLE_HAIKU_MEDIA
 126 #include "haiku/MediaHandlerHaiku.h"
 127 #endif
 128
 129 namespace gnash {
 130 namespace media {
 131
 132 RegisterAllHandlers::RegisterAllHandlers()
 133 {
 134 #ifdef ENABLE_FFMPEG_MEDIA
 135     static const MediaFactory::RegisterHandler<ffmpeg::MediaHandlerFfmpeg>
 136         ffmpeg("ffmpeg");
 137 #endif
 138 #ifdef ENABLE_GST_MEDIA
 139     static const MediaFactory::RegisterHandler<gst::MediaHandlerGst> gst("gst");
 140 #endif
 141 #ifdef ENABLE_HAIKU_MEDIA
 142     static const MediaFactory::RegisterHandler<haiku::MediaHandlerHaiku>
 143         haiku("haiku");
 144 #endif
 145 }
 146
 147 } // namespace media
 148 } // namespace gnash