git.sesse.net Git - casparcg/blob - core/producer/ffmpeg/input.cpp

   1 #include "..\..\stdafx.h"\r
   2 \r
   3 #include "input.h"\r
   4 \r
   5 #include "../../frame/frame_format.h"\r
   6 #include "../../../common/utility/memory.h"\r
   7 #include "../../../common/utility/scope_exit.h"\r
   8 \r
   9 #include <tbb/concurrent_queue.h>\r
  10 #include <tbb/queuing_mutex.h>\r
  11 \r
  12 #include <boost/thread.hpp>\r
  13 \r
  14 #include <errno.h>\r
  15 #include <system_error>\r
  16                 \r
  17 namespace caspar { namespace core { namespace ffmpeg{\r
  18                 \r
  19 struct input::implementation : boost::noncopyable\r
  20 {\r
  21         implementation(const frame_format_desc& format_desc) \r
  22                 : video_frame_rate_(25.0), video_s_index_(-1), audio_s_index_(-1), video_codec_(nullptr), audio_codec_(nullptr), format_desc_(format_desc)\r
  23         {\r
  24                 loop_ = false;\r
  25                 //file_buffer_size_ = 0;                \r
  26                 video_packet_buffer_.set_capacity(25);\r
  27                 audio_packet_buffer_.set_capacity(25);\r
  28         }\r
  29 \r
  30         ~implementation()\r
  31         {               \r
  32                 stop();\r
  33         }\r
  34         \r
  35         void stop()\r
  36         {\r
  37                 is_running_ = false;\r
  38                 audio_packet_buffer_.clear();\r
  39                 video_packet_buffer_.clear();\r
  40                 //file_buffer_size_ = 0;\r
  41                 //file_buffer_size_cond_.notify_all();\r
  42                 io_thread_.join();\r
  43         }\r
  44 \r
  45         void load(const std::string& filename)\r
  46         {       \r
  47                 try\r
  48                 {\r
  49                         int errn;\r
  50                         AVFormatContext* weak_format_context_;\r
  51                         if((errn = -av_open_input_file(&weak_format_context_, filename.c_str(), nullptr, 0, nullptr)) > 0)\r
  52                                 BOOST_THROW_EXCEPTION(file_read_error() << msg_info("No video or audio codec found."));\r
  53                         format_context_.reset(weak_format_context_, av_close_input_file);\r
  54                         \r
  55                         if((errn = -av_find_stream_info(format_context_.get())) > 0)\r
  56                                 throw std::runtime_error("File read error");\r
  57 \r
  58                         video_codec_context_ = open_video_stream();\r
  59                         if(!video_codec_context_)\r
  60                                 CASPAR_LOG(warning) << "No video stream found.";\r
  61                 \r
  62                         audio_codex_context_ = open_audio_stream();\r
  63                         if(!audio_codex_context_)\r
  64                                 CASPAR_LOG(warning) << "No audio stream found.";\r
  65 \r
  66                         if(!video_codec_context_ && !audio_codex_context_)\r
  67                                 BOOST_THROW_EXCEPTION(file_read_error() << msg_info("No video or audio codec found."));\r
  68                         \r
  69                         video_frame_rate_ = static_cast<double>(video_codec_context_->time_base.den) / static_cast<double>(video_codec_context_->time_base.num);                        \r
  70                 }\r
  71                 catch(...)\r
  72                 {\r
  73                         video_codec_context_.reset();\r
  74                         audio_codex_context_.reset();\r
  75                         format_context_.reset();\r
  76                         video_frame_rate_ = 25.0;\r
  77                         video_s_index_ = -1;\r
  78                         audio_s_index_ = -1;    \r
  79                         throw;\r
  80                 }\r
  81                 filename_ = filename;\r
  82         }\r
  83 \r
  84         void start()\r
  85         {\r
  86                 io_thread_ = boost::thread([=]{read_file();});\r
  87         }\r
  88                         \r
  89         std::shared_ptr<AVCodecContext> open_video_stream()\r
  90         {               \r
  91                 AVStream** streams_end = format_context_->streams+format_context_->nb_streams;\r
  92                 AVStream** video_stream = std::find_if(format_context_->streams, streams_end, \r
  93                         [](AVStream* stream) { return stream != nullptr && stream->codec->codec_type == CODEC_TYPE_VIDEO ;});\r
  94 \r
  95                 video_s_index_ = video_stream != streams_end ? (*video_stream)->index : -1;\r
  96                 if(video_s_index_ == -1) \r
  97                         return nullptr;\r
  98                 \r
  99                 video_codec_ = avcodec_find_decoder((*video_stream)->codec->codec_id);                  \r
 100                 if(video_codec_ == nullptr)\r
 101                         return nullptr;\r
 102                         \r
 103                 if((-avcodec_open((*video_stream)->codec, video_codec_)) > 0)           \r
 104                         return nullptr;\r
 105 \r
 106                 return std::shared_ptr<AVCodecContext>((*video_stream)->codec, avcodec_close);\r
 107         }\r
 108 \r
 109         std::shared_ptr<AVCodecContext> open_audio_stream()\r
 110         {       \r
 111                 AVStream** streams_end = format_context_->streams+format_context_->nb_streams;\r
 112                 AVStream** audio_stream = std::find_if(format_context_->streams, streams_end, \r
 113                         [](AVStream* stream) { return stream != nullptr && stream->codec->codec_type == CODEC_TYPE_AUDIO;});\r
 114 \r
 115                 audio_s_index_ = audio_stream != streams_end ? (*audio_stream)->index : -1;\r
 116                 if(audio_s_index_ == -1)\r
 117                         return nullptr;\r
 118                 \r
 119                 audio_codec_ = avcodec_find_decoder((*audio_stream)->codec->codec_id);\r
 120                 if(audio_codec_ == nullptr)\r
 121                         return nullptr;\r
 122 \r
 123                 if((-avcodec_open((*audio_stream)->codec, audio_codec_)) > 0)           \r
 124                         return nullptr;\r
 125 \r
 126                 return std::shared_ptr<AVCodecContext>((*audio_stream)->codec, avcodec_close);\r
 127         }       \r
 128 \r
 129         void read_file()\r
 130         {       \r
 131                 CASPAR_LOG(info) << "Started ffmpeg_producer::read_file Thread for " << filename_.c_str();\r
 132                 win32_exception::install_handler();\r
 133                 \r
 134                 is_running_ = true;\r
 135                 AVPacket tmp_packet;\r
 136                 while(is_running_)\r
 137                 {\r
 138                         std::shared_ptr<AVPacket> packet(&tmp_packet, av_free_packet);  \r
 139                         tbb::queuing_mutex::scoped_lock lock(seek_mutex_);      \r
 140 \r
 141                         if (av_read_frame(format_context_.get(), packet.get()) >= 0) // NOTE: Packet is only valid until next call of av_read_frame or av_close_input_file\r
 142                         {\r
 143                                 if(packet->stream_index == video_s_index_)              \r
 144                                 {\r
 145                                         video_packet_buffer_.push(std::make_shared<video_packet>(packet, format_desc_, video_codec_context_.get(), video_codec_)); // NOTE: video_packet makes a copy of AVPacket\r
 146                                         //file_buffer_size_ += packet->size;\r
 147                                 }\r
 148                                 else if(packet->stream_index == audio_s_index_)         \r
 149                                 {\r
 150                                         audio_packet_buffer_.push(std::make_shared<audio_packet>(packet, audio_codex_context_.get(), audio_codec_, video_frame_rate_));         \r
 151                                         //file_buffer_size_ += packet->size;\r
 152                                 }\r
 153                         }\r
 154                         else if(!loop_ || av_seek_frame(format_context_.get(), -1, 0, AVSEEK_FLAG_BACKWARD) < 0) // TODO: av_seek_frame does not work for all formats\r
 155                                 is_running_ = false;\r
 156                         \r
 157                         //if(is_running_)\r
 158                         //{\r
 159                         //      boost::unique_lock<boost::mutex> lock(file_buffer_size_mutex_);\r
 160                         //      while(file_buffer_size_ > 32*1000000)\r
 161                         //              file_buffer_size_cond_.wait(lock);      \r
 162                         //}\r
 163                 }\r
 164                 \r
 165                 is_running_ = false;\r
 166                 \r
 167                 CASPAR_LOG(info) << " Ended ffmpeg_producer::read_file Thread for " << filename_.c_str();\r
 168         }\r
 169         \r
 170         video_packet_ptr get_video_packet()\r
 171         {\r
 172                 video_packet_ptr video_packet;\r
 173                 if(video_packet_buffer_.try_pop(video_packet))\r
 174                 {\r
 175                         //file_buffer_size_ -= video_packet->size;\r
 176                         //file_buffer_size_cond_.notify_all();\r
 177                 }\r
 178                 return video_packet;\r
 179         }\r
 180 \r
 181         audio_packet_ptr get_audio_packet()\r
 182         {\r
 183                 audio_packet_ptr audio_packet;\r
 184                 if(audio_packet_buffer_.try_pop(audio_packet))\r
 185                 {\r
 186                         //file_buffer_size_ -= audio_packet->size;\r
 187                         //file_buffer_size_cond_.notify_all();\r
 188                 }\r
 189                 return audio_packet;\r
 190         }\r
 191 \r
 192         bool is_eof() const\r
 193         {\r
 194                 return !is_running_ && video_packet_buffer_.empty() && audio_packet_buffer_.empty();\r
 195         }\r
 196         \r
 197         bool seek(unsigned long long seek_target)\r
 198         {\r
 199                 tbb::queuing_mutex::scoped_lock lock(seek_mutex_);\r
 200                 if(av_seek_frame(format_context_.get(), -1, seek_target*AV_TIME_BASE, 0) >= 0)\r
 201                 {\r
 202                         video_packet_buffer_.clear();\r
 203                         audio_packet_buffer_.clear();\r
 204                         // TODO: Not sure its enough to jsut flush in input class\r
 205                         if(video_codec_context_)\r
 206                                 avcodec_flush_buffers(video_codec_context_.get());\r
 207                         if(audio_codex_context_)\r
 208                                 avcodec_flush_buffers(audio_codex_context_.get());\r
 209                         return true;\r
 210                 }\r
 211                 \r
 212                 return false;\r
 213         }\r
 214         \r
 215         //int                                                                   file_buffer_max_size_;\r
 216         //tbb::atomic<int>                                      file_buffer_size_;\r
 217         //boost::condition_variable                     file_buffer_size_cond_;\r
 218         //boost::mutex                                          file_buffer_size_mutex_;\r
 219                 \r
 220         tbb::queuing_mutex                                      seek_mutex_;\r
 221 \r
 222         std::string                                                     filename_;\r
 223         std::shared_ptr<AVFormatContext>        format_context_;        // Destroy this last\r
 224 \r
 225         std::shared_ptr<AVCodecContext>         video_codec_context_;\r
 226         AVCodec*                                                        video_codec_;\r
 227 \r
 228         std::shared_ptr<AVCodecContext>         audio_codex_context_;\r
 229         AVCodec*                                                        audio_codec_;\r
 230 \r
 231         tbb::atomic<bool>                                       loop_;\r
 232         int                                                                     video_s_index_;\r
 233         int                                                                     audio_s_index_;\r
 234         \r
 235         tbb::concurrent_bounded_queue<video_packet_ptr> video_packet_buffer_;\r
 236         tbb::concurrent_bounded_queue<audio_packet_ptr> audio_packet_buffer_;\r
 237         boost::thread   io_thread_;\r
 238         tbb::atomic<bool> is_running_;\r
 239 \r
 240         double video_frame_rate_;\r
 241 \r
 242         frame_format_desc format_desc_;\r
 243 };\r
 244 \r
 245 input::input(const frame_format_desc& format_desc) : impl_(new implementation(format_desc)){}\r
 246 void input::load(const std::string& filename){impl_->load(filename);}\r
 247 void input::set_loop(bool value){impl_->loop_ = value;}\r
 248 const std::shared_ptr<AVCodecContext>& input::get_video_codec_context() const{return impl_->video_codec_context_;}\r
 249 const std::shared_ptr<AVCodecContext>& input::get_audio_codec_context() const{return impl_->audio_codex_context_;}\r
 250 bool input::is_eof() const{return impl_->is_eof();}\r
 251 video_packet_ptr input::get_video_packet(){return impl_->get_video_packet();}\r
 252 audio_packet_ptr input::get_audio_packet(){return impl_->get_audio_packet();}\r
 253 bool input::seek(unsigned long long frame){return impl_->seek(frame);}\r
 254 void input::start(){impl_->start();}\r
 255 }}}