1/*
2 *  Copyright (c) 2012 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#ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_FRAMEWORK_NORMAL_ASYNC_TEST_H_
12#define WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_FRAMEWORK_NORMAL_ASYNC_TEST_H_
13
14#include "webrtc/common_types.h"
15
16#include <list>
17#include <map>
18#include <queue>
19#include "webrtc/modules/video_coding/codecs/test_framework/normal_test.h"
20#include "webrtc/system_wrappers/interface/rw_lock_wrapper.h"
21
22class FrameQueueTuple
23{
24public:
25    FrameQueueTuple(webrtc::VideoFrame *frame,
26                    const webrtc::CodecSpecificInfo* codecSpecificInfo = NULL)
27    :
28        _frame(frame),
29        _codecSpecificInfo(codecSpecificInfo)
30    {};
31    ~FrameQueueTuple();
32    webrtc::VideoFrame*          _frame;
33    const webrtc::CodecSpecificInfo* _codecSpecificInfo;
34};
35
36class FrameQueue
37{
38public:
39    FrameQueue()
40    :
41        _queueRWLock(*webrtc::RWLockWrapper::CreateRWLock())
42    {
43    }
44
45    ~FrameQueue()
46    {
47        delete &_queueRWLock;
48    }
49
50    void PushFrame(webrtc::VideoFrame *frame,
51                   webrtc::CodecSpecificInfo* codecSpecificInfo = NULL);
52    FrameQueueTuple* PopFrame();
53    bool Empty();
54
55private:
56    webrtc::RWLockWrapper&                       _queueRWLock;
57    std::queue<FrameQueueTuple *>     _frameBufferQueue;
58};
59
60// feedback signal to encoder
61struct fbSignal
62{
63    fbSignal(int d, uint8_t pid) : delay(d), id(pid) {};
64    int         delay;
65    uint8_t id;
66};
67
68class NormalAsyncTest : public NormalTest
69{
70public:
71    NormalAsyncTest();
72    NormalAsyncTest(uint32_t bitRate);
73    NormalAsyncTest(std::string name, std::string description,
74                    unsigned int testNo);
75    NormalAsyncTest(std::string name, std::string description,
76                    uint32_t bitRate, unsigned int testNo);
77    NormalAsyncTest(std::string name, std::string description,
78                    uint32_t bitRate, unsigned int testNo,
79                    unsigned int rttFrames);
80    virtual ~NormalAsyncTest() {};
81    virtual void Perform();
82    virtual void Encoded(const webrtc::EncodedImage& encodedImage);
83    virtual void Decoded(const webrtc::I420VideoFrame& decodedImage);
84    virtual webrtc::CodecSpecificInfo*
85    CopyCodecSpecificInfo(
86        const webrtc::CodecSpecificInfo* codecSpecificInfo) const;
87    virtual void CopyEncodedImage(webrtc::VideoFrame& dest,
88                                  webrtc::EncodedImage& src,
89                                  void* /*codecSpecificInfo*/) const;
90    virtual webrtc::CodecSpecificInfo* CreateEncoderSpecificInfo() const
91    {
92        return NULL;
93    };
94    virtual int32_t ReceivedDecodedReferenceFrame(
95        const uint64_t pictureId);
96    virtual int32_t ReceivedDecodedFrame(const uint64_t pictureId);
97
98protected:
99    virtual void Setup();
100    virtual void Teardown();
101    virtual bool Encode();
102    virtual int Decode(int lossValue = 0);
103    virtual void CodecSpecific_InitBitrate();
104    virtual int SetCodecSpecificParameters() {return 0;};
105    double tGetTime();// return time in sec
106
107    FILE*                   _sourceFile;
108    FILE*                   _decodedFile;
109    uint32_t          _decodedWidth;
110    uint32_t          _decodedHeight;
111    double                  _totalEncodeTime;
112    double                  _totalDecodeTime;
113    double                  _decodeCompleteTime;
114    double                  _encodeCompleteTime;
115    double                  _totalEncodePipeTime;
116    double                  _totalDecodePipeTime;
117    int                     _framecnt;
118    int                     _encFrameCnt;
119    int                     _decFrameCnt;
120    bool                    _requestKeyFrame;
121    unsigned int            _lengthEncFrame;
122    FrameQueueTuple*        _frameToDecode;
123    bool                    _appendNext;
124    std::map<uint32_t, double> _encodeTimes;
125    std::map<uint32_t, double> _decodeTimes;
126    bool                    _missingFrames;
127    std::list<fbSignal>     _signalSLI;
128    int                     _rttFrames;
129    mutable bool            _hasReceivedSLI;
130    mutable bool            _hasReceivedRPSI;
131    uint8_t           _pictureIdSLI;
132    uint16_t          _pictureIdRPSI;
133    uint64_t          _lastDecRefPictureId;
134    uint64_t          _lastDecPictureId;
135    std::list<fbSignal>     _signalPLI;
136    bool                    _hasReceivedPLI;
137    bool                    _waitForKey;
138};
139
140class VideoEncodeCompleteCallback : public webrtc::EncodedImageCallback
141{
142public:
143    VideoEncodeCompleteCallback(FILE* encodedFile, FrameQueue *frameQueue,
144                                NormalAsyncTest& test)
145    :
146      _encodedFile(encodedFile),
147      _frameQueue(frameQueue),
148      _test(test),
149      _encodedBytes(0)
150    {}
151
152    int32_t
153    Encoded(webrtc::EncodedImage& encodedImage,
154            const webrtc::CodecSpecificInfo* codecSpecificInfo = NULL,
155            const webrtc::RTPFragmentationHeader* fragmentation = NULL);
156    uint32_t EncodedBytes();
157private:
158    FILE*             _encodedFile;
159    FrameQueue*       _frameQueue;
160    NormalAsyncTest&  _test;
161    uint32_t    _encodedBytes;
162};
163
164class VideoDecodeCompleteCallback : public webrtc::DecodedImageCallback
165{
166public:
167    VideoDecodeCompleteCallback(FILE* decodedFile, NormalAsyncTest& test)
168    :
169        _decodedFile(decodedFile),
170        _test(test),
171        _decodedBytes(0)
172    {}
173
174    virtual int32_t Decoded(webrtc::I420VideoFrame& decodedImage);
175    virtual int32_t
176    ReceivedDecodedReferenceFrame(const uint64_t pictureId);
177    virtual int32_t ReceivedDecodedFrame(const uint64_t pictureId);
178
179    uint32_t DecodedBytes();
180private:
181    FILE* _decodedFile;
182    NormalAsyncTest& _test;
183    uint32_t    _decodedBytes;
184};
185
186#endif // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_FRAMEWORK_NORMAL_ASYNC_TEST_H_
187