git.sesse.net Git - casparcg/blob - modules/ffmpeg/producer/muxer/frame_muxer.cpp

   1 /*
   2 * Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
   3 *
   4 * This file is part of CasparCG (www.casparcg.com).
   5 *
   6 * CasparCG is free software: you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation, either version 3 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * CasparCG is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
  18 *
  19 * Author: Robert Nagy, ronag89@gmail.com
  20 */
  21
  22 #include "../../StdAfx.h"
  23
  24 #include "frame_muxer.h"
  25
  26 #include "../filter/filter.h"
  27 #include "../util/util.h"
  28
  29 #include <core/producer/frame_producer.h>
  30 #include <core/frame/draw_frame.h>
  31 #include <core/frame/frame_transform.h>
  32 #include <core/frame/pixel_format.h>
  33 #include <core/frame/frame_factory.h>
  34 #include <core/frame/frame.h>
  35
  36 #include <common/env.h>
  37 #include <common/except.h>
  38 #include <common/log.h>
  39
  40 #if defined(_MSC_VER)
  41 #pragma warning (push)
  42 #pragma warning (disable : 4244)
  43 #endif
  44 extern "C"
  45 {
  46         #define __STDC_CONSTANT_MACROS
  47         #define __STDC_LIMIT_MACROS
  48         #include <libavcodec/avcodec.h>
  49         #include <libavformat/avformat.h>
  50 }
  51 #if defined(_MSC_VER)
  52 #pragma warning (pop)
  53 #endif
  54
  55 #include <common/assert.h>
  56 #include <boost/foreach.hpp>
  57 #include <boost/range/algorithm_ext/push_back.hpp>
  58 #include <boost/algorithm/string/predicate.hpp>
  59
  60 #include <deque>
  61 #include <queue>
  62 #include <vector>
  63
  64 using namespace caspar::core;
  65
  66 namespace caspar { namespace ffmpeg {
  67
  68 struct frame_muxer::impl : boost::noncopyable
  69 {
  70         std::queue<core::mutable_frame>                                 video_stream_;
  71         core::audio_buffer                                                              audio_stream_;
  72         std::queue<draw_frame>                                                  frame_buffer_;
  73         display_mode                                                                    display_mode_;
  74         const double                                                                    in_fps_;
  75         const video_format_desc                                                 format_desc_;
  76
  77         std::vector<int>                                                                audio_cadence_;
  78
  79         spl::shared_ptr<core::frame_factory>                    frame_factory_;
  80
  81         filter                                                                                  filter_;
  82         const std::wstring                                                              filter_str_;
  83         bool                                                                                    force_deinterlacing_;
  84
  85         impl(double in_fps, const spl::shared_ptr<core::frame_factory>& frame_factory, const core::video_format_desc& format_desc, const std::wstring& filter_str)
  86                 : display_mode_(display_mode::invalid)
  87                 , in_fps_(in_fps)
  88                 , format_desc_(format_desc)
  89                 , audio_cadence_(format_desc_.audio_cadence)
  90                 , frame_factory_(frame_factory)
  91                 , filter_str_(filter_str)
  92                 , force_deinterlacing_(env::properties().get(L"configuration.force-deinterlace", true))
  93         {
  94                 // Note: Uses 1 step rotated cadence for 1001 modes (1602, 1602, 1601, 1602, 1601)
  95                 // This cadence fills the audio mixer most optimally.
  96                 boost::range::rotate(audio_cadence_, std::end(audio_cadence_)-1);
  97         }
  98
  99         void push_video(const std::shared_ptr<AVFrame>& video)
 100         {
 101                 if(!video)
 102                         return;
 103
 104                 if(!video->data[0])
 105                 {
 106                         auto empty_frame = frame_factory_->create_frame(this, core::pixel_format_desc(core::pixel_format::invalid));
 107                         video_stream_.push(std::move(empty_frame));
 108                         display_mode_ = display_mode::simple;
 109                 }
 110                 else
 111                 {
 112                         if(display_mode_ == display_mode::invalid)
 113                                 update_display_mode(video);
 114
 115                         filter_.push(video);
 116                         BOOST_FOREACH(auto& av_frame, filter_.poll_all())
 117                                 video_stream_.push(make_frame(this, av_frame, format_desc_.fps, *frame_factory_));
 118                 }
 119
 120                 merge();
 121         }
 122
 123         void push_audio(const std::shared_ptr<AVFrame>& audio)
 124         {
 125                 if(!audio)
 126                         return;
 127
 128                 if(!audio->data[0])
 129                 {
 130                         boost::range::push_back(audio_stream_, core::audio_buffer(audio_cadence_.front(), 0));
 131                 }
 132                 else
 133                 {
 134                         auto ptr = reinterpret_cast<int32_t*>(audio->data[0]);
 135                         audio_stream_.insert(audio_stream_.end(), ptr, ptr + audio->linesize[0]/sizeof(int32_t));
 136                 }
 137
 138                 merge();
 139         }
 140
 141         bool video_ready() const
 142         {
 143                 switch(display_mode_)
 144                 {
 145                 case display_mode::deinterlace_bob_reinterlace:
 146                 case display_mode::interlace:
 147                 case display_mode::half:
 148                         return video_stream_.size() >= 2;
 149                 default:
 150                         return video_stream_.size() >= 1;
 151                 }
 152         }
 153
 154         bool audio_ready() const
 155         {
 156                 switch(display_mode_)
 157                 {
 158                 case display_mode::duplicate:
 159                         return audio_stream_.size() >= static_cast<size_t>(audio_cadence_[0] + audio_cadence_[1 % audio_cadence_.size()]);
 160                 default:
 161                         return audio_stream_.size() >= static_cast<size_t>(audio_cadence_.front());
 162                 }
 163         }
 164
 165         bool empty() const
 166         {
 167                 return frame_buffer_.empty();
 168         }
 169
 170         core::draw_frame front() const
 171         {
 172                 return frame_buffer_.front();
 173         }
 174
 175         void pop()
 176         {
 177                 frame_buffer_.pop();
 178         }
 179
 180         void merge()
 181         {
 182                 while(video_ready() && audio_ready() && display_mode_ != display_mode::invalid)
 183                 {
 184                         auto frame1                     = pop_video();
 185                         frame1.audio_data()     = pop_audio();
 186
 187                         switch(display_mode_)
 188                         {
 189                         case display_mode::simple:
 190                         case display_mode::deinterlace_bob:
 191                         case display_mode::deinterlace:
 192                                 {
 193                                         frame_buffer_.push(core::draw_frame(std::move(frame1)));
 194                                         break;
 195                                 }
 196                         case display_mode::interlace:
 197                         case display_mode::deinterlace_bob_reinterlace:
 198                                 {
 199                                         auto frame2 = pop_video();
 200
 201                                         frame_buffer_.push(core::draw_frame::interlace(
 202                                                 core::draw_frame(std::move(frame1)),
 203                                                 core::draw_frame(std::move(frame2)),
 204                                                 format_desc_.field_mode));
 205                                         break;
 206                                 }
 207                         case display_mode::duplicate:
 208                                 {
 209                                         boost::range::push_back(frame1.audio_data(), pop_audio());
 210
 211                                         auto draw_frame = core::draw_frame(std::move(frame1));
 212                                         frame_buffer_.push(draw_frame);
 213                                         frame_buffer_.push(draw_frame);
 214                                         break;
 215                                 }
 216                         case display_mode::half:
 217                                 {
 218                                         pop_video(); // Throw away
 219
 220                                         frame_buffer_.push(core::draw_frame(std::move(frame1)));
 221                                         break;
 222                                 }
 223                         default:
 224                                 CASPAR_THROW_EXCEPTION(invalid_operation());
 225                         }
 226                 }
 227         }
 228
 229         core::mutable_frame pop_video()
 230         {
 231                 auto frame = std::move(video_stream_.front());
 232                 video_stream_.pop();
 233                 return std::move(frame);
 234         }
 235
 236         core::audio_buffer pop_audio()
 237         {
 238                 if(audio_stream_.size() < audio_cadence_.front())
 239                         CASPAR_THROW_EXCEPTION(out_of_range());
 240
 241                 auto begin = audio_stream_.begin();
 242                 auto end   = begin + audio_cadence_.front();
 243
 244                 core::audio_buffer samples(begin, end);
 245                 audio_stream_.erase(begin, end);
 246
 247                 boost::range::rotate(audio_cadence_, std::begin(audio_cadence_)+1);
 248
 249                 return samples;
 250         }
 251
 252         void update_display_mode(const std::shared_ptr<AVFrame>& frame)
 253         {
 254                 std::wstring filter_str = filter_str_;
 255
 256                 display_mode_ = display_mode::simple;
 257
 258                 auto mode = get_mode(*frame);
 259                 if(mode == core::field_mode::progressive && frame->height < 720 && in_fps_ < 50.0) // SD frames are interlaced. Probably incorrect meta-data. Fix it.
 260                         mode = core::field_mode::upper;
 261
 262                 auto fps  = in_fps_;
 263
 264                 if(filter::is_deinterlacing(filter_str_))
 265                         mode = core::field_mode::progressive;
 266
 267                 if(filter::is_double_rate(filter_str_))
 268                         fps *= 2;
 269
 270                 display_mode_ = get_display_mode(mode, fps, format_desc_.field_mode, format_desc_.fps);
 271
 272                 if((frame->height != 480 || format_desc_.height != 486) && // don't deinterlace for NTSC DV
 273                                 display_mode_ == display_mode::simple && mode != core::field_mode::progressive && format_desc_.field_mode != core::field_mode::progressive &&
 274                                 frame->height != format_desc_.height)
 275                 {
 276                         display_mode_ = display_mode::deinterlace_bob_reinterlace; // The frame will most likely be scaled, we need to deinterlace->reinterlace
 277                 }
 278
 279                 // ALWAYS de-interlace, until we have GPU de-interlacing.
 280                 if(force_deinterlacing_ && frame->interlaced_frame && display_mode_ != display_mode::deinterlace_bob && display_mode_ != display_mode::deinterlace)
 281                         display_mode_ = display_mode::deinterlace_bob_reinterlace;
 282
 283                 if(display_mode_ == display_mode::deinterlace)
 284                         filter_str = append_filter(filter_str, L"YADIF=0:-1");
 285                 else if(display_mode_ == display_mode::deinterlace_bob || display_mode_ == display_mode::deinterlace_bob_reinterlace)
 286                         filter_str = append_filter(filter_str, L"YADIF=1:-1");
 287
 288                 if(display_mode_ == display_mode::invalid)
 289                 {
 290                         CASPAR_LOG(warning) << L"[frame_muxer] Auto-transcode: Failed to detect display-mode.";
 291                         display_mode_ = display_mode::simple;
 292                 }
 293
 294                 if(frame->height == 480) // NTSC DV
 295                 {
 296                         auto pad_str = L"PAD=" + boost::lexical_cast<std::wstring>(frame->width) + L":486:0:2:black";
 297                         filter_str = append_filter(filter_str, pad_str);
 298                 }
 299
 300                 filter_ = filter(filter_str);
 301                 CASPAR_LOG(info) << L"[frame_muxer] " << display_mode_ << L" " << print_mode(frame->width, frame->height, in_fps_, frame->interlaced_frame > 0);
 302         }
 303
 304         uint32_t calc_nb_frames(uint32_t nb_frames) const
 305         {
 306                 uint64_t nb_frames2 = nb_frames;
 307
 308                 if(filter_.is_double_rate()) // Take into account transformations in filter.
 309                         nb_frames2 *= 2;
 310
 311                 switch(display_mode_) // Take into account transformation in run.
 312                 {
 313                 case display_mode::deinterlace_bob_reinterlace:
 314                 case display_mode::interlace:
 315                 case display_mode::half:
 316                         nb_frames2 /= 2;
 317                         break;
 318                 case display_mode::duplicate:
 319                         nb_frames2 *= 2;
 320                         break;
 321                 }
 322
 323                 return static_cast<uint32_t>(nb_frames2);
 324         }
 325
 326         void clear()
 327         {
 328                 while(!video_stream_.empty())
 329                         video_stream_.pop();
 330
 331                 audio_stream_.clear();
 332
 333                 while(!frame_buffer_.empty())
 334                         frame_buffer_.pop();
 335
 336                 filter_ = filter(filter_.filter_str());
 337         }
 338 };
 339
 340 frame_muxer::frame_muxer(double in_fps, const spl::shared_ptr<core::frame_factory>& frame_factory, const core::video_format_desc& format_desc, const std::wstring& filter)
 341         : impl_(new impl(in_fps, frame_factory, format_desc, filter)){}
 342 void frame_muxer::push_video(const std::shared_ptr<AVFrame>& frame){impl_->push_video(frame);}
 343 void frame_muxer::push_audio(const std::shared_ptr<AVFrame>& frame){impl_->push_audio(frame);}
 344 bool frame_muxer::empty() const{return impl_->empty();}
 345 core::draw_frame frame_muxer::front() const{return impl_->front();}
 346 void frame_muxer::pop(){return impl_->pop();}
 347 void frame_muxer::clear(){impl_->clear();}
 348 uint32_t frame_muxer::calc_nb_frames(uint32_t nb_frames) const {return impl_->calc_nb_frames(nb_frames);}
 349 bool frame_muxer::video_ready() const{return impl_->video_ready();}
 350 bool frame_muxer::audio_ready() const{return impl_->audio_ready();}
 351
 352 }}