git.sesse.net Git - casparcg/blob - core/frame/draw_frame.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 "draw_frame.h"
  25 #include "frame.h"
  26 #include "frame_transform.h"
  27
  28 namespace caspar { namespace core {
  29
  30 enum class tags
  31 {
  32         frame_tag = 0,
  33         empty_tag,
  34         eof_tag,
  35         late_tag
  36 };
  37
  38 struct draw_frame::impl
  39 {
  40         std::shared_ptr<const_frame>    frame_;
  41         std::vector<draw_frame>                 frames_;
  42         core::frame_transform                   frame_transform_;
  43 public:
  44
  45         impl()
  46         {
  47         }
  48
  49         impl(const_frame&& frame)
  50                 : frame_(new const_frame(std::move(frame)))
  51         {
  52         }
  53
  54         impl(mutable_frame&& frame)
  55                 : frame_(new const_frame(std::move(frame)))
  56         {
  57         }
  58
  59         impl(std::vector<draw_frame> frames)
  60                 : frames_(std::move(frames))
  61         {
  62         }
  63
  64         impl(const impl& other)
  65                 : frames_(other.frames_)
  66                 , frame_(other.frame_)
  67                 , frame_transform_(other.frame_transform_)
  68         {
  69         }
  70
  71         void accept(frame_visitor& visitor) const
  72         {
  73                 visitor.push(frame_transform_);
  74                 if(frame_)
  75                 {
  76                         visitor.visit(*frame_);
  77                 }
  78                 else
  79                 {
  80                         for (auto& frame : frames_)
  81                                 frame.accept(visitor);
  82                 }
  83                 visitor.pop();
  84         }
  85
  86         bool operator==(const impl& other)
  87         {
  88                 return  frames_                         == other.frames_ &&
  89                                 frame_                          == other.frame_ &&
  90                                 frame_transform_        == other.frame_transform_;
  91         }
  92
  93         int64_t get_and_record_age_millis(const draw_frame& self)
  94         {
  95                 int64_t result = 0;
  96
  97                 for (auto& frame : frames_)
  98                 {
  99                         if (frame != self)
 100                                 result = std::max(result, frame.get_and_record_age_millis());
 101                 }
 102
 103                 if (frame_)
 104                         result = std::max(result, frame_->get_age_millis());
 105
 106                 return result;
 107         }
 108 };
 109
 110 draw_frame::draw_frame() : impl_(new impl()){}
 111 draw_frame::draw_frame(const draw_frame& other) : impl_(new impl(*other.impl_)){}
 112 draw_frame::draw_frame(draw_frame&& other) : impl_(std::move(other.impl_)){}
 113 draw_frame::draw_frame(const_frame&& frame)  : impl_(new impl(std::move(frame))){}
 114 draw_frame::draw_frame(mutable_frame&& frame)  : impl_(new impl(std::move(frame))){}
 115 draw_frame::draw_frame(std::vector<draw_frame> frames) : impl_(new impl(frames)){}
 116 draw_frame::~draw_frame(){}
 117 draw_frame& draw_frame::operator=(draw_frame other)
 118 {
 119         other.swap(*this);
 120         return *this;
 121 }
 122 void draw_frame::swap(draw_frame& other){impl_.swap(other.impl_);}
 123
 124 const core::frame_transform& draw_frame::transform() const { return impl_->frame_transform_;}
 125 core::frame_transform& draw_frame::transform() { return impl_->frame_transform_;}
 126 void draw_frame::accept(frame_visitor& visitor) const{impl_->accept(visitor);}
 127 int64_t draw_frame::get_and_record_age_millis() { return impl_->get_and_record_age_millis(*this); }
 128 bool draw_frame::operator==(const draw_frame& other)const{return *impl_ == *other.impl_;}
 129 bool draw_frame::operator!=(const draw_frame& other)const{return !(*this == other);}
 130
 131 draw_frame draw_frame::interlace(draw_frame frame1, draw_frame frame2, core::field_mode mode)
 132 {
 133         if(frame1 == draw_frame::empty() && frame2 == draw_frame::empty())
 134                 return draw_frame::empty();
 135
 136         if(frame1 == frame2 || mode == field_mode::progressive)
 137                 return frame2;
 138
 139         if(mode == field_mode::upper)
 140         {
 141                 frame1.transform().image_transform.field_mode = field_mode::upper;
 142                 frame2.transform().image_transform.field_mode = field_mode::lower;
 143         }
 144         else
 145         {
 146                 frame1.transform().image_transform.field_mode = field_mode::lower;
 147                 frame2.transform().image_transform.field_mode = field_mode::upper;
 148         }
 149
 150         std::vector<draw_frame> frames;
 151         frames.push_back(std::move(frame1));
 152         frames.push_back(std::move(frame2));
 153         return draw_frame(std::move(frames));
 154 }
 155
 156 draw_frame draw_frame::over(draw_frame frame1, draw_frame frame2)
 157 {
 158         if(frame1 == draw_frame::empty() && frame2 == draw_frame::empty())
 159                 return draw_frame::empty();
 160
 161         std::vector<draw_frame> frames;
 162         frames.push_back(std::move(frame1));
 163         frames.push_back(std::move(frame2));
 164         return draw_frame(std::move(frames));
 165 }
 166
 167 draw_frame draw_frame::mask(draw_frame fill, draw_frame key)
 168 {
 169         if(fill == draw_frame::empty() || key == draw_frame::empty())
 170                 return draw_frame::empty();
 171
 172         std::vector<draw_frame> frames;
 173         key.transform().image_transform.is_key = true;
 174         frames.push_back(std::move(key));
 175         frames.push_back(std::move(fill));
 176         return draw_frame(std::move(frames));
 177 }
 178
 179 draw_frame draw_frame::push(draw_frame frame)
 180 {
 181         std::vector<draw_frame> frames;
 182         frames.push_back(std::move(frame));
 183         return draw_frame(std::move(frames));
 184 }
 185
 186 draw_frame eof_frame(const_frame(0));
 187 draw_frame empty_frame(const_frame(0));
 188 draw_frame late_frame(const_frame(0));
 189
 190 draw_frame draw_frame::still(draw_frame frame)
 191 {
 192         frame.transform().image_transform.is_still = true;
 193         frame.transform().audio_transform.is_still = true;
 194         return frame;
 195 }
 196
 197 const draw_frame& draw_frame::empty()
 198 {
 199         return empty_frame;
 200 }
 201
 202 const draw_frame& draw_frame::late()
 203 {
 204         return late_frame;
 205 }
 206
 207
 208 }}