]> git.sesse.net Git - casparcg/blob - modules/ffmpeg/producer/video/video_decoder.cpp
git-svn-id: https://casparcg.svn.sourceforge.net/svnroot/casparcg/server/branches...
[casparcg] / modules / ffmpeg / producer / video / video_decoder.cpp
1 /*\r
2 * copyright (c) 2010 Sveriges Television AB <info@casparcg.com>\r
3 *\r
4 *  This file is part of CasparCG.\r
5 *\r
6 *    CasparCG is free software: you can redistribute it and/or modify\r
7 *    it under the terms of the GNU General Public License as published by\r
8 *    the Free Software Foundation, either version 3 of the License, or\r
9 *    (at your option) any later version.\r
10 *\r
11 *    CasparCG is distributed in the hope that it will be useful,\r
12 *    but WITHOUT ANY WARRANTY; without even the implied warranty of\r
13 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
14 *    GNU General Public License for more details.\r
15 \r
16 *    You should have received a copy of the GNU General Public License\r
17 *    along with CasparCG.  If not, see <http://www.gnu.org/licenses/>.\r
18 *\r
19 */\r
20 #include "../../stdafx.h"\r
21 \r
22 #include "video_decoder.h"\r
23 \r
24 #include "../util.h"\r
25 #include "../filter/filter.h"\r
26 \r
27 #include "../../ffmpeg_error.h"\r
28 \r
29 #include <core/producer/frame/basic_frame.h>\r
30 \r
31 #if defined(_MSC_VER)\r
32 #pragma warning (push)\r
33 #pragma warning (disable : 4244)\r
34 #endif\r
35 extern "C" \r
36 {\r
37         #include <libavcodec/avcodec.h>\r
38         #include <libavformat/avformat.h>\r
39 }\r
40 #if defined(_MSC_VER)\r
41 #pragma warning (pop)\r
42 #endif\r
43 \r
44 #include <connect.h>\r
45 #include <semaphore.h>\r
46 \r
47 using namespace Concurrency;\r
48 \r
49 namespace caspar { namespace ffmpeg {\r
50         \r
51 struct video_decoder::implementation : public Concurrency::agent, boost::noncopyable\r
52 {       \r
53         int                                                                             index_;\r
54         safe_ptr<AVCodecContext>                                codec_context_; \r
55         const double                                                    fps_;\r
56         const int64_t                                                   nb_frames_;\r
57         const size_t                                                    width_;\r
58         const size_t                                                    height_;\r
59 \r
60         bool                                                                    is_progressive_;\r
61         \r
62         overwrite_buffer<bool>                                  is_running_;\r
63         unbounded_buffer<safe_ptr<AVPacket>>    source_;\r
64         ITarget<safe_ptr<AVFrame>>&                             target_;\r
65         \r
66         safe_ptr<semaphore>                                             semaphore_;\r
67 \r
68 public:\r
69         explicit implementation(video_decoder::source_t& source, video_decoder::target_t& target, AVFormatContext& context) \r
70                 : codec_context_(open_codec(context, AVMEDIA_TYPE_VIDEO, index_))\r
71                 , fps_(static_cast<double>(codec_context_->time_base.den) / static_cast<double>(codec_context_->time_base.num))\r
72                 , nb_frames_(context.streams[index_]->nb_frames)\r
73                 , width_(codec_context_->width)\r
74                 , height_(codec_context_->height)\r
75                 , is_progressive_(true)\r
76                 , source_([this](const safe_ptr<AVPacket>& packet){return packet->stream_index == index_;})\r
77                 , target_(target)\r
78                 , semaphore_(make_safe<Concurrency::semaphore>(1))\r
79         {               \r
80                 CASPAR_LOG(debug) << "[video_decoder] " << context.streams[index_]->codec->codec->long_name;\r
81                 \r
82                 Concurrency::connect(source, source_);\r
83 \r
84                 start();\r
85         }\r
86 \r
87         ~implementation()\r
88         {\r
89                 send(is_running_, false);\r
90                 agent::wait(this);\r
91         }\r
92 \r
93         virtual void run()\r
94         {\r
95                 try\r
96                 {\r
97                         send(is_running_, true);\r
98                         while(is_running_.value())\r
99                         {\r
100                                 auto packet = receive(source_);\r
101                         \r
102                                 if(packet == loop_packet(index_))\r
103                                 {\r
104                                         send(target_, loop_video());\r
105                                         continue;\r
106                                 }\r
107 \r
108                                 if(packet == eof_packet(index_))\r
109                                         break;\r
110 \r
111                                 std::shared_ptr<AVFrame> decoded_frame(avcodec_alloc_frame(), [this](AVFrame* frame)\r
112                                 {\r
113                                         av_free(frame);\r
114                                         semaphore_->release();\r
115                                 });\r
116                                 semaphore_->acquire();\r
117 \r
118                                 int frame_finished = 0;\r
119                                 THROW_ON_ERROR2(avcodec_decode_video2(codec_context_.get(), decoded_frame.get(), &frame_finished, packet.get()), "[video_decocer]");\r
120 \r
121                                 // 1 packet <=> 1 frame.\r
122                                 // If a decoder consumes less then the whole packet then something is wrong\r
123                                 // that might be just harmless padding at the end, or a problem with the\r
124                                 // AVParser or demuxer which puted more then one frame in a AVPacket.\r
125 \r
126                                 if(frame_finished == 0) \r
127                                         continue;\r
128 \r
129                                 if(decoded_frame->repeat_pict > 0)\r
130                                         CASPAR_LOG(warning) << "[video_decoder]: Field repeat_pict not implemented.";\r
131                 \r
132                                 is_progressive_ = decoded_frame->interlaced_frame == 0;\r
133                                 \r
134                                 send(target_, make_safe_ptr(decoded_frame));\r
135                                 Concurrency::wait(10);\r
136                         }\r
137                 }\r
138                 catch(...)\r
139                 {\r
140                         CASPAR_LOG_CURRENT_EXCEPTION();\r
141                 }\r
142                 \r
143                 send(is_running_, false),\r
144                 send(target_, eof_video());\r
145 \r
146                 done();\r
147         }\r
148                 \r
149         double fps() const\r
150         {\r
151                 return fps_;\r
152         }\r
153 };\r
154 \r
155 video_decoder::video_decoder(video_decoder::source_t& source, video_decoder::target_t& target, AVFormatContext& context) \r
156         : impl_(new implementation(source, target, context))\r
157 {\r
158 }\r
159 \r
160 double video_decoder::fps() const{return impl_->fps();}\r
161 int64_t video_decoder::nb_frames() const{return impl_->nb_frames_;}\r
162 size_t video_decoder::width() const{return impl_->width_;}\r
163 size_t video_decoder::height() const{return impl_->height_;}\r
164 bool video_decoder::is_progressive() const{return impl_->is_progressive_;}\r
165 \r
166 }}