File indexing completed on 2024-06-23 05:24:07

 // SPDX-FileCopyrightText: 2023 Arjen Hiemstra <ahiemstra@heimr.nl>
 //
 // SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 
 #pragma once
 
 #include <memory>
 #include <optional>
 
 #include <QImage>
 #include <QObject>
 #include <QPoint>
 #include <QRegion>
 #include <QSize>
 
 #include <freerdp/server/rdpgfx.h>
 
 #include "krdp_export.h"
 
 namespace KRdp
 {
 
 class RdpConnection;
 
 /**
  * A frame of compressed video data.
  */
 struct VideoFrame {
     /**
      * The size of the frame, in pixels.
      */
     QSize size;
     /**
      * h264 compressed data in YUV420 color space.
      */
     QByteArray data;
     /**
      * Area of the frame that was actually damaged.
      * TODO: Actually use this information.
      */
     QRegion damage;
     /**
      * Whether the packet contains all the information
      */
     bool isKeyFrame;
     /**
      * When was this frame presented.
      */
     std::chrono::system_clock::time_point presentationTimeStamp;
 };
 
 /**
  * A class that encapsulates an RdpGfx video stream.
  *
  * Video streaming is done using the "RDP Graphics Pipeline" protocol
  * extension which allows using h264 as the codec for the video stream.
  * However, this protocol extension is fairly complex to setup and use.
  *
  * VideoStream makes sure to handle most of the complexity of the RdpGfx
  * protocol like ensuring the client knows the right resolution and a
  * surface at the right size. It also takes care of sending the frames,
  * using a separate thread for a submission queue.
  *
  * VideoStream is managed by Session. Each session will have one instance
  * of this class.
  */
 class KRDP_EXPORT VideoStream : public QObject
 {
     Q_OBJECT
 
 public:
     explicit VideoStream(RdpConnection *session);
     ~VideoStream() override;
 
     bool initialize();
     void close();
     Q_SIGNAL void closed();
 
     /**
      * Queue a frame to be sent to the client.
      *
      * This will add the provided frame to the queue of frames that should
      * be sent to the client.
      *
      * \param frame The frame to send.
      */
     void queueFrame(const VideoFrame &frame);
 
     /**
      * Indicate that the video state should be reset.
      *
      * This means the screen resolution and other information of the client
      * will be updated based on the current state of the VideoStream.
      */
     void reset();
 
     /**
      */
     bool enabled() const;
     void setEnabled(bool enabled);
     Q_SIGNAL void enabledChanged();
 
     uint32_t requestedFrameRate() const;
     Q_SIGNAL void requestedFrameRateChanged();
 
 private:
     friend BOOL gfxChannelIdAssigned(RdpgfxServerContext *, uint32_t);
     friend uint32_t gfxCapsAdvertise(RdpgfxServerContext *, const RDPGFX_CAPS_ADVERTISE_PDU *);
     friend uint32_t gfxFrameAcknowledge(RdpgfxServerContext *, const RDPGFX_FRAME_ACKNOWLEDGE_PDU *);
 
     bool onChannelIdAssigned(uint32_t channelId);
     uint32_t onCapsAdvertise(const RDPGFX_CAPS_ADVERTISE_PDU *capsAdvertise);
     uint32_t onFrameAcknowledge(const RDPGFX_FRAME_ACKNOWLEDGE_PDU *frameAcknowledge);
 
     void performReset(const QSize &size);
     void sendFrame(const VideoFrame &frame);
 
     void updateRequestedFrameRate();
 
     class Private;
     const std::unique_ptr<Private> d;
 };
 
 }