video_decoder.h

Go to the documentation of this file.

#ifndef VIDEO_DECODER_H
#define VIDEO_DECODER_H
 
#include <SDL2/SDL.h>
extern "C" {
#include <libavutil/buffer.h>
#include <libavutil/pixfmt.h>
}
#include <chrono>
#include <string>
#include <mutex>
#include <atomic>
 
// Forward declarations for FFmpeg structs
struct AVFormatContext;
struct AVCodecContext;
struct AVFrame;
struct AVPacket;
struct SwsContext;
 
class FFmpegPlayer; // Forward declaration
 
class VideoDecoder {
public:
    VideoDecoder(FFmpegPlayer* player);
 
    ~VideoDecoder();
 
    bool setup(AVFormatContext* formatContext, SDL_Renderer* renderer, int width, int height);
 
    void play();
 
    void stop();
 
    void update();
 
    SDL_Texture* getTexture() const;
 
    bool decodeVideoFrame();
 
    void updateTexture();
 
    void flush();
 
    void resetPlaybackTimes();
 
    void applyPendingTextureUpdate();   // Uploads queued frame data to the texture (main thread)
    void queueFrameForTextureUpdate();  // Queues frame data from decoder thread
 
private:
    friend class FFmpegPlayer; // Allow FFmpegPlayer to access private members
    FFmpegPlayer* player_;              
    AVCodecContext* videoCodecContext_; 
    SDL_Renderer* renderer_;            
    int width_;                         
    int height_;                        
    AVFrame* videoFrame_;               
    AVFrame* rgbFrame_;                 
    AVPacket* videoPacket_;             
    SwsContext* swsContext_;            
    int videoStreamIndex_;              
    uint8_t* rgbBuffer_;                
    SDL_Texture* texture_;              
    double videoClock_;                 
    std::chrono::high_resolution_clock::time_point lastFrameTime_; 
    std::chrono::high_resolution_clock::time_point playbackStartTime_; 
    bool needsReset_;                   
    AVBufferRef* hwDeviceCtx_ = nullptr;
    AVPixelFormat expectedSwFormat_ = AV_PIX_FMT_NONE;
    // thread-swap buffer for main thread upload
    std::mutex pendingMutex_;
    std::vector<uint8_t> pendingBuffer_;     // contiguous RGB24 data: height * width * 3
    std::atomic_bool hasPendingFrame_{false};
    int pendingPitch_{0};                    // bytes per row in pendingBuffer_ (usually width*3)
 
 
    void cleanup();
 
};
 
#endif // VIDEO_DECODER_H