From patchwork Wed Sep 8 11:37:52 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Bartsevich, Dmitry" X-Patchwork-Id: 30072 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6602:2a4a:0:0:0:0 with SMTP id k10csp330508iov; Wed, 8 Sep 2021 04:38:20 -0700 (PDT) X-Google-Smtp-Source: ABdhPJzviO9zmGh6ba2aodj4WPrGqn0DinGmckUmiW7R/6y5NYHfX4oo0uP9gfS1UsRgYRsY0yGO X-Received: by 2002:aa7:d51a:: with SMTP id y26mr3363139edq.163.1631101100184; Wed, 08 Sep 2021 04:38:20 -0700 (PDT) Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id m1si1824463ejj.616.2021.09.08.04.38.03; Wed, 08 Sep 2021 04:38:20 -0700 (PDT) Received-SPF: pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) client-ip=79.124.17.100; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@scnsoft.com header.s=selector2 header.b=napOlTRB; arc=fail (body hash mismatch); spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=scnsoft.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 984D868A8C7; Wed, 8 Sep 2021 14:38:00 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR04-VI1-obe.outbound.protection.outlook.com (mail-eopbgr80083.outbound.protection.outlook.com [40.107.8.83]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 5B05D68A8A5 for ; Wed, 8 Sep 2021 14:37:54 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=jWmp4S8fKA/w5DHzLcoeBSC42ny7ZBNMUO8eAa4mNrkMLvjGSMgq7x8OAZaKRmwyVEU3PSK+f/cFzUjX5cVSuvxELWEs6u3eCmyhMUG0RLLbjTkxgeXKSj9m2fG7cgFaEbIms8lWmJG9gdu2pa1RHn71ltC2yMqL1JIoL31Pzw5cpZJl2tJQR+s2XF2P0jmXIYPYHADnoboD5wqS0YwxX9YAwAtwE0cisuuAh6a0q3+GH/hMC5yWQK/C8DPDQ6Lt/qwA3gr/StwPk6wKFslxyXIhNZIreXTGXr6sH30KQ8W100nKBmuDx1nFDeV7UMi++bKZxICC9nE+277A3iMQlg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=P90TmqlmDuSHXFo12OccJO6umyenfDvGZz+19OgQu3U=; b=jeJJz7hFXoV8oPyjoz7mEJcvw0f4ks8fUNvYgwL12Y1QILL4WOn2Oza3khMcJVWRbHLJ8vGG6hit1UgOYBBqEN+YgD0IFfJyLBGRPma++sYThmBO6nfS8fW/fnYTfHOs72J/OpOp/sMVL+VkU+ZFFMy6JOg+D7p/HB8dTCN29hKP4/7nCYsPd0tXKKrLbc04DfdWxdmMn3btYsbi/R2E5hhCOlb85ZcPm1KPscl6Atp0OnFbn6KSl3RtfZJRZl3zu/HyiNH4y16Tn9hIy80nwpIj3KPPBEZ/hfH5U4yEN0d3fURWaWv0AWpenoNKVId3DeBbIOiFP9WvleLcfuMY/g== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=scnsoft.com; dmarc=pass action=none header.from=scnsoft.com; dkim=pass header.d=scnsoft.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=scnsoft.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=P90TmqlmDuSHXFo12OccJO6umyenfDvGZz+19OgQu3U=; b=napOlTRBAo+upiqo437d+b+tA7WXIFuWN3kZCt0EYfeOU2VRY9pkWDgNrNq31jqKEnpRbVq73ARePFgzjjzQM4ltNpj934KUK/R6M1t76qEOea3DiXjrZTS5quD+POHBF7+zvANnvdav8eAKNVrZb5BZc3I78XCGc1kabKZLgQI= Received: from DB9PR10MB4619.EURPRD10.PROD.OUTLOOK.COM (2603:10a6:10:224::10) by DB9PR10MB4521.EURPRD10.PROD.OUTLOOK.COM (2603:10a6:10:1ff::13) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.4478.19; Wed, 8 Sep 2021 11:37:52 +0000 Received: from DB9PR10MB4619.EURPRD10.PROD.OUTLOOK.COM ([fe80::ed08:432d:40b6:8319]) by DB9PR10MB4619.EURPRD10.PROD.OUTLOOK.COM ([fe80::ed08:432d:40b6:8319%5]) with mapi id 15.20.4478.025; Wed, 8 Sep 2021 11:37:52 +0000 From: "Bartsevich, Dmitry" To: "ffmpeg-devel@ffmpeg.org" Thread-Topic: [PATCH] avformat/libsrt: data transmission bitrate control Thread-Index: Adeko43fZEoEaV2JTKq2SlwjeGBdoA== Date: Wed, 8 Sep 2021 11:37:52 +0000 Message-ID: Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: authentication-results: ffmpeg.org; dkim=none (message not signed) header.d=none;ffmpeg.org; dmarc=none action=none header.from=scnsoft.com; x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: be61fd93-9d50-4b40-a04b-08d972bd17f6 x-ms-traffictypediagnostic: DB9PR10MB4521: x-microsoft-antispam-prvs: x-ms-oob-tlc-oobclassifiers: OLM:2000; x-ms-exchange-senderadcheck: 1 x-ms-exchange-antispam-relay: 0 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: 9648luCLfEoFY5h24/d9ozuW7VvPMYk0YnkdVL6Jo3jo/64ABF58k7t2huzrQpcFQHQMEtldByGue6li0wsT8LDoJdpzc6OTrL9UNKWlJnWP8jgdX7UzBCmjRc1AItgWMQFx3MrMqnYwROTngHLk2gGu6+4CQN4PAxSpNON3bfZX+0uy5QpKDDi1AtqzxoDDpzK4lU6HOx2CUvKYN7GYTdm3050eBweHrv8k3axGtfgFYVdi6ElmLByUxbnO8NOwiVLyqMt7b6UhbY+vchTyV+Up9b37BkF4HLZJnsUWjNRZae0VJgCoIQWMmOp24F4H9FSwJrYtVtPieQjNV9CtboX7XbZD7kUOr6MOXsIDbKQhua970jPKv26hsVYTqWLzzzW9QHDGXnxDI707ZujisMlsFzQqOUvEcts6fQJCwOZWM0WZjOxuoxOuoyfKI1jBUUEp38vRiXx4s290vqs7uX2kKQxZMD3IM/oDkpAonlR6LzGUyt2y8jNKWMwZvvrpBhPe525XlR4NamnvWjcBlXcK8D8UDC2h/PwJoWWIfAB2VOEQ7R559EQLi7STTfG19Nb8I85GTc6oIgbFIYBFJww31Zl1cXvZ/8Xy1rmxkZzQJ9vY1E1vuVCae+0XJ+DgBOWc/G4tK+uEK9g3Dzxwkb8NuElRFy33frf1OfejhWnq4iqqTFnDMoSCAdTSXdrql51PYa4F9Bm8H8XwuD7WKA== x-forefront-antispam-report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:DB9PR10MB4619.EURPRD10.PROD.OUTLOOK.COM; PTR:; CAT:NONE; SFS:(366004)(39850400004)(136003)(376002)(346002)(396003)(76116006)(83380400001)(30864003)(71200400001)(122000001)(66476007)(316002)(8676002)(186003)(2906002)(38070700005)(5660300002)(7696005)(6506007)(26005)(52536014)(66446008)(9686003)(478600001)(38100700002)(86362001)(66946007)(8936002)(55016002)(66556008)(6916009)(64756008)(33656002); DIR:OUT; SFP:1101; x-ms-exchange-antispam-messagedata-chunkcount: 1 x-ms-exchange-antispam-messagedata-0: xECy3YqTAFrxfH1eYA6W40SIYvFYorj5Cz6LvTGnUhCi2RbvvoJ9x3MnrdLAkAc9PpTiiL1Nki8QdSte6HOMVvgKcS6fbLaq62Yj+E8EY9ZJ6vuI2nGE8kYyFjY0d5ECbqWFaM8XtVneDRG1CfWyjhf2Oo1IzLcn4NKiYVNfmXFtEJdsHJZuk/UUfYR5KG1xwT8P1qg/MzNqhPeeBAXmjKlY7DNTJGhY9CPZ8sGFeljSWNURq/vuhbDrdmjrwEs/t3V9vdEt/XrqHMasdLzuC3aspQ51pAE+13197pukzXL8vMHjiPJ60Ho6suGtQIGl4tS/jaflDc2vXGlpW/IEZHwPJsMuswprsW7jcKh6hYyE0nvdNcN16MAJP5K/1DvGP07F18Ya9GNvHCQoQqGNMzXJKyMjRl/s7urzHHfAx2JYrtvBUpv3TEg+mObCWs2x56qTQJ4UyzwOLEMOtEs8dsHRz2be4tyVUrKWuNra/3x8ZzhHu7zbiuTYs7rR4XCP/0WhQ7EiNywUflQpm3Ktu9cC1C4k+vuMzgPE07rn10PUbkBltqTmNWL4GHin8LNOkcTgyMMpU3Hsqss5NQcDr2h2ji/D6wJzdJVcOwig+0AYvODPaHfozWWPgv/lL+qPqCNPTMqIIRilYJTDv/26ZK1nVtdjQXXYp7aTDaMpArmig6GZm2EX6wWAHA4HPcxDd4/RtCulHkLdQJUWSfGg1MJnyvWwBe8oNXStaahkpZn8vFAe2c3epCOLjEdzGFwnzWWxrRIfBajs5bjjGuBtwHUNh9+pO4I+yKHCfD578IyVCpwt6rv7sJs3Vl+3CBGAwxiQM/DQpb79+CYxQh/QTs3ykbe2ztKYRboCPMqWkEXBrI8ozwHgzWopPTsWO4lVzbN4gwEvTWX02iViR+yGEKdMgwG3FbpPWRJFGYe3BSTMfemM1FmzeCSm8/LHCG9P/KY29tZgkBziWG9YOL+Ztywn5l+m4SzyvPd69QWEB5zfbtlD5r+sgvsRC43CKnAdpvdRUyBoWJ7NwHjZZfZ+CzkCaM+hvP1d0IN4CNTp1hmY2jliCs5RqXVQXyCt60lQk/53oq0QJ3PGrqNiCOsd1YXbzX0oeLfd1ROqoigdAk0g8SdT3iXyAV2o4PGyLHLx+OLzNbwTmV6LhMqeS6vADraeDv1JlD/Xu+p6cC9nxlvH1wwySvS6qZ5j3V2Tr53Fse3lV4bAXhjQAgab1+zS1MhTGCp0sxQz3ywUhRThMWcHrmjsVkPTsL/b7wOM7xWtnjeU/TJp17G+mmAPffHv+Mssgo22P/N0G9XYJSOSpzw= x-ms-exchange-transport-forked: True MIME-Version: 1.0 X-OriginatorOrg: scnsoft.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-AuthSource: DB9PR10MB4619.EURPRD10.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-Network-Message-Id: be61fd93-9d50-4b40-a04b-08d972bd17f6 X-MS-Exchange-CrossTenant-originalarrivaltime: 08 Sep 2021 11:37:52.4735 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: 73e2d4c4-aed9-4e34-924b-f5449c11a2d6 X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: dv+NJ7HsHr4FYgCPW3zJJbYVxN3RYUfyUKOtcqfNjF3L+g4A9HgiL/8ccDjMIVhQqhfDqnkHJZe/wfZsvSjhzA== X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB9PR10MB4521 X-Content-Filtered-By: Mailman/MimeDel 2.1.29 Subject: [FFmpeg-devel] [PATCH] avformat/libsrt: data transmission bitrate control X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: xW5ngPM1Ze87 The patch adds 3 parameters ("bitrate", "burst_bits", "fifo_size") and output bitrate control to the libsrt muxer. The code is mostly taken from udp.c and the reasoning is the same: data transmission bursts cause decoding errors on some decoders. Windows-specific APIs (performance counters and waitable timers) are used instead of standard FFmpeg routines to measure time intervals and to delay thread execution in Windows build: standard ones don't provide sub-millisecond precision and accuracy which are required for smooth outbound traffic. Muxer URL would look like this: "srt://10.10.10.10:12345?mode=caller&bitrate=15000000&burst_bits=150000" Signed-off-by: Dmitry Bartsevich --- libavformat/libsrt.c | 275 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 275 insertions(+) #include "url.h" +#if HAVE_W32THREADS +#undef HAVE_PTHREAD_CANCEL +#define HAVE_PTHREAD_CANCEL 1 +#endif + +#if HAVE_PTHREAD_CANCEL +#include "libavutil/thread.h" +#endif + /* This is for MPEG-TS and it's a default SRTO_PAYLOADSIZE for SRTT_LIVE (8 TS packets) */ #ifndef SRT_LIVE_DEFAULT_PAYLOAD_SIZE #define SRT_LIVE_DEFAULT_PAYLOAD_SIZE 1316 @@ -90,6 +102,21 @@ typedef struct SRTContext { SRT_TRANSTYPE transtype; int linger; int tsbpd; + + /* Circular Buffer variables for use in SRT sending code */ + int circular_buffer_size; + AVFifoBuffer *fifo; + int circular_buffer_error; + int64_t bitrate; /* number of bits to send per second */ + int64_t burst_bits; + int close_req; +#if HAVE_PTHREAD_CANCEL + pthread_t circular_buffer_thread; + pthread_mutex_t mutex; + pthread_cond_t cond; + int thread_started; +#endif + uint8_t tmp[SRT_LIVE_MAX_PAYLOAD_SIZE+4]; } SRTContext; #define D AV_OPT_FLAG_DECODING_PARAM @@ -142,6 +169,9 @@ static const AVOption libsrt_options[] = { { "file", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = SRTT_FILE }, INT_MIN, INT_MAX, .flags = D|E, "transtype" }, { "linger", "Number of seconds that the socket waits for unsent data when closing", OFFSET(linger), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E }, { "tsbpd", "Timestamp-based packet delivery", OFFSET(tsbpd), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, .flags = D|E }, + { "bitrate", "Bits to send per second", OFFSET(bitrate), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, .flags = E }, + { "burst_bits", "Max length of bursts in bits (when using bitrate)", OFFSET(burst_bits), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, .flags = E }, + { "fifo_size", "set the SRT sending circular buffer size, expressed as a number of packets with size of 188 bytes", OFFSET(circular_buffer_size), AV_OPT_TYPE_INT, {.i64 = 7*4096}, 0, INT_MAX, .flags = E }, { NULL } }; @@ -165,6 +195,138 @@ static int libsrt_socket_nonblock(int socket, int enable) return srt_setsockopt(socket, 0, SRTO_RCVSYN, &blocking, sizeof(blocking)); } +#if HAVE_PTHREAD_CANCEL + +/* More precise time measurement in Windows, call default routine otherwise */ +static int64_t av_gettime_relative_precise(void) +{ +#ifdef _WIN32 + static LARGE_INTEGER freq; + LARGE_INTEGER t; + + if (freq.QuadPart == 0) { + QueryPerformanceFrequency(&freq); + } + + QueryPerformanceCounter(&t); + return t.QuadPart * 1000000 / freq.QuadPart; +#else + return av_gettime_relative(); +#endif +} + +static void *circular_buffer_task_tx(void *_URLContext) +{ + URLContext *h = _URLContext; + SRTContext *s = h->priv_data; + int old_cancelstate; + int64_t target_timestamp = av_gettime_relative_precise(); + int64_t start_timestamp = av_gettime_relative_precise(); + int64_t sent_bits = 0; + int64_t burst_interval = s->bitrate ? (s->burst_bits * 1000000 / s->bitrate) : 0; + int64_t max_delay = s->bitrate ? ((int64_t)h->max_packet_size * 8 * 1000000 / s->bitrate + 1) : 0; +#ifdef _WIN32 + /* Use waitable timers to delay thread execution in Windows, as default + Sleep() API call has 1ms resolution and is not accurate enough */ + LARGE_INTEGER timeout; + HANDLE waitable_timer = CreateWaitableTimer(NULL, FALSE, NULL); +#endif + + pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancelstate); + pthread_mutex_lock(&s->mutex); + + if (libsrt_socket_nonblock(s->fd, 0) < 0) { + av_log(h, AV_LOG_ERROR, "Failed to set blocking mode"); + s->circular_buffer_error = AVERROR(EIO); + goto end; + } + + for(;;) { + int len; + const uint8_t *p; + uint8_t tmp[4]; + int64_t timestamp; + + len = av_fifo_size(s->fifo); + + while (len<4) { + if (s->close_req) + goto end; + pthread_cond_wait(&s->cond, &s->mutex); + len = av_fifo_size(s->fifo); + } + + av_fifo_generic_read(s->fifo, tmp, 4, NULL); + len = AV_RL32(tmp); + + av_assert0(len >= 0); + av_assert0(len <= sizeof(s->tmp)); + + av_fifo_generic_read(s->fifo, s->tmp, len, NULL); + + pthread_mutex_unlock(&s->mutex); + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old_cancelstate); + + if (s->bitrate) { + timestamp = av_gettime_relative_precise(); + if (timestamp < target_timestamp) { + int64_t delay = target_timestamp - timestamp; + if (delay > max_delay) { + delay = max_delay; + start_timestamp = timestamp + delay; + sent_bits = 0; + } +#ifdef _WIN32 + /* Relative waitable timer delay in 100-nanosecond units */ + timeout.QuadPart = -delay * 10; + if (SetWaitableTimer(waitable_timer, &timeout, NULL, NULL, NULL, FALSE)) + WaitForSingleObject(waitable_timer, INFINITE); +#else + av_usleep(delay); +#endif + } else { + if (timestamp - burst_interval > target_timestamp) { + start_timestamp = timestamp - burst_interval; + sent_bits = 0; + } + } + sent_bits += len * 8; + target_timestamp = start_timestamp + sent_bits * 1000000 / s->bitrate; + } + + p = s->tmp; + while (len) { + int ret; + av_assert0(len > 0); + ret = srt_sendmsg(s->fd, p, len, -1, 0); + if (ret >= 0) { + len -= ret; + p += ret; + } else { + ret = ff_neterrno(); + if (ret != AVERROR(EAGAIN) && ret != AVERROR(EINTR)) { + pthread_mutex_lock(&s->mutex); + s->circular_buffer_error = ret; + pthread_mutex_unlock(&s->mutex); + return NULL; + } + } + } + + pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancelstate); + pthread_mutex_lock(&s->mutex); + } + +end: + pthread_mutex_unlock(&s->mutex); +#ifdef _WIN32 + CloseHandle(waitable_timer); +#endif + return NULL; +} + +#endif + static int libsrt_epoll_create(URLContext *h, int fd, int write) { int modes = SRT_EPOLL_ERR | (write ? SRT_EPOLL_OUT : SRT_EPOLL_IN); @@ -379,6 +541,7 @@ static int libsrt_setup(URLContext *h, const char *uri, int flags) char portstr[10]; int64_t open_timeout = 0; int eid, write_eid; + int is_output = (flags & AVIO_FLAG_WRITE) != 0; av_url_split(proto, sizeof(proto), NULL, 0, hostname, sizeof(hostname), &port, path, sizeof(path), uri); @@ -490,9 +653,55 @@ static int libsrt_setup(URLContext *h, const char *uri, int flags) s->fd = fd; s->eid = eid; +#if HAVE_PTHREAD_CANCEL + /* + Create thread in case of: + output and bitrate and circular_buffer_size is set + */ + + if (is_output && s->bitrate && !s->circular_buffer_size) { + /* Warn user in case of 'circular_buffer_size' is not set */ + av_log(h, AV_LOG_WARNING,"'bitrate' option was set but 'circular_buffer_size' is not, but required\n"); + } + + if (is_output && s->bitrate && s->circular_buffer_size) { + /* start the task going */ + s->fifo = av_fifo_alloc(s->circular_buffer_size); + if (!s->fifo) { + ret = AVERROR(ENOMEM); + goto fail; + } + ret = pthread_mutex_init(&s->mutex, NULL); + if (ret != 0) { + av_log(h, AV_LOG_ERROR, "pthread_mutex_init failed : %s\n", strerror(ret)); + ret = AVERROR(ret); + goto fail; + } + ret = pthread_cond_init(&s->cond, NULL); + if (ret != 0) { + av_log(h, AV_LOG_ERROR, "pthread_cond_init failed : %s\n", strerror(ret)); + ret = AVERROR(ret); + goto cond_fail; + } + ret = pthread_create(&s->circular_buffer_thread, NULL, circular_buffer_task_tx, h); + if (ret != 0) { + av_log(h, AV_LOG_ERROR, "pthread_create failed : %s\n", strerror(ret)); + ret = AVERROR(ret); + goto thread_fail; + } + s->thread_started = 1; + } +#endif + freeaddrinfo(ai); return 0; +#if HAVE_PTHREAD_CANCEL + thread_fail: + pthread_cond_destroy(&s->cond); + cond_fail: + pthread_mutex_destroy(&s->mutex); +#endif fail: if (cur_ai->ai_next) { /* Retry with the next sockaddr */ @@ -643,7 +852,25 @@ static int libsrt_open(URLContext *h, const char *uri, int flags) if (av_find_info_tag(buf, sizeof(buf), "linger", p)) { s->linger = strtol(buf, NULL, 10); } + if (av_find_info_tag(buf, sizeof(buf), "fifo_size", p)) { + s->circular_buffer_size = strtol(buf, NULL, 10); + if (!HAVE_PTHREAD_CANCEL) + av_log(h, AV_LOG_WARNING, + "'circular_buffer_size' option was set but it is not supported " + "on this build (pthread support is required)\n"); + } + if (av_find_info_tag(buf, sizeof(buf), "bitrate", p)) { + s->bitrate = strtoll(buf, NULL, 10); + if (!HAVE_PTHREAD_CANCEL) + av_log(h, AV_LOG_WARNING, + "'bitrate' option was set but it is not supported " + "on this build (pthread support is required)\n"); + } + if (av_find_info_tag(buf, sizeof(buf), "burst_bits", p)) { + s->burst_bits = strtoll(buf, NULL, 10); + } } + s->circular_buffer_size *= 188; ret = libsrt_setup(h, uri, flags); if (ret < 0) goto err; @@ -680,6 +907,36 @@ static int libsrt_write(URLContext *h, const uint8_t *buf, int size) SRTContext *s = h->priv_data; int ret; +#if HAVE_PTHREAD_CANCEL + if (s->fifo) { + uint8_t tmp[4]; + + pthread_mutex_lock(&s->mutex); + + /* + Return error if last tx failed. + Here we can't know on which packet error was, but it needs to know that error exists. + */ + if (s->circular_buffer_error < 0) { + int err = s->circular_buffer_error; + pthread_mutex_unlock(&s->mutex); + return err; + } + + if(av_fifo_space(s->fifo) < size + 4) { + /* What about a partial packet tx ? */ + pthread_mutex_unlock(&s->mutex); + return AVERROR(ENOMEM); + } + AV_WL32(tmp, size); + av_fifo_generic_write(s->fifo, tmp, 4, NULL); /* size of packet */ + av_fifo_generic_write(s->fifo, (uint8_t *)buf, size, NULL); /* the data */ + pthread_cond_signal(&s->cond); + pthread_mutex_unlock(&s->mutex); + return size; + } +#endif + if (!(h->flags & AVIO_FLAG_NONBLOCK)) { ret = libsrt_network_wait_fd_timeout(h, s->eid, 1, h->rw_timeout, &h->interrupt_callback); if (ret) @@ -698,6 +955,24 @@ static int libsrt_close(URLContext *h) { SRTContext *s = h->priv_data; +#if HAVE_PTHREAD_CANCEL + // Request close once writing is finished + if (s->thread_started) { + int ret; + + pthread_mutex_lock(&s->mutex); + s->close_req = 1; + pthread_cond_signal(&s->cond); + pthread_mutex_unlock(&s->mutex); + + ret = pthread_join(s->circular_buffer_thread, NULL); + if (ret != 0) + av_log(h, AV_LOG_ERROR, "pthread_join(): %s\n", strerror(ret)); + pthread_mutex_destroy(&s->mutex); + pthread_cond_destroy(&s->cond); + } +#endif + srt_epoll_release(s->eid); srt_close(s->fd); -- 2.16.1.windows.4 diff --git a/libavformat/libsrt.c b/libavformat/libsrt.c index e5701625b8..0a00277d80 100644 --- a/libavformat/libsrt.c +++ b/libavformat/libsrt.c @@ -23,6 +23,9 @@ #include +#include "libavutil/avassert.h" +#include "libavutil/fifo.h" +#include "libavutil/intreadwrite.h" #include "libavutil/opt.h" #include "libavutil/parseutils.h" #include "libavutil/time.h" @@ -33,6 +36,15 @@ #include "os_support.h"