myvtm/Other/libvideoframework/adaptive_jitter_buffer/video_jbuff_jitterbuffer.h

#ifndef VIDEO_JBUFF_JITTERBUFFER_H
#define VIDEO_JBUFF_JITTERBUFFER_H

#include "../adaptive_jitter_buffer/video_jbuff_defines.h"
#include "../adaptive_jitter_buffer/video_jbuff_frame.h"
#include "../adaptive_jitter_buffer/video_jbuff_framelist.h"

#include <queue>

namespace AJB {


class JitterBuffer
{
private:
	class SequenceNumberLessThan {
	 public:
	  bool operator()(const uint16_t& sequence_number1,
					  const uint16_t& sequence_number2) const {
		return IsNewerSequenceNumber(sequence_number2, sequence_number1);
	  }
	};
	typedef std::set<uint16_t, SequenceNumberLessThan> SequenceNumberSet;

    /* frame rate */
    double _frameRate;
    double _lastFrameRate;
    double _avgFrameRate;
    std::queue<int64_t> _decodedFrameTime;

    FrameList _decodableFrames;
    FrameList _incompleteFrames;
	UnorderedFrameList _freeFrames;

	int _max_number_of_frames;
	int _num_consecutive_old_packets;
	DecodingState _last_decoded_state;

	// Holds the missing sequence numbers.
	SequenceNumberSet missing_sequence_numbers_;
	uint16_t latest_received_sequence_number_;
	
	VideoJBufferObserver observer_;

	void Flush();
	bool IsContinuousInState(const Frame& frame, DecodingState& decoding_state);
	bool IsContinuous(const Frame& frame) ;
	void FindAndInsertContinuousFrames(const Frame& new_frame);
	void FindAndInsertContinuousFramesWithState(const DecodingState& original_decoded_state);
	void CleanUpOldFrames() ;
	bool RecycleFramesUntilKeyFrame();
	void RecycleFrameBuffer(Frame* frame);
	bool TryToIncreaseJitterBufferSize();
	Frame * GetEmptyFrame();
	FrameBufferEnum GetBuffer(const uint32_t timestamp,
								Frame** frame,
								FrameList** frame_list);
	FrameBufferEnum InsertPacket(std::shared_ptr<Packet> packet);
	Frame *NextDecodableFrame() ;

	/*****MISSING LIST*****/
	uint16_t EstimatedLowSequenceNumber(const Frame *frame) const;
	int NonContinuousOrIncompleteDuration();
	bool UpdateMissingList(uint16_t sequence_number);
	bool TooLargeMissingList() const;
	bool HandleTooLargeMissingList();
	bool MissingTooOldPacket(uint16_t latest_sequence_number) const;
	bool HandleTooOldPackets(uint16_t latest_sequence_number);
	void DropPacketsFromMissingList(uint16_t last_decoded_sequence_number);

public:
    JitterBuffer(VideoJBufferObserver *observer);
 
    FrameBufferEnum ReceivePacket(const char* buffer, VideoJBufferPacketInfo *packet_info);

    double FrameRate() const { return _frameRate; }
    double AverageFrameRate() const { return _avgFrameRate; }
    double BufferSize() const { return _decodableFrames.size(); }
	
    void GetFrame();
	
	/*****MISSING LIST*****/
	std::vector<uint16_t> GetMissingList(int* request_key_frame);

    ~JitterBuffer();
};

}

#endif /* VIDEO_JBUFF_JITTERBUFFER_H */