mirrors/QtScrcpy
1
0
Fork 0
mirror of https://github.com/barry-ran/QtScrcpy.git synced 2025-04-20 03:25:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add stream layer

Browse source 
The decoder initially read from the socket, decoded the video and sent
the decoded frames to the screen:

              +---------+      +----------+
  socket ---> | decoder | ---> |  screen  |
              +---------+      +----------+

The design was simple, but the decoder had several responsabilities.

Then we added the recording feature, so we added a recorder, which
reused the packets received from the socket managed by the decoder:

                                    +----------+
                               ---> |  screen  |
              +---------+     /     +----------+
  socket ---> | decoder | ----
              +---------+     \     +----------+
                               ---> | recorder |
                                    +----------+

This lack of separation of concerns now have concrete implications: we
could not (properly) disable the decoder/display to only record the
video.

Therefore, split the decoder to extract the stream:

                                    +----------+      +----------+
                               ---> | decoder  | ---> |  screen  |
              +---------+     /     +----------+      +----------+
  socket ---> | stream  | ----
              +---------+     \     +----------+
                               ---> | recorder |
                                    +----------+

This will allow to record the stream without decoding the video.
This commit is contained in:
Barry 2019-06-18 14:40:25 +08:00
parent 2d6dfc09e1
commit e61a09f477
8 changed files with 538 additions and 440 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

467
QtScrcpy/decoder/decoder.cpp
View file

@ -1,19 +1,11 @@
#include <QDebug>
#include <QTime>
#include "compat.h"
#include "decoder.h"
#include "videobuffer.h"
#include "devicesocket.h"
#include "recorder.h"
#define BUFSIZE 0x10000
#define HEADER_SIZE 12
#define NO_PTS UINT64_C(-1)
typedef qint32 (*ReadPacketFunc)(void*, quint8*, qint32);
#include "decoder.h"
Decoder::Decoder()
: QObject(Q_NULLPTR)
{
}
@ -23,414 +15,113 @@ Decoder::~Decoder()
}
static void avLogCallback(void *avcl, int level, const char *fmt, va_list vl) {
Q_UNUSED(avcl);
Q_UNUSED(vl);
QString localFmt = QString::fromUtf8(fmt);
localFmt.prepend("[FFmpeg] ");
switch (level) {
case AV_LOG_PANIC:
case AV_LOG_FATAL:
qFatal(localFmt.toUtf8());
break;
case AV_LOG_ERROR:
qCritical(localFmt.toUtf8());
break;
case AV_LOG_WARNING:
qWarning(localFmt.toUtf8());
break;
case AV_LOG_INFO:
qInfo(localFmt.toUtf8());
break;
case AV_LOG_DEBUG:
//qDebug(localFmt.toUtf8());
break;
}
// do not forward others, which are too verbose
return;
}
bool Decoder::init()
{
#ifdef QTSCRCPY_LAVF_REQUIRES_REGISTER_ALL
av_register_all();
#endif
if (avformat_network_init()) {
return false;
}
av_log_set_callback(avLogCallback);
return true;
}
void Decoder::deInit()
{
avformat_network_deinit(); // ignore failure
}
void Decoder::setVideoBuffer(VideoBuffer* vb)
{
m_vb = vb;
}
static quint32 bufferRead32be(quint8* buf) {
return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
}
static quint64 bufferRead64be(quint8* buf) {
quint32 msb = bufferRead32be(buf);
quint32 lsb = bufferRead32be(&buf[4]);
return ((quint64) msb << 32) | lsb;
}
static Decoder::FrameMeta* frameMetaNew(quint64 pts) {
Decoder::FrameMeta* meta = new Decoder::FrameMeta;
if (!meta) {
return meta;
}
meta->pts = pts;
meta->next = Q_NULLPTR;
return meta;
}
static void frameMetaDelete(Decoder::FrameMeta* frameMeta) {
if (frameMeta) {
delete frameMeta;
}
}
static bool receiverStatePushMeta(Decoder::ReceiverState* state, quint64 pts) {
Decoder::FrameMeta* frameMeta = frameMetaNew(pts);
if (!frameMeta) {
bool Decoder::open(const AVCodec *codec)
{
// codec context
m_codecCtx = avcodec_alloc_context3(codec);
if (!m_codecCtx) {
qCritical("Could not allocate decoder context");
return false;
}
// append to the list
// (iterate to find the last item, in practice the list should be tiny)
Decoder::FrameMeta **p = &state->frameMetaQueue;
while (*p) {
p = &(*p)->next;
if (avcodec_open2(m_codecCtx, codec, NULL) < 0) {
qCritical("Could not open H.264 codec");
return false;
}
*p = frameMeta;
m_isCodecCtxOpen = true;
return true;
}
static quint64 receiverStateTakeMeta(Decoder::ReceiverState* state) {
Decoder::FrameMeta *frameMeta = state->frameMetaQueue; // first item
Q_ASSERT(frameMeta); // must not be empty
quint64 pts = frameMeta->pts;
state->frameMetaQueue = frameMeta->next; // remove the item
frameMetaDelete(frameMeta);
return pts;
}
static qint32 readPacketWithMeta(void *opaque, uint8_t *buf, int bufSize) {
Decoder* decoder = (Decoder*)opaque;
Decoder::ReceiverState* state = decoder->getReceiverState();
// The video stream contains raw packets, without time information. When we
// record, we retrieve the timestamps separately, from a "meta" header
// added by the server before each raw packet.
//
// The "meta" header length is 12 bytes:
// [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
// <-------------> <-----> <-----------------------------...
// PTS packet raw packet
// size
//
// It is followed by <packet_size> bytes containing the packet/frame.
if (!state->remaining) {
quint8 header[HEADER_SIZE];
qint32 r = decoder->recvData(header, HEADER_SIZE);
if (r == -1) {
return AVERROR(errno);
}
if (r == 0) {
return AVERROR_EOF;
}
// no partial read (net_recv_all())
if (r != HEADER_SIZE) {
return AVERROR(ENOMEM);
}
uint64_t pts = bufferRead64be(header);
state->remaining = bufferRead32be(&header[8]);
if (pts != NO_PTS && !receiverStatePushMeta(state, pts)) {
qCritical("Could not store PTS for recording");
// we cannot save the PTS, the recording would be broken
return AVERROR(ENOMEM);
}
}
Q_ASSERT(state->remaining);
if (bufSize > state->remaining) {
bufSize = state->remaining;
}
qint32 r = decoder->recvData(buf, bufSize);
if (r == -1) {
return AVERROR(errno);
}
if (r == 0) {
return AVERROR_EOF;
}
Q_ASSERT(state->remaining >= r);
state->remaining -= r;
return r;
}
static qint32 readRawPacket(void *opaque, quint8 *buf, qint32 bufSize) {
Decoder *decoder = (Decoder*)opaque;
if (decoder) {
qint32 len = decoder->recvData(buf, bufSize);
if (len == -1) {
return AVERROR(errno);
}
if (len == 0) {
return AVERROR_EOF;
}
return len;
}
return AVERROR_EOF;
}
void Decoder::setDeviceSocket(DeviceSocket* deviceSocket)
void Decoder::close()
{
m_deviceSocket = deviceSocket;
}
void Decoder::setRecoder(Recorder *recorder)
{
m_recorder = recorder;
}
qint32 Decoder::recvData(quint8* buf, qint32 bufSize)
{
if (!buf) {
return 0;
if (!m_codecCtx) {
return;
}
if (m_deviceSocket) {
qint32 len = m_deviceSocket->subThreadRecvData(buf, bufSize);
return len;
if (m_isCodecCtxOpen) {
avcodec_close(m_codecCtx);
}
return 0;
avcodec_free_context(&m_codecCtx);
}
bool Decoder::startDecode()
bool Decoder::push(const AVPacket* packet)
{
if (!m_deviceSocket) {
if (!m_codecCtx || !m_vb) {
return false;
}
m_quit = false;
start();
AVFrame* decodingFrame = m_vb->decodingFrame();
#ifdef QTSCRCPY_LAVF_HAS_NEW_ENCODING_DECODING_API
int ret = -1;
if ((ret = avcodec_send_packet(m_codecCtx, packet)) < 0) {
char errorbuf[255] = { 0 };
av_strerror(ret, errorbuf, 254);
qCritical("Could not send video packet: %s", errorbuf);
return false;
}
if (decodingFrame) {
ret = avcodec_receive_frame(m_codecCtx, decodingFrame);
}
if (!ret) {
// a frame was received
pushFrame();
//emit getOneFrame(yuvDecoderFrame->data[0], yuvDecoderFrame->data[1], yuvDecoderFrame->data[2],
// yuvDecoderFrame->linesize[0], yuvDecoderFrame->linesize[1], yuvDecoderFrame->linesize[2]);
/*
// m_conver转换yuv为rgb是使用cpu转的，占用cpu太高，改用opengl渲染yuv
// QImage的copy也非常占用内存，此方案不考虑
if (!m_conver.isInit()) {
qDebug() << "decoder frame format" << decodingFrame->format;
m_conver.setSrcFrameInfo(codecCtx->width, codecCtx->height, AV_PIX_FMT_YUV420P);
m_conver.setDstFrameInfo(codecCtx->width, codecCtx->height, AV_PIX_FMT_RGB32);
m_conver.init();
}
if (!outBuffer) {
outBuffer=new quint8[avpicture_get_size(AV_PIX_FMT_RGB32, codecCtx->width, codecCtx->height)];
avpicture_fill((AVPicture *)rgbDecoderFrame, outBuffer, AV_PIX_FMT_RGB32, codecCtx->width, codecCtx->height);
}
m_conver.convert(decodingFrame, rgbDecoderFrame);
//QImage tmpImg((uchar *)outBuffer, codecCtx->width, codecCtx->height, QImage::Format_RGB32);
//QImage image = tmpImg.copy();
//emit getOneImage(image);
*/
} else if (ret != AVERROR(EAGAIN)) {
qCritical("Could not receive video frame: %d", ret);
return false;
}
#else
int gotPicture = 0;
int len = -1;
if (decodingFrame) {
len = avcodec_decode_video2(m_codecCtx, decodingFrame, &gotPicture, packet);
}
if (len < 0) {
qCritical("Could not decode video packet: %d", len);
return false;
}
if (gotPicture) {
pushFrame();
}
#endif
return true;
}
void Decoder::stopDecode()
void Decoder::interrupt()
{
m_quit = true;
if (m_vb) {
m_vb->interrupt();
}
wait();
}
Decoder::ReceiverState *Decoder::getReceiverState()
{
return &m_receiverState;
}
void Decoder::run()
{
unsigned char *decoderBuffer = Q_NULLPTR;
AVIOContext *avioCtx = Q_NULLPTR;
AVFormatContext *formatCtx = Q_NULLPTR;
AVCodec *codec = Q_NULLPTR;
AVCodecContext *codecCtx = Q_NULLPTR;
ReadPacketFunc readPacket = Q_NULLPTR;
bool isFormatCtxOpen = false;
bool isCodecCtxOpen = false;
// decoder buffer
decoderBuffer = (unsigned char*)av_malloc(BUFSIZE);
if (!decoderBuffer) {
qCritical("Could not allocate buffer");
goto runQuit;
}
// initialize the receiver state
m_receiverState.frameMetaQueue = Q_NULLPTR;
m_receiverState.remaining = 0;
// if recording is enabled, a "header" is sent between raw packets
readPacket = m_recorder ? readPacketWithMeta: readRawPacket;
// io context
avioCtx = avio_alloc_context(decoderBuffer, BUFSIZE, 0, this, readPacket, NULL, NULL);
if (!avioCtx) {
qCritical("Could not allocate avio context");
// avformat_open_input takes ownership of 'decoderBuffer'
// so only free the buffer before avformat_open_input()
av_free(decoderBuffer);
goto runQuit;
}
// format context
formatCtx = avformat_alloc_context();
if (!formatCtx) {
qCritical("Could not allocate format context");
goto runQuit;
}
formatCtx->pb = avioCtx;
if (avformat_open_input(&formatCtx, NULL, NULL, NULL) < 0) {
qCritical("Could not open video stream");
goto runQuit;
}
isFormatCtxOpen = true;
// codec
codec = avcodec_find_decoder(AV_CODEC_ID_H264);
if (!codec) {
qCritical("H.264 decoder not found");
goto runQuit;
}
// codec context
codecCtx = avcodec_alloc_context3(codec);
if (!codecCtx) {
qCritical("Could not allocate decoder context");
goto runQuit;
}
if (avcodec_open2(codecCtx, codec, NULL) < 0) {
qCritical("Could not open H.264 codec");
goto runQuit;
}
isCodecCtxOpen = true;
if (m_recorder && !m_recorder->open(codec)) {
qCritical("Could not open recorder");
goto runQuit;
}
AVPacket packet;
av_init_packet(&packet);
packet.data = Q_NULLPTR;
packet.size = 0;
while (!m_quit && !av_read_frame(formatCtx, &packet)) {
AVFrame* decodingFrame = m_vb->decodingFrame();
// the new decoding/encoding API has been introduced by:
// <http://git.videolan.org/?p=ffmpeg.git;a=commitdiff;h=7fc329e2dd6226dfecaa4a1d7adf353bf2773726>
#ifdef QTSCRCPY_LAVF_HAS_NEW_ENCODING_DECODING_API
int ret;
if ((ret = avcodec_send_packet(codecCtx, &packet)) < 0) {
char errorbuf[255] = { 0 };
av_strerror(ret, errorbuf, 254);
qCritical("Could not send video packet: %s", errorbuf);
goto runQuit;
}
if (decodingFrame) {
ret = avcodec_receive_frame(codecCtx, decodingFrame);
}
if (!ret) {
// a frame was received
pushFrame();
//emit getOneFrame(yuvDecoderFrame->data[0], yuvDecoderFrame->data[1], yuvDecoderFrame->data[2],
// yuvDecoderFrame->linesize[0], yuvDecoderFrame->linesize[1], yuvDecoderFrame->linesize[2]);
/*
// m_conver转换yuv为rgb是使用cpu转的，占用cpu太高，改用opengl渲染yuv
// QImage的copy也非常占用内存，此方案不考虑
if (!m_conver.isInit()) {
qDebug() << "decoder frame format" << decodingFrame->format;
m_conver.setSrcFrameInfo(codecCtx->width, codecCtx->height, AV_PIX_FMT_YUV420P);
m_conver.setDstFrameInfo(codecCtx->width, codecCtx->height, AV_PIX_FMT_RGB32);
m_conver.init();
}
if (!outBuffer) {
outBuffer=new quint8[avpicture_get_size(AV_PIX_FMT_RGB32, codecCtx->width, codecCtx->height)];
avpicture_fill((AVPicture *)rgbDecoderFrame, outBuffer, AV_PIX_FMT_RGB32, codecCtx->width, codecCtx->height);
}
m_conver.convert(decodingFrame, rgbDecoderFrame);
//QImage tmpImg((uchar *)outBuffer, codecCtx->width, codecCtx->height, QImage::Format_RGB32);
//QImage image = tmpImg.copy();
//emit getOneImage(image);
*/
} else if (ret != AVERROR(EAGAIN)) {
qCritical("Could not receive video frame: %d", ret);
av_packet_unref(&packet);
goto runQuit;
}
#else
int gotPicture = 0;
int len = -1;
if (decodingFrame) {
len = avcodec_decode_video2(codecCtx, decodingFrame, &gotPicture, &packet);
}
if (len < 0) {
qCritical("Could not decode video packet: %d", len);
av_packet_unref(&packet);
goto runQuit;
}
if (gotPicture) {
pushFrame();
}
#endif
if (m_recorder) {
// we retrieve the PTS in order they were received, so they will
// be assigned to the correct frame
quint64 pts = receiverStateTakeMeta(&m_receiverState);
packet.pts = pts;
packet.dts = pts;
// no need to rescale with av_packet_rescale_ts(), the timestamps
// are in microseconds both in input and output
if (!m_recorder->write(&packet)) {
qCritical("Could not write frame to output file");
av_packet_unref(&packet);
goto runQuit;
}
}
av_packet_unref(&packet);
if (avioCtx->eof_reached) {
break;
}
}
qDebug() << "End of frames";
runQuit:
if (m_recorder) {
m_recorder->close();
}
if (avioCtx) {
av_free(avioCtx->buffer);
av_freep(&avioCtx);
}
if (formatCtx && isFormatCtxOpen) {
avformat_close_input(&formatCtx);
}
if (formatCtx) {
avformat_free_context(formatCtx);
}
if (codecCtx && isCodecCtxOpen) {
avcodec_close(codecCtx);
}
if (codecCtx) {
avcodec_free_context(&codecCtx);
}
emit onDecodeStop();
}
void Decoder::pushFrame()
{
if (!m_vb) {
return;
}
bool previousFrameConsumed = m_vb->offerDecodedFrame();
if (!previousFrameConsumed) {
// the previous newFrame will consume this frame

49
QtScrcpy/decoder/decoder.h
View file

@ -1,65 +1,36 @@
#ifndef DECODER_H
#define DECODER_H
#include <QThread>
#include <QPointer>
#include <QMutex>
#include <QObject>
extern "C"
{
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
}
class VideoBuffer;
class DeviceSocket;
class Recorder;
class Decoder : public QThread
class Decoder : public QObject
{
Q_OBJECT
public:
typedef struct FrameMeta {
quint64 pts;
struct FrameMeta* next;
} FrameMeta;
typedef struct ReceiverState {
// meta (in order) for frames not consumed yet
FrameMeta* frameMetaQueue;
qint32 remaining; // remaining bytes to receive for the current frame
} ReceiverState;
Decoder();
virtual ~Decoder();
public:
static bool init();
static void deInit();
void setVideoBuffer(VideoBuffer* vb);
void setDeviceSocket(DeviceSocket* deviceSocket);
void setRecoder(Recorder* recorder);
qint32 recvData(quint8* buf, qint32 bufSize);
bool startDecode();
void stopDecode();
ReceiverState* getReceiverState();
bool open(const AVCodec *codec);
void close();
bool push(const AVPacket *packet);
void interrupt();
signals:
void onNewFrame();
void onDecodeStop();
protected:
void run();
void pushFrame();
private:
QPointer<DeviceSocket> m_deviceSocket;
bool m_quit = false;
VideoBuffer* m_vb;
// for recorder
Recorder* m_recorder = Q_NULLPTR;
ReceiverState m_receiverState;
private:
VideoBuffer* m_vb = Q_NULLPTR;
AVCodecContext* m_codecCtx = Q_NULLPTR;
bool m_isCodecCtxOpen = false;
};
#endif // DECODER_H

6
QtScrcpy/decoder/decoder.pri
View file

@ -2,11 +2,13 @@ HEADERS += \
$$PWD/decoder.h \
$$PWD/fpscounter.h \
$$PWD/avframeconvert.h \
$$PWD/videobuffer.h
$$PWD/videobuffer.h \
$$PWD/stream.h
SOURCES += \
$$PWD/decoder.cpp \
$$PWD/fpscounter.cpp \
$$PWD/avframeconvert.cpp \
$$PWD/videobuffer.cpp
$$PWD/videobuffer.cpp \
$$PWD/stream.cpp

367
QtScrcpy/decoder/stream.cpp Normal file
View file

@ -0,0 +1,367 @@
#include <QDebug>
#include <QTime>
#include "compat.h"
#include "stream.h"
#include "decoder.h"
#include "devicesocket.h"
#include "recorder.h"
#define BUFSIZE 0x10000
#define HEADER_SIZE 12
#define NO_PTS UINT64_C(-1)
typedef qint32 (*ReadPacketFunc)(void*, quint8*, qint32);
Stream::Stream()
{
}
Stream::~Stream()
{
}
static void avLogCallback(void *avcl, int level, const char *fmt, va_list vl) {
Q_UNUSED(avcl);
Q_UNUSED(vl);
QString localFmt = QString::fromUtf8(fmt);
localFmt.prepend("[FFmpeg] ");
switch (level) {
case AV_LOG_PANIC:
case AV_LOG_FATAL:
qFatal(localFmt.toUtf8());
break;
case AV_LOG_ERROR:
qCritical(localFmt.toUtf8());
break;
case AV_LOG_WARNING:
qWarning(localFmt.toUtf8());
break;
case AV_LOG_INFO:
qInfo(localFmt.toUtf8());
break;
case AV_LOG_DEBUG:
//qDebug(localFmt.toUtf8());
break;
}
// do not forward others, which are too verbose
return;
}
bool Stream::init()
{
#ifdef QTSCRCPY_LAVF_REQUIRES_REGISTER_ALL
av_register_all();
#endif
if (avformat_network_init()) {
return false;
}
av_log_set_callback(avLogCallback);
return true;
}
void Stream::deInit()
{
avformat_network_deinit(); // ignore failure
}
void Stream::setDecoder(Decoder* decoder)
{
m_decoder = decoder;
}
static quint32 bufferRead32be(quint8* buf) {
return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
}
static quint64 bufferRead64be(quint8* buf) {
quint32 msb = bufferRead32be(buf);
quint32 lsb = bufferRead32be(&buf[4]);
return ((quint64) msb << 32) | lsb;
}
static Stream::FrameMeta* frameMetaNew(quint64 pts) {
Stream::FrameMeta* meta = new Stream::FrameMeta;
if (!meta) {
return meta;
}
meta->pts = pts;
meta->next = Q_NULLPTR;
return meta;
}
static void frameMetaDelete(Stream::FrameMeta* frameMeta) {
if (frameMeta) {
delete frameMeta;
}
}
static bool receiverStatePushMeta(Stream::ReceiverState* state, quint64 pts) {
Stream::FrameMeta* frameMeta = frameMetaNew(pts);
if (!frameMeta) {
return false;
}
// append to the list
// (iterate to find the last item, in practice the list should be tiny)
Stream::FrameMeta **p = &state->frameMetaQueue;
while (*p) {
p = &(*p)->next;
}
*p = frameMeta;
return true;
}
static quint64 receiverStateTakeMeta(Stream::ReceiverState* state) {
Stream::FrameMeta *frameMeta = state->frameMetaQueue; // first item
Q_ASSERT(frameMeta); // must not be empty
quint64 pts = frameMeta->pts;
state->frameMetaQueue = frameMeta->next; // remove the item
frameMetaDelete(frameMeta);
return pts;
}
static qint32 readPacketWithMeta(void *opaque, uint8_t *buf, int bufSize) {
Stream* stream = (Stream*)opaque;
Stream::ReceiverState* state = stream->getReceiverState();
// The video stream contains raw packets, without time information. When we
// record, we retrieve the timestamps separately, from a "meta" header
// added by the server before each raw packet.
//
// The "meta" header length is 12 bytes:
// [. . . . . . . .|. . . .]. . . . . . . . . . . . . . . ...
// <-------------> <-----> <-----------------------------...
// PTS packet raw packet
// size
//
// It is followed by <packet_size> bytes containing the packet/frame.
if (!state->remaining) {
quint8 header[HEADER_SIZE];
qint32 r = stream->recvData(header, HEADER_SIZE);
if (r == -1) {
return AVERROR(errno);
}
if (r == 0) {
return AVERROR_EOF;
}
// no partial read (net_recv_all())
if (r != HEADER_SIZE) {
return AVERROR(ENOMEM);
}
uint64_t pts = bufferRead64be(header);
state->remaining = bufferRead32be(&header[8]);
if (pts != NO_PTS && !receiverStatePushMeta(state, pts)) {
qCritical("Could not store PTS for recording");
// we cannot save the PTS, the recording would be broken
return AVERROR(ENOMEM);
}
}
Q_ASSERT(state->remaining);
if (bufSize > state->remaining) {
bufSize = state->remaining;
}
qint32 r = stream->recvData(buf, bufSize);
if (r == -1) {
return AVERROR(errno);
}
if (r == 0) {
return AVERROR_EOF;
}
Q_ASSERT(state->remaining >= r);
state->remaining -= r;
return r;
}
static qint32 readRawPacket(void *opaque, quint8 *buf, qint32 bufSize) {
Stream *stream = (Stream*)opaque;
if (stream) {
qint32 len = stream->recvData(buf, bufSize);
if (len == -1) {
return AVERROR(errno);
}
if (len == 0) {
return AVERROR_EOF;
}
return len;
}
return AVERROR_EOF;
}
void Stream::setDeviceSocket(DeviceSocket* deviceSocket)
{
m_deviceSocket = deviceSocket;
}
void Stream::setRecoder(Recorder *recorder)
{
m_recorder = recorder;
}
qint32 Stream::recvData(quint8* buf, qint32 bufSize)
{
if (!buf) {
return 0;
}
if (m_deviceSocket) {
qint32 len = m_deviceSocket->subThreadRecvData(buf, bufSize);
return len;
}
return 0;
}
bool Stream::startDecode()
{
if (!m_deviceSocket) {
return false;
}
m_quit.store(0);
start();
return true;
}
void Stream::stopDecode()
{
m_quit.store(1);
if (m_decoder) {
m_decoder->interrupt();
}
wait();
}
Stream::ReceiverState *Stream::getReceiverState()
{
return &m_receiverState;
}
void Stream::run()
{
unsigned char *decoderBuffer = Q_NULLPTR;
AVIOContext *avioCtx = Q_NULLPTR;
AVFormatContext *formatCtx = Q_NULLPTR;
AVCodec *codec = Q_NULLPTR;
AVCodecContext *codecCtx = Q_NULLPTR;
ReadPacketFunc readPacket = Q_NULLPTR;
bool isFormatCtxOpen = false;
// decoder buffer
decoderBuffer = (unsigned char*)av_malloc(BUFSIZE);
if (!decoderBuffer) {
qCritical("Could not allocate buffer");
goto runQuit;
}
// initialize the receiver state
m_receiverState.frameMetaQueue = Q_NULLPTR;
m_receiverState.remaining = 0;
// if recording is enabled, a "header" is sent between raw packets
readPacket = m_recorder ? readPacketWithMeta: readRawPacket;
// io context
avioCtx = avio_alloc_context(decoderBuffer, BUFSIZE, 0, this, readPacket, NULL, NULL);
if (!avioCtx) {
qCritical("Could not allocate avio context");
// avformat_open_input takes ownership of 'decoderBuffer'
// so only free the buffer before avformat_open_input()
av_free(decoderBuffer);
goto runQuit;
}
// format context
formatCtx = avformat_alloc_context();
if (!formatCtx) {
qCritical("Could not allocate format context");
goto runQuit;
}
formatCtx->pb = avioCtx;
if (avformat_open_input(&formatCtx, NULL, NULL, NULL) < 0) {
qCritical("Could not open video stream");
goto runQuit;
}
isFormatCtxOpen = true;
// codec
codec = avcodec_find_decoder(AV_CODEC_ID_H264);
if (!codec) {
qCritical("H.264 decoder not found");
goto runQuit;
}
if (m_decoder && !m_decoder->open(codec)) {
qCritical("Could not open m_decoder");
goto runQuit;
}
if (m_recorder && !m_recorder->open(codec)) {
qCritical("Could not open recorder");
goto runQuit;
}
AVPacket packet;
av_init_packet(&packet);
packet.data = Q_NULLPTR;
packet.size = 0;
while (!m_quit.load() && !av_read_frame(formatCtx, &packet)) {
if (m_decoder && !m_decoder->push(&packet)) {
av_packet_unref(&packet);
goto runQuit;
}
if (m_recorder) {
// we retrieve the PTS in order they were received, so they will
// be assigned to the correct frame
quint64 pts = receiverStateTakeMeta(&m_receiverState);
packet.pts = pts;
packet.dts = pts;
// no need to rescale with av_packet_rescale_ts(), the timestamps
// are in microseconds both in input and output
if (!m_recorder->write(&packet)) {
qCritical("Could not write frame to output file");
av_packet_unref(&packet);
goto runQuit;
}
}
av_packet_unref(&packet);
if (avioCtx->eof_reached) {
break;
}
}
qDebug() << "End of frames";
runQuit:
if (m_recorder) {
m_recorder->close();
}
if (avioCtx) {
av_free(avioCtx->buffer);
av_freep(&avioCtx);
}
if (formatCtx && isFormatCtxOpen) {
avformat_close_input(&formatCtx);
}
if (formatCtx) {
avformat_free_context(formatCtx);
}
if (m_decoder) {
m_decoder->close();
}
if (codecCtx) {
avcodec_free_context(&codecCtx);
}
emit onDecodeStop();
}

64
QtScrcpy/decoder/stream.h Normal file
View file

@ -0,0 +1,64 @@
#ifndef STREAM_H
#define STREAM_H
#include <QThread>
#include <QPointer>
#include <QMutex>
#include <QAtomicInteger>
extern "C"
{
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
}
class DeviceSocket;
class Recorder;
class Decoder;
class Stream : public QThread
{
Q_OBJECT
public:
typedef struct FrameMeta {
quint64 pts;
struct FrameMeta* next;
} FrameMeta;
typedef struct ReceiverState {
// meta (in order) for frames not consumed yet
FrameMeta* frameMetaQueue;
qint32 remaining; // remaining bytes to receive for the current frame
} ReceiverState;
Stream();
virtual ~Stream();
public:
static bool init();
static void deInit();
void setDecoder(Decoder* vb);
void setDeviceSocket(DeviceSocket* deviceSocket);
void setRecoder(Recorder* recorder);
qint32 recvData(quint8* buf, qint32 bufSize);
bool startDecode();
void stopDecode();
ReceiverState* getReceiverState();
signals:
void onDecodeStop();
protected:
void run();
private:
QPointer<DeviceSocket> m_deviceSocket;
QAtomicInteger<qint8> m_quit;
// for recorder
Recorder* m_recorder = Q_NULLPTR;
ReceiverState m_receiverState;
Decoder* m_decoder = Q_NULLPTR;
};
#endif // STREAM_H

6
QtScrcpy/main.cpp
View file

@ -5,7 +5,7 @@
#include <QTranslator>
#include "dialog.h"
#include "decoder.h"
#include "stream.h"
#include "mousetap/mousetap.h"
Dialog* g_mainDlg = Q_NULLPTR;
@ -21,7 +21,7 @@ int main(int argc, char *argv[])
//QApplication::setAttribute(Qt::AA_UseSoftwareOpenGL);
g_oldMessageHandler = qInstallMessageHandler(myMessageOutput);
Decoder::init();
Stream::init();
QApplication a(argc, argv);
installTranslator();
@ -54,7 +54,7 @@ int main(int argc, char *argv[])
int ret = a.exec();
MouseTap::getInstance()->quitMouseEventTap();
Decoder::deInit();
Stream::deInit();
return ret;
}

13
QtScrcpy/videoform.cpp
View file

@ -33,9 +33,10 @@ VideoForm::VideoForm(const QString& serial, quint16 maxSize, quint32 bitRate, co
m_server = new Server();
m_vb.init();
m_decoder.setVideoBuffer(&m_vb);
m_stream.setDecoder(&m_decoder);
if (!fileName.trimmed().isEmpty()) {
m_recorder = new Recorder(fileName.trimmed());
m_decoder.setRecoder(m_recorder);
m_stream.setRecoder(m_recorder);
}
initSignals();
@ -63,7 +64,7 @@ VideoForm::~VideoForm()
{
m_server->stop();
// server must stop before decoder, because decoder block main thread
m_decoder.stopDecode();
m_stream.stopDecode();
delete m_server;
if (m_recorder) {
delete m_recorder;
@ -167,8 +168,8 @@ void VideoForm::initSignals()
}
// init decoder
m_decoder.setDeviceSocket(m_server->getDeviceSocket());
m_decoder.startDecode();
m_stream.setDeviceSocket(m_server->getDeviceSocket());
m_stream.startDecode();
// init controller
m_inputConvert.setDeviceSocket(m_server->getDeviceSocket());
@ -180,9 +181,9 @@ void VideoForm::initSignals()
qDebug() << "server process stop";
});
connect(&m_decoder, &Decoder::onDecodeStop, this, [this](){
connect(&m_stream, &Stream::onStreamStop, this, [this](){
close();
qDebug() << "decoder thread stop";
qDebug() << "stream thread stop";
});
// must be Qt::QueuedConnection, ui update must be main thread

6
QtScrcpy/videoform.h
View file

@ -6,8 +6,9 @@
#include <QTime>
#include "server.h"
#include "decoder.h"
#include "stream.h"
#include "videobuffer.h"
#include "decoder.h"
#include "inputconvertnormal.h"
#include "inputconvertgame.h"
#include "filehandler.h"
@ -70,7 +71,7 @@ private:
Ui::videoForm *ui;
QSize frameSize;
Server* m_server = Q_NULLPTR;
Decoder m_decoder;
Stream m_stream;
VideoBuffer m_vb;
//InputConvertNormal m_inputConvert;
InputConvertGame m_inputConvert;
@ -82,6 +83,7 @@ private:
float m_widthHeightRatio = 0.5f;
QPointer<ToolForm> m_toolForm;
Recorder* m_recorder = Q_NULLPTR;
Decoder m_decoder;
QTime m_startTimeCount;
QPointer<QWidget> m_loadingWidget;
};