Home | History | Annotate | Download | only in include 
      1 /*
      2  *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 // This sub-API supports the following functionalities:
     12 //  - Effect filters
     13 //  - Deflickering
     14 //  - Denoising
     15 //  - Color enhancement
     16 
     17 #ifndef WEBRTC_VIDEO_ENGINE_INCLUDE_VIE_IMAGE_PROCESS_H_
     18 #define WEBRTC_VIDEO_ENGINE_INCLUDE_VIE_IMAGE_PROCESS_H_
     19 
     20 #include "webrtc/common_types.h"
     21 
     22 namespace webrtc {
     23 
     24 class EncodedImageCallback;
     25 class I420FrameCallback;
     26 class VideoEngine;
     27 
     28 // This class declares an abstract interface for a user defined effect filter.
     29 // The effect filter is registered using RegisterCaptureEffectFilter(),
     30 // RegisterSendEffectFilter() or RegisterRenderEffectFilter() and deregistered
     31 // with the corresponding deregister function.
     32 class WEBRTC_DLLEXPORT ViEEffectFilter {
     33  public:
     34   // This method is called with an I420 video frame allowing the user to
     35   // modify the video frame.
     36   virtual int Transform(int size,
     37                         unsigned char* frame_buffer,
     38                         int64_t ntp_time_ms,
     39                         unsigned int timestamp,
     40                         unsigned int width,
     41                         unsigned int height) = 0;
     42  protected:
     43   ViEEffectFilter() {}
     44   virtual ~ViEEffectFilter() {}
     45 };
     46 
     47 class WEBRTC_DLLEXPORT ViEImageProcess {
     48  public:
     49   // Factory for the ViEImageProcess subAPI and increases an internal
     50   // reference counter if successful. Returns NULL if the API is not supported
     51   // or if construction fails.
     52   static ViEImageProcess* GetInterface(VideoEngine* video_engine);
     53 
     54   // Releases the ViEImageProcess sub-API and decreases an internal reference
     55   // counter. Returns the new reference count. This value should be zero
     56   // for all sub-API:s before the VideoEngine object can be safely deleted.
     57   virtual int Release() = 0;
     58 
     59   // This function registers a EffectFilter to use for a specified capture
     60   // device.
     61   virtual int RegisterCaptureEffectFilter(const int capture_id,
     62                                           ViEEffectFilter& capture_filter) = 0;
     63 
     64   // This function deregisters a EffectFilter for a specified capture device.
     65   virtual int DeregisterCaptureEffectFilter(const int capture_id) = 0;
     66 
     67   // This function registers an EffectFilter to use for a specified channel.
     68   virtual int RegisterSendEffectFilter(const int video_channel,
     69                                        ViEEffectFilter& send_filter) = 0;
     70 
     71   // This function deregisters a send effect filter for a specified channel.
     72   virtual int DeregisterSendEffectFilter(const int video_channel) = 0;
     73 
     74   // This function registers a EffectFilter to use for the rendered video
     75   // stream on an incoming channel.
     76   virtual int RegisterRenderEffectFilter(const int video_channel,
     77                                          ViEEffectFilter& render_filter) = 0;
     78 
     79   // This function deregisters a render effect filter for a specified channel.
     80   virtual int DeregisterRenderEffectFilter(const int video_channel) = 0;
     81 
     82   // All cameras run the risk of getting in almost perfect sync with
     83   // florescent lamps, which will result in a very annoying flickering of the
     84   // image. Most cameras have some type of filter to protect against this but
     85   // not all of them succeed. Enabling this function will remove the flicker.
     86   virtual int EnableDeflickering(const int capture_id, const bool enable) = 0;
     87 
     88   // Some cameras produce very noisy captured images, especially in lowlight
     89   // conditions. This functionality will reduce the camera noise.
     90   virtual int EnableDenoising(const int capture_id, const bool enable) = 0;
     91 
     92   // This function enhances the colors on the decoded video stream, enabled by
     93   // default.
     94   virtual int EnableColorEnhancement(const int video_channel,
     95                                      const bool enable) = 0;
     96 
     97   // New-style callbacks, used by VideoSendStream/VideoReceiveStream.
     98   virtual void RegisterPreEncodeCallback(
     99       int video_channel,
    100       I420FrameCallback* pre_encode_callback) = 0;
    101   virtual void DeRegisterPreEncodeCallback(int video_channel) = 0;
    102 
    103   virtual void RegisterPostEncodeImageCallback(
    104       int video_channel,
    105       EncodedImageCallback* post_encode_callback) {}
    106   virtual void DeRegisterPostEncodeCallback(int video_channel) {}
    107 
    108   virtual void RegisterPreDecodeImageCallback(
    109       int video_channel,
    110       EncodedImageCallback* pre_decode_callback) {}
    111   virtual void DeRegisterPreDecodeCallback(int video_channel) {}
    112 
    113   virtual void RegisterPreRenderCallback(
    114       int video_channel,
    115       I420FrameCallback* pre_render_callback) = 0;
    116   virtual void DeRegisterPreRenderCallback(int video_channel) = 0;
    117 
    118  protected:
    119   ViEImageProcess() {}
    120   virtual ~ViEImageProcess() {}
    121 };
    122 
    123 }  // namespace webrtc
    124 
    125 #endif  // WEBRTC_VIDEO_ENGINE_INCLUDE_VIE_IMAGE_PROCESS_H_
    126