Line data    Source code

       1             : /*
       2             :  *  Copyright (C) 2004-2024 Savoir-faire Linux Inc.
       3             :  *
       4             :  *  This program is free software: you can redistribute it and/or modify
       5             :  *  it under the terms of the GNU General Public License as published by
       6             :  *  the Free Software Foundation, either version 3 of the License, or
       7             :  *  (at your option) any later version.
       8             :  *
       9             :  *  This program is distributed in the hope that it will be useful,
      10             :  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      12             :  *  GNU General Public License for more details.
      13             :  *
      14             :  *  You should have received a copy of the GNU General Public License
      15             :  *  along with this program. If not, see <https://www.gnu.org/licenses/>.
      16             :  */
      17             : 
      18             : #include "libav_deps.h" // MUST BE INCLUDED FIRST
      19             : #include "video_receive_thread.h"
      20             : #include "media/media_decoder.h"
      21             : #include "socket_pair.h"
      22             : #include "manager.h"
      23             : #include "client/videomanager.h"
      24             : #include "sinkclient.h"
      25             : #include "logger.h"
      26             : 
      27             : extern "C" {
      28             : #include <libavutil/display.h>
      29             : }
      30             : 
      31             : #include <unistd.h>
      32             : #include <map>
      33             : 
      34             : namespace jami {
      35             : namespace video {
      36             : 
      37             : using std::string;
      38             : 
      39         146 : VideoReceiveThread::VideoReceiveThread(const std::string& id,
      40             :                                        bool useSink,
      41             :                                        const std::string& sdp,
      42         146 :                                        uint16_t mtu)
      43             :     : VideoGenerator::VideoGenerator()
      44         146 :     , args_()
      45         146 :     , id_(id)
      46         146 :     , useSink_(useSink)
      47         146 :     , stream_(sdp)
      48         146 :     , sdpContext_(stream_.str().size(), false, &readFunction, 0, 0, this)
      49         146 :     , sink_ {Manager::instance().createSinkClient(id)}
      50         146 :     , mtu_(mtu)
      51         292 :     , loop_(std::bind(&VideoReceiveThread::setup, this),
      52         292 :             std::bind(&VideoReceiveThread::decodeFrame, this),
      53         584 :             std::bind(&VideoReceiveThread::cleanup, this))
      54             : {
      55         146 :     JAMI_DBG("[%p] Instance created", this);
      56         146 : }
      57             : 
      58         438 : VideoReceiveThread::~VideoReceiveThread()
      59             : {
      60         146 :     loop_.join();
      61         146 :     JAMI_DBG("[%p] Instance destroyed", this);
      62         292 : }
      63             : 
      64             : void
      65         146 : VideoReceiveThread::startLoop()
      66             : {
      67         146 :     JAMI_DBG("[%p] Starting receiver's loop", this);
      68         146 :     loop_.start();
      69         146 : }
      70             : 
      71             : void
      72         295 : VideoReceiveThread::stopLoop()
      73             : {
      74         295 :     if (loop_.isStopping())
      75         157 :         return;
      76         138 :     JAMI_DBG("[%p] Stopping receiver's loop and waiting for the thread to exit ...", this);
      77         138 :     loop_.stop();
      78         138 :     loop_.join();
      79         138 :     JAMI_DBG("[%p] Receiver's thread exited", this);
      80             : }
      81             : 
      82             : // We do this setup here instead of the constructor because we don't want the
      83             : // main thread to block while this executes, so it happens in the video thread.
      84             : bool
      85         146 : VideoReceiveThread::setup()
      86             : {
      87         146 :     JAMI_DBG("[%p] Setupping video receiver", this);
      88             : 
      89         292 :     videoDecoder_.reset(new MediaDecoder([this](const std::shared_ptr<MediaFrame>& frame) mutable {
      90        5435 :         libav_utils::AVBufferPtr displayMatrix;
      91             :         {
      92        5435 :             std::lock_guard l(rotationMtx_);
      93        5435 :             if (displayMatrix_)
      94        5435 :                 displayMatrix.reset(av_buffer_ref(displayMatrix_.get()));
      95        5435 :         }
      96        5435 :         if (displayMatrix)
      97        5435 :             av_frame_new_side_data_from_buf(frame->pointer(),
      98             :                                             AV_FRAME_DATA_DISPLAYMATRIX,
      99             :                                             displayMatrix.release());
     100        5435 :         publishFrame(std::static_pointer_cast<VideoFrame>(frame));
     101        5581 :     }));
     102         146 :     videoDecoder_->setContextCallback([this]() {
     103          30 :         if (recorderCallback_)
     104          30 :             recorderCallback_(getInfo());
     105          30 :     });
     106         146 :     videoDecoder_->setResolutionChangedCallback([this](int width, int height) {
     107           0 :         dstWidth_ = width;
     108           0 :         dstHeight_ = height;
     109           0 :         sink_->setFrameSize(dstWidth_, dstHeight_);
     110           0 :     });
     111             : 
     112         146 :     dstWidth_ = args_.width;
     113         146 :     dstHeight_ = args_.height;
     114             : 
     115         146 :     static const std::string SDP_FILENAME = "dummyFilename";
     116         146 :     if (args_.input.empty()) {
     117         146 :         args_.format = "sdp";
     118         146 :         args_.input = SDP_FILENAME;
     119           0 :     } else if (args_.input.substr(0, strlen("/dev/video")) == "/dev/video") {
     120             :         // it's a v4l device if starting with /dev/video
     121             :         // FIXME: This is not a robust way of checking if we mean to use a
     122             :         // v4l2 device
     123           0 :         args_.format = "video4linux2";
     124             :     }
     125             : 
     126         146 :     videoDecoder_->setInterruptCallback(interruptCb, this);
     127             : 
     128         146 :     if (args_.input == SDP_FILENAME) {
     129             :         // Force custom_io so the SDP demuxer will not open any UDP connections
     130             :         // We need it to use ICE transport.
     131         146 :         args_.sdp_flags = "custom_io";
     132             : 
     133         146 :         if (stream_.str().empty()) {
     134           0 :             JAMI_ERR("No SDP loaded");
     135           0 :             return false;
     136             :         }
     137             : 
     138         146 :         videoDecoder_->setIOContext(&sdpContext_);
     139             :     }
     140             : 
     141         146 :     if (videoDecoder_->openInput(args_)) {
     142           0 :         JAMI_ERR("Unable to open input \"%s\"", args_.input.c_str());
     143           0 :         return false;
     144             :     }
     145             : 
     146         146 :     if (args_.input == SDP_FILENAME) {
     147             :         // Now replace our custom AVIOContext with one that will read packets
     148         146 :         videoDecoder_->setIOContext(demuxContext_.get());
     149             :     }
     150         146 :     return true;
     151             : }
     152             : 
     153             : void
     154         146 : VideoReceiveThread::cleanup()
     155             : {
     156         146 :     JAMI_DBG("[%p] Stopping receiver", this);
     157             : 
     158         146 :     detach(sink_.get());
     159         146 :     sink_->stop();
     160             : 
     161         146 :     videoDecoder_.reset();
     162         146 : }
     163             : 
     164             : // This callback is used by libav internally to break out of blocking calls
     165             : int
     166         472 : VideoReceiveThread::interruptCb(void* data)
     167             : {
     168         472 :     const auto context = static_cast<VideoReceiveThread*>(data);
     169         472 :     return not context->loop_.isRunning();
     170             : }
     171             : 
     172             : int
     173         584 : VideoReceiveThread::readFunction(void* opaque, uint8_t* buf, int buf_size)
     174             : {
     175         584 :     std::istream& is = static_cast<VideoReceiveThread*>(opaque)->stream_;
     176         584 :     is.read(reinterpret_cast<char*>(buf), buf_size);
     177             : 
     178         584 :     auto count = is.gcount();
     179         584 :     if (count != 0)
     180         146 :         return count;
     181             :     else
     182         438 :         return AVERROR_EOF;
     183             : }
     184             : 
     185             : void
     186         146 : VideoReceiveThread::addIOContext(SocketPair& socketPair)
     187             : {
     188         146 :     demuxContext_.reset(socketPair.createIOContext(mtu_));
     189         146 : }
     190             : 
     191             : void
     192         151 : VideoReceiveThread::setRecorderCallback(
     193             :     const std::function<void(const MediaStream& ms)>& cb)
     194             : {
     195         151 :     recorderCallback_ = cb;
     196         151 :     if (videoDecoder_)
     197           3 :         videoDecoder_->setContextCallback([this]() {
     198           1 :             if (recorderCallback_)
     199           1 :                 recorderCallback_(getInfo());
     200           1 :         });
     201         151 : }
     202             : 
     203             : void
     204        5781 : VideoReceiveThread::decodeFrame()
     205             : {
     206        5781 :     if (not loop_.isRunning())
     207           0 :         return;
     208             : 
     209        5781 :     if (not isVideoConfigured_) {
     210         146 :         if (!configureVideoOutput()) {
     211           0 :             JAMI_ERROR("[{:p}] Failed to configure video output", fmt::ptr(this));
     212           0 :             return;
     213             :         } else {
     214         438 :             JAMI_LOG("[{:p}] Decoder configured, starting decoding", fmt::ptr(this));
     215             :         }
     216             :     }
     217        5781 :     auto status = videoDecoder_->decode();
     218        5781 :     if (status == MediaDemuxer::Status::EndOfFile) {
     219         357 :         JAMI_LOG("[{:p}] End of file", fmt::ptr(this));
     220         119 :         loop_.stop();
     221             :     }
     222        5662 :     else if (status == MediaDemuxer::Status::ReadError) {
     223           0 :         JAMI_ERROR("[{:p}] Decoding error: %s", fmt::ptr(this), MediaDemuxer::getStatusStr(status));
     224             :     }
     225        5662 :     else if (status == MediaDemuxer::Status::FallBack) {
     226           0 :         if (keyFrameRequestCallback_)
     227           0 :             keyFrameRequestCallback_();
     228             :     }
     229             : }
     230             : 
     231             : bool
     232         146 : VideoReceiveThread::configureVideoOutput()
     233             : {
     234         146 :     assert(not isVideoConfigured_);
     235             : 
     236         146 :     JAMI_DBG("[%p] Configuring video output", this);
     237             : 
     238         146 :     if (not loop_.isRunning()) {
     239           0 :         JAMI_WARN("[%p] Unable to configure video output, the loop is not running!", this);
     240           0 :         return false;
     241             :     }
     242             : 
     243         146 :     if (videoDecoder_->setupVideo() < 0) {
     244           0 :         JAMI_ERR("decoder IO startup failed");
     245           0 :         stopLoop();
     246           0 :         return false;
     247             :     }
     248             : 
     249             :     // Default size from input video
     250         146 :     if (dstWidth_ == 0 and dstHeight_ == 0) {
     251         146 :         dstWidth_ = videoDecoder_->getWidth();
     252         146 :         dstHeight_ = videoDecoder_->getHeight();
     253             :     }
     254             : 
     255         146 :     if (not sink_->start()) {
     256           0 :         JAMI_ERR("RX: sink startup failed");
     257           0 :         stopLoop();
     258           0 :         return false;
     259             :     }
     260             : 
     261         146 :     if (useSink_)
     262         111 :         startSink();
     263             : 
     264         146 :     if (onSuccessfulSetup_)
     265         146 :         onSuccessfulSetup_(MEDIA_VIDEO, 1);
     266             : 
     267         146 :     return isVideoConfigured_ = true;
     268             : }
     269             : 
     270             : void
     271         351 : VideoReceiveThread::stopSink()
     272             : {
     273         351 :     JAMI_DBG("[%p] Stopping sink", this);
     274             : 
     275         351 :     if (!loop_.isRunning())
     276         297 :         return;
     277             : 
     278          54 :     detach(sink_.get());
     279          54 :     sink_->setFrameSize(0, 0);
     280             : }
     281             : 
     282             : void
     283         161 : VideoReceiveThread::startSink()
     284             : {
     285         161 :     JAMI_DBG("[%p] Starting sink", this);
     286             : 
     287         161 :     if (!loop_.isRunning())
     288          81 :         return;
     289             : 
     290          80 :     if (dstWidth_ > 0 and dstHeight_ > 0 and attach(sink_.get()))
     291          30 :         sink_->setFrameSize(dstWidth_, dstHeight_);
     292             : }
     293             : 
     294             : int
     295           0 : VideoReceiveThread::getWidth() const
     296             : {
     297           0 :     return dstWidth_;
     298             : }
     299             : 
     300             : int
     301           0 : VideoReceiveThread::getHeight() const
     302             : {
     303           0 :     return dstHeight_;
     304             : }
     305             : 
     306             : AVPixelFormat
     307           0 : VideoReceiveThread::getPixelFormat() const
     308             : {
     309           0 :     if (videoDecoder_)
     310           0 :         return videoDecoder_->getPixelFormat();
     311           0 :     return {};
     312             : }
     313             : 
     314             : MediaStream
     315         474 : VideoReceiveThread::getInfo() const
     316             : {
     317         474 :     if (videoDecoder_)
     318         188 :         return videoDecoder_->getStream("v:remote");
     319         286 :     return {};
     320             : }
     321             : 
     322             : void
     323         195 : VideoReceiveThread::setRotation(int angle)
     324             : {
     325         195 :     libav_utils::AVBufferPtr displayMatrix(av_buffer_alloc(sizeof(int32_t) * 9));
     326         195 :     av_display_rotation_set(reinterpret_cast<int32_t*>(displayMatrix->data), angle);
     327         195 :     std::lock_guard l(rotationMtx_);
     328         195 :     displayMatrix_ = std::move(displayMatrix);
     329         195 : }
     330             : 
     331             : } // namespace video
     332             : } // namespace jami