2.1.0: Renamed hint to flag.

git-svn-id: https://casparcg.svn.sourceforge.net/svnroot/casparcg/server/branches/2.1.0@1842 362d55ac-95cf-4e76-9f9a-cbaa9c17b72d

diff --git a/core/producer/frame_producer.cpp b/core/producer/frame_producer.cpp
index d2a11fdef3543e86d709c66e15aea07b65ad0926..68c6b5e2554fddd03422c1cdad431fc276a54c64 100644 (file)
--- a/core/producer/frame_producer.cpp
+++ b/core/producer/frame_producer.cpp
@@ -92,7 +92,7 @@ public:
                }\r
        }\r
 \r
-       virtual safe_ptr<basic_frame>                                                           receive(int hints) override                                                                                             {return (*producer_)->receive(hints);}\r
+       virtual safe_ptr<basic_frame>                                                           receive(int flags) override                                                                                             {return (*producer_)->receive(flags);}\r
        virtual safe_ptr<basic_frame>                                                           last_frame() const override                                                                                             {return (*producer_)->last_frame();}\r
        virtual std::wstring                                                                            print() const override                                                                                                  {return (*producer_)->print();}\r
        virtual boost::property_tree::wptree                                            info() const override                                                                                                   {return (*producer_)->info();}\r
@@ -154,9 +154,9 @@ const safe_ptr<frame_producer>& frame_producer::empty() // nothrow
        return producer;\r
 }      \r
 \r
-safe_ptr<basic_frame> receive_and_follow(safe_ptr<frame_producer>& producer, int hints)\r
+safe_ptr<basic_frame> receive_and_follow(safe_ptr<frame_producer>& producer, int flags)\r
 {      \r
-       auto frame = producer->receive(hints);\r
+       auto frame = producer->receive(flags);\r
        if(frame == basic_frame::eof())\r
        {\r
                CASPAR_LOG(info) << producer->print() << " End Of File.";\r
@@ -169,7 +169,7 @@ safe_ptr<basic_frame> receive_and_follow(safe_ptr<frame_producer>& producer, int
                else\r
                        producer = make_safe<last_frame_producer>(producer);\r
 \r
-               return receive_and_follow(producer, hints);\r
+               return receive_and_follow(producer, flags);\r
        }\r
        return frame;\r
 }\r

diff --git a/core/producer/frame_producer.h b/core/producer/frame_producer.h
index 5375707c37625cdc6ba1500b8fb65a4bfc9a353e..06fc0cd53ba6e05f13e154338408d46d92f4fd45 100644 (file)
--- a/core/producer/frame_producer.h
+++ b/core/producer/frame_producer.h
@@ -47,11 +47,11 @@ struct frame_factory;
 struct frame_producer : boost::noncopyable\r
 {\r
 public:\r
-       enum hints\r
+       enum flags\r
        {\r
-               NO_HINT = 0,\r
-               ALPHA_HINT = 1,\r
-               DEINTERLACE_HINT\r
+               NO_FLAG = 0,\r
+               ALPHA_ONLY_FLAG = 1,\r
+               DEINTERLACE_FLAG\r
        };\r
 \r
        virtual ~frame_producer(){}     \r
@@ -71,13 +71,13 @@ public:
                \r
        virtual uint32_t nb_frames() const {return std::numeric_limits<uint32_t>::max();}\r
        \r
-       virtual safe_ptr<basic_frame> receive(int hints) = 0;\r
+       virtual safe_ptr<basic_frame> receive(int flags) = 0;\r
        virtual safe_ptr<core::basic_frame> last_frame() const = 0;\r
 \r
        static const safe_ptr<frame_producer>& empty(); // nothrow\r
 };\r
 \r
-safe_ptr<basic_frame> receive_and_follow(safe_ptr<frame_producer>& producer, int hints);\r
+safe_ptr<basic_frame> receive_and_follow(safe_ptr<frame_producer>& producer, int flags);\r
 \r
 typedef std::function<safe_ptr<core::frame_producer>(const safe_ptr<frame_factory>&, const std::vector<std::wstring>&)> producer_factory_t;\r
 void register_producer_factory(const producer_factory_t& factory); // Not thread-safe.\r

diff --git a/core/producer/layer.cpp b/core/producer/layer.cpp
index 2a5cfe5368a2fb8fed943562dfdc3550435b1c8b..f94dee40177e16faf5715d7ddc3d016ea94b2b7c 100644 (file)
--- a/core/producer/layer.cpp
+++ b/core/producer/layer.cpp
@@ -69,7 +69,7 @@ public:
                if(preview) // Play the first frame and pause.\r
                {                       \r
                        play();\r
-                       receive(frame_producer::NO_HINT);\r
+                       receive(frame_producer::NO_FLAG);\r
                        pause();\r
                }\r
        }\r
@@ -99,14 +99,14 @@ public:
                is_paused_                      = true;\r
        }\r
                \r
-       safe_ptr<basic_frame> receive(int hints)\r
+       safe_ptr<basic_frame> receive(int flags)\r
        {               \r
                try\r
                {\r
                        if(is_paused_)\r
                                return disable_audio(foreground_->last_frame());\r
                \r
-                       auto frame = receive_and_follow(foreground_, hints);\r
+                       auto frame = receive_and_follow(foreground_, flags);\r
                        if(frame == core::basic_frame::late())\r
                                return foreground_->last_frame();\r
 \r
@@ -114,7 +114,7 @@ public:
                        if(auto_play_delta_ > -1 && frames_left < 1)\r
                        {\r
                                play();\r
-                               return receive(hints);\r
+                               return receive(flags);\r
                        }\r
                                \r
                        return frame;\r
@@ -178,7 +178,7 @@ void layer::pause(){impl_->pause();}
 void layer::stop(){impl_->stop();}\r
 bool layer::is_paused() const{return impl_->is_paused_;}\r
 int64_t layer::frame_number() const{return impl_->frame_number_;}\r
-safe_ptr<basic_frame> layer::receive(int hints) {return impl_->receive(hints);}\r
+safe_ptr<basic_frame> layer::receive(int flags) {return impl_->receive(flags);}\r
 safe_ptr<frame_producer> layer::foreground() const { return impl_->foreground_;}\r
 safe_ptr<frame_producer> layer::background() const { return impl_->background_;}\r
 bool layer::empty() const {return impl_->empty();}\r

diff --git a/core/producer/layer.h b/core/producer/layer.h
index 38ccd43a6651e08c18ce3575f63d502e44da2b55..d7d190aa18a4ad2b0b27cf0edfc231df638660aa 100644 (file)
--- a/core/producer/layer.h
+++ b/core/producer/layer.h
@@ -59,7 +59,7 @@ public:
        safe_ptr<frame_producer> foreground() const; // nothrow\r
        safe_ptr<frame_producer> background() const; // nothrow\r
 \r
-       safe_ptr<basic_frame> receive(int hints); // nothrow\r
+       safe_ptr<basic_frame> receive(int flags); // nothrow\r
 \r
        boost::property_tree::wptree info() const;\r
 private:\r

diff --git a/core/producer/playlist/playlist_producer.cpp b/core/producer/playlist/playlist_producer.cpp
index 2068e2a57c4969611e4a2e4532ee8ac4dfc66ec3..305b36ce19b1c7a0f6348994a76d598ec7efaa09 100644 (file)
--- a/core/producer/playlist/playlist_producer.cpp
+++ b/core/producer/playlist/playlist_producer.cpp
@@ -52,16 +52,16 @@ struct playlist_producer : public frame_producer
 \r
        // frame_producer\r
        \r
-       virtual safe_ptr<basic_frame> receive(int hints) override\r
+       virtual safe_ptr<basic_frame> receive(int flags) override\r
        {\r
                if(current_ == frame_producer::empty() && !producers_.empty())\r
                        next();\r
 \r
-               auto frame = current_->receive(hints);\r
+               auto frame = current_->receive(flags);\r
                if(frame == basic_frame::eof())\r
                {\r
                        current_ = frame_producer::empty();\r
-                       return receive(hints);\r
+                       return receive(flags);\r
                }\r
 \r
                return last_frame_ = frame;\r

diff --git a/core/producer/separated/separated_producer.cpp b/core/producer/separated/separated_producer.cpp
index f52789f11bd266efd34d8e5366243b9262d35431..b316e32093745466cf1218e2ddd151973dd40d8d 100644 (file)
--- a/core/producer/separated/separated_producer.cpp
+++ b/core/producer/separated/separated_producer.cpp
@@ -48,18 +48,18 @@ struct separated_producer : public frame_producer
 \r
        // frame_producer\r
        \r
-       virtual safe_ptr<basic_frame> receive(int hints) override\r
+       virtual safe_ptr<basic_frame> receive(int flags) override\r
        {\r
                tbb::parallel_invoke(\r
                [&]\r
                {\r
                        if(fill_ == core::basic_frame::late())\r
-                               fill_ = receive_and_follow(fill_producer_, hints);\r
+                               fill_ = receive_and_follow(fill_producer_, flags);\r
                },\r
                [&]\r
                {\r
                        if(key_ == core::basic_frame::late())\r
-                               key_ = receive_and_follow(key_producer_, hints | ALPHA_HINT);\r
+                               key_ = receive_and_follow(key_producer_, flags | ALPHA_ONLY_FLAG);\r
                });\r
 \r
                if(fill_ == basic_frame::eof() || key_ == basic_frame::eof())\r

diff --git a/core/producer/stage.cpp b/core/producer/stage.cpp
index 2396e7be6b2368fa75ae80737531b428cdd3ae48..ee95491eedd41900e0e30fc660c5369a3e8990bc 100644 (file)
--- a/core/producer/stage.cpp
+++ b/core/producer/stage.cpp
@@ -122,17 +122,17 @@ public:
                        {\r
                                auto transform = transforms_[layer.first].fetch_and_tick(1);\r
 \r
-                               int hints = frame_producer::NO_HINT;\r
+                               int flags = frame_producer::NO_FLAG;\r
                                if(format_desc_.field_mode != field_mode::progressive)\r
                                {\r
-                                       hints |= std::abs(transform.fill_scale[1]  - 1.0) > 0.0001 ? frame_producer::DEINTERLACE_HINT : frame_producer::NO_HINT;\r
-                                       hints |= std::abs(transform.fill_translation[1]) > 0.0001 ? frame_producer::DEINTERLACE_HINT : frame_producer::NO_HINT;\r
+                                       flags |= std::abs(transform.fill_scale[1]  - 1.0) > 0.0001 ? frame_producer::DEINTERLACE_FLAG : frame_producer::NO_FLAG;\r
+                                       flags |= std::abs(transform.fill_translation[1]) > 0.0001 ? frame_producer::DEINTERLACE_FLAG : frame_producer::NO_FLAG;\r
                                }\r
 \r
                                if(transform.is_key)\r
-                                       hints |= frame_producer::ALPHA_HINT;\r
+                                       flags |= frame_producer::ALPHA_ONLY_FLAG;\r
 \r
-                               auto frame = layer.second.receive(hints);       \r
+                               auto frame = layer.second.receive(flags);       \r
                                \r
                                auto frame1 = make_safe<core::basic_frame>(frame);\r
                                frame1->get_frame_transform() = transform;\r
@@ -167,7 +167,8 @@ public:
                        CASPAR_LOG_CURRENT_EXCEPTION();\r
                }               \r
        }\r
-               void set_transform(int index, const frame_transform& transform, unsigned int mix_duration, const std::wstring& tween)\r
+               \r
+       void set_transform(int index, const frame_transform& transform, unsigned int mix_duration, const std::wstring& tween)\r
        {\r
                executor_.begin_invoke([=]\r
                {\r

diff --git a/core/producer/transition/transition_producer.cpp b/core/producer/transition/transition_producer.cpp
index 2b14faaf7d89ba4ea9c69421750878c3772909b0..c4d61bd6aa5402c9711b8ec07f90b462e9eb2a39 100644 (file)
--- a/core/producer/transition/transition_producer.cpp
+++ b/core/producer/transition/transition_producer.cpp
@@ -68,7 +68,7 @@ struct transition_producer : public frame_producer
                source_producer_ = producer;\r
        }\r
 \r
-       virtual safe_ptr<basic_frame> receive(int hints) override\r
+       virtual safe_ptr<basic_frame> receive(int flags) override\r
        {\r
                if(++current_frame_ >= info_.duration)\r
                        return basic_frame::eof();\r
@@ -79,13 +79,13 @@ struct transition_producer : public frame_producer
                tbb::parallel_invoke(\r
                [&]\r
                {\r
-                       dest = receive_and_follow(dest_producer_, hints);\r
+                       dest = receive_and_follow(dest_producer_, flags);\r
                        if(dest == core::basic_frame::late())\r
                                dest = dest_producer_->last_frame();\r
                },\r
                [&]\r
                {\r
-                       source = receive_and_follow(source_producer_, hints);\r
+                       source = receive_and_follow(source_producer_, flags);\r
                        if(source == core::basic_frame::late())\r
                                source = source_producer_->last_frame();\r
                });\r

diff --git a/modules/decklink/producer/decklink_producer.cpp b/modules/decklink/producer/decklink_producer.cpp
index 601c39de8fe3f89bbdc4d53a2be4741f1261caa4..afb748b46ad50586368c3c315a1a8546d2fa922a 100644 (file)
--- a/modules/decklink/producer/decklink_producer.cpp
+++ b/modules/decklink/producer/decklink_producer.cpp
@@ -90,7 +90,7 @@ class decklink_producer : boost::noncopyable, public IDeckLinkInputCallback
        boost::timer                                                                                            tick_timer_;\r
        boost::timer                                                                                            frame_timer_;\r
                \r
-       tbb::atomic<int>                                                                                        hints_;\r
+       tbb::atomic<int>                                                                                        flags_;\r
        safe_ptr<core::frame_factory>                                                           frame_factory_;\r
        std::vector<size_t>                                                                                     audio_cadence_;\r
 \r
@@ -114,7 +114,7 @@ public:
                , muxer_(format_desc.fps, frame_factory, filter)\r
                , sync_buffer_(format_desc.audio_cadence.size())\r
        {               \r
-               hints_ = 0;\r
+               flags_ = 0;\r
                frame_buffer_.set_capacity(2);\r
                \r
                graph_->add_guide("tick-time", 0.5);\r
@@ -222,7 +222,7 @@ public:
                        }\r
 \r
                        muxer_.push(audio_buffer);\r
-                       muxer_.push(av_frame, hints_);  \r
+                       muxer_.push(av_frame, flags_);  \r
                                                                                        \r
                        boost::range::rotate(audio_cadence_, std::begin(audio_cadence_)+1);\r
                        \r
@@ -247,12 +247,12 @@ public:
                return S_OK;\r
        }\r
        \r
-       safe_ptr<core::basic_frame> get_frame(int hints)\r
+       safe_ptr<core::basic_frame> get_frame(int flags)\r
        {\r
                if(exception_ != nullptr)\r
                        std::rethrow_exception(exception_);\r
 \r
-               hints_ = hints;\r
+               flags_ = flags;\r
 \r
                safe_ptr<core::basic_frame> frame = core::basic_frame::late();\r
                if(!frame_buffer_.try_pop(frame))\r
@@ -291,9 +291,9 @@ public:
 \r
        // frame_producer\r
                                \r
-       virtual safe_ptr<core::basic_frame> receive(int hints) override\r
+       virtual safe_ptr<core::basic_frame> receive(int flags) override\r
        {\r
-               auto frame = context_->get_frame(hints);\r
+               auto frame = context_->get_frame(flags);\r
                if(frame != core::basic_frame::late())\r
                        last_frame_ = frame;\r
                return frame;\r

diff --git a/modules/ffmpeg/producer/ffmpeg_producer.cpp b/modules/ffmpeg/producer/ffmpeg_producer.cpp
index 6975901a2516809bc4536fe9839b3601756da1fa..420f9c9df43b2d3996688960025acf56c3e5daae 100644 (file)
--- a/modules/ffmpeg/producer/ffmpeg_producer.cpp
+++ b/modules/ffmpeg/producer/ffmpeg_producer.cpp
@@ -138,12 +138,12 @@ public:
 \r
        // frame_producer\r
        \r
-       virtual safe_ptr<core::basic_frame> receive(int hints) override\r
+       virtual safe_ptr<core::basic_frame> receive(int flags) override\r
        {               \r
                frame_timer_.restart();\r
                                \r
                for(int n = 0; n < 16 && frame_buffer_.size() < 2; ++n)\r
-                       try_decode_frame(hints);\r
+                       try_decode_frame(flags);\r
                \r
                graph_->update_value("frame-time", frame_timer_.elapsed()*format_desc_.fps*0.5);\r
                                \r
@@ -253,7 +253,7 @@ public:
                BOOST_THROW_EXCEPTION(invalid_argument());\r
        }\r
 \r
-       void try_decode_frame(int hints)\r
+       void try_decode_frame(int flags)\r
        {\r
                std::shared_ptr<AVPacket> pkt;\r
 \r
@@ -280,7 +280,7 @@ public:
                                audio = audio_decoder_->poll();         \r
                });\r
                \r
-               muxer_->push(video, hints);\r
+               muxer_->push(video, flags);\r
                muxer_->push(audio);\r
 \r
                if(!audio_decoder_)\r

diff --git a/modules/ffmpeg/producer/muxer/frame_muxer.cpp b/modules/ffmpeg/producer/muxer/frame_muxer.cpp
index 102a66f91b03a702fa4540039b963d3bb82fc429..4a2aa7121cd1ef8a34f4c47f0481d80d32e05558 100644 (file)
--- a/modules/ffmpeg/producer/muxer/frame_muxer.cpp
+++ b/modules/ffmpeg/producer/muxer/frame_muxer.cpp
@@ -100,7 +100,7 @@ struct frame_muxer::implementation : boost::noncopyable
                boost::range::reverse(audio_cadence_);\r
        }\r
 \r
-       void push(const std::shared_ptr<AVFrame>& video_frame, int hints)\r
+       void push(const std::shared_ptr<AVFrame>& video_frame, int flags)\r
        {               \r
                if(!video_frame)\r
                        return;\r
@@ -116,18 +116,18 @@ struct frame_muxer::implementation : boost::noncopyable
                }\r
                else\r
                {\r
-                       bool deinterlace_hint = (hints & core::frame_producer::DEINTERLACE_HINT) != 0;\r
+                       bool DEINTERLACE_FLAG = (flags & core::frame_producer::DEINTERLACE_FLAG) != 0;\r
                \r
-                       if(auto_deinterlace_ && force_deinterlacing_ != deinterlace_hint)\r
+                       if(auto_deinterlace_ && force_deinterlacing_ != DEINTERLACE_FLAG)\r
                        {\r
-                               force_deinterlacing_ = deinterlace_hint;\r
+                               force_deinterlacing_ = DEINTERLACE_FLAG;\r
                                display_mode_ = display_mode::invalid;\r
                        }\r
 \r
                        if(display_mode_ == display_mode::invalid)\r
                                update_display_mode(video_frame, force_deinterlacing_);\r
                                \r
-                       if(hints & core::frame_producer::ALPHA_HINT)\r
+                       if(flags & core::frame_producer::ALPHA_ONLY_FLAG)\r
                                video_frame->format = make_alpha_format(video_frame->format);\r
                \r
                        auto format = video_frame->format;\r
@@ -140,7 +140,7 @@ struct frame_muxer::implementation : boost::noncopyable
                                if(video_frame->format == PIX_FMT_GRAY8 && format == CASPAR_PIX_FMT_LUMA)\r
                                        av_frame->format = format;\r
 \r
-                               video_streams_.back().push(make_write_frame(this, av_frame, frame_factory_, hints));\r
+                               video_streams_.back().push(make_write_frame(this, av_frame, frame_factory_, flags));\r
                        }\r
                }\r
 \r
@@ -373,7 +373,7 @@ struct frame_muxer::implementation : boost::noncopyable
 \r
 frame_muxer::frame_muxer(double in_fps, const safe_ptr<core::frame_factory>& frame_factory, const std::wstring& filter)\r
        : impl_(new implementation(in_fps, frame_factory, filter)){}\r
-void frame_muxer::push(const std::shared_ptr<AVFrame>& video_frame, int hints){impl_->push(video_frame, hints);}\r
+void frame_muxer::push(const std::shared_ptr<AVFrame>& video_frame, int flags){impl_->push(video_frame, flags);}\r
 void frame_muxer::push(const std::shared_ptr<core::audio_buffer>& audio_samples){return impl_->push(audio_samples);}\r
 std::shared_ptr<basic_frame> frame_muxer::poll(){return impl_->poll();}\r
 uint32_t frame_muxer::calc_nb_frames(uint32_t nb_frames) const {return impl_->calc_nb_frames(nb_frames);}\r

diff --git a/modules/ffmpeg/producer/muxer/frame_muxer.h b/modules/ffmpeg/producer/muxer/frame_muxer.h
index 50759aea0e4771281c5cd8f7f960281e1317a354..33c5eb9376961b38806bbaa63469d6b304812de7 100644 (file)
--- a/modules/ffmpeg/producer/muxer/frame_muxer.h
+++ b/modules/ffmpeg/producer/muxer/frame_muxer.h
@@ -50,7 +50,7 @@ class frame_muxer : boost::noncopyable
 public:\r
        frame_muxer(double in_fps, const safe_ptr<core::frame_factory>& frame_factory, const std::wstring& filter = L"");\r
        \r
-       void push(const std::shared_ptr<AVFrame>& video_frame, int hints = 0);\r
+       void push(const std::shared_ptr<AVFrame>& video_frame, int flags = 0);\r
        void push(const std::shared_ptr<core::audio_buffer>& audio_samples);\r
        \r
        bool video_ready() const;\r

diff --git a/modules/ffmpeg/producer/util/util.cpp b/modules/ffmpeg/producer/util/util.cpp
index dd170c15514e7d5903aff2ac5ea9885cbcda7815..cd839ac3d78c001533dcb5a33b1fe917b204a569 100644 (file)
--- a/modules/ffmpeg/producer/util/util.cpp
+++ b/modules/ffmpeg/producer/util/util.cpp
@@ -171,7 +171,7 @@ int make_alpha_format(int format)
        }\r
 }\r
 \r
-safe_ptr<core::write_frame> make_write_frame(const void* tag, const safe_ptr<AVFrame>& decoded_frame, const safe_ptr<core::frame_factory>& frame_factory, int hints)\r
+safe_ptr<core::write_frame> make_write_frame(const void* tag, const safe_ptr<AVFrame>& decoded_frame, const safe_ptr<core::frame_factory>& frame_factory, int flags)\r
 {                      \r
        static tbb::concurrent_unordered_map<size_t, tbb::concurrent_queue<std::shared_ptr<SwsContext>>> sws_contexts_;\r
        \r
@@ -182,7 +182,7 @@ safe_ptr<core::write_frame> make_write_frame(const void* tag, const safe_ptr<AVF
        const auto height = decoded_frame->height;\r
        auto desc                 = get_pixel_format_desc(static_cast<PixelFormat>(decoded_frame->format), width, height);\r
        \r
-       if(hints & core::frame_producer::ALPHA_HINT)\r
+       if(flags & core::frame_producer::ALPHA_ONLY_FLAG)\r
                desc = get_pixel_format_desc(static_cast<PixelFormat>(make_alpha_format(decoded_frame->format)), width, height);\r
 \r
        std::shared_ptr<core::write_frame> write;\r

diff --git a/modules/ffmpeg/producer/util/util.h b/modules/ffmpeg/producer/util/util.h
index 2960c2e94a1af35e89201831f400082b7e11228f..c0bfd97aeae2fee631dda95dc1e63ca958e7cc55 100644 (file)
--- a/modules/ffmpeg/producer/util/util.h
+++ b/modules/ffmpeg/producer/util/util.h
@@ -57,7 +57,7 @@ static const int CASPAR_PIX_FMT_LUMA = 10; // Just hijack some unual pixel forma
 \r
 core::field_mode::type         get_mode(const AVFrame& frame);\r
 int                                                    make_alpha_format(int format); // NOTE: Be careful about CASPAR_PIX_FMT_LUMA, change it to PIX_FMT_GRAY8 if you want to use the frame inside some ffmpeg function.\r
-safe_ptr<core::write_frame> make_write_frame(const void* tag, const safe_ptr<AVFrame>& decoded_frame, const safe_ptr<core::frame_factory>& frame_factory, int hints);\r
+safe_ptr<core::write_frame> make_write_frame(const void* tag, const safe_ptr<AVFrame>& decoded_frame, const safe_ptr<core::frame_factory>& frame_factory, int flags);\r
 \r
 safe_ptr<AVPacket> create_packet();\r
 \r

diff --git a/modules/flash/producer/cg_producer.cpp b/modules/flash/producer/cg_producer.cpp
index 0236304814fefad7791354b04a53a19c6e57eda3..e7dfad962f23f827be9a7b3b1ef5e8925ea21ca2 100644 (file)
--- a/modules/flash/producer/cg_producer.cpp
+++ b/modules/flash/producer/cg_producer.cpp
@@ -145,9 +145,9 @@ public:
                return flash_producer_->call(str);\r
        }\r
 \r
-       safe_ptr<core::basic_frame> receive(int hints)\r
+       safe_ptr<core::basic_frame> receive(int flags)\r
        {\r
-               return flash_producer_->receive(hints);\r
+               return flash_producer_->receive(flags);\r
        }\r
 \r
        safe_ptr<core::basic_frame> last_frame() const\r
@@ -231,7 +231,7 @@ safe_ptr<core::frame_producer> create_cg_producer(const safe_ptr<core::frame_fac
 \r
 cg_producer::cg_producer(const safe_ptr<core::frame_producer>& frame_producer) : impl_(new implementation(frame_producer)){}\r
 cg_producer::cg_producer(cg_producer&& other) : impl_(std::move(other.impl_)){}\r
-safe_ptr<core::basic_frame> cg_producer::receive(int hints){return impl_->receive(hints);}\r
+safe_ptr<core::basic_frame> cg_producer::receive(int flags){return impl_->receive(flags);}\r
 safe_ptr<core::basic_frame> cg_producer::last_frame() const{return impl_->last_frame();}\r
 void cg_producer::add(int layer, const std::wstring& template_name,  bool play_on_load, const std::wstring& startFromLabel, const std::wstring& data){impl_->add(layer, template_name, play_on_load, startFromLabel, data);}\r
 void cg_producer::remove(int layer){impl_->remove(layer);}\r