refactored VideoWriter class (convert it to abstract interface)

modules/gpucodec/include/opencv2/gpucodec.hpp

@@ -7,11 +7,12 @@
 //  copy or use the software.
 //
 //
-//                           License Agreement
+//                          License Agreement
 //                For Open Source Computer Vision Library
 //
 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
 // Third party copyrights are property of their respective owners.
 //
 // Redistribution and use in source and binary forms, with or without modification,
@@ -51,111 +52,101 @@
 
 #include "opencv2/core/gpu.hpp"
 
-namespace cv { namespace gpu {
+namespace cv { namespace gpucodec {
 
 ////////////////////////////////// Video Encoding //////////////////////////////////
 
-// Works only under Windows
-// Supports olny H264 video codec and AVI files
-class CV_EXPORTS VideoWriter_GPU
+// Works only under Windows.
+// Supports olny H264 video codec and AVI files.
+
+enum SurfaceFormat
 {
-public:
-    struct EncoderParams;
+    SF_UYVY = 0,
+    SF_YUY2,
+    SF_YV12,
+    SF_NV12,
+    SF_IYUV,
+    SF_BGR,
+    SF_GRAY = SF_BGR
+};
 
-    // Callbacks for video encoder, use it if you want to work with raw video stream
-    class EncoderCallBack;
+struct CV_EXPORTS EncoderParams
+{
+    int P_Interval;      // NVVE_P_INTERVAL,
+    int IDR_Period;      // NVVE_IDR_PERIOD,
+    int DynamicGOP;      // NVVE_DYNAMIC_GOP,
+    int RCType;          // NVVE_RC_TYPE,
+    int AvgBitrate;      // NVVE_AVG_BITRATE,
+    int PeakBitrate;     // NVVE_PEAK_BITRATE,
+    int QP_Level_Intra;  // NVVE_QP_LEVEL_INTRA,
+    int QP_Level_InterP; // NVVE_QP_LEVEL_INTER_P,
+    int QP_Level_InterB; // NVVE_QP_LEVEL_INTER_B,
+    int DeblockMode;     // NVVE_DEBLOCK_MODE,
+    int ProfileLevel;    // NVVE_PROFILE_LEVEL,
+    int ForceIntra;      // NVVE_FORCE_INTRA,
+    int ForceIDR;        // NVVE_FORCE_IDR,
+    int ClearStat;       // NVVE_CLEAR_STAT,
+    int DIMode;          // NVVE_SET_DEINTERLACE,
+    int Presets;         // NVVE_PRESETS,
+    int DisableCabac;    // NVVE_DISABLE_CABAC,
+    int NaluFramingType; // NVVE_CONFIGURE_NALU_FRAMING_TYPE
+    int DisableSPSPPS;   // NVVE_DISABLE_SPS_PPS
+
+    EncoderParams();
+    explicit EncoderParams(const String& configFile);
+
+    void load(const String& configFile);
+    void save(const String& configFile) const;
+};
 
-    enum SurfaceFormat
+class CV_EXPORTS EncoderCallBack
+{
+public:
+    enum PicType
     {
-        SF_UYVY = 0,
-        SF_YUY2,
-        SF_YV12,
-        SF_NV12,
-        SF_IYUV,
-        SF_BGR,
-        SF_GRAY = SF_BGR
+        IFRAME = 1,
+        PFRAME = 2,
+        BFRAME = 3
     };
 
-    VideoWriter_GPU();
-    VideoWriter_GPU(const String& fileName, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR);
-    VideoWriter_GPU(const String& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR);
-    VideoWriter_GPU(const cv::Ptr<EncoderCallBack>& encoderCallback, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR);
-    VideoWriter_GPU(const cv::Ptr<EncoderCallBack>& encoderCallback, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR);
-    ~VideoWriter_GPU();
-
-    // all methods throws cv::Exception if error occurs
-    void open(const String& fileName, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR);
-    void open(const String& fileName, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR);
-    void open(const cv::Ptr<EncoderCallBack>& encoderCallback, cv::Size frameSize, double fps, SurfaceFormat format = SF_BGR);
-    void open(const cv::Ptr<EncoderCallBack>& encoderCallback, cv::Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR);
-
-    bool isOpened() const;
-    void close();
+    virtual ~EncoderCallBack() {}
 
-    void write(const cv::gpu::GpuMat& image, bool lastFrame = false);
+    //! callback function to signal the start of bitstream that is to be encoded
+    //! callback must allocate host buffer for CUDA encoder and return pointer to it and it's size
+    virtual uchar* acquireBitStream(int* bufferSize) = 0;
 
-    struct CV_EXPORTS EncoderParams
-    {
-        int       P_Interval;      //    NVVE_P_INTERVAL,
-        int       IDR_Period;      //    NVVE_IDR_PERIOD,
-        int       DynamicGOP;      //    NVVE_DYNAMIC_GOP,
-        int       RCType;          //    NVVE_RC_TYPE,
-        int       AvgBitrate;      //    NVVE_AVG_BITRATE,
-        int       PeakBitrate;     //    NVVE_PEAK_BITRATE,
-        int       QP_Level_Intra;  //    NVVE_QP_LEVEL_INTRA,
-        int       QP_Level_InterP; //    NVVE_QP_LEVEL_INTER_P,
-        int       QP_Level_InterB; //    NVVE_QP_LEVEL_INTER_B,
-        int       DeblockMode;     //    NVVE_DEBLOCK_MODE,
-        int       ProfileLevel;    //    NVVE_PROFILE_LEVEL,
-        int       ForceIntra;      //    NVVE_FORCE_INTRA,
-        int       ForceIDR;        //    NVVE_FORCE_IDR,
-        int       ClearStat;       //    NVVE_CLEAR_STAT,
-        int       DIMode;          //    NVVE_SET_DEINTERLACE,
-        int       Presets;         //    NVVE_PRESETS,
-        int       DisableCabac;    //    NVVE_DISABLE_CABAC,
-        int       NaluFramingType; //    NVVE_CONFIGURE_NALU_FRAMING_TYPE
-        int       DisableSPSPPS;   //    NVVE_DISABLE_SPS_PPS
-
-        EncoderParams();
-        explicit EncoderParams(const String& configFile);
-
-        void load(const String& configFile);
-        void save(const String& configFile) const;
-    };
+    //! callback function to signal that the encoded bitstream is ready to be written to file
+    virtual void releaseBitStream(unsigned char* data, int size) = 0;
 
-    EncoderParams getParams() const;
+    //! callback function to signal that the encoding operation on the frame has started
+    virtual void onBeginFrame(int frameNumber, PicType picType) = 0;
 
-    class CV_EXPORTS EncoderCallBack
-    {
-    public:
-        enum PicType
-        {
-            IFRAME = 1,
-            PFRAME = 2,
-            BFRAME = 3
-        };
+    //! callback function signals that the encoding operation on the frame has finished
+    virtual void onEndFrame(int frameNumber, PicType picType) = 0;
+};
 
-        virtual ~EncoderCallBack() {}
+class CV_EXPORTS VideoWriter
+{
+public:
+    virtual ~VideoWriter() {}
 
-        // callback function to signal the start of bitstream that is to be encoded
-        // must return pointer to buffer
-        virtual uchar* acquireBitStream(int* bufferSize) = 0;
+    //! writes the next frame from GPU memory
+    virtual void write(InputArray frame, bool lastFrame = false) = 0;
 
-        // callback function to signal that the encoded bitstream is ready to be written to file
-        virtual void releaseBitStream(unsigned char* data, int size) = 0;
+    virtual EncoderParams getEncoderParams() const = 0;
+};
 
-        // callback function to signal that the encoding operation on the frame has started
-        virtual void onBeginFrame(int frameNumber, PicType picType) = 0;
+//! create VideoWriter for specified output file (only AVI file format is supported)
+CV_EXPORTS Ptr<VideoWriter> createVideoWriter(const String& fileName, Size frameSize, double fps, SurfaceFormat format = SF_BGR);
+CV_EXPORTS Ptr<VideoWriter> createVideoWriter(const String& fileName, Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR);
 
-        // callback function signals that the encoding operation on the frame has finished
-        virtual void onEndFrame(int frameNumber, PicType picType) = 0;
-    };
+//! create VideoWriter for user-defined callbacks
+CV_EXPORTS Ptr<VideoWriter> createVideoWriter(const Ptr<EncoderCallBack>& encoderCallback, Size frameSize, double fps, SurfaceFormat format = SF_BGR);
+CV_EXPORTS Ptr<VideoWriter> createVideoWriter(const Ptr<EncoderCallBack>& encoderCallback, Size frameSize, double fps, const EncoderParams& params, SurfaceFormat format = SF_BGR);
 
-    class Impl;
+}} // namespace cv { namespace gpucodec {
 
-private:
-    cv::Ptr<Impl> impl_;
-};
+namespace cv { namespace gpu {
 
 ////////////////////////////////// Video Decoding //////////////////////////////////////////
 
@@ -257,7 +248,6 @@ private:
 
 namespace cv {
 
-template <> CV_EXPORTS void Ptr<cv::gpu::VideoWriter_GPU::Impl>::delete_obj();
 template <> CV_EXPORTS void Ptr<cv::gpu::VideoReader_GPU::Impl>::delete_obj();
 
 }

modules/gpucodec/perf/perf_video.cpp

@@ -119,7 +119,7 @@ PERF_TEST_P(FileName, VideoWriter, Values("gpu/video/768x576.avi", "gpu/video/19
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::VideoWriter_GPU d_writer;
+        cv::Ptr<cv::gpucodec::VideoWriter> d_writer;
 
         cv::gpu::GpuMat d_frame;
 
@@ -130,11 +130,11 @@ PERF_TEST_P(FileName, VideoWriter, Values("gpu/video/768x576.avi", "gpu/video/19
 
             d_frame.upload(frame);
 
-            if (!d_writer.isOpened())
-                d_writer.open(outputFile, frame.size(), FPS);
+            if (d_writer.empty())
+                d_writer = cv::gpucodec::createVideoWriter(outputFile, frame.size(), FPS);
 
             startTimer(); next();
-            d_writer.write(d_frame);
+            d_writer->write(d_frame);
             stopTimer();
         }
     }

modules/gpucodec/src/precomp.hpp

@@ -7,11 +7,12 @@
 //  copy or use the software.
 //
 //
-//                           License Agreement
+//                          License Agreement
 //                For Open Source Computer Vision Library
 //
 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
 // Third party copyrights are property of their respective owners.
 //
 // Redistribution and use in source and binary forms, with or without modification,

modules/gpucodec/test/test_video.cpp

@@ -89,7 +89,7 @@ GPU_TEST_P(Video, Writer)
     cv::VideoCapture reader(inputFile);
     ASSERT_TRUE(reader.isOpened());
 
-    cv::gpu::VideoWriter_GPU d_writer;
+    cv::Ptr<cv::gpucodec::VideoWriter> d_writer;
 
     cv::Mat frame;
     cv::gpu::GpuMat d_frame;
@@ -101,14 +101,14 @@ GPU_TEST_P(Video, Writer)
 
         d_frame.upload(frame);
 
-        if (!d_writer.isOpened())
-            d_writer.open(outputFile, frame.size(), FPS);
+        if (d_writer.empty())
+            d_writer = cv::gpucodec::createVideoWriter(outputFile, frame.size(), FPS);
 
-        d_writer.write(d_frame);
+        d_writer->write(d_frame);
     }
 
     reader.release();
-    d_writer.close();
+    d_writer.release();
 
     reader.open(outputFile);
     ASSERT_TRUE(reader.isOpened());

samples/gpu/video_writer.cpp

@@ -33,7 +33,7 @@ int main(int argc, const char* argv[])
     cv::gpu::printShortCudaDeviceInfo(cv::gpu::getDevice());
 
     cv::VideoWriter writer;
-    cv::gpu::VideoWriter_GPU d_writer;
+    cv::Ptr<cv::gpucodec::VideoWriter> d_writer;
 
     cv::Mat frame;
     cv::gpu::GpuMat d_frame;
@@ -64,11 +64,11 @@ int main(int argc, const char* argv[])
                 return -1;
         }
 
-        if (!d_writer.isOpened())
+        if (d_writer.empty())
         {
             std::cout << "Open GPU Writer" << std::endl;
 
-            d_writer.open("output_gpu.avi", frame.size(), FPS);
+            d_writer = cv::gpucodec::createVideoWriter("output_gpu.avi", frame.size(), FPS);
         }
 
         d_frame.upload(frame);
@@ -81,7 +81,7 @@ int main(int argc, const char* argv[])
         cpu_times.push_back(tm.getTimeMilli());
 
         tm.reset(); tm.start();
-        d_writer.write(d_frame);
+        d_writer->write(d_frame);
         tm.stop();
         gpu_times.push_back(tm.getTimeMilli());
     }