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