From patchwork Mon Apr 8 19:51:59 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47937 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp124206pzb; Mon, 8 Apr 2024 12:52:51 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCWlaRc8oJLgXDue0jrgUhtTUvaEdWSFyN13v4Qkfqcsf6crHKHvvkLRG/46tGdaguGPd2W+o2RYMYp/JY7kvx3vVbSkenPKp8tTyQ== X-Google-Smtp-Source: AGHT+IFU0XXRQpcSjYvReKWwt7W+xKtpDyHFgEbFlK010T5z/hfwZ2pbTuNbtlG0Q6pxkPI8IrlZ X-Received: by 2002:a19:8c58:0:b0:516:d4bb:47fb with SMTP id i24-20020a198c58000000b00516d4bb47fbmr6215983lfj.1.1712605971595; Mon, 08 Apr 2024 12:52:51 -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 gx17-20020a170906f1d100b00a51ad5c4700si3448764ejb.433.2024.04.08.12.52.47; Mon, 08 Apr 2024 12:52:51 -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=@outlook.com header.s=selector1 header.b=omuO+4TR; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 1148C68D305; Mon, 8 Apr 2024 22:52:44 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR02-DB5-obe.outbound.protection.outlook.com (mail-db5eur02olkn2092.outbound.protection.outlook.com [40.92.50.92]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 42F9D68D202 for ; Mon, 8 Apr 2024 22:52:37 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=M4KkrSC79ZHkG/9DOTEAR0A57sU4sFUfXhGEXcpHZn3s4KX+l4SXjSTOUBBicTX+ARsxfbuCbcmGmx87TOJp8pobwB4KkhYTuHi6oY0UcrmOqGgFBUyrKXli271pI5trSeKCPAj4XMHqantfQ3vHmItLA+CevWyavPjyh/SU21Ge74dOOPskwrG91tjjA371wzviW0WXxLXXBBwe7tzy0gZ3n8NwwZab8POKkkzL7cWcxtPRB/5LVBGJVTdj5zAxvw9p7Wkqbhrl0PDUlYgYG7etTkpX/5SEeyDy9y/f7bKpuVY7E0sEQTnidwERKnL1DzuAq16WXoDymgFFANbswQ== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=vWDONketteIUyWVGkxmxuwA30m0LVr9WWbAOERvkLoc=; b=kPvkKBZZ1ceHGxU71TBDFowTcVZ+8S5YHHMo8kHWapOuVNbFxDXLMuFLmZeDA1GIqDfGFhUDxQx4baEstnvHaRdTW2xXBjt/YcdOKG8hEhq2kCd/XLXzabv90HoXrRteSxvffHRJmt/by+asRQ3xQocELcHvybqW6+kwkGs3l9XYRganiqcEBOaowZ2GKpCdZ+Z2V3Cx4ihIvGpRL2k0AhQZFqejh6TooYlogT7/9DcUsQMPg/9QY/3sE/2fTb7OOzJMTQE5j9ZoNLVDfRmfRGKIPbd1QYIz5GDZyclPeK1EmLhE+dAc3zaYU34ya82+e6TKJlRTnicvoqxuDSQulg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=vWDONketteIUyWVGkxmxuwA30m0LVr9WWbAOERvkLoc=; b=omuO+4TRC7nuxf4fOE9px0iiELg4tldY17Jd6xzM9cN+Z0uaX2FJgZWkNC/zMxg2g/KJZBeV+93SwDX4W31XcgMUmPVbSO4Nuubc3Wz1xBVp77QW711W79q9QW9fP1fVJ+1houY737QKsW/8agSomEM4CM4IvspljX/846PSidX04rKocI3IPUPYQgAj1rJ/SQiQRGv/BFG7pDI6KHcUQnZ6Dpe1RtdP0+JE8D1YcRIIhRiv0gqF95FP+ibNwaxQN0MP2PFO6Qc/lyvzGxqnZUUzIoRGhJeIYGqI9BPmLxCPjnujQ/Gq8cmm6ll+uqDeT0Neg5hUnpJ6el6BXCSuwQ== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by DU0P250MB0457.EURP250.PROD.OUTLOOK.COM (2603:10a6:10:345::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 19:52:33 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 19:52:32 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 21:51:59 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 X-TMN: [6l7T92+I2hhCZYOCP/LceBM1a1FpuzLqbhrnyS03Dgs=] X-ClientProxiedBy: FR3P281CA0148.DEUP281.PROD.OUTLOOK.COM (2603:10a6:d10:95::7) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408195225.2136769-1-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|DU0P250MB0457:EE_ X-MS-Office365-Filtering-Correlation-Id: c7405960-0e22-4274-2bf6-08dc58056e3c X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: EfxAPsnOk6X+ySViYihHnSxvVHde8RZVPrJYRDu7oe+vWezOQDuL9ZG0r08WrzyJExLatokHITS84+KSgqEuTk+U2d6TFIn9U9VwylTuJx+BJ1UcqecFcwPHq+SG5s5DyvLaWG3pIv7TZ6yWVWCFVaH8KirJJ0vIRAPQWVWU//0mp+BBnGo9fqhzfrrsNglHRpyrRM+Tw8HDypje9V73ZMlUoFk2G8NpR3J14Zj6wsksTgsyJD5cAjryUPgiuUCh28c8xuQg6ngJr2Ie9GmqashTaUBWi2vfSqvcoEVS+rRobdfNSRExcRsrhL96ivQLhm0UhajLjCmDJZF4hw9Xr5dNZzpVC3xWhjk52xFKt24ykSeOnl8ZqBzBQ6Muy3LmyFDV+OBCIeGaqXR9WHxKbA7uKjE5j7wtGp0pfj8YaTmAUR/xkOOFIcFXY5h5Gp2vVCm484UTwZ6soHGIkkS+HgC0nE4xWRumpUOCcvWfVKrud2j7vywmTMvSLlJLjqiwLQ0EOdaS/ry/BFyuoDCVRGhkFvB29xJDcK4zevst/ZSjiwUjbo5gZ8eu4lLVv2dDJwNBX7schIw49etA+SO6+qBuq22M+Ji7fBvyeBN/CiU= X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: aq7FEkGNY95rI2tlp5YUCNJq1V1zD3xsUuSY/8q7x8LQlB8DL3cVvp5LcXgP6bRY7tJ8FIDE/g4pbkQwqdYn3/rNQlsGFTb5o3EkxugSSmTusgUvtvHpNY6zFidsUbOZTrFyy8/lbVFfbrlIMHQMzlGepYYk/zLXOx2fwRjDppuZeqG0wy1jrWLyrN00NZPFQF6GeQO3sBbfct/T2RV7R8D47aZVoJfrdhflqR49a2F5zAD/SPkFKTBUXmztI2CQo7FPi7vcLm9Qnxpi+1YqNWqRTV4PocCSEtBJVCfFDcHLIqkUJo4GaZqvhOogkFV7rT6dg1P1W+Epocz9iBiEDoYsm0m8GZkgA/6wuyTisOqEKs0QzZPHOg+8186JM+ABr8mCKossvfaBgRbMSdiCh29TLHVAjKgIRiy7bihPA6+9Ti7vZbhzylr9SZZ/5fWr6NmB5dgfJxhh4387lZMKZCR0Xlr4TFl4H9w0ErIW5jwjwTrUIDy29Yve5hcBGasgHvwv7AzS4vh2T1iUe+0+4NNRewY5TD/6XuJAilLc8DPS31HiPwV+3NJvsgQkAQLtS72pfqlI8Kt9xag4tWr3C/3BMSuLBmWI/jfY7ZIDg02mpImvGfqWfxFiRUoOkGFyer9aaeeBOaCfW38i1lN0Hl1xcucIupigfRLtUnxNgI6qK/XhfVj37CfUEPfta50MMVOcMizyEgVwmP2gdhheKH6cg2TYdTOLfwMfHVp6DEgjM0sDLmOFESmegWxo2UuQzdith1qsiQT4WAzxflSCSx1LGXokBwu8Nel3KpRD86C9SHfAj4Fsqg6cdmiXHt77WggWlnZTZJ/dYnZPJWPtCrrBz0LUgxrwPaylBbVp8Sa+7evngv7sPAeGYqZVwQWZLOJWg6uIglRYZBSINuPoNVbcXQIxFY1joLu2LvpwvJU98ZxZ4HlCDuN6scZtn/s/mXSQxyb6RTpU2DF1aGbY7T79f0x8wtdx5v4cU272/+ek11nkzRXFW9NNawyD69Nd8Hw/zxBQXTO0rClmQ1dmLw2Etzd2DgAYh2ACfTi3BkFbV4ynJ+nRH7fNExryUdqz2WQ0F8WO3Ob1/qnexy78g1m9daSzIxau17fo6P3hzUUQYNLny7d9KcizV6YKHWy7e8fkDuXupbRKi5E1mEvQiddYAZhOzkq0UAvUZuk8LP5sfDyEnOjYh1+XfoexeOqHokrzzCVl8u+t2F/h4ADOG/itXiSHKg9W6wXMizKmkAIL3LQ/Rp8j4rWGyFMakQCG3SwjQ2UgV4UGOb154OPmGA== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: c7405960-0e22-4274-2bf6-08dc58056e3c X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 19:52:32.9203 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: DU0P250MB0457 Subject: [FFmpeg-devel] [PATCH v2 01/27] avcodec/threadprogress: Add new API for frame-threaded progress 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: kKQG0THWr9Y3 The API is similar to the ThreadFrame API, with the exception that it no longer has an included AVFrame and that it has its own mutexes and condition variables which makes it more independent of pthread_frame.c. One can wait on anything via a ThreadProgress. One just has to ensure that the lifetime of the object containing the ThreadProgress is long enough. This will typically be solved by putting a ThreadProgress in a refcounted structure that is shared between threads. Signed-off-by: Andreas Rheinhardt --- Now including its own mutex and condition variable. Hopefully no system has constraints on the number of mutexes and condition variables it supports. libavcodec/threadprogress.c | 73 +++++++++++++++++++++++++++++ libavcodec/threadprogress.h | 91 +++++++++++++++++++++++++++++++++++++ 2 files changed, 164 insertions(+) create mode 100644 libavcodec/threadprogress.c create mode 100644 libavcodec/threadprogress.h diff --git a/libavcodec/threadprogress.c b/libavcodec/threadprogress.c new file mode 100644 index 0000000000..dd2a4d2336 --- /dev/null +++ b/libavcodec/threadprogress.c @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2022 Andreas Rheinhardt + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include +#include + +#include "pthread_internal.h" +#include "threadprogress.h" +#include "libavutil/attributes.h" + +DEFINE_OFFSET_ARRAY(ThreadProgress, thread_progress, init, + (offsetof(ThreadProgress, progress_mutex)), + (offsetof(ThreadProgress, progress_cond))); + +av_cold int ff_thread_progress_init(ThreadProgress *pro, int init_mode) +{ + atomic_init(&pro->progress, init_mode ? -1 : INT_MAX); + if (!init_mode) { + pro->init = 0; + return 0; + } + return ff_pthread_init(pro, thread_progress_offsets); +} + +av_cold void ff_thread_progress_destroy(ThreadProgress *pro) +{ + ff_pthread_free(pro, thread_progress_offsets); +} + +void ff_thread_progress_report(ThreadProgress *pro, int n) +{ + if (atomic_load_explicit(&pro->progress, memory_order_relaxed) >= n) + return; + + atomic_store_explicit(&pro->progress, n, memory_order_release); + + pthread_mutex_lock(&pro->progress_mutex); + pthread_cond_broadcast(&pro->progress_cond); + pthread_mutex_unlock(&pro->progress_mutex); +} + +void ff_thread_progress_await(const ThreadProgress *pro_c, int n) +{ + /* Casting const away here is safe, because we only read from progress + * and will leave pro_c in the same state upon leaving the function + * as it had at the beginning. */ + ThreadProgress *pro = (ThreadProgress*)pro_c; + + if (atomic_load_explicit(&pro->progress, memory_order_acquire) >= n) + return; + + pthread_mutex_lock(&pro->progress_mutex); + while (atomic_load_explicit(&pro->progress, memory_order_relaxed) < n) + pthread_cond_wait(&pro->progress_cond, &pro->progress_mutex); + pthread_mutex_unlock(&pro->progress_mutex); +} diff --git a/libavcodec/threadprogress.h b/libavcodec/threadprogress.h new file mode 100644 index 0000000000..786802cbf1 --- /dev/null +++ b/libavcodec/threadprogress.h @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2022 Andreas Rheinhardt + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVCODEC_THREADPROGRESS_H +#define AVCODEC_THREADPROGRESS_H + +/** + * ThreadProgress is an API to easily notify other threads about progress + * of any kind as long as it can be packaged into an int and is consistent + * with the natural ordering of integers. + * + * Each initialized ThreadProgress can be in one of two modes: No-op mode + * or ordinary mode. In the former mode, ff_thread_report_progress() and + * ff_thread_await_progress() are no-ops to simply support usecases like + * non-frame-threading. Only in the latter case perform these functions + * what their name already implies. + */ + +#include +#include +#include "libavutil/thread.h" + +/** + * This struct should be treated as opaque by users. + */ +typedef struct ThreadProgress { + atomic_int progress; + unsigned init; + AVMutex progress_mutex; + AVCond progress_cond; +} ThreadProgress; + +/** + * Initialize a ThreadProgress. + * + * @param init_mode If zero, the ThreadProgress will be initialized so that + * to be in no-op mode as described above. Otherwise + */ +int ff_thread_progress_init(ThreadProgress *pro, int init_mode); + +/** + * Destroy a ThreadProgress. Can be called on a ThreadProgress that + * has never been initialized provided that the ThreadProgress struct + * has been initially zeroed. Must be called even if ff_thread_progress_init() + * failed. + */ +void ff_thread_progress_destroy(ThreadProgress *pro); + +/** + * Reset the ThreadProgress's progress progress counter; must only be called + * if it is not in use in any way (e.g. no thread may wait on it via + * ff_thread_progress_await()). + */ +static inline void ff_thread_progress_reset(ThreadProgress *pro) +{ + atomic_init(&pro->progress, pro->init ? -1 : INT_MAX); +} + +/** + * This function is a no-op in no-op mode; otherwise it notifies + * other threads that a certain level of progress has been reached. + * Later calls with lower values of progress have no effect. + */ +void ff_thread_progress_report(ThreadProgress *pro, int progress); + +/** + * This function is a no-op in no-op mode; otherwise it waits + * until other threads have reached a certain level of progress: + * This function will return after another thread has called + * ff_thread_progress_report() with the same or higher value for progress. + */ +void ff_thread_progress_await(const ThreadProgress *pro, int progress); + +#endif /* AVCODEC_THREADPROGRESS_H */ From patchwork Mon Apr 8 20:13:40 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47938 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp135338pzb; Mon, 8 Apr 2024 13:14:27 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCWcA6n64ZHm/NkjM5W5kGI/+7i3XBkIsecEHlL6nIp6yBeXvsUN2wf04Ad+Ui4IUCb/lnppB9M9ZodLRN+q4uR5QpXB8Fwt6cawtg== X-Google-Smtp-Source: AGHT+IHN1pi4ha67yhby6QrQQ9DzebYzGP1W5yoZxV89hRClYr8Kx/uUszxQHk3xTsS2x2uhRFDA X-Received: by 2002:a17:906:3c9:b0:a51:7a49:4a3a with SMTP id c9-20020a17090603c900b00a517a494a3amr6719434eja.54.1712607267026; Mon, 08 Apr 2024 13:14:27 -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 uz29-20020a170907119d00b00a4652723d04si3928207ejb.390.2024.04.08.13.14.26; Mon, 08 Apr 2024 13:14:27 -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=@outlook.com header.s=selector1 header.b=pOXSjzGe; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id C420D68D306; Mon, 8 Apr 2024 23:14:22 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2067.outbound.protection.outlook.com [40.92.66.67]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 2030E68D1CC for ; Mon, 8 Apr 2024 23:14:16 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=eRzwrmA309AwGUAY7ctUsljYdu1Aa3Sn2GnTcRjPHFFTnkHPBf6hi+BFSjYa6t476jqamZhbRfQnkB2jGo9GbJQJFRkXjqqnNOTS8pcS2Wrs1XiPxHMGTAq2YUmAQqpK+xTfk5yTAMPS5BOQh457EQdapt5DKMjDhXdStCUFcsymhj3z08O3WgNwXmyVHk1+ZmGPNf1d5/AXVFY1FrV/ogqbQ7ZaD9TvxOym6IMK3oCgBTTDpVDUFvJBjCZU0ZZrh0vP3aZnh2UZzD/X9idIkSaXo3+zVfAqoVPKDpgH0D6JYZ4ipxr8mEbHyODa5W2hvBrzovVQlcoUpPWoA8QTIw== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=gHZm5YRrOdFN2+NIaUI1yKGoL8YxwvGHOPOZyxx1cZM=; b=VLYnyK86pyFPZGeM1Tt18zbBT7/AN9aOYlSqLfBoIhjDbegudnA7HIUOtkoNiavB7xj+8Zyu2MDL39VYmT1uysjOdyWz3xIWJROoa6jX1Aa9EpCfJXivGGK3K9eS/Pijsrn/Bx08upwDEjMdkkCp7QJYgLPFlmGkAVT2DaeY8E8xTZ8yHaGOjSUnbDH/HNCccDQ0Zg5Ark6kdz3wQKEtln5LSuIV5YaU4GUHqdPCRv2lLDvwahB0cniGfwCpbPGg0noRLD+sS0WIHS6QUgHSLgjlZxoXbqjqtFieRsNL/OUGrEV+KRnka/NzeKb58KRR6zWeDF82adBqkuKGdTVTGg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=gHZm5YRrOdFN2+NIaUI1yKGoL8YxwvGHOPOZyxx1cZM=; b=pOXSjzGejeZ/QvJ7nuqz42Mgw2L5sO1Nv24WgeBvtfAibrWldOVYxO3ZpNr/m/EPHJI4X4DRfVpG7HmjQhSO2knJkLc2JF7PueHUeex2EXMRQxXXRqHWjzrtu87fIt5DDasL1algOEQ5UX290HitsnBrAXsYpXDDlLWvyhoWwv7O3e2N2YvgNvEdjtxWMVmh0FKHzv+xNSXMS+AuzwlKAQSCvyGdBo/0pFC6dowDBQe2GQIK3JS5YpR7VLVnuGYo4DjEFsPbGXQ1PHVmHjIsAyPRtfO2hPAOappmnfiPJV3qQDAURwOLIbTb7tMwfZRgGCfn1/Kvc+FwUcs1EAx/Zg== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:14:13 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:14:13 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:40 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [kOUasJ/+w0jHFLuJbAUfmN1fjysXkShSDC1v8mnQzEQ=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-1-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 2139bff0-1c07-408c-1fab-08dc58087518 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 5d3CyBtEdCHm8UDIyxTB3u+nE/UzDXwL8u3amlaqmzDh1g6UW2x9dSMlIB2/qXaeR9u55OqADFrcJbqJOuXlXnODDx19ubFRhgRYUseEzdIDUe1QRxf5ATlFCZ3I+81xO5KGxJH91HXDmaRzojklPklOcCUJ7QTvizgK0FHjCywHEDuQrELXDZ8YD39hFe1HQAzJqb+zLYLiLp+zDiPgRd2CQXpeHOdQdRHWnozA+A2Zk+2BnF3VLDdl2KUJ3X7Mc40qwgmgHpBFN18ygxIiG54sbnBMjlfCIMX53jZAh0B87zn/ID+DPtghxRrUUuv7dS00vwLcpVBGFdlHKLdS1oP/Ffv4cp2KRbMcFloPTTM7OdpevtvK2yVFfinYPd9Qmyw7zk7qPlKaaeJPVCY8Gfv6EG0n1pyBPGg3LLrFnXZTBT0JJmjGGHxUrUSidi2dRi6bgODlD6Y1Q5PBhT4X3nLLrIc1OR8vXT5cAReZVn8yL/vZ3NXCGY/fXqP3MHvTz98d+RMvn20FATdgW/TQmA6oeYnStngBqMBq6oeMSOnb2tFOWA1YVOE6qe0949+ImSDy5ixIZjEDPoL2WIxyK0PkcHzf26I4jdk5r/qGE/bd9JrK9WmgyggnzWjcmjfI X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: zcMLKZDb1cqk+9MAZr/1Thoq3XPHnuj3eEDzVNdt1r29qan6sIj7em3jvKV2Ej4ChAudWILdseklSnWcB6JGl4+LigQdxjG+8gh263WLFft6BQDQNztDiDzFVq9mLK0eaGTA2BEkoDSdm/IVLtGuzAB6i3WiBXQfNA7y9kNbPJ2DKpd2UCX0T6ydPI6QbPtj7C+o7/d552kvUrUnYK6JtBKL/fhnHf95GELQ+5wHV9zaXmRmkUcjDDdnEZCxG7FGWc8+KKzwhtic5gGoquPMjlX4LmKPKs8F+V9Nri6CGzDsE9H8aiUwQ/v6iR3QHf6lcBJ2ncFD44FUIu3SVa/yTv2ZEjUgo7Z6epDUdyeoJbUmaaCCH45l6W6zjYEyezP2L8qulGA79fGm9M7mDG8H9J4p10roovCoNVTupdNUgNMWi5k+jd7tKkOYW+wNLfOUUWV4XR6O5rQRBbb/QeaqAXM6iH46W0AI4YHdS2UY2iKmte0Uf7a2MaFUi05FD0nQ6EV8aYaVACU7mQHnOYy3ZUGO3GAoARmkoY50aGDuc57JxUc4Oks5N+cfY3KbDZl5TcCCnw30rFPfJlDzSQ2unPFOfSvWmVN3vmtRezLby7QyCubg4SwnaN4GMreoyKpmxDhhWYnwY3b4X262aZobMzPgqqk7M/pCzkhfW+ERMFr6MCdX7O1E6QFjnqcKYHINXih5mF+jtR+qoxbZzmW+fulce+j4pzq/MJgwkGfsHCUdqYS1HO7dJfX9mjNxG4GFTshi9R36E+rktag1JqENJsW9MPuqvtR8fB0drlh1fieInsJBLToygrcCkPoMFMUBOsjSi0u9ietnewp2KeR7FAh9Eqoy+Por4gtx1ey9gZzyEHXLNQhcPnk5B79c6QgizQ00nx9K3WLAAPzCJOIltMmjVN2LpnO/11NQHn0pzU90e7cgX7IpKIGByf9n/UpQnMHKTfEuaR8WArDrqYh7aZx0wG8R9R+xWbAwxj80Rt5dj3+/1nHxN8cXEHjo8khr4prCQHPy9KLNifAKXOKRUUqx8uvkJk6FYP+9AIHxrunXeu+TteTPioj8/KVO4H8rQZhIFADvxb5LB447k2qld+mrsfslTtWrXbCsr85/+dDT/U9+XdOvpFvNA0L4+YIZ8oJvRctzbSA/wiaRuivKglnLYDAQv3ELF/CinxY2yfijETow0PsAnrMaub6ziTovhrSeSrcD8Cz8mxSR9q8D5oQ39/s2pycF/ELxebWD4nAa2Mc/6QGVS1CauHNlTeypAr73T/1WQSVHe07wm+zyBQ== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 2139bff0-1c07-408c-1fab-08dc58087518 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:14:12.9440 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 02/27] avcodec/decode: Add new ProgressFrame API 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: jXYHUMitexkZ Frame-threaded decoders with inter-frame dependencies use the ThreadFrame API for syncing. It works as follows: During init each thread allocates an AVFrame for every ThreadFrame. Thread A reads the header of its packet and allocates a buffer for an AVFrame with ff_thread_get_ext_buffer() (which also allocates a small structure that is shared with other references to this frame) and sets its fields, including side data. Then said thread calls ff_thread_finish_setup(). From that moment onward it is not allowed to change any of the AVFrame fields at all any more, but it may change fields which are an indirection away, like the content of AVFrame.data or already existing side data. After thread A has called ff_thread_finish_setup(), another thread (the user one) calls the codec's update_thread_context callback which in turn calls ff_thread_ref_frame() which calls av_frame_ref() which reads every field of A's AVFrame; hence the above restriction on modifications of the AVFrame (as any modification of the AVFrame by A after ff_thread_finish_setup() would be a data race). Of course, this av_frame_ref() also incurs allocations and therefore needs to be checked. ff_thread_ref_frame() also references the small structure used for communicating progress. This av_frame_ref() makes it awkward to propagate values that only become known during decoding to later threads (in case of frame reordering or other mechanisms of delayed output (like show-existing-frames) it's not the decoding thread, but a later thread that returns the AVFrame). E.g. for VP9 when exporting video encoding parameters as side data the number of blocks only becomes known during decoding, so one can't allocate the side data before ff_thread_finish_setup(). It is currently being done afterwards and this leads to a data race in the vp9-encparams test when using frame-threading. Returning decode_error_flags is also complicated by this. To perform this exchange a buffer shared between the references is needed (notice that simply giving the later threads a pointer to the original AVFrame does not work, because said AVFrame will be reused lateron when thread A decodes the next packet given to it). One could extend the buffer already used for progress for this or use a new one (requiring yet another allocation), yet both of these approaches have the drawback of being unnatural, ugly and requiring quite a lot of ad-hoc code. E.g. in case of the VP9 side data mentioned above one could not simply use the helper that allocates and adds the side data to an AVFrame in one go. The ProgressFrame API meanwhile offers a different solution to all of this. It is based around the idea that the most natural shared object for sharing information about an AVFrame between decoding threads is the AVFrame itself. To actually implement this the AVFrame needs to be reference counted. This is achieved by putting a (ownership) pointer into a shared (and opaque) structure that is managed by the RefStruct API and which also contains the stuff necessary for progress reporting. The users get a pointer to this AVFrame with the understanding that the owner may set all the fields until it has indicated that it has finished decoding this AVFrame; then the users are allowed to read everything. Every decoder may of course employ a different contract than the one outlined above. Given that there is no underlying av_frame_ref(), creating references to a ProgressFrame can't fail. Only ff_thread_progress_get_buffer() can fail, but given that it will replace calls to ff_thread_get_ext_buffer() it is at places where errors are already expected and properly taken care of. The ProgressFrames are empty (i.e. the AVFrame pointer is NULL and the AVFrames are not allocated during init at all) while not being in use; ff_thread_progress_get_buffer() both sets up the actual ProgressFrame and already calls ff_thread_get_buffer(). So instead of checking for ThreadFrame.f->data[0] or ThreadFrame.f->buf[0] being NULL for "this reference frame is non-existing" one should check for ProgressFrame.f. This also implies that one can only set AVFrame properties after having allocated the buffer. This restriction is not deep: if it becomes onerous for any codec, ff_thread_progress_get_buffer() can be broken up. The user would then have to get a buffer himself. In order to avoid unnecessary allocations, the shared structure is pooled, so that both the structure as well as the AVFrame itself are reused. This means that there won't be lots of unnecessary allocations in case of non-frame-threaded decoding. It might even turn out to have fewer than the current code (the current code allocates AVFrames for every DPB slot, but these are often excessively large and not completely used; the new code allocates them on demand). Pooling relies on the reset function of the RefStruct pool API, it would be impossible to implement with the AVBufferPool API. Finally, ProgressFrames have no notion of owner; they are built on top of the ThreadProgress API which also lacks such a concept. Instead every ThreadProgress and every ProgressFrame contains its own mutex and condition variable, making it completely independent of pthread_frame.c. Just like the ThreadFrame API it is simply presumed that only the actual owner/producer of a frame reports progress on said frame. Signed-off-by: Andreas Rheinhardt --- libavcodec/Makefile | 1 + libavcodec/avcodec.c | 1 + libavcodec/codec_internal.h | 4 ++ libavcodec/decode.c | 122 +++++++++++++++++++++++++++++++++ libavcodec/internal.h | 2 + libavcodec/progressframe.h | 133 ++++++++++++++++++++++++++++++++++++ libavcodec/pthread_frame.c | 1 + libavcodec/tests/avcodec.c | 3 +- 8 files changed, 266 insertions(+), 1 deletion(-) create mode 100644 libavcodec/progressframe.h diff --git a/libavcodec/Makefile b/libavcodec/Makefile index 7f6de4470e..472568bd6c 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -56,6 +56,7 @@ OBJS = ac3_parser.o \ qsv_api.o \ raw.o \ refstruct.o \ + threadprogress.o \ utils.o \ version.o \ vlc.o \ diff --git a/libavcodec/avcodec.c b/libavcodec/avcodec.c index 525fe516bd..888dd76228 100644 --- a/libavcodec/avcodec.c +++ b/libavcodec/avcodec.c @@ -441,6 +441,7 @@ av_cold void ff_codec_close(AVCodecContext *avctx) av_frame_free(&avci->recon_frame); ff_refstruct_unref(&avci->pool); + ff_refstruct_pool_uninit(&avci->progress_frame_pool); ff_hwaccel_uninit(avctx); diff --git a/libavcodec/codec_internal.h b/libavcodec/codec_internal.h index d6757e2def..832e6440d7 100644 --- a/libavcodec/codec_internal.h +++ b/libavcodec/codec_internal.h @@ -62,6 +62,10 @@ * Codec initializes slice-based threading with a main function */ #define FF_CODEC_CAP_SLICE_THREAD_HAS_MF (1 << 5) +/** + * The decoder might make use of the ProgressFrame API. + */ +#define FF_CODEC_CAP_USES_PROGRESSFRAMES (1 << 11) /* * The codec supports frame threading and has inter-frame dependencies, so it * uses ff_thread_report/await_progress(). diff --git a/libavcodec/decode.c b/libavcodec/decode.c index 255347766a..f18f85c33c 100644 --- a/libavcodec/decode.c +++ b/libavcodec/decode.c @@ -49,8 +49,10 @@ #include "hwconfig.h" #include "internal.h" #include "packet_internal.h" +#include "progressframe.h" #include "refstruct.h" #include "thread.h" +#include "threadprogress.h" typedef struct DecodeContext { AVCodecInternal avci; @@ -1668,6 +1670,116 @@ int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags) return ret; } +typedef struct ProgressInternal { + ThreadProgress progress; + struct AVFrame *f; +} ProgressInternal; + +static void check_progress_consistency(const ProgressFrame *f) +{ + av_assert1(!!f->f == !!f->progress); + av_assert1(!f->progress || f->progress->f == f->f); +} + +static int progress_frame_get(AVCodecContext *avctx, ProgressFrame *f) +{ + FFRefStructPool *pool = avctx->internal->progress_frame_pool; + + av_assert1(!f->f && !f->progress); + + f->progress = ff_refstruct_pool_get(pool); + if (!f->progress) + return AVERROR(ENOMEM); + + f->f = f->progress->f; + return 0; +} + +int ff_progress_frame_get_buffer(AVCodecContext *avctx, ProgressFrame *f, int flags) +{ + int ret; + + ret = progress_frame_get(avctx, f); + if (ret < 0) + return ret; + + ret = ff_thread_get_buffer(avctx, f->progress->f, flags); + if (ret < 0) { + f->f = NULL; + ff_refstruct_unref(&f->progress); + return ret; + } + return 0; +} + +void ff_progress_frame_ref(ProgressFrame *dst, const ProgressFrame *src) +{ + av_assert1(src->progress && src->f && src->f == src->progress->f); + av_assert1(!dst->f && !dst->progress); + dst->f = src->f; + dst->progress = ff_refstruct_ref(src->progress); +} + +void ff_progress_frame_unref(ProgressFrame *f) +{ + check_progress_consistency(f); + f->f = NULL; + ff_refstruct_unref(&f->progress); +} + +void ff_progress_frame_replace(ProgressFrame *dst, const ProgressFrame *src) +{ + if (dst == src) + return; + ff_progress_frame_unref(dst); + check_progress_consistency(src); + if (src->f) + ff_progress_frame_ref(dst, src); +} + +void ff_progress_frame_report(ProgressFrame *f, int n) +{ + ff_thread_progress_report(&f->progress->progress, n); +} + +void ff_progress_frame_await(const ProgressFrame *f, int n) +{ + ff_thread_progress_await(&f->progress->progress, n); +} + +static av_cold int progress_frame_pool_init_cb(FFRefStructOpaque opaque, void *obj) +{ + const AVCodecContext *avctx = opaque.nc; + ProgressInternal *progress = obj; + int ret; + + ret = ff_thread_progress_init(&progress->progress, avctx->active_thread_type & FF_THREAD_FRAME); + if (ret < 0) + return ret; + + progress->f = av_frame_alloc(); + if (!progress->f) + return AVERROR(ENOMEM); + + return 0; +} + +static void progress_frame_pool_reset_cb(FFRefStructOpaque unused, void *obj) +{ + ProgressInternal *progress = obj; + + ff_thread_progress_reset(&progress->progress); + av_frame_unref(progress->f); +} + +static av_cold void progress_frame_pool_free_entry_cb(FFRefStructOpaque opaque, void *obj) +{ + ProgressInternal *progress = obj; + + ff_thread_progress_destroy(&progress->progress); + av_frame_free(&progress->f); +} + int ff_decode_preinit(AVCodecContext *avctx) { AVCodecInternal *avci = avctx->internal; @@ -1766,6 +1878,16 @@ int ff_decode_preinit(AVCodecContext *avctx) if (!avci->in_pkt || !avci->last_pkt_props) return AVERROR(ENOMEM); + if (ffcodec(avctx->codec)->caps_internal & FF_CODEC_CAP_USES_PROGRESSFRAMES) { + avci->progress_frame_pool = + ff_refstruct_pool_alloc_ext(sizeof(ProgressInternal), + FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR, + avctx, progress_frame_pool_init_cb, + progress_frame_pool_reset_cb, + progress_frame_pool_free_entry_cb, NULL); + if (!avci->progress_frame_pool) + return AVERROR(ENOMEM); + } ret = decode_bsfs_init(avctx); if (ret < 0) return ret; diff --git a/libavcodec/internal.h b/libavcodec/internal.h index 64fe0122c8..bc20a797ae 100644 --- a/libavcodec/internal.h +++ b/libavcodec/internal.h @@ -61,6 +61,8 @@ typedef struct AVCodecInternal { struct FramePool *pool; + struct FFRefStructPool *progress_frame_pool; + void *thread_ctx; /** diff --git a/libavcodec/progressframe.h b/libavcodec/progressframe.h new file mode 100644 index 0000000000..dc841f30d2 --- /dev/null +++ b/libavcodec/progressframe.h @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2022 Andreas Rheinhardt + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVCODEC_PROGRESSFRAME_H +#define AVCODEC_PROGRESSFRAME_H + +/** + * ProgressFrame is an API to easily share frames without an underlying + * av_frame_ref(). Its main usecase is in frame-threading scenarios, + * yet it could also be used for purely single-threaded decoders that + * want to keep multiple references to the same frame. + * + * The underlying principle behind the API is that all that is needed + * to share a frame is a reference count and a contract between all parties. + * The ProgressFrame provides the reference count and the frame is unreferenced + * via ff_thread_release_buffer() when the reference count reaches zero. + * + * In order to make this API also usable for frame-threaded decoders it also + * provides a way of exchanging simple information about the state of + * decoding the frame via ff_thread_progress_report() and + * ff_thread_progress_await(). + * + * The typical contract for frame-threaded decoders is as follows: + * Thread A initializes a ProgressFrame via ff_thread_progress_get_buffer() + * (which already allocates the AVFrame's data buffers), calls + * ff_thread_finish_setup() and starts decoding the frame. Later threads + * receive a reference to this frame, which means they get a pointer + * to the AVFrame and the internal reference count gets incremented. + * Later threads whose frames use A's frame as reference as well as + * the thread that will eventually output A's frame will wait for + * progress on said frame reported by A. As soon as A has reported + * that it has finished decoding its frame, it must no longer modify it + * (neither its data nor its properties). + * + * Because creating a reference with this API does not involve reads + * from the actual AVFrame, the decoding thread may modify the properties + * (i.e. non-data fields) until it has indicated to be done with this + * frame. This is important for e.g. propagating decode_error_flags; + * it also allows to add side-data late. + */ + +struct AVCodecContext; + +typedef struct ProgressFrame { + struct AVFrame *f; + struct ProgressInternal *progress; +} ProgressFrame; + +/** + * Notify later decoding threads when part of their reference frame is ready. + * Call this when some part of the frame is finished decoding. + * Later calls with lower values of progress have no effect. + * + * @param f The frame being decoded. + * @param progress Value, in arbitrary units, of how much of the frame has decoded. + * + * @warning Calling this on a blank ProgressFrame causes undefined behaviour + */ +void ff_progress_frame_report(ProgressFrame *f, int progress); + +/** + * Wait for earlier decoding threads to finish reference frames. + * Call this before accessing some part of a frame, with a given + * value for progress, and it will return after the responsible decoding + * thread calls ff_thread_progress_report() with the same or + * higher value for progress. + * + * @param f The frame being referenced. + * @param progress Value, in arbitrary units, to wait for. + * + * @warning Calling this on a blank ProgressFrame causes undefined behaviour + */ +void ff_progress_frame_await(const ProgressFrame *f, int progress); + +/** + * This function sets up the ProgressFrame, i.e. gets ProgressFrame.f + * and also calls ff_thread_get_buffer() on the frame. + * + * @note: This must only be called by codecs with the + * FF_CODEC_CAP_USES_PROGRESSFRAMES internal cap. + */ +int ff_progress_frame_get_buffer(struct AVCodecContext *avctx, + ProgressFrame *f, int flags); + +/** + * Give up a reference to the underlying frame contained in a ProgressFrame + * and reset the ProgressFrame, setting all pointers to NULL. + * + * @note: This implies that when using this API the check for whether + * a frame exists is by checking ProgressFrame.f and not + * ProgressFrame.f->data[0] or ProgressFrame.f->buf[0]. + */ +void ff_progress_frame_unref(ProgressFrame *f); + +/** + * Set dst->f to src->f and make dst a co-owner of src->f. + * dst can then be used to wait on progress of the underlying frame. + * + * @note: There is no underlying av_frame_ref() here. dst->f and src->f + * really point to the same AVFrame. Typically this means that + * the decoding thread is allowed to set all the properties of + * the AVFrame until it has indicated to have finished decoding. + * Afterwards later threads may read all of these fields. + * Access to the frame's data is governed by + * ff_thread_progress_report/await(). + */ +void ff_progress_frame_ref(ProgressFrame *dst, const ProgressFrame *src); + +/** + * Do nothing if dst and src already refer to the same AVFrame; + * otherwise unreference dst and if src is not blank, put a reference + * to src's AVFrame in its place (in case src is not blank). + */ +void ff_progress_frame_replace(ProgressFrame *dst, const ProgressFrame *src); + +#endif /* AVCODEC_PROGRESSFRAME_H */ diff --git a/libavcodec/pthread_frame.c b/libavcodec/pthread_frame.c index fd356bd190..6b2c4312e0 100644 --- a/libavcodec/pthread_frame.c +++ b/libavcodec/pthread_frame.c @@ -779,6 +779,7 @@ static av_cold int init_thread(PerThreadContext *p, int *threads_to_free, if (!copy->internal) return AVERROR(ENOMEM); copy->internal->thread_ctx = p; + copy->internal->progress_frame_pool = avctx->internal->progress_frame_pool; copy->delay = avctx->delay; diff --git a/libavcodec/tests/avcodec.c b/libavcodec/tests/avcodec.c index 08ca507bf0..58f54cac74 100644 --- a/libavcodec/tests/avcodec.c +++ b/libavcodec/tests/avcodec.c @@ -141,7 +141,8 @@ int main(void){ ret = 1; } } - if (codec2->caps_internal & (FF_CODEC_CAP_ALLOCATE_PROGRESS | + if (codec2->caps_internal & (FF_CODEC_CAP_USES_PROGRESSFRAMES | + FF_CODEC_CAP_ALLOCATE_PROGRESS | FF_CODEC_CAP_SETS_PKT_DTS | FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | FF_CODEC_CAP_EXPORTS_CROPPING | From patchwork Mon Apr 8 20:13:41 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47940 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp135398pzb; Mon, 8 Apr 2024 13:14:37 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCUB1/Pua2fUgA4h9DG1xsfAs/cpV88QvUtE9mUA4e3ll5M2aEbujJSChlgEkf9bLEcfFDkTA43CFWHbjxDKjBBw2HlGzW4PESBifA== X-Google-Smtp-Source: AGHT+IEr6BJuhbs+cFOqX5524VPIsjxn8cs0Mn/F3KhssDOcp96D59RYjXSOlLASPWfN02K/hi/o X-Received: by 2002:a05:6512:3c96:b0:513:cc4f:52b8 with SMTP id h22-20020a0565123c9600b00513cc4f52b8mr9786096lfv.12.1712607276916; Mon, 08 Apr 2024 13:14:36 -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 h19-20020a1709063b5300b00a4e7c30929fsi3936533ejf.326.2024.04.08.13.14.36; Mon, 08 Apr 2024 13:14:36 -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=@outlook.com header.s=selector1 header.b=b+pPnNNA; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id E914668D2E7; Mon, 8 Apr 2024 23:14:27 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2067.outbound.protection.outlook.com [40.92.66.67]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 3E39668D2E7 for ; Mon, 8 Apr 2024 23:14:21 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=Wa42q2wS5YALXARkrH6XPHQtMqcy1AL2zfhnpl0rx+9o+E7j8k+wP2yJTPMRrUMzvC3t6TrIFjFSB0UZfkUnRkPwpaytJQDQ493Mt6tdYolg8kcIRma9B3Lrw5r47pvpKhrmBm3UHo0x72qmeUE/tNDaKshj5tYtu9T3Pxjy6dboPn06aJqFDjhczey1qmh5CLzSD40PlGr0PMDryLuuauZAZJxuLMaF1NX9q0SQ6Vpu7KONM2lI5XnvGuwwEmXPRo6neDT50spteM3QCNQoC7wHFkxLdOVx3axvqUNP9JpOs2VivhS7ZVXM9oym7QvKQgXlPG7f+mDs0YTb68ydEQ== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=S0mh8wUiI270YF2yJquq0k2wPIqRx7E6wiFa6AeOVig=; b=Qc4RPCdDBnmgiPT3GjOSqZ5HmuPu6DZIbpkhqICMqxGQ13h/Vgr4QpVhXMDU+/gDvEPS1aa/baAWpIfFJUac6e2BxPICaGa5ae8W5O7oNTSlwqcVNMhwKAN/XtE6pD3/54x7cjHQeaeOeR6Yy7aGTBwTzalIZ36kfkjgMLmnloDW+XxqgEEbeyBLqYh3aw3+D6PbtqypxQcXU5IWQjAkuihU0sELMO+gAmvQDJ/M559k2rpyykqlgEzt10r/vkf37bkRNW2fhmUZHSqm4cI085ZTXj4ca1YAiW4ajXP87yl6gI7SQ0qgez9Bj2OfVlgkWTcQWC7ErYE7fafgHbSXfQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=S0mh8wUiI270YF2yJquq0k2wPIqRx7E6wiFa6AeOVig=; b=b+pPnNNAd8m+FkWCyjPUikZ4z3EUSh+SG86ieEkP/Q6qlwd5mPznUbislny79QekhhnhYnuoLkHgwqYUGOI1KRBAhcraLfrsl5wpN71YdXK4/JP+a3dBVdBUykEpwDmr0eJv/PfclU6Y4HJs/NU7YqvXXcjJ/oZqABSrAgvA9Y6bhQZK+lmtC9l4x4aTVw28JRZbQZBqVaeELaBcd72utx6TPGwOcSSnvsrnT8PUkFQT5ttx56ppcIOEoo9RIXayD4UYWyblMO59ct/KznxCV3JjmoEJKYBzNBaWkvYbUmfwNHIv4kV5cGbXB/E3IAB4f7xsYEQXcD1yVote9rQ+0g== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:14:16 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:14:16 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:41 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [kQRtIMEAMtHgGr5AqV3snFUIxuRZSa4edpQgizsJafg=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-2-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 03988b75-459c-4fea-1839-08dc580876ed X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: q2Dp23noX5W8D/H9FBTVgC7QZZBugDi/YEyvtn7lZIo4up16qPVIzcO8UAUOmJhhUNLWs8zmJeNMRBmrN1viiIZYP8DW4pnsvdUhqXSaU+gv/vVc792TI8kr5VzuKugsoTTA1/NuWFbckeNY40crMNmomhJD+5Vzn/9bVsB3kCoPLRVzxr5YI1O6QTf4xQVB4P14H61nncIgXntbj06tLiuE/+MMBE7mwCCdSsTq6pY95IAVfQ4FX4uQaNeZuU/BXGzL4Qnew5Lbn+utBpOUBMQYqu1T0PRspC21HuVVhKGyN56wfkFXf3jc8nFgqvIUblXNQgmhYrlM0ubWVuZt++iy8DwYlqcR167ITAoCyqwe4e3Onfca8hGJRWdSAx6YMGWg4qVt5VHjRY4dzP26lLtPGWAKnI6fGN/iBruZSIs6gFQpYlROiBmowjF9W6QgN0agNOmeGhmQ5mVu5m3fc9iU45bvCtGsMdyWnP9YDm1EEHfkHUMoKlAGxFxOLJDJh16ndPHrQMtFJUzf0m+afBf9F1Xa9RpLeN8OSkd4U9DGLPwaDu8SEr66560GmMMStC9Iw8IHfZcG0VSjvthjHVeLaOFrdTfASpzDRVq/O89AMo55So48L0MBXOxllPKR X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: wiFcczg97+/g8h9BShzjPITc6nwQZH3tRQPGB5WOOEOXK6Oez3l29fy5CR8976fzucEmE1LUEV791+lNeC1mwTsXK6d7CUx92nQZQAnFPFyjFitlgIDzhssIVYMbcsHRyPE5csLPw+CBUKAqZAxl+rUZjdprXXOyBAV53Dbpmup6uEazVmEPzvTDMjLbu9UKwlfX+86XVmfZUs7tPYW/vJew2bLv7uqK7IgCLfSAg+/AkCuNnjtYZAvgoK3s76syo4g83VLNsU7EpHLVrVo/Upiox1hyemNEVc6vn8aDIoezvTGaI2kW/Z6cFdTC5v1hppsAT8/44hKp/z1LoY+3T6SDWu0pQZV0RONqDMgtZOArksVMFtyip+8S8w8s2cCRTOKJXy7lLFTKUeO0mZergfkv8GmJ2rbIcFUSLYaxg+I/yNKxzu2zvKmjK8kXQYKq4zMhBnoL3tBUCCm8aWDfu6uWThHwlVPRHx4J7VoUks9sZWZPNm0ZcKOrJCK82RkqgA7lIt34PZfylvHOa5jmpZrT+38HPsMOU97Qdqa/3kyHaW3DNu8nJIQuZlGUulJJf9V8uM1M4JOzRPl37ntsosJueiUpozNjf+Uo+717Ee0+B8fdhPi9uhsHWntAopWqpAevgcPT0ATmlvpHE60qvpYGi45bPlUxMsg2s5JX9sfKfpGZjzp8nxIyVoGwOP3JFvSMlLcDhLyJVMVr+NlmO2SJEAxsOJWBRSC7cM1D1smRN1kiRaJ9oSpzjGEJZFZgsqw9FaJfYChmAL3cf27/EitCfrashzjFl4atpCxP442B9wD1Ae1r4MDkagCGMX3O9NNzWPOM51ZGrOQP+8B6OmMMRPHfIz0HxjxH9vrV6rBnZkwTRD6MiCiGEesv7lmvUwXsnaeRzBc8scW9Mm4D8iwaqyl5gug0sf8Uxjvlsm6HDiHFkmYrKU9E50c0CK+qa/TUuUwRpqfgwGDbLzqP6CTN/rrtHW5QCMx3lWX+kM/5QHteR6+0yP8BainVOAwIT+s5F58OstL1c2y9sk1UaIfokvXNEsNEYQ0ERdOZwB+heOqyWtC9or6EP6PWtfyY/hy+6Fx6hNhxQMo/I11DR32g1Q8OA3JU68tbC6b19/fYKOn4OkRgI+R2qN+sl3OOhmbB1dFgY1qRFKZtWJirBC5ie1qxGK+T9drHIT9BkY8x+kFjH/KNn3kNv5FWHNoSVIHBOFvH8EZTwyFLyyHovko+5J8bc2KGc4LKoD7PcgHie4uybQAja5XZIQIKNI2xy0EeMht8nOtukFJrswaSNw== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 03988b75-459c-4fea-1839-08dc580876ed X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:14:15.9642 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 03/27] avcodec/mimic: Switch to ProgressFrames 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 Cc: Anton Khirnov , Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: 6K64unQvNHs2 Avoids implicit av_frame_ref() and therefore allocations and error checks. Reviewed-by: Anton Khirnov Signed-off-by: Andreas Rheinhardt --- libavcodec/mimic.c | 61 +++++++++++++++++----------------------------- 1 file changed, 22 insertions(+), 39 deletions(-) diff --git a/libavcodec/mimic.c b/libavcodec/mimic.c index 8928f24022..2925aa50f7 100644 --- a/libavcodec/mimic.c +++ b/libavcodec/mimic.c @@ -34,8 +34,8 @@ #include "bswapdsp.h" #include "hpeldsp.h" #include "idctdsp.h" +#include "progressframe.h" #include "thread.h" -#include "threadframe.h" #define MIMIC_HEADER_SIZE 20 #define MIMIC_VLC_BITS 11 @@ -52,7 +52,7 @@ typedef struct MimicContext { int cur_index; int prev_index; - ThreadFrame frames [16]; + ProgressFrame frames[16]; DECLARE_ALIGNED(32, int16_t, dct_block)[64]; @@ -105,16 +105,12 @@ static const uint8_t col_zag[64] = { static av_cold int mimic_decode_end(AVCodecContext *avctx) { MimicContext *ctx = avctx->priv_data; - int i; av_freep(&ctx->swap_buf); ctx->swap_buf_size = 0; - for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) { - if (ctx->frames[i].f) - ff_thread_release_ext_buffer(&ctx->frames[i]); - av_frame_free(&ctx->frames[i].f); - } + for (int i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) + ff_progress_frame_unref(&ctx->frames[i]); return 0; } @@ -130,7 +126,6 @@ static av_cold int mimic_decode_init(AVCodecContext *avctx) { static AVOnce init_static_once = AV_ONCE_INIT; MimicContext *ctx = avctx->priv_data; - int i; ctx->prev_index = 0; ctx->cur_index = 15; @@ -141,12 +136,6 @@ static av_cold int mimic_decode_init(AVCodecContext *avctx) ff_idctdsp_init(&ctx->idsp, avctx); ff_permute_scantable(ctx->permutated_scantable, col_zag, ctx->idsp.idct_permutation); - for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) { - ctx->frames[i].f = av_frame_alloc(); - if (!ctx->frames[i].f) - return AVERROR(ENOMEM); - } - ff_thread_once(&init_static_once, mimic_init_static); return 0; @@ -156,7 +145,6 @@ static av_cold int mimic_decode_init(AVCodecContext *avctx) static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from) { MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data; - int i, ret; if (avctx == avctx_from) return 0; @@ -164,13 +152,10 @@ static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCod dst->cur_index = src->next_cur_index; dst->prev_index = src->next_prev_index; - for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) { - ff_thread_release_ext_buffer(&dst->frames[i]); - if (i != src->next_cur_index && src->frames[i].f->data[0]) { - ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]); - if (ret < 0) - return ret; - } + for (int i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) { + ff_progress_frame_unref(&dst->frames[i]); + if (i != src->next_cur_index && src->frames[i].f) + ff_progress_frame_ref(&dst->frames[i], &src->frames[i]); } return 0; @@ -293,11 +278,10 @@ static int decode(MimicContext *ctx, int quality, int num_coeffs, } else { unsigned int backref = get_bits(&ctx->gb, 4); int index = (ctx->cur_index + backref) & 15; - uint8_t *p = ctx->frames[index].f->data[0]; - if (index != ctx->cur_index && p) { - ff_thread_await_progress(&ctx->frames[index], - cur_row, 0); + if (index != ctx->cur_index && ctx->frames[index].f) { + const uint8_t *p = ctx->frames[index].f->data[0]; + ff_progress_frame_await(&ctx->frames[index], cur_row); p += src - ctx->frames[ctx->prev_index].f->data[plane]; ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8); @@ -307,8 +291,7 @@ static int decode(MimicContext *ctx, int quality, int num_coeffs, } } } else { - ff_thread_await_progress(&ctx->frames[ctx->prev_index], - cur_row, 0); + ff_progress_frame_await(&ctx->frames[ctx->prev_index], cur_row); ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8); } src += 8; @@ -317,8 +300,7 @@ static int decode(MimicContext *ctx, int quality, int num_coeffs, src += (stride - ctx->num_hblocks[plane]) << 3; dst += (stride - ctx->num_hblocks[plane]) << 3; - ff_thread_report_progress(&ctx->frames[ctx->cur_index], - cur_row++, 0); + ff_progress_frame_report(&ctx->frames[ctx->cur_index], cur_row++); } } @@ -392,17 +374,18 @@ static int mimic_decode_frame(AVCodecContext *avctx, AVFrame *rframe, return AVERROR_PATCHWELCOME; } - if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) { + if (is_pframe && !ctx->frames[ctx->prev_index].f) { av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n"); return AVERROR_INVALIDDATA; } - ff_thread_release_ext_buffer(&ctx->frames[ctx->cur_index]); + ff_progress_frame_unref(&ctx->frames[ctx->cur_index]); + res = ff_progress_frame_get_buffer(avctx, &ctx->frames[ctx->cur_index], + AV_GET_BUFFER_FLAG_REF); + if (res < 0) + return res; ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I; - if ((res = ff_thread_get_ext_buffer(avctx, &ctx->frames[ctx->cur_index], - AV_GET_BUFFER_FLAG_REF)) < 0) - return res; ctx->next_prev_index = ctx->cur_index; ctx->next_cur_index = (ctx->cur_index - 1) & 15; @@ -419,10 +402,10 @@ static int mimic_decode_frame(AVCodecContext *avctx, AVFrame *rframe, init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3); res = decode(ctx, quality, num_coeffs, !is_pframe); - ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0); + ff_progress_frame_report(&ctx->frames[ctx->cur_index], INT_MAX); if (res < 0) { if (!(avctx->active_thread_type & FF_THREAD_FRAME)) - ff_thread_release_ext_buffer(&ctx->frames[ctx->cur_index]); + ff_progress_frame_unref(&ctx->frames[ctx->cur_index]); return res; } @@ -449,6 +432,6 @@ const FFCodec ff_mimic_decoder = { FF_CODEC_DECODE_CB(mimic_decode_frame), .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, UPDATE_THREAD_CONTEXT(mimic_decode_update_thread_context), - .caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS | + .caps_internal = FF_CODEC_CAP_USES_PROGRESSFRAMES | FF_CODEC_CAP_INIT_CLEANUP, }; From patchwork Mon Apr 8 20:13:42 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47942 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp135611pzb; Mon, 8 Apr 2024 13:15:00 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCVfOB5ValnOKmyI0r6TMUo6EaF23D3J/YNcLYyT6Y+NgKhbGPmcrmfUokDHAm4ssuQwvLWtuBFQLwEpDR/LbuujuiSbs0gIt+sGvQ== X-Google-Smtp-Source: AGHT+IG5qbw1O4bOIUNZhkQIySZ57gazId75x92kAeWzb85/AvnMhZ6TCGneEzVK850ztLt3CvRS X-Received: by 2002:a50:d557:0:b0:56e:2cb1:c517 with SMTP id f23-20020a50d557000000b0056e2cb1c517mr6719918edj.19.1712607299937; Mon, 08 Apr 2024 13:14:59 -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 30-20020a508e1e000000b0056e2abf021asi3897390edw.256.2024.04.08.13.14.59; Mon, 08 Apr 2024 13:14:59 -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=@outlook.com header.s=selector1 header.b="uy7g+8/b"; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 13A6F68D342; Mon, 8 Apr 2024 23:14:57 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2085.outbound.protection.outlook.com [40.92.66.85]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id D199B68D307 for ; Mon, 8 Apr 2024 23:14:54 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=E8QTryyEu1rCDw8MxPCBx26lXj9cDu1MNwLOLy6khwCX1AOWQtbcpUqJCXOYtgevGO8jtOk0PWXjwMfbbickl2r83Gb+A95RHpuOt0GmbLYUyL05+OJJTUubMoGWqGiQHj1Q0eZ0ewNur+LGidcVcNvXOywuuxfwmEGONkLM04gayrZQI4zALafWsjEVbF0u41CNemHAPz76mJ+Hn5MBekxzipsrEeuARcDlgyWMYOfZWeXn2b37ROu1sCYsyqldrrnJSjLSrFxXCGYNiycsF7nGLbnhvSMoVIPVzfjHtkyOYqLXC60sg/cfcT3X+6KCge3XND/UGzWLkRLvhpROfA== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=l0wIHKxGzWp80D2O+OLXIrsdhN+pBoe3RX0Dktd+OmU=; b=DfqF6KHZMLVeI+ApqL1IdgoUqs41TMBO+9gDvkdB/FqnYzup+kaCY74xrmEqh+/dRooHkDLHeyz47NLQG73KiFQOoFQX21mzw8oeZueeKx2BNRiZ4h4rMXxStWsRqie/EaRfcKIN3wqLc/wag/E67FQ0PHFvehAta63yC/3fPNsYwEGMVNdjhGpuNwBh1+868NjewQeUCoga/EJJWhOFrIlPjqUH+fjYtUCUm1r/SVfqDYj6IAwL6y3Jkc2I3l1JeFcqLp201slAanaKfTWt2yMnHGyf+Uzbcnc5KElRvGF7UdrKVvtE9hq2ysW9mcRQImM+tgVhPysMWejA7FAGZw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=l0wIHKxGzWp80D2O+OLXIrsdhN+pBoe3RX0Dktd+OmU=; b=uy7g+8/bdpNFvbbaRsJwOgZP1nXLcbJYiRwv1AKAihkoMifyvteIEMjBcfIXIQT+46wJXNFYHyjY8INJIY8cBWh7mHeNL5IYAAceY+PuA2yCP+iD39oywBhzYRuWo7llX/itwmytOeyRPv8/E8lZdzTowShywWbvtcKDFGX6uxZsDE566nu50uDyTNSEkrLMzsqsGXEXcVQWyce3dtLsdi5hPc6NGdQXrJ0E9bLDwUoDTWAXD+lhI/LTn2X3uNovGupAGIGhUyGS6DDV+9ko17OColnCYZ7hKotgd3lx6w58sbzgJndNGErUCcgvee8U/J4wtN0eSECJPVLk3oTy+A== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:14:53 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:14:53 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:42 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [I+kppMV6QFOBMMoE++Da0PWY0B/NsKxdWXdYyPHQp6g=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-3-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: f11a6b30-a180-4c24-9773-08dc58088cff X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: /HjswZpTmBnHB4Ut/Zf4Efn/ZGETKrI+7MrwFUTyXM5XvHDgQc8ptBnKsfLwhwSV9vQexuGvZFCW+/z3lbWdX16yjb0tBrAhQRqHzKZpd1dkN3vzWRsiIhmQDiKOjTUG53rXm18HxE4dRPeOcAmJiIX5ji9wx/c034UUJxp/2JgJcvcYgmSGVpaOZqfGRrVlIPVqYj8/hh1JT1vlZddA2vnK0CgLDTgm75PMPZHHc75H8V4lxbG4bvEuwS9W/AEVJlPC8KHHeFFrIUiZ8idVKQUbXczwUqgMokQLtk/u/6lJcZyZusp10w/kV4U40pKp13q7UKvMMrGle6iPZCvLh6jT9KS54Pu2r92x5A/DL9toFdkcXRbsgPN7o71HUtvGkLgQWw84mQ0QaSq5MASYpYmdUu/dGZspYzlpD6ah5XHUdf3AtnMZcvQqqHCtHwFua9VlsF5F7dn70jmbHEUMrn/xf/PsuZx7J9nTQ5tuGDS2KlLpQYYmxfZkR2yJQVo41jL4S9+wuf0WcOpZmTrdx3jFjyD+X7Mh6+kaR8T+nxlD35xaq/oOSOCR1ohYPH9AuAywZj2PA+8Y2uyyRH4WnTmP3PblMxrI82pccMc1WdtSVsp16Xm1WmuPMfbBkNYf X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: H861duFLVKk0k3aOBQZ/Hhk1uiocz7DLFi52rzN/WbZWyZ1Lv0LWVUENzb0+ryS5rWJUAVWUNZ53gkNFNfGPrEFJU3F9sYfvLtPpBbQuWDL8AOX2rBHnugpQuWJ2zCAMUBj6K44fQg4lPuhLt6VNCKPACvPjDn+s8HqFU3Nrgnf5WNfxSWl6xoXLZpVSmsFAmNmfTTIu98IjzMy3dIl6dvzRlz54eyqLNphi0lK0ekSdYbVDZbYDTbg+1fMf72803ZBLLujpTLYV3vN1NWMxaPoRH+/vYEDL+2u75maQPM30nAA5EL1sytg3zy2So4tLLKFW5TK6CzbfDKrpblqUq+nX//i9GQuQsCi3RkJYK3TS1QO/XVlr6uj9ZHQz79Oha+6v6/AUzkcgziWWiwkmnU8ler8GU/L7bmzH1GxTsKSR88+Wh0o8AWEh46sA5nJqijtUdyQgob8NAN2ey+KGukX7e9qLAefv5C2aKmqRdMnU+30onvIqWqDMxKdI5pe4XwklBFM7jGqE8+FkyJG7fShnndHI/O6td9ZkHSdOB5z/sFCsmYQVCKwBl+Ottp1cpVuQIndELEHjfGAkxMLkLwNcGZAFL5ec3kW2YsBoap8xCEJ2ZqvFZPb+t/lDvT0NL3dp+zL9D0jc4WNZmIdeTZzNZbVJ3xzhulSj2OyY7sHm7D5gj4V24lJocxJ5JAaHX7WzoqTReNn66PrxBEL862WFMrI+FSXtMXMPs923S32lXTgR0mmmliWr6DAjzKdcQgutiptk6Rof/l3aMAHPemmdFau8sCjlHSgnji+Umfk29Nh3ssr9xuKISqYTyd/20JrXVxWcM4hXmo790BzpXcKRrna8jwuMHK8c3jSbLHqjREdAXNS2HBm3K0Z8GbDxC/QhGjd2QH4hZxJFVbg7rTn8ZJ2PuZTPItzcb9GpF6rPh5z89uTeSHvPm/i/sUQO5yVorofGWPKhFmvz3VR7OfZ7dQgIiAITA+yuiNphXoCyDGPbEbZZrOjd2hDS2W0hS1WRQgmNBsseFbyvKjDca42qNegRYNGGiLcvbVx0MKD9TNF+iXJXIkldyt18oRhSAMufd9ukncxp1T5pAQjcbVhnJGlWy4PL4fksJL9R/PVJaoAZvBt6XPV0ebqxbOyADzQUeGCsjW/Sfw6x+O6VzXnfOrvOYnhJ4UsP0rUi7hx7g4xGUC19dBcGcdVSA6pzj6smAwq8ff2TITNKQCkZn9wR2BmKTbkIOVb56YlnPSjh85j6t5TYszcKSnD/Zw8o3BnwU+sME1gfqQr3ZoAvrw== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: f11a6b30-a180-4c24-9773-08dc58088cff X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:14:53.0032 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 04/27] avcodec/vp3: Switch to ProgressFrames 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 Cc: Anton Khirnov , Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: Yy2fJEnpKZ0L Avoids implicit av_frame_ref() and therefore allocations and error checks. It also avoids explicitly allocating the AVFrames (done implicitly when getting the buffer) and it also allows to reuse the flushing code for freeing the ProgressFrames. Reviewed-by: Anton Khirnov Signed-off-by: Andreas Rheinhardt --- libavcodec/vp3.c | 147 +++++++++++++++++------------------------------ 1 file changed, 53 insertions(+), 94 deletions(-) diff --git a/libavcodec/vp3.c b/libavcodec/vp3.c index 201bab0e32..2a5f68dfa8 100644 --- a/libavcodec/vp3.c +++ b/libavcodec/vp3.c @@ -49,9 +49,9 @@ #include "internal.h" #include "jpegquanttables.h" #include "mathops.h" +#include "progressframe.h" #include "refstruct.h" #include "thread.h" -#include "threadframe.h" #include "videodsp.h" #include "vp3data.h" #include "vp4data.h" @@ -201,9 +201,9 @@ typedef struct Vp3DecodeContext { int version; int width, height; int chroma_x_shift, chroma_y_shift; - ThreadFrame golden_frame; - ThreadFrame last_frame; - ThreadFrame current_frame; + ProgressFrame golden_frame; + ProgressFrame last_frame; + ProgressFrame current_frame; int keyframe; uint8_t idct_permutation[64]; uint8_t idct_scantable[64]; @@ -353,12 +353,9 @@ static void vp3_decode_flush(AVCodecContext *avctx) { Vp3DecodeContext *s = avctx->priv_data; - if (s->golden_frame.f) - ff_thread_release_ext_buffer(&s->golden_frame); - if (s->last_frame.f) - ff_thread_release_ext_buffer(&s->last_frame); - if (s->current_frame.f) - ff_thread_release_ext_buffer(&s->current_frame); + ff_progress_frame_unref(&s->golden_frame); + ff_progress_frame_unref(&s->last_frame); + ff_progress_frame_unref(&s->current_frame); } static av_cold int vp3_decode_end(AVCodecContext *avctx) @@ -372,9 +369,6 @@ static av_cold int vp3_decode_end(AVCodecContext *avctx) /* release all frames */ vp3_decode_flush(avctx); - av_frame_free(&s->current_frame.f); - av_frame_free(&s->last_frame.f); - av_frame_free(&s->golden_frame.f); ff_refstruct_unref(&s->coeff_vlc); @@ -1908,10 +1902,9 @@ static void vp3_draw_horiz_band(Vp3DecodeContext *s, int y) /* At the end of the frame, report INT_MAX instead of the height of * the frame. This makes the other threads' ff_thread_await_progress() * calls cheaper, because they don't have to clip their values. */ - ff_thread_report_progress(&s->current_frame, - y_flipped == s->height ? INT_MAX - : y_flipped - 1, - 0); + ff_progress_frame_report(&s->current_frame, + y_flipped == s->height ? INT_MAX + : y_flipped - 1); } if (!s->avctx->draw_horiz_band) @@ -1942,7 +1935,7 @@ static void vp3_draw_horiz_band(Vp3DecodeContext *s, int y) static void await_reference_row(Vp3DecodeContext *s, const Vp3Fragment *fragment, int motion_y, int y) { - const ThreadFrame *ref_frame; + const ProgressFrame *ref_frame; int ref_row; int border = motion_y & 1; @@ -1955,7 +1948,7 @@ static void await_reference_row(Vp3DecodeContext *s, const Vp3Fragment *fragment ref_row = y + (motion_y >> 1); ref_row = FFMAX(FFABS(ref_row), ref_row + 8 + border); - ff_thread_await_progress(ref_frame, ref_row, 0); + ff_progress_frame_await(ref_frame, ref_row); } #if CONFIG_VP4_DECODER @@ -2066,12 +2059,12 @@ static void render_slice(Vp3DecodeContext *s, int slice) int16_t *block = s->block; int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef; /* When decoding keyframes, the earlier frames may not be available, - * so to avoid using undefined pointer arithmetic on them we just - * use the current frame instead. Nothing is ever read from these - * frames in case of a keyframe. */ - const AVFrame *last_frame = s->last_frame.f->data[0] ? + * so we just use the current frame in this case instead; + * it also avoid using undefined pointer arithmetic. Nothing is + * ever read from these frames in case of a keyframe. */ + const AVFrame *last_frame = s->last_frame.f ? s->last_frame.f : s->current_frame.f; - const AVFrame *golden_frame = s->golden_frame.f->data[0] ? + const AVFrame *golden_frame = s->golden_frame.f ? s->golden_frame.f : s->current_frame.f; int motion_halfpel_index; int first_pixel; @@ -2353,17 +2346,6 @@ static av_cold int allocate_tables(AVCodecContext *avctx) return 0; } -static av_cold int init_frames(Vp3DecodeContext *s) -{ - s->current_frame.f = av_frame_alloc(); - s->last_frame.f = av_frame_alloc(); - s->golden_frame.f = av_frame_alloc(); - - if (!s->current_frame.f || !s->last_frame.f || !s->golden_frame.f) - return AVERROR(ENOMEM); - - return 0; -} static av_cold void free_vlc_tables(FFRefStructOpaque unused, void *obj) { @@ -2382,10 +2364,6 @@ static av_cold int vp3_decode_init(AVCodecContext *avctx) int c_height; int y_fragment_count, c_fragment_count; - ret = init_frames(s); - if (ret < 0) - return ret; - if (avctx->codec_tag == MKTAG('V', 'P', '4', '0')) { s->version = 3; #if !CONFIG_VP4_DECODER @@ -2524,61 +2502,42 @@ static av_cold int vp3_decode_init(AVCodecContext *avctx) } /// Release and shuffle frames after decode finishes -static int update_frames(AVCodecContext *avctx) +static void update_frames(AVCodecContext *avctx) { Vp3DecodeContext *s = avctx->priv_data; - int ret = 0; - if (s->keyframe) { - ff_thread_release_ext_buffer(&s->golden_frame); - ret = ff_thread_ref_frame(&s->golden_frame, &s->current_frame); - } - /* shuffle frames */ - ff_thread_release_ext_buffer(&s->last_frame); - FFSWAP(ThreadFrame, s->last_frame, s->current_frame); + if (s->keyframe) + ff_progress_frame_replace(&s->golden_frame, &s->current_frame); - return ret; + /* shuffle frames */ + ff_progress_frame_unref(&s->last_frame); + FFSWAP(ProgressFrame, s->last_frame, s->current_frame); } #if HAVE_THREADS -static int ref_frame(ThreadFrame *dst, const ThreadFrame *src) +static void ref_frames(Vp3DecodeContext *dst, const Vp3DecodeContext *src) { - ff_thread_release_ext_buffer(dst); - if (src->f->data[0]) - return ff_thread_ref_frame(dst, src); - return 0; -} - -static int ref_frames(Vp3DecodeContext *dst, const Vp3DecodeContext *src) -{ - int ret; - if ((ret = ref_frame(&dst->current_frame, &src->current_frame)) < 0 || - (ret = ref_frame(&dst->golden_frame, &src->golden_frame)) < 0 || - (ret = ref_frame(&dst->last_frame, &src->last_frame)) < 0) - return ret; - return 0; + ff_progress_frame_replace(&dst->current_frame, &src->current_frame); + ff_progress_frame_replace(&dst->golden_frame, &src->golden_frame); + ff_progress_frame_replace(&dst->last_frame, &src->last_frame); } static int vp3_update_thread_context(AVCodecContext *dst, const AVCodecContext *src) { Vp3DecodeContext *s = dst->priv_data; const Vp3DecodeContext *s1 = src->priv_data; - int qps_changed = 0, err; + int qps_changed = 0; ff_refstruct_replace(&s->coeff_vlc, s1->coeff_vlc); - if (!s1->current_frame.f->data[0] || + // copy previous frame data + ref_frames(s, s1); + if (!s1->current_frame.f || s->width != s1->width || s->height != s1->height) { - if (s != s1) - ref_frames(s, s1); return -1; } if (s != s1) { - // copy previous frame data - if ((err = ref_frames(s, s1)) < 0) - return err; - s->keyframe = s1->keyframe; // copy qscale data if necessary @@ -2600,7 +2559,8 @@ static int vp3_update_thread_context(AVCodecContext *dst, const AVCodecContext * } } - return update_frames(dst); + update_frames(dst); + return 0; } #endif @@ -2691,15 +2651,19 @@ static int vp3_decode_frame(AVCodecContext *avctx, AVFrame *frame, if (avctx->skip_frame >= AVDISCARD_NONKEY && !s->keyframe) return buf_size; + ret = ff_progress_frame_get_buffer(avctx, &s->current_frame, + AV_GET_BUFFER_FLAG_REF); + if (ret < 0) { + // Don't goto error here, as one can't report progress on or + // unref a non-existent frame. + return ret; + } s->current_frame.f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P; if (s->keyframe) s->current_frame.f->flags |= AV_FRAME_FLAG_KEY; else s->current_frame.f->flags &= ~AV_FRAME_FLAG_KEY; - if ((ret = ff_thread_get_ext_buffer(avctx, &s->current_frame, - AV_GET_BUFFER_FLAG_REF)) < 0) - goto error; if (!s->edge_emu_buffer) { s->edge_emu_buffer = av_malloc(9 * FFABS(s->current_frame.f->linesize[0])); @@ -2757,19 +2721,16 @@ static int vp3_decode_frame(AVCodecContext *avctx, AVFrame *frame, #endif } } else { - if (!s->golden_frame.f->data[0]) { + if (!s->golden_frame.f) { av_log(s->avctx, AV_LOG_WARNING, "vp3: first frame not a keyframe\n"); - s->golden_frame.f->pict_type = AV_PICTURE_TYPE_I; - if ((ret = ff_thread_get_ext_buffer(avctx, &s->golden_frame, - AV_GET_BUFFER_FLAG_REF)) < 0) + if ((ret = ff_progress_frame_get_buffer(avctx, &s->golden_frame, + AV_GET_BUFFER_FLAG_REF)) < 0) goto error; - ff_thread_release_ext_buffer(&s->last_frame); - if ((ret = ff_thread_ref_frame(&s->last_frame, - &s->golden_frame)) < 0) - goto error; - ff_thread_report_progress(&s->last_frame, INT_MAX, 0); + s->golden_frame.f->pict_type = AV_PICTURE_TYPE_I; + ff_progress_frame_replace(&s->last_frame, &s->golden_frame); + ff_progress_frame_report(&s->golden_frame, INT_MAX); } } ff_thread_finish_setup(avctx); @@ -2847,16 +2808,13 @@ static int vp3_decode_frame(AVCodecContext *avctx, AVFrame *frame, *got_frame = 1; - if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_FRAME)) { - ret = update_frames(avctx); - if (ret < 0) - return ret; - } + if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_FRAME)) + update_frames(avctx); return buf_size; error: - ff_thread_report_progress(&s->current_frame, INT_MAX, 0); + ff_progress_frame_report(&s->current_frame, INT_MAX); if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_FRAME)) av_frame_unref(s->current_frame.f); @@ -3206,7 +3164,8 @@ const FFCodec ff_theora_decoder = { .flush = vp3_decode_flush, UPDATE_THREAD_CONTEXT(vp3_update_thread_context), .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | - FF_CODEC_CAP_EXPORTS_CROPPING | FF_CODEC_CAP_ALLOCATE_PROGRESS, + FF_CODEC_CAP_EXPORTS_CROPPING | + FF_CODEC_CAP_USES_PROGRESSFRAMES, }; #endif @@ -3224,7 +3183,7 @@ const FFCodec ff_vp3_decoder = { .flush = vp3_decode_flush, UPDATE_THREAD_CONTEXT(vp3_update_thread_context), .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | - FF_CODEC_CAP_ALLOCATE_PROGRESS, + FF_CODEC_CAP_USES_PROGRESSFRAMES, }; #if CONFIG_VP4_DECODER @@ -3242,6 +3201,6 @@ const FFCodec ff_vp4_decoder = { .flush = vp3_decode_flush, UPDATE_THREAD_CONTEXT(vp3_update_thread_context), .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | - FF_CODEC_CAP_ALLOCATE_PROGRESS, + FF_CODEC_CAP_USES_PROGRESSFRAMES, }; #endif From patchwork Mon Apr 8 20:13:43 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47943 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp135692pzb; Mon, 8 Apr 2024 13:15:09 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCVZpTD5tXNF71geMWlaRdlM4r6J+63Vd340stpgiTgKSACtHUWJlmHkwzeJW40YRyPhvjFussGn2JeDk+N8hKfXnOTcQxCLD8QPCg== X-Google-Smtp-Source: AGHT+IFwZKtUCdfqheBQ44+fsZH7WVrS3+vbRETsMFSNAtkfjTEXQTk+KsXCugWkg1bFSaFbhVYF X-Received: by 2002:a17:907:a0c:b0:a51:d66a:6f8 with SMTP id bb12-20020a1709070a0c00b00a51d66a06f8mr2924705ejc.20.1712607309393; Mon, 08 Apr 2024 13:15:09 -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 g10-20020a1709063b0a00b00a4e29be9c8bsi4058536ejf.31.2024.04.08.13.15.08; Mon, 08 Apr 2024 13:15:09 -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=@outlook.com header.s=selector1 header.b=oGFeS3xX; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 4DB6F68D275; Mon, 8 Apr 2024 23:15:03 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2073.outbound.protection.outlook.com [40.92.66.73]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 13D5A68D352 for ; Mon, 8 Apr 2024 23:15:00 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=Xvt0/celExI4XIKYqy0iyQq7ZIMG1wxoPTNmqsflF7/YpDP8QIzueJw0ICb8fsUSwiC7UV3eEjpm5M/RK/OpeF1QdfrxxhiKGglaa0X8SX778dsruW7JZFDbNjE/3ZAGU6t87jjqWsXMKEibB640++vA+p2CR151H+VlfUlXga7N+3+u69WVhKMWL21PjNCwiP7decDJwB4DyPhRRVElyjy0OcrHfaI/gK6xIO0Zt9OlC+foyKkxk2gn+zeWaLcVUAdClWJtIIytr+P1jQeo1hT94j8Zr8RO+Mku3KZVlAxUwMFZ3ThkXD2b5vLmMSu/xKHhw/3+Epq9KNP5rAwC5Q== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=YzKi1tCOA36bTbZ6Q+NZOeTXgyrDSU1LbsD1Q41CF2Q=; b=moxuonV+xuz2NO01wqXLhGqxV0ki3/BcOsgI752uGMReZMcsEWztEv84U63VftTwwC/6tnkymM6sVAK6I1j603phlVo/RDba6wUheyumIHwdNZUBzSzLenoXWLx33G3xeGuEaCYrm1UGUsfZDQA/ShBTQsKJ+6BPYClNycsjVRZYFbpioHzKqUwdIIOHVLsVhQa715aKxa86/MtDZU6Qtzwqvi13tJ19v4fh2EqcXIbC+fUYZT5GIpWcvLZ3hmaKU12Li59Hcz7NF6vglJXC97HngwUJjH1fZ7qcuHPGlvBHL15cNpTI7fDLK5xwNv5odbS8WzRAbvJR76vhxPWWNg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=YzKi1tCOA36bTbZ6Q+NZOeTXgyrDSU1LbsD1Q41CF2Q=; b=oGFeS3xXfeyf4XozSp5Z/4Yji+KVHSfPi3flJVBuS4UX+bZKY5s8LEFii6zI29SVe686q3wo9AOak0Fl//quIIffc+bUDM6BshotnhwwVgUhQ+BaiKzkYYR5cVPNqFwALpfwmwq7+Mynhqv//ziUBC2Mig2S58EbNSePX3hrkb4yzTacJHbex7F4L7DqdKzBEYtenKKd1w56+JAbiNTXpgTFKcjZ8RCYkPu4ETa89llG1SGEbcOycsJnIMMyNuUDL9y48/FWRbzZo7LDK7LZ2qIqzi7vdQqqWm027YA32nxZeKN3n9srZakYS7cdHOnNTKen2DDHV33eftkQpxCT3g== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:14:55 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:14:55 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:43 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [OJFGxV/ehQW9to9JEyCCK7F/C0pApbHZV58DUFdYlRY=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-4-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 935ab315-f797-40d5-61b3-08dc58088ea7 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: XxbegTeDZSttm5RXx2U9N328RJL4+XB0fKoC/xtntX9dIOpaDQr2qunVXDvXtv/rizDceL5IW8yI7bWz5o2X+7CQpmijCY4bd7kEdWVzsDXKog2O9FObS+7L7Ql9uIq8W361kSAoL6Jebxdm3Me/CJuxD7xw6t9hVFqJ5DBbrvRBfctpWPKSHp9HIoC2vRl4TOmIYUywjMxCsYBF2dYTabCGMePJO/vAny8oytzbklam3kzFu/8CwEaDd01kV0VXiatEEX/XUG38jcMmztP/Ts5mgxIFjMzSg2HmJplO2dJrBrl01s3itoce02A0PuAbYf2MPg8JlJVDhzYcjzAaJoQWNtmo20stQbF6YhqCTsuasSVs0VZqdVahQuVeH1ABqooBP22tnHhtJeM7mPyjz7uxfNeJ/1AU/jvBNAtBo+7fNv5OQfcBefeNOjzP8DRanKuI6BZKDjvnyw7z1yO6FnZgBfwMwbD3vd2UwYkyI2DyRbkyCLr6yzDL2fAW1HbkQgmmp4a2jrkJb41bTWYD/joWNZN1zt3pcCG47IFJT+DtVq3EEqQ+/Ewpqrq5z9+6WBPNAaJUc1+ZIOdU2qCcdApJYhc3Qq8qm9ds3QeXm9StGHxohnCXBw3H7pSiCtla X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: Yh5yTvWBoHdWtzxaRSJ4mI4aIniLjdImWMy1trQZWPjAL1SFEq8yed/2POEbDAkzEc/zQYXsNXGrlp4tcWyCmX7cFCKVgDBYmJbBf+vZ+OsTxs3zlpMlJeDM5EUGB8WJ2NjcpymsaT4ljVcUsL8GWxsPfHPfiULkYZuJn3kBSQjzqflHFI/tMD9O7hLOFDN5V81glTknxJYutcXtZlDKwwQ3VuDZ5A/YWWpyUMcatLmS1qskM1h81LaEAMSRg4IiGDFbL3+IBAG63kIHklVKw/ND6qERRB5CjaGKtuNJly4PD6HtpjY8aZcTZazEp1Xv5Nmw9gZsdhSIVgagVlyWIou6iLn6O8t6mzeZBEpaOEzHbUFtWRt0KQ5jw9XUDjG/BrWioEK5wuvq8NnX0Py2mD0Ef33rJFxHwuLvrrQrAlcM503+FvhJh4a8FgSu1bRRjLx7jYLfk/q7xkv9UDk+kYaoPumaeGPHTJvh5mBV8GBxUbhJ8h4+eRXwi+Jm/tv9b2aSGSrEbBOHd0H4jiJ6p93yLnYYDBi804IzM4M9VAEaG92asP0WV1LZsCOjlWW4FcnfCs+hTXBv9kh8d6Baix5QQr/W0IhveNIqEHJL+XZgyS9rd3gsG0NVne9obYtwJn30BnW6o9tKkvHAaKc6DFbNcLYEq9rt2g8Bvk+Y+OQWCXFUutol7O+M2kwT1SwN+/CNv27cHzasrAgkKrqi0t6UVCr780QXQsmz9MCG/ZAynatd4uNiiFqpyA3Gh+BqXDewHCpN6jAnwMmQwnwJxkID8MbJA/PQLjLj2doPglFb4JGiMi6D/1/W57DMRb8RE9XS3k/iq8sX++mPNICVe/ByPr39hNtigHcGG0NRbjykXJy/sNNlDTuYW13DbxCyBhg2uLi1W01L7RoyyP0lUUoAuDhuHPFiTXgsW6dLnoLupQYyjkOr0YZmsMrpoOgS9yVu/3aQ3ERpGdvpMpzEBxDSMW5kfPlyV5C3MUlo7wbDbf24AaHL2/v5CkGmNQxX4My52/kYGUbhKQp+MNem3bSPy0Lq8daNJxRzZ+gMz23ZtCpudpzRaZ24zZwSGMj6ICc7Rrq5s3zcU6hobbDsHPSJDT8bMEi2BIwsO/AId1udsMgo/ximt5SWCEYk98eq3GGSlLZyKCSTjiNvVRCGvAwuWfWKcWfB3EMelPPFv5LQy+q8UzvkRq0MaR58pt/sGfV4s9HUETcoVf/0nucNO7D8JFBKtK91jD9h2CD1I5SvtpgznPT2z5lKtsFShOSvI75Z0aLITxMv0BpJM5+/7g== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 935ab315-f797-40d5-61b3-08dc58088ea7 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:14:55.8190 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 05/27] avcodec/vp9: Switch to ProgressFrames 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 Cc: Anton Khirnov , Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: d9phwertnuDE This already fixes a race in the vp9-encparams test. In this test, side data is added to the current frame after having been decoded (and therefore after ff_thread_finish_setup() has been called). Yet the update_thread_context callback called ff_thread_ref_frame() and therefore av_frame_ref() with this frame as source frame and the ensuing read was unsynchronised with adding the side data, i.e. there was a data race. By switching to the ProgressFrame API the implicit av_frame_ref() is removed and the race fixed except if this frame is later reused by a show-existing-frame which uses an explicit av_frame_ref(). The vp9-encparams test does not cover this, so this commit already fixes all the races in this test. This decoder kept multiple references to the same ThreadFrames in the same context and therefore had lots of implicit av_frame_ref() even when decoding single-threaded. This incurred lots of small allocations: When decoding an ordinary 10s video in single-threaded mode the number of allocations reported by Valgrind went down from 57,814 to 20,908; for 10 threads it went down from 84,223 to 21,901. Reviewed-by: Anton Khirnov Signed-off-by: Andreas Rheinhardt --- libavcodec/dxva2_vp9.c | 4 +- libavcodec/vaapi_vp9.c | 2 +- libavcodec/vp9.c | 137 +++++++++++------------------------ libavcodec/vp9_mc_template.c | 2 +- libavcodec/vp9block.c | 5 +- libavcodec/vp9dec.h | 6 +- libavcodec/vp9lpf.c | 1 + libavcodec/vp9mvs.c | 4 +- libavcodec/vp9recon.c | 19 ++--- libavcodec/vp9shared.h | 6 +- 10 files changed, 70 insertions(+), 116 deletions(-) diff --git a/libavcodec/dxva2_vp9.c b/libavcodec/dxva2_vp9.c index 1498deb3c8..ca8b3b136d 100644 --- a/libavcodec/dxva2_vp9.c +++ b/libavcodec/dxva2_vp9.c @@ -79,7 +79,7 @@ int ff_dxva2_vp9_fill_picture_parameters(const AVCodecContext *avctx, AVDXVACont pp->Reserved8Bits = 0; for (i = 0; i < 8; i++) { - if (h->refs[i].f->buf[0]) { + if (h->refs[i].f) { fill_picture_entry(&pp->ref_frame_map[i], ff_dxva2_get_surface_index(avctx, ctx, h->refs[i].f, 0), 0); pp->ref_frame_coded_width[i] = h->refs[i].f->width; pp->ref_frame_coded_height[i] = h->refs[i].f->height; @@ -89,7 +89,7 @@ int ff_dxva2_vp9_fill_picture_parameters(const AVCodecContext *avctx, AVDXVACont for (i = 0; i < 3; i++) { uint8_t refidx = h->h.refidx[i]; - if (h->refs[refidx].f->buf[0]) + if (h->refs[refidx].f) fill_picture_entry(&pp->frame_refs[i], ff_dxva2_get_surface_index(avctx, ctx, h->refs[refidx].f, 0), 0); else pp->frame_refs[i].bPicEntry = 0xFF; diff --git a/libavcodec/vaapi_vp9.c b/libavcodec/vaapi_vp9.c index 9dc7d5e72b..b8e760c807 100644 --- a/libavcodec/vaapi_vp9.c +++ b/libavcodec/vaapi_vp9.c @@ -100,7 +100,7 @@ static int vaapi_vp9_start_frame(AVCodecContext *avctx, } for (i = 0; i < 8; i++) { - if (h->refs[i].f->buf[0]) + if (h->refs[i].f) pic_param.reference_frames[i] = ff_vaapi_get_surface_id(h->refs[i].f); else pic_param.reference_frames[i] = VA_INVALID_ID; diff --git a/libavcodec/vp9.c b/libavcodec/vp9.c index 6bcda8bfff..bd52478ce7 100644 --- a/libavcodec/vp9.c +++ b/libavcodec/vp9.c @@ -30,9 +30,9 @@ #include "hwaccel_internal.h" #include "hwconfig.h" #include "profiles.h" +#include "progressframe.h" #include "refstruct.h" #include "thread.h" -#include "threadframe.h" #include "pthread_internal.h" #include "videodsp.h" @@ -100,7 +100,7 @@ static void vp9_tile_data_free(VP9TileData *td) static void vp9_frame_unref(VP9Frame *f) { - ff_thread_release_ext_buffer(&f->tf); + ff_progress_frame_unref(&f->tf); ff_refstruct_unref(&f->extradata); ff_refstruct_unref(&f->hwaccel_picture_private); f->segmentation_map = NULL; @@ -111,7 +111,7 @@ static int vp9_frame_alloc(AVCodecContext *avctx, VP9Frame *f) VP9Context *s = avctx->priv_data; int ret, sz; - ret = ff_thread_get_ext_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF); + ret = ff_progress_frame_get_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF); if (ret < 0) return ret; @@ -147,13 +147,9 @@ fail: return ret; } -static int vp9_frame_ref(VP9Frame *dst, VP9Frame *src) +static void vp9_frame_ref(VP9Frame *dst, const VP9Frame *src) { - int ret; - - ret = ff_thread_ref_frame(&dst->tf, &src->tf); - if (ret < 0) - return ret; + ff_progress_frame_ref(&dst->tf, &src->tf); dst->extradata = ff_refstruct_ref(src->extradata); @@ -163,8 +159,13 @@ static int vp9_frame_ref(VP9Frame *dst, VP9Frame *src) ff_refstruct_replace(&dst->hwaccel_picture_private, src->hwaccel_picture_private); +} - return 0; +static void vp9_frame_replace(VP9Frame *dst, const VP9Frame *src) +{ + vp9_frame_unref(dst); + if (src && src->tf.f) + vp9_frame_ref(dst, src); } static int update_size(AVCodecContext *avctx, int w, int h) @@ -589,9 +590,9 @@ static int decode_frame_header(AVCodecContext *avctx, s->s.h.signbias[1] = get_bits1(&s->gb) && !s->s.h.errorres; s->s.h.refidx[2] = get_bits(&s->gb, 3); s->s.h.signbias[2] = get_bits1(&s->gb) && !s->s.h.errorres; - if (!s->s.refs[s->s.h.refidx[0]].f->buf[0] || - !s->s.refs[s->s.h.refidx[1]].f->buf[0] || - !s->s.refs[s->s.h.refidx[2]].f->buf[0]) { + if (!s->s.refs[s->s.h.refidx[0]].f || + !s->s.refs[s->s.h.refidx[1]].f || + !s->s.refs[s->s.h.refidx[2]].f) { av_log(avctx, AV_LOG_ERROR, "Not all references are available\n"); return AVERROR_INVALIDDATA; } @@ -611,7 +612,8 @@ static int decode_frame_header(AVCodecContext *avctx, // Note that in this code, "CUR_FRAME" is actually before we // have formally allocated a frame, and thus actually represents // the _last_ frame - s->s.h.use_last_frame_mvs &= s->s.frames[CUR_FRAME].tf.f->width == w && + s->s.h.use_last_frame_mvs &= s->s.frames[CUR_FRAME].tf.f && + s->s.frames[CUR_FRAME].tf.f->width == w && s->s.frames[CUR_FRAME].tf.f->height == h; if (get_bits1(&s->gb)) // display size skip_bits(&s->gb, 32); @@ -1240,16 +1242,12 @@ static av_cold int vp9_decode_free(AVCodecContext *avctx) VP9Context *s = avctx->priv_data; int i; - for (i = 0; i < 3; i++) { + for (int i = 0; i < 3; i++) vp9_frame_unref(&s->s.frames[i]); - av_frame_free(&s->s.frames[i].tf.f); - } ff_refstruct_pool_uninit(&s->frame_extradata_pool); for (i = 0; i < 8; i++) { - ff_thread_release_ext_buffer(&s->s.refs[i]); - av_frame_free(&s->s.refs[i].f); - ff_thread_release_ext_buffer(&s->next_refs[i]); - av_frame_free(&s->next_refs[i].f); + ff_progress_frame_unref(&s->s.refs[i]); + ff_progress_frame_unref(&s->next_refs[i]); } free_buffers(s); @@ -1384,7 +1382,7 @@ static int decode_tiles(AVCodecContext *avctx, // FIXME maybe we can make this more finegrained by running the // loopfilter per-block instead of after each sbrow // In fact that would also make intra pred left preparation easier? - ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, row >> 3, 0); + ff_progress_frame_report(&s->s.frames[CUR_FRAME].tf, row >> 3); } } return 0; @@ -1561,12 +1559,13 @@ static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, int ret, i, j, ref; int retain_segmap_ref = s->s.frames[REF_FRAME_SEGMAP].segmentation_map && (!s->s.h.segmentation.enabled || !s->s.h.segmentation.update_map); + const VP9Frame *src; AVFrame *f; if ((ret = decode_frame_header(avctx, data, size, &ref)) < 0) { return ret; } else if (ret == 0) { - if (!s->s.refs[ref].f->buf[0]) { + if (!s->s.refs[ref].f) { av_log(avctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref); return AVERROR_INVALIDDATA; } @@ -1574,33 +1573,19 @@ static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, return ret; frame->pts = pkt->pts; frame->pkt_dts = pkt->dts; - for (i = 0; i < 8; i++) { - if (s->next_refs[i].f->buf[0]) - ff_thread_release_ext_buffer(&s->next_refs[i]); - if (s->s.refs[i].f->buf[0] && - (ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i])) < 0) - return ret; - } + for (int i = 0; i < 8; i++) + ff_progress_frame_replace(&s->next_refs[i], &s->s.refs[i]); *got_frame = 1; return pkt->size; } data += ret; size -= ret; - if (!retain_segmap_ref || s->s.h.keyframe || s->s.h.intraonly) { - if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0]) - vp9_frame_unref(&s->s.frames[REF_FRAME_SEGMAP]); - if (!s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] && - (ret = vp9_frame_ref(&s->s.frames[REF_FRAME_SEGMAP], &s->s.frames[CUR_FRAME])) < 0) - return ret; - } - if (s->s.frames[REF_FRAME_MVPAIR].tf.f->buf[0]) - vp9_frame_unref(&s->s.frames[REF_FRAME_MVPAIR]); - if (!s->s.h.intraonly && !s->s.h.keyframe && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] && - (ret = vp9_frame_ref(&s->s.frames[REF_FRAME_MVPAIR], &s->s.frames[CUR_FRAME])) < 0) - return ret; - if (s->s.frames[CUR_FRAME].tf.f->buf[0]) - vp9_frame_unref(&s->s.frames[CUR_FRAME]); + src = !s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres ? &s->s.frames[CUR_FRAME] : NULL; + if (!retain_segmap_ref || s->s.h.keyframe || s->s.h.intraonly) + vp9_frame_replace(&s->s.frames[REF_FRAME_SEGMAP], src); + vp9_frame_replace(&s->s.frames[REF_FRAME_MVPAIR], src); + vp9_frame_unref(&s->s.frames[CUR_FRAME]); if ((ret = vp9_frame_alloc(avctx, &s->s.frames[CUR_FRAME])) < 0) return ret; f = s->s.frames[CUR_FRAME].tf.f; @@ -1610,7 +1595,8 @@ static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, f->flags &= ~AV_FRAME_FLAG_KEY; f->pict_type = (s->s.h.keyframe || s->s.h.intraonly) ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P; - if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0] && + // Non-existent frames have the implicit dimension 0x0 != CUR_FRAME + if (!s->s.frames[REF_FRAME_MVPAIR].tf.f || (s->s.frames[REF_FRAME_MVPAIR].tf.f->width != s->s.frames[CUR_FRAME].tf.f->width || s->s.frames[REF_FRAME_MVPAIR].tf.f->height != s->s.frames[CUR_FRAME].tf.f->height)) { vp9_frame_unref(&s->s.frames[REF_FRAME_SEGMAP]); @@ -1618,15 +1604,9 @@ static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, // ref frame setup for (i = 0; i < 8; i++) { - if (s->next_refs[i].f->buf[0]) - ff_thread_release_ext_buffer(&s->next_refs[i]); - if (s->s.h.refreshrefmask & (1 << i)) { - ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.frames[CUR_FRAME].tf); - } else if (s->s.refs[i].f->buf[0]) { - ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i]); - } - if (ret < 0) - return ret; + ff_progress_frame_replace(&s->next_refs[i], + s->s.h.refreshrefmask & (1 << i) ? + &s->s.frames[CUR_FRAME].tf : &s->s.refs[i]); } if (avctx->hwaccel) { @@ -1736,7 +1716,7 @@ static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, { ret = decode_tiles(avctx, data, size); if (ret < 0) { - ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0); + ff_progress_frame_report(&s->s.frames[CUR_FRAME].tf, INT_MAX); return ret; } } @@ -1752,7 +1732,7 @@ static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, ff_thread_finish_setup(avctx); } } while (s->pass++ == 1); - ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0); + ff_progress_frame_report(&s->s.frames[CUR_FRAME].tf, INT_MAX); if (s->td->error_info < 0) { av_log(avctx, AV_LOG_ERROR, "Failed to decode tile data\n"); @@ -1767,13 +1747,8 @@ static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, finish: // ref frame setup - for (i = 0; i < 8; i++) { - if (s->s.refs[i].f->buf[0]) - ff_thread_release_ext_buffer(&s->s.refs[i]); - if (s->next_refs[i].f->buf[0] && - (ret = ff_thread_ref_frame(&s->s.refs[i], &s->next_refs[i])) < 0) - return ret; - } + for (int i = 0; i < 8; i++) + ff_progress_frame_replace(&s->s.refs[i], &s->next_refs[i]); if (!s->s.h.invisible) { if ((ret = av_frame_ref(frame, s->s.frames[CUR_FRAME].tf.f)) < 0) @@ -1792,7 +1767,7 @@ static void vp9_decode_flush(AVCodecContext *avctx) for (i = 0; i < 3; i++) vp9_frame_unref(&s->s.frames[i]); for (i = 0; i < 8; i++) - ff_thread_release_ext_buffer(&s->s.refs[i]); + ff_progress_frame_unref(&s->s.refs[i]); if (FF_HW_HAS_CB(avctx, flush)) FF_HW_SIMPLE_CALL(avctx, flush); @@ -1814,42 +1789,18 @@ static av_cold int vp9_decode_init(AVCodecContext *avctx) } #endif - for (int i = 0; i < 3; i++) { - s->s.frames[i].tf.f = av_frame_alloc(); - if (!s->s.frames[i].tf.f) - return AVERROR(ENOMEM); - } - for (int i = 0; i < 8; i++) { - s->s.refs[i].f = av_frame_alloc(); - s->next_refs[i].f = av_frame_alloc(); - if (!s->s.refs[i].f || !s->next_refs[i].f) - return AVERROR(ENOMEM); - } return 0; } #if HAVE_THREADS static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src) { - int i, ret; VP9Context *s = dst->priv_data, *ssrc = src->priv_data; - for (i = 0; i < 3; i++) { - if (s->s.frames[i].tf.f->buf[0]) - vp9_frame_unref(&s->s.frames[i]); - if (ssrc->s.frames[i].tf.f->buf[0]) { - if ((ret = vp9_frame_ref(&s->s.frames[i], &ssrc->s.frames[i])) < 0) - return ret; - } - } - for (i = 0; i < 8; i++) { - if (s->s.refs[i].f->buf[0]) - ff_thread_release_ext_buffer(&s->s.refs[i]); - if (ssrc->next_refs[i].f->buf[0]) { - if ((ret = ff_thread_ref_frame(&s->s.refs[i], &ssrc->next_refs[i])) < 0) - return ret; - } - } + for (int i = 0; i < 3; i++) + vp9_frame_replace(&s->s.frames[i], &ssrc->s.frames[i]); + for (int i = 0; i < 8; i++) + ff_progress_frame_replace(&s->s.refs[i], &ssrc->next_refs[i]); ff_refstruct_replace(&s->frame_extradata_pool, ssrc->frame_extradata_pool); s->frame_extradata_pool_size = ssrc->frame_extradata_pool_size; @@ -1889,7 +1840,7 @@ const FFCodec ff_vp9_decoder = { .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS, .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_SLICE_THREAD_HAS_MF | - FF_CODEC_CAP_ALLOCATE_PROGRESS, + FF_CODEC_CAP_USES_PROGRESSFRAMES, .flush = vp9_decode_flush, UPDATE_THREAD_CONTEXT(vp9_decode_update_thread_context), .p.profiles = NULL_IF_CONFIG_SMALL(ff_vp9_profiles), diff --git a/libavcodec/vp9_mc_template.c b/libavcodec/vp9_mc_template.c index e654c0e5ed..81e4ed59c7 100644 --- a/libavcodec/vp9_mc_template.c +++ b/libavcodec/vp9_mc_template.c @@ -36,7 +36,7 @@ static void FN(inter_pred)(VP9TileData *td) const VP9Context *s = td->s; VP9Block *b = td->b; int row = td->row, col = td->col; - const ThreadFrame *tref1 = &s->s.refs[s->s.h.refidx[b->ref[0]]], *tref2; + const ProgressFrame *tref1 = &s->s.refs[s->s.h.refidx[b->ref[0]]], *tref2; const AVFrame *ref1 = tref1->f, *ref2; int w1 = ref1->width, h1 = ref1->height, w2, h2; ptrdiff_t ls_y = td->y_stride, ls_uv = td->uv_stride; diff --git a/libavcodec/vp9block.c b/libavcodec/vp9block.c index 5743f048cc..3a694763ce 100644 --- a/libavcodec/vp9block.c +++ b/libavcodec/vp9block.c @@ -22,8 +22,9 @@ */ #include "libavutil/avassert.h" +#include "libavutil/frame.h" -#include "threadframe.h" +#include "progressframe.h" #include "vp89_rac.h" #include "vp9.h" #include "vp9data.h" @@ -113,7 +114,7 @@ static void decode_mode(VP9TileData *td) uint8_t *refsegmap = s->s.frames[REF_FRAME_SEGMAP].segmentation_map; if (!s->s.frames[REF_FRAME_SEGMAP].uses_2pass) - ff_thread_await_progress(&s->s.frames[REF_FRAME_SEGMAP].tf, row >> 3, 0); + ff_progress_frame_await(&s->s.frames[REF_FRAME_SEGMAP].tf, row >> 3); for (y = 0; y < h4; y++) { int idx_base = (y + row) * 8 * s->sb_cols + col; for (x = 0; x < w4; x++) diff --git a/libavcodec/vp9dec.h b/libavcodec/vp9dec.h index 013aac49eb..81dc801052 100644 --- a/libavcodec/vp9dec.h +++ b/libavcodec/vp9dec.h @@ -29,8 +29,8 @@ #include #include "libavutil/mem_internal.h" +#include "libavutil/pixfmt.h" #include "libavutil/thread.h" -#include "libavutil/internal.h" #include "get_bits.h" #include "videodsp.h" @@ -120,7 +120,7 @@ typedef struct VP9Context { int w, h; enum AVPixelFormat pix_fmt, last_fmt, gf_fmt; unsigned sb_cols, sb_rows, rows, cols; - ThreadFrame next_refs[8]; + ProgressFrame next_refs[8]; struct { uint8_t lim_lut[64]; @@ -245,7 +245,7 @@ void ff_vp9_decode_block(VP9TileData *td, int row, int col, VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl, enum BlockPartition bp); -void ff_vp9_loopfilter_sb(AVCodecContext *avctx, VP9Filter *lflvl, +void ff_vp9_loopfilter_sb(struct AVCodecContext *avctx, VP9Filter *lflvl, int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff); void ff_vp9_intra_recon_8bpp(VP9TileData *td, diff --git a/libavcodec/vp9lpf.c b/libavcodec/vp9lpf.c index 414cede852..afeebebf59 100644 --- a/libavcodec/vp9lpf.c +++ b/libavcodec/vp9lpf.c @@ -21,6 +21,7 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ +#include "avcodec.h" #include "vp9dec.h" static av_always_inline void filter_plane_cols(VP9Context *s, int col, int ss_h, int ss_v, diff --git a/libavcodec/vp9mvs.c b/libavcodec/vp9mvs.c index b93d878d6f..b706d1660f 100644 --- a/libavcodec/vp9mvs.c +++ b/libavcodec/vp9mvs.c @@ -21,7 +21,7 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#include "threadframe.h" +#include "progressframe.h" #include "vp89_rac.h" #include "vp9data.h" #include "vp9dec.h" @@ -175,7 +175,7 @@ static void find_ref_mvs(VP9TileData *td, VP9mvrefPair *mv = &s->s.frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col]; if (!s->s.frames[REF_FRAME_MVPAIR].uses_2pass) - ff_thread_await_progress(&s->s.frames[REF_FRAME_MVPAIR].tf, row >> 3, 0); + ff_progress_frame_await(&s->s.frames[REF_FRAME_MVPAIR].tf, row >> 3); if (mv->ref[0] == ref) RETURN_MV(mv->mv[0]); else if (mv->ref[1] == ref) diff --git a/libavcodec/vp9recon.c b/libavcodec/vp9recon.c index 073c04b47d..ef08ed17c8 100644 --- a/libavcodec/vp9recon.c +++ b/libavcodec/vp9recon.c @@ -22,9 +22,10 @@ */ #include "libavutil/avassert.h" +#include "libavutil/frame.h" #include "libavutil/mem_internal.h" -#include "threadframe.h" +#include "progressframe.h" #include "videodsp.h" #include "vp9data.h" #include "vp9dec.h" @@ -298,7 +299,7 @@ void ff_vp9_intra_recon_16bpp(VP9TileData *td, ptrdiff_t y_off, ptrdiff_t uv_off static av_always_inline void mc_luma_unscaled(VP9TileData *td, const vp9_mc_func (*mc)[2], uint8_t *dst, ptrdiff_t dst_stride, const uint8_t *ref, ptrdiff_t ref_stride, - const ThreadFrame *ref_frame, + const ProgressFrame *ref_frame, ptrdiff_t y, ptrdiff_t x, const VP9mv *mv, int bw, int bh, int w, int h, int bytesperpixel) { @@ -314,7 +315,7 @@ static av_always_inline void mc_luma_unscaled(VP9TileData *td, const vp9_mc_func // we use +7 because the last 7 pixels of each sbrow can be changed in // the longest loopfilter of the next sbrow th = (y + bh + 4 * !!my + 7) >> 6; - ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0); + ff_progress_frame_await(ref_frame, FFMAX(th, 0)); // The arm/aarch64 _hv filters read one more row than what actually is // needed, so switch to emulated edge one pixel sooner vertically // (!!my * 5) than horizontally (!!mx * 4). @@ -336,7 +337,7 @@ static av_always_inline void mc_chroma_unscaled(VP9TileData *td, const vp9_mc_fu ptrdiff_t dst_stride, const uint8_t *ref_u, ptrdiff_t src_stride_u, const uint8_t *ref_v, ptrdiff_t src_stride_v, - const ThreadFrame *ref_frame, + const ProgressFrame *ref_frame, ptrdiff_t y, ptrdiff_t x, const VP9mv *mv, int bw, int bh, int w, int h, int bytesperpixel) { @@ -353,7 +354,7 @@ static av_always_inline void mc_chroma_unscaled(VP9TileData *td, const vp9_mc_fu // we use +7 because the last 7 pixels of each sbrow can be changed in // the longest loopfilter of the next sbrow th = (y + bh + 4 * !!my + 7) >> (6 - s->ss_v); - ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0); + ff_progress_frame_await(ref_frame, FFMAX(th, 0)); // The arm/aarch64 _hv filters read one more row than what actually is // needed, so switch to emulated edge one pixel sooner vertically // (!!my * 5) than horizontally (!!mx * 4). @@ -407,7 +408,7 @@ static av_always_inline void mc_luma_scaled(VP9TileData *td, vp9_scaled_mc_func const vp9_mc_func (*mc)[2], uint8_t *dst, ptrdiff_t dst_stride, const uint8_t *ref, ptrdiff_t ref_stride, - const ThreadFrame *ref_frame, + const ProgressFrame *ref_frame, ptrdiff_t y, ptrdiff_t x, const VP9mv *in_mv, int px, int py, int pw, int ph, int bw, int bh, int w, int h, int bytesperpixel, @@ -444,7 +445,7 @@ static av_always_inline void mc_luma_scaled(VP9TileData *td, vp9_scaled_mc_func // we use +7 because the last 7 pixels of each sbrow can be changed in // the longest loopfilter of the next sbrow th = (y + refbh_m1 + 4 + 7) >> 6; - ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0); + ff_progress_frame_await(ref_frame, FFMAX(th, 0)); // The arm/aarch64 _hv filters read one more row than what actually is // needed, so switch to emulated edge one pixel sooner vertically // (y + 5 >= h - refbh_m1) than horizontally (x + 4 >= w - refbw_m1). @@ -467,7 +468,7 @@ static av_always_inline void mc_chroma_scaled(VP9TileData *td, vp9_scaled_mc_fun ptrdiff_t dst_stride, const uint8_t *ref_u, ptrdiff_t src_stride_u, const uint8_t *ref_v, ptrdiff_t src_stride_v, - const ThreadFrame *ref_frame, + const ProgressFrame *ref_frame, ptrdiff_t y, ptrdiff_t x, const VP9mv *in_mv, int px, int py, int pw, int ph, int bw, int bh, int w, int h, int bytesperpixel, @@ -514,7 +515,7 @@ static av_always_inline void mc_chroma_scaled(VP9TileData *td, vp9_scaled_mc_fun // we use +7 because the last 7 pixels of each sbrow can be changed in // the longest loopfilter of the next sbrow th = (y + refbh_m1 + 4 + 7) >> (6 - s->ss_v); - ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0); + ff_progress_frame_await(ref_frame, FFMAX(th, 0)); // The arm/aarch64 _hv filters read one more row than what actually is // needed, so switch to emulated edge one pixel sooner vertically // (y + 5 >= h - refbh_m1) than horizontally (x + 4 >= w - refbw_m1). diff --git a/libavcodec/vp9shared.h b/libavcodec/vp9shared.h index b445a2a746..805668416f 100644 --- a/libavcodec/vp9shared.h +++ b/libavcodec/vp9shared.h @@ -29,8 +29,8 @@ #include "libavutil/mem_internal.h" +#include "progressframe.h" #include "vp9.h" -#include "threadframe.h" enum BlockPartition { PARTITION_NONE, // [ ] <-. @@ -63,7 +63,7 @@ typedef struct VP9mvrefPair { } VP9mvrefPair; typedef struct VP9Frame { - ThreadFrame tf; + ProgressFrame tf; void *extradata; ///< RefStruct reference uint8_t *segmentation_map; VP9mvrefPair *mv; @@ -164,7 +164,7 @@ typedef struct VP9BitstreamHeader { typedef struct VP9SharedContext { VP9BitstreamHeader h; - ThreadFrame refs[8]; + ProgressFrame refs[8]; #define CUR_FRAME 0 #define REF_FRAME_MVPAIR 1 #define REF_FRAME_SEGMAP 2 From patchwork Mon Apr 8 20:13:44 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47944 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp135797pzb; Mon, 8 Apr 2024 13:15:19 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCWISIZd3eKdYKHbWJug2dr+ISqdypOx5da64bmslB3eGqrTr+P0uzlFqSpO3Uw6gvDtlovkCe4S/h/ZrCe48lCWjJzpnqlXS0LybA== X-Google-Smtp-Source: AGHT+IEt5kv1w7dE/C1BtlKGzd8nVkYv89mylOK/d5y3NUCLnCWOcSjpEl8xemsc8jloSfBZTxpa X-Received: by 2002:a19:e019:0:b0:513:c428:9daa with SMTP id x25-20020a19e019000000b00513c4289daamr6287113lfg.0.1712607319186; Mon, 08 Apr 2024 13:15:19 -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 i22-20020a170906265600b00a4720ded990si3909687ejc.305.2024.04.08.13.15.18; Mon, 08 Apr 2024 13:15:19 -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=@outlook.com header.s=selector1 header.b=kpbSnshV; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 4D69268D37D; Mon, 8 Apr 2024 23:15:04 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2073.outbound.protection.outlook.com [40.92.66.73]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 5A5EB68D352 for ; Mon, 8 Apr 2024 23:15:01 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=BQEJ8PGfDe3l3PNvz69Pvnxhpwp6j6R5p8gXbuLL1W+ndmKLp92AdrPg7G3C0u8k2hxpJUtr4oSZYZQ9MAG+xgcpSvV9LgMtu58Iy3xIwBc5F2jPrO6Z2iNVurYbBwm6s5TYYotp676mliFq8H8r8Kw2Ne51RwF9EMa3J5C3h/8h0ZN7uH08D3biqUF1iDB2si02z2t9HGUS3V+9Mbn3RrgpCiUyuKVqZBysP1k+iMoFyYhLRT3mUgAAhq3ywjOdwj4KWiuFkW+kP6OYY52q9wSIK1ezYSKu8FUIAjajuJiFsA3HkslA2z9tkXDm/7PGmsKWG1SsZfuvKzFbhLLGWA== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=7NdU7vnDYhuhI36eodouxYfJfgX4KZ6lfTP/pulXJ9E=; b=RbJXC4yK8HYrz2tkGwxpr1xZvjzobBHyQsFDKEN4qgZGboqBW8LHSziBCQUe5mdvN9+M3tTZyuUq3uHJA2qCTME/1wYQLqDjzaZNJPQ0g4jwyM9d8zCKad5tfuc3bIk7+2ntIE5953K1RlTB3HiJie91TJ7rdEon4TQ1aVMHusYf+kCgxeZ08fCjpM++0NElWlQmgDxeUNNXgoO0nxSslWoq6R4YLpTLdXS9H8MX0EHX69v959lq2rEoZq4xdcb8HmOwyQCd5Gvg8KUyKdIasqxE8gBdbMi0WxZUQneQAMAKT4WMh8tbOrUsAjyc12xEhVC4DEomhQjktqqIQAye/w== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=7NdU7vnDYhuhI36eodouxYfJfgX4KZ6lfTP/pulXJ9E=; b=kpbSnshVDJ/nWW/tE+7Jvi9uKTKS/jOq1240/OMkYfr1LCRxCBMSmiM7b2n2I7mzqH0DXCSe1tdVJrxc4VP3ZQUFVkLucZNwG2+VOqgeE9+gfp6rFvkJU+S766IclKRoqu2C0PIxWzwi0KIK2uS2sYyBcC7l2jigvYnHkxeGct+lMM7VfJtCYfer/jGiA9IPgExgtsbhpLotZnjrMeR7BQVKGNdvHzs0HziTFSH0jNRfGNHhOycvP4+zFjFtIL2WrOgEXa1w3Eh17turHgcSxNOCE6HtglsXzVhpXMT1oiSQFso/ew99umiX+Uu9dF6/IcbWieAzbRVMS6z7eLbp9g== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:14:59 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:14:59 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:44 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [BzApZGA/HKWOqY/kW+WVC1LcVRm4s8mW1Q+9ZThYIrA=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-5-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 714d5516-7e5b-4603-f942-08dc58088fb9 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: mB177/u8m9x428I3CwnQhkbktytfu9Ta9tnlG26i6HirNYNUzvKF0PZVSTdZRFFtcQKaS/uWCXNTGgql0QVp5mR+3iMHTcmLoQNb0O2h7BPxWy7wDV5DJujKF3mIylKwC8KN/e3Wn2A6TWioPGI7PuRt6J8gcot2fdXOtEaD7Qh2KBvLnjX7PajGoOInJb65zevwrwB0U8WQVWZAwRHK70xFOSOq+LTCiPrr78Mv0BPHS19iGY/RyzZTcs29LQVS8o/1VJ67m6wlzAto4xODmG/NxsHizjvDfGjAxy65ubBFJr4+W+sNqcRpDNM3AiWNYaeWfp/qOWUnrtF44k1JZ9o7ITAOrDzvRVedeRrOlgQURzlKqJ6TLuvn75Y6oLi3rn9K2rbxfj2C25GU9aTbIA/6wKDgkvvrCq8pIfpkJgfFXj8UJn8u0eo5M9z3T92LDG4uukwpMiqRcJIk23ZQkZeUOq5OE9O8nC90BTjt2L2GVOeJEq0IkS0nH7efsHFXfqyIUWJTBSJYzKdBg44wc+SQvAQTI6GjNqYaGHfVYDNLFc6ZuGjKA4hxIY1KEixS7UmyXL2frnUqKNYDYVQ91H/T1hGe1BSKiwH8QIAu2Qb+2sVWgBuaf26UYCs4hCJx X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: 3Wn6X/nZnr8BRicHJQnjumq6ogafl1qALk3qSw/+VbpOmiJsckO3mfKkumyRwstJcOjHuyxhMX9r0P2JBN2uLTHuAdB0eH8I0vAphKWHSsubDAML6okJ3e4nDmxFJ4wDTX6NNYDs3liQTSESLDMKtzK2OsIpn63xg1CW6qw4BmEv23KwsrdbFLFMCTw7myRs68Bz6UT1z563fbl88oTsXaUEW+4f8APQuR+oIpE57FWXV4XB6ZVlkJb7+WjslRiSjZlZvlMBQ1oCwOOYbxFQIOzDR2DdPo6NGPmR/1VDn7ojuvlO+JaBEBs+UaVmwn1B/mkj6MG3Dc0Cb9QQFI6s9npKkE0IupN2XAaS0yDbXLqX6fhimY45iytsq3U+nqRQzKRbQA/xZ0RR8VfKnMG7NSvTqs13d3iQI5HraaQ2Uun3Y1CkwxDNvbunNp/gtpN1AGptWTsVK846mjHKzcnZHx15LBo3Mn77R310BGmqTBOyJOQgPJAF0c1rUrp7IwdpSq8cUZFke27OCgwfNpx7EMaT496g7aQ0xEmPlugO10lEmBL3iq871K+2nkk2LxetqVGNmn2JkcqrKC/+iZtOzrVXH2s90jp+1I+ehdDj7uzzw7xUDecYix1GlhKK1JOF18ixknmcy1O1y8GOZasec3YYtpQezBe/rX2/7Ii3KxtXxbKcQ+G3qg5b+/UbQ/WP37PDrsEm9T1y4EZvLYxTbdu7ZVSS34FuG4kSHCTuzEhiNiv8tGCBryFKUhkECsShGzkNN8Nor2o4Uni5BWqRaWmq744LakzK6bNebd9NdfGWvQZqTO4VAxxkYFz50Msi0wGDcZgZWCrLz/yHZvrjhHtIaL+7H0z9f/HaQz5EoeweL6lsy0D8Q5NdFs+aQ1NSRgmRC4VWXEYPGo80BZQFqshXdjWvT0AdYBCCKkAWzFArOdDxPCfeVpFUkQDy7edKtH00PsT2Uw3d2T4z3GH8rHseCMPlcrq5lH82ckadLtvxCi7gHanhltxDi+3DfaSgE7B2c81KNiXNDpeS7H5poSONtuVuh+2+pLQHJzn1jtiCsFC5343J0tFpYdxFFjvUmTeGK4r4BEM6/IxFXksba102zVHRrgIWoD/448Mp1uBdjBxIq5xq4iqxJPwZlrI/q00yLWIScDDxukIGjkQyUhddn9dQHPnqSPPrhLM0bj8DWBn1rO5G8kDL0cXZbnb84iFCPsogGZSyuzJuOOfTFyuwzxI0vNuYjRKFFHzTLQ/t+BzCLorIzrzXTD1K/Mi1EnrrVhNc2yZFw3P4f6PHRA== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 714d5516-7e5b-4603-f942-08dc58088fb9 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:14:57.5774 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 06/27] avcodec/vp9: Fix race when attaching side-data for show-existing frame 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: r1gOxWua+duX When outputting a show-existing frame, the VP9 decoder simply created a reference to said frame and returned it immediately to the caller, without waiting for it to have finished decoding. In case of frame-threading it is possible for the frame to only be decoded while it was waiting to be output. This is normally benign. But there is one case where it is not: If the user wants video encoding parameters to be exported, said side data will only be attached to the src AVFrame at the end of decoding the frame that is actually being shown. Without synchronisation adding said side data in the decoder thread and the reads in av_frame_ref() in the output thread constitute a data race. This happens e.g. when using the venc_data_dump tool with vp90-2-10-show-existing-frame.webm from the FATE-suite. Fix this by actually waiting for the frame to be output. Signed-off-by: Andreas Rheinhardt --- libavcodec/vp9.c | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/libavcodec/vp9.c b/libavcodec/vp9.c index bd52478ce7..e0bc313301 100644 --- a/libavcodec/vp9.c +++ b/libavcodec/vp9.c @@ -1569,6 +1569,8 @@ static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, av_log(avctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref); return AVERROR_INVALIDDATA; } + ff_progress_frame_await(&s->s.refs[ref], INT_MAX); + if ((ret = av_frame_ref(frame, s->s.refs[ref].f)) < 0) return ret; frame->pts = pkt->pts; @@ -1715,10 +1717,8 @@ static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, #endif { ret = decode_tiles(avctx, data, size); - if (ret < 0) { - ff_progress_frame_report(&s->s.frames[CUR_FRAME].tf, INT_MAX); - return ret; - } + if (ret < 0) + goto fail; } // Sum all counts fields into td[0].counts for tile threading @@ -1732,18 +1732,19 @@ static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, ff_thread_finish_setup(avctx); } } while (s->pass++ == 1); - ff_progress_frame_report(&s->s.frames[CUR_FRAME].tf, INT_MAX); if (s->td->error_info < 0) { av_log(avctx, AV_LOG_ERROR, "Failed to decode tile data\n"); s->td->error_info = 0; - return AVERROR_INVALIDDATA; + ret = AVERROR_INVALIDDATA; + goto fail; } if (avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS) { ret = vp9_export_enc_params(s, &s->s.frames[CUR_FRAME]); if (ret < 0) - return ret; + goto fail; } + ff_progress_frame_report(&s->s.frames[CUR_FRAME].tf, INT_MAX); finish: // ref frame setup @@ -1757,6 +1758,9 @@ finish: } return pkt->size; +fail: + ff_progress_frame_report(&s->s.frames[CUR_FRAME].tf, INT_MAX); + return ret; } static void vp9_decode_flush(AVCodecContext *avctx) From patchwork Mon Apr 8 20:13:45 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47945 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp135860pzb; Mon, 8 Apr 2024 13:15:28 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCWj07IBt5KQyUmxTtM0fn7wHOc4Z84M29Nxyup5BADK9jLjy3qhg8LQKCi8A53IkB5H+TvZmIEiM2FI5Tq3PSDorvdyrxqRf1xxug== X-Google-Smtp-Source: AGHT+IGaruy6nhptpCrGoZBsAytPvfTd5sw0Z/v+t9xAjPglB7phurggUX9X8qVGclh+waSjdAoz X-Received: by 2002:a2e:8088:0:b0:2d8:319b:7d34 with SMTP id i8-20020a2e8088000000b002d8319b7d34mr6523255ljg.2.1712607328138; Mon, 08 Apr 2024 13:15:28 -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 f26-20020a50d55a000000b0056e32427d2fsi3689287edj.144.2024.04.08.13.15.27; Mon, 08 Apr 2024 13:15:28 -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=@outlook.com header.s=selector1 header.b=mgMRBpuM; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 49C9168D352; Mon, 8 Apr 2024 23:15:05 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2073.outbound.protection.outlook.com [40.92.66.73]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 74FF268D358 for ; Mon, 8 Apr 2024 23:15:01 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=kBFEL5FP7qha5UFs29G4hn091eGnE0P+C2mpI4E0nyBbU8DZFsijw7T5iAt/FaBR+iJdqIp3jYd8zsPcM9eFDSxSFyomaMv+oFDThvpuSLogHRw51t7Ekd7EwgHzwSDNxfAHE2Hs6dpPAvoR9flImn7Zh0inEo0gw6HS0tgnzoY6DTqbmok34XTXHkY65Fot6YvRPfYdhJSLMPaFMqJvTw1lTFmkRiE4o7H27OX2GFWi+oAqj9QUj5VhFBOx4PGY3LhESLmaH/wReigEKHr8mXjcqXl01ydhomAdmAcx88TmAvmBcWzBTm6S6kB942zlrKxFiUbYtEEcTNiPs6VaIw== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=aDAuu+eUzCos29YUwqLMSrupY+MXOwS+XpT2UNnhS6Y=; b=JGWj9RIaKtU4l86vvzVxttolIt32M1sc/+EFAWRCn3Pdpr9Gl7GjzoDyMMV1xBaYjS2NbZ419mDZypKLi51gakUo5YQtQYGVXdW7k0DqzZfz1LvdoCqJjh1ieq2EEKRhM15nZ/nJOilmIsXsQFkk7l9gUplW2yIzhEmUdIVuu3uWNyVdWn/T10/fPaq9TdcSuxa+QmfJtvtRJOfwpFJ8KJV7oCEJ0H7sQ12MqcylNTOpemuyEb4OKmJUUE8UkGm8U9LHoTi7FedcJllK2+XLb2Q4gs26JEC+GKqRE7gV+uHg/lWyq6hFg9MULF8qXb85/kbU+B3MqbT6gDStoNIdWw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=aDAuu+eUzCos29YUwqLMSrupY+MXOwS+XpT2UNnhS6Y=; b=mgMRBpuMCxOT3ZE0QzQ6g0U7qBpZpJoDaHrbXbGEs7DGKSJ3Axnge0cHtX4CsNj1hZX6DXGpU8RGWo8DkgkU745w+Nayd1d0HjHh6Q/ynIKKbZdyVvfEpRZauIKcXt1woxjODSHtKDDIDccgO3L5RevwExL1WhiKDrlk1e7rdKn/LwCgFNa/Pbmq60AZLg4IBXVGzWk1SrJ7TWYgV2aMoNVYGsGjMuLZAFl8LxPoAO84NzGEuReaNiK34OJMQFF4x2t5bAgn+y/UXoFkkd2rhfQWu27oXKOjV05vlTmNqsAKiybNNZlPeMRkoea8fzqggsuIQ1JTfLlop8sDsCSQ8A== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:14:59 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:14:59 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:45 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [85RIAIr/JfTERe2I7FA5qVxnIjumJkAxoaEQuxXx1dM=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-6-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 2ee44fca-defd-4ae0-3993-08dc5808909c X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: ydLm+TYjxP8OuDCNnPu1FoXR8dq84wR8mWOMBf+PnFL697FAAluTeO6ghweHP5J4k/hfu2kTMIQRr4zfv4rRcjx0rB+KMD7Glt26k7j0f7QOpmdVSSfgF40wuakLfwaY5lskRaPtZHKjNiWlY0jpiDK+AlbNAEhArR6rwo4B9ip+uk+/b+4YBdBZraIdNrGEmV4kR6003qI81Fr4qov4AnL5jBgknlyNuaap4o4/eFqS29svquNs+l+fWgZxE8J7z8b8AsFpexwiyJn94sYgwmvH0h7mltdfhs9UzAejA4Q9uHOUu8vQB/z4I8ZuO8ENt480GioGTt0E/pZpuFTZreuXN3WNYJQUWoqkc2B14VLYMhR7HiitaJaJ9SxAEgZ+/8z/9Js+nu4yAqG9nzLFBC9qgXLo3nvmTNfG+oo53Tyjm68W0nBT7+RCEw+3PgPMauhmRnAD/fYO1oJioWP930jdz5nKhhOK31HSRkFVYB8TAIUwDdaxYC4n0aQGHV1R21cer6f1f4Ca6PRoZiHZM2VRhECYNY2qKFQHeuibRkmznAUjYLMloF7SyuhP8KZmg2fH6Uul9/smscaNyup2fls0H9VqFgOyXrwDw6qUvIhjC7Ejj5G6XkG+njNUW5vX X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: kdBQ04qF1FKjSBH2QLW5loqZnJ6QNBCDWteKjqPDoHyHg8nChH/zs4Z1OMCmOFa3suJNIgtl1zKEZL2DOKSBHmvX/a2LZfBXn1/yYIx1+YFbLllgZya4VmAyX2GHBqE5UOMNcvitOrqwnqBhVe3qxcQCaTMNB/y9YcmqxuyamwfzXm07X4T2N4aLRMzGg57IimfhCaPQX2cvIwUDWeeMeO/gjVJg9LrIEYYXNSmFZ9jTgWNMYk1+P7LSucUqNu9A+n8v+q7ljX59jFTlPEXclNMGvOyXtBNc5POoziLzBZV8M4A8FvkPVKBhEZSoC4Cac9yaI//Jux1seToOGDDDFFw/59DKD36lu9xYTJRcxUEXvnLKZazX+5d6X/Y7OfH89YWJ8vC4sBBbgTD/WwY9Le5lpRFxPikW/5tc2bSQvdHBSPqok7rG5NEEDyOz8zG9AqaaYbUXRKaup2Z33ouUtoqloXykExQkLE5HIW1Jx+2CquJyotduNGt34Pd1+ccs/EK1873dGUm2eGBhYfCTEyJaqxpcTkyfBM+J0dtxXIfXv2vjsGDMec4vO2FJRBOWbgtKKf/5rZDCnTGVtMDaZqCVMc2n3uYalVEoRGYiajJvbcKT/DqCwPAx7ojJWKyYVxEeXACYOHRX3now82M00SEpxFXfmT2ZIzIPrWn1e+FUWg+Mq5thuLHeWx31pcpxGS2liv+zRojfWwDk3dcE7AMciFrHItH5lqZRP8M+UsF7vpAaX+4kuVYyeWLAFapGBJnb/jw+36he59M1/YgEsdLNv3fDKkREmhXI1bH4/DbKYm1tpjOXXcKh+yCJtrSLV1wMNOKeXy/pczMJ7dJ3EqVLUAq2g+IiprjbqIFpVr1NT00wWCGhHkUyip62rpLqubGvCfFyPmEvGMyE9F3aSTgrPt86sp16q9igpMEChjzZ5HHWhQ4ciYHfjyrtP+WJ7e3eCy6gu6cgG9R2fkN1l2BbWXoixV6i0SRUG/top6tZe6dxAnRpm+z09LbDZQUO4XDynM3HUbRyYDrW/2zeb05pT9/fwa4CpvpTVatHEpptfxscqgXnmYxjr0GXhlbeUkX75bcDarv/VH9S/ARt9d6820OvMhzxtXBDKYOPA9AjahVudUni+RdfTMzeUt97KVUsIbbZdiMpHNimfZ0wDkobK7PwDgMZoBfvgeeur0xrnFB6jdX+mYVkagRTvHO21BxFDuxq6aGsjbxR2FEaks2QKLfob6gjzofSFduoS2JO5vSQm0khuuh2h5sGdujf3Ku3km++MwaInwY1IHxfNw== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 2ee44fca-defd-4ae0-3993-08dc5808909c X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:14:59.1413 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 07/27] avcodec/vp9: Reduce wait times 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: MFF/HCDakTku Signed-off-by: Andreas Rheinhardt --- libavcodec/vp9.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/libavcodec/vp9.c b/libavcodec/vp9.c index e0bc313301..bdfa543188 100644 --- a/libavcodec/vp9.c +++ b/libavcodec/vp9.c @@ -1569,14 +1569,15 @@ static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, av_log(avctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref); return AVERROR_INVALIDDATA; } + for (int i = 0; i < 8; i++) + ff_progress_frame_replace(&s->next_refs[i], &s->s.refs[i]); + ff_thread_finish_setup(avctx); ff_progress_frame_await(&s->s.refs[ref], INT_MAX); if ((ret = av_frame_ref(frame, s->s.refs[ref].f)) < 0) return ret; frame->pts = pkt->pts; frame->pkt_dts = pkt->dts; - for (int i = 0; i < 8; i++) - ff_progress_frame_replace(&s->next_refs[i], &s->s.refs[i]); *got_frame = 1; return pkt->size; } From patchwork Mon Apr 8 20:13:46 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47946 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp135949pzb; Mon, 8 Apr 2024 13:15:37 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCVTtmMfBIF5gzwd6BZPMKyuuFpsXFPojQJ9KQ4NsOPDxmF9UW0LADkUQWa4cuk1bibY9L94QHjgjOVepZK6e/o6Tt0BbJYtiEbwBQ== X-Google-Smtp-Source: AGHT+IE0niyogysF+2yMEuIjq7fECqcbjwWm0Ac3H9WPMPTjE6FXsC/SrgLO1ynI6tKMk4wbM/cN X-Received: by 2002:a05:6512:3154:b0:516:c422:ab1f with SMTP id s20-20020a056512315400b00516c422ab1fmr5982734lfi.4.1712607336822; Mon, 08 Apr 2024 13:15:36 -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 ck7-20020a170906c44700b00a5196a15dd1si3781211ejb.176.2024.04.08.13.15.36; Mon, 08 Apr 2024 13:15:36 -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=@outlook.com header.s=selector1 header.b="bki/nokG"; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 4E97268D391; Mon, 8 Apr 2024 23:15:06 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2073.outbound.protection.outlook.com [40.92.66.73]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 9F9D168D352 for ; Mon, 8 Apr 2024 23:15:01 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=kfLXkJ+44//JapzjdE4YMWgIRIgj9NjYeHDdhC1WKqvyIQZ+/b90TyI4Eimw1bX4TV8dRQARQfcDaaw0aaYs8DaRUra7rlF7vhFmaTxFOQfnhFSvVZ5Fd5IEYeqJKqEq1g/vmQq9WMIKK02wXQMSCrX0Q4744hZmxRSiVFv2HBcnrXqjDm52DI/z5RTo9nHxk1DI9S0wD/I5CblU6VsW6in4hFADvgsOrtT8HnxPBHGTs6Eu7UofqhJmpyPCUKSASFUihc/93rRd5cyfL+jmuvAgzaOU7btNER/chYCubBhFzV5Zl1/QBc6nhEERIqX6gtFKFFITxyKGOxA2U41rmg== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=lFLIaQBuwNkCp4YDja6ZV1H/pkryIVEN0qBPCQw4C3Q=; b=gMcLz3A9tN7SPQtitXIM0wFMcuCvjGPPJIgxiyKNzouVwIGWVJG17BP4UlvjWhyXqQKV0xM7YeIpX/fVo/9ZrPwyB87w8mmaCeSYSF7kVlshi9CdOVyexyzYG6f/jkW1XG7A5zDW6RanxYqhp+hrV0s7vk0K8Qb63NzTHVwr929r42wnMHd1MQ8mS/0MK5Cyh0MgXeWgzlzDiZ/l8YwptKY31UOj+GDrddVEEuq1kZSaUUk9mzr7zexKzisdAvr3VMrLKSAm8GvVGatw/LtLDOJXa59a9afIMQXWWcjVj9PBE3RmOC5K4omar+nIM5ubwfvIhRSaGt2W7PrpUWm7Sg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=lFLIaQBuwNkCp4YDja6ZV1H/pkryIVEN0qBPCQw4C3Q=; b=bki/nokGI+U2fTMkcLKW34dljv2v639JKFXjcNDuiLPJ1VwG/xaCwKGzs5HvyPFR/50wWjX8p8XpRKDMtuPMlKjsjXwEfkInXaZaRG1vgbOI3e3ZAycWmLM84LoXO3/6tjUlsHBc1LEFuSXCED4MTsXAiVmIl4I9PW66t4+EPSmA2eq/HTGbwS23ymLvL1QyyTqc+ygPKDZLWd/Vdgwg4sJuVQj6Vnee82iVdgRyYCKcK+WwBNN4Rr9a1IgodZY69KbkNXy4x+oouN4JKL6zOBxgVzrl3v7diveSLsaJiPlF2Frm7Hu28/dbE9lJ7CEzCRMnsX2dwRXM7qwOye6M4A== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:15:00 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:15:00 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:46 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [sxkWN7mgGjniIjSk0Ehe2Tod3bvfRTBBf2P+lGy5R5s=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-7-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: dbb194c5-1c26-4908-fb15-08dc5808917a X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: Am0WAy1WNQe56y7FWJMNP1jNIPB/4xKJl+r/ISmLSaCrwIAJNy6GJihga9OoN7olA3Kw0kRB49sxZzGLntGyTBSsdOyi+Ns/mIB4U5mwXb+X8ChUUWuPhPLKX001hcQJ2SC60pnW0C7XiKDtXCHvirTKr7eBvMPEfJNyn4uVyfHKTssCZ+OtWvRn57lvzo+QucxgCJkG0vQIJavJEfVODNKTyIVWGLOMaoplrwvpp0LmRBC6loS23IZdV8I5StgO5rWKTvqoqUaKnCdGK7cAPGYQfylYWYq0/OwX0HCrJVkvozZXzmptkneTsiTNYifeLWOkhXDHa05tIbdMSnWhkiRPydoo8jYvEgC67rSepOkBxmI+6yv0/NsqgwLwMxOhwnHrZDu9YV27psIjueMrAj2XkZW2394xS+OGWVxS80Sitsl7ieglPYjpi5NEgJT1uXUfrkMrvfag6767cvDQaQlf7sSIDDw1lSwivb8P+SGaAkSjsB69nj7+h9jXSx6fjm0G13Rus4VbeZafHLKYNHFl8tEJAeM4yiBIqh0FNQp47oBmEYsWDVOJ9Tk0NTR9+yuKLPIDz4uewiInuM+qwTCHGp/Bx6nbvv6GbrNUVQCc8fL2Zf8Wn3SULyx/9hkC X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: H1uwXd8rk1llbB4ohax3gB0LYmvNTA0g8FscS9rrVfLiiQLgZInVSrGZHRc3ESLo2CMbQn0GqGQlupsbO6n6oKV9KnBKUiEHBe3gNhzifCtIgC3zKbogR8gS4bkJAO0tnS95sjf9gIhh6/jAIaEn27bmhDswiToJDKotMHBsQECUiLkoh0JgQG2deqWD2HZtx/dWnqccbD4p+nVHbbEBUoD1GKiAwgXe99nN1i8RZ9JiGJimPtneS9l7M4jfPPPJcxUEIZXVoohBPaeQY/HByx1XEMvtw9EyB7ZL5i95ToNUm+yvMVAY8lBDhWl6ZC3nCNQrkQ22/fNelA4+N9qupz9IRKeU8VKBWOqMaBvOS05KsYzUZeQBfwWJ3QPrrxoeU2mNru11oVo7ilb/jtSn4pEUrFkzhiqc12oVgPG+kYlgsM3hazeKB97b4291PN7dD4lWmAq1V32rMtefGzm/XQgWkycCKPsPR1NzksWuseDmuzI9nxpbP8t5YBDtFOECLUfxvEptzoM9LxM1gnhAZ+F/0frPuK6WygCJbUOKhtOvfHv2wh69IrIc6jx18TjKbbkyxPD9DUqLkKff211UBiMLKQUnPFW+UZf0hbNG4QtWrVIfbZAvXBFvKFOLKu23hxULCjwMd37++tMnIgU79yhPjlP2hogjduZ60N2Ob25ZrO1f72BMNoa5f2Ayr2arKDJsK1KY45OXV23zRlK9itUrtThl841RsiRVRKLaKd3K14XGLjPcwOGGMxCv42CBso/JG9jRPIvW8Qj4ffNHLP51wMpQzYz1S/z4YiyKrEZZoJJV6pFaIrrPlYVPFPp0YGJKycJef6ezIPj7+g6PSyO7VRCB9Je/UYzvzoAVZUUpGRwss+XDxQsY+OQqKeFjhGb0dNCn6L15AwOWfuAf2B/aohxyrJvfwBs4M4a67tFcKfIV7o150t7wA2rlCwQmQGFEbo8OJ5JyjJgto6GJGG6XeiAZMJ0NyH8hDAQ7CMNEYLHMYJe0jwRooVWl1XY+i0wxFJx5K6MJQnA27yuS7m7Bodv9Hu/4xXhrTkpjP3ZHPKNLF7wTjtTVhpE8ReC5rtUz2BWBi0+t3pIxj8AELM45lt8NLwMXElTp6bpWGzngO3NcPdU/pudksZpwEKuaRB8zf9c8yb7Mll5thDvlDLVT/zZ57bopPF1d5XRYN9KxVwA5P6dwpaDgCqaluh0F2wlJa6i2/TXQbjdKw3y2Bd+bYqiwUfwmPGQsLszWfwm8o9IFJrLdnbawINn4Nu14DVm1kjh1Oi8ZKWQzjzD/uw== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: dbb194c5-1c26-4908-fb15-08dc5808917a X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:15:00.5379 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 08/27] avcodec/vp9: Simplify replacing VP9Frame 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: tUhkC5LdCJSx ff_thread_progress_replace() can handle a blank ProgressFrame as src (in which case it simply unreferences dst), but not a NULL one. So add a blank frame to be used as source for this case, so that we can use the replace functions to simplify vp9_frame_replace(). Signed-off-by: Andreas Rheinhardt --- libavcodec/vp9.c | 16 +++++----------- libavcodec/vp9shared.h | 3 ++- 2 files changed, 7 insertions(+), 12 deletions(-) diff --git a/libavcodec/vp9.c b/libavcodec/vp9.c index bdfa543188..443eb74c3c 100644 --- a/libavcodec/vp9.c +++ b/libavcodec/vp9.c @@ -147,11 +147,11 @@ fail: return ret; } -static void vp9_frame_ref(VP9Frame *dst, const VP9Frame *src) +static void vp9_frame_replace(VP9Frame *dst, const VP9Frame *src) { - ff_progress_frame_ref(&dst->tf, &src->tf); + ff_progress_frame_replace(&dst->tf, &src->tf); - dst->extradata = ff_refstruct_ref(src->extradata); + ff_refstruct_replace(&dst->extradata, src->extradata); dst->segmentation_map = src->segmentation_map; dst->mv = src->mv; @@ -161,13 +161,6 @@ static void vp9_frame_ref(VP9Frame *dst, const VP9Frame *src) src->hwaccel_picture_private); } -static void vp9_frame_replace(VP9Frame *dst, const VP9Frame *src) -{ - vp9_frame_unref(dst); - if (src && src->tf.f) - vp9_frame_ref(dst, src); -} - static int update_size(AVCodecContext *avctx, int w, int h) { #define HWACCEL_MAX (CONFIG_VP9_DXVA2_HWACCEL + \ @@ -1584,7 +1577,8 @@ static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, data += ret; size -= ret; - src = !s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres ? &s->s.frames[CUR_FRAME] : NULL; + src = !s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres ? + &s->s.frames[CUR_FRAME] : &s->s.frames[BLANK_FRAME]; if (!retain_segmap_ref || s->s.h.keyframe || s->s.h.intraonly) vp9_frame_replace(&s->s.frames[REF_FRAME_SEGMAP], src); vp9_frame_replace(&s->s.frames[REF_FRAME_MVPAIR], src); diff --git a/libavcodec/vp9shared.h b/libavcodec/vp9shared.h index 805668416f..8a450c26a6 100644 --- a/libavcodec/vp9shared.h +++ b/libavcodec/vp9shared.h @@ -168,7 +168,8 @@ typedef struct VP9SharedContext { #define CUR_FRAME 0 #define REF_FRAME_MVPAIR 1 #define REF_FRAME_SEGMAP 2 - VP9Frame frames[3]; +#define BLANK_FRAME 3 + VP9Frame frames[4]; } VP9SharedContext; #endif /* AVCODEC_VP9SHARED_H */ From patchwork Mon Apr 8 20:13:47 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47939 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp136037pzb; Mon, 8 Apr 2024 13:15:45 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCXGn6+wta6kkgeW0Bf2R3TqvMswEkgWiV52nsqgDBq1yprPog8Zbaku2ETpijk1W6Zh3EfMIkHULh0vCU4cRfL3+L9FyWtRgLBWuQ== X-Google-Smtp-Source: AGHT+IGd2cfiW1TCuFPxQYtUcf0HPD63sZzaPqjR35KqCUFMqiUfwSKBs72QehRkYI4oTSliQk+7 X-Received: by 2002:a19:ca45:0:b0:516:d8ca:40a9 with SMTP id h5-20020a19ca45000000b00516d8ca40a9mr6159789lfj.62.1712607345391; Mon, 08 Apr 2024 13:15:45 -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 h26-20020a170906111a00b00a5197312ca1si3931947eja.29.2024.04.08.13.15.44; Mon, 08 Apr 2024 13:15:45 -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=@outlook.com header.s=selector1 header.b=bzwNZG3d; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 6434D68D398; Mon, 8 Apr 2024 23:15:07 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2061.outbound.protection.outlook.com [40.92.66.61]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id CE10268D369 for ; Mon, 8 Apr 2024 23:15:03 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=ci3+uAvGuJkmYqu5XbhYziAw+Lub1INCK9K8donEfJdRZvnjlNsIfwxCoV67jcJkUGVPLfRYcNZbHtA5zjCvGJqheMbxreTrvkwp67XNQLBXeavNH5fU87CFq8eatj3jeEmxWIqczphXxOi1HG8Lc3ZL0zTV9yP58MOEWscl9jrAW97OnWwS4Yw+FnuA9HNExGn+3I4lO9XNR4PbLUOd/vk3Tk+v+Lab8Tte18KHGenFKNGOS3Ik9VkzF3vZLdHLZIPQzAXeLWRb31ky4ev5RQchLcsKlqojJAeT0343GKAfeDzYzayoDIYuMUatk0IUiRXtXhoUYwSI8Hr3p2rvKg== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=lTZij8djsi673dwUrJMVLvHKIgcfswSC0Ue8C0WjXD4=; b=C9aYYt6HvtfyV2dss4M0LDc0R2Hlp2T+EZiqMVj2ew/afIrZ1VM5WsvwhbMUpH974XF0eyIiU+xD22H7QR01eVZyZqXlgrL4zvV+4NLfm+Vjn1QWNxsRIAqW2uOf4CWQPnC2Xwl5SVNpxhJz3leE66gAehwwCkEIJcbHMLwpzal14j9Ut1Oa1FCCFU5nmKlp0bfypLG9r26BXdWIZsrhLeVwTrFp1SuX5wwcvJ7kulZIIC7Fg6pJJVA4IYsc3e7eDddXSOqFDBuC9PJfLQ3WMkKWiZQ6dCKYOJNDqEr8PzZiiuT6UUKTFIcW3w6kbFKcX9H32KtORcfEIq+IbIZGhA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=lTZij8djsi673dwUrJMVLvHKIgcfswSC0Ue8C0WjXD4=; b=bzwNZG3d3UNTm22rxsS9x6ScM7kkHVrJLBGWbGpqYy6YtntZsT4DkvsQ5JrvXUruaCrrs2LJk+CT5rBu3yo+d+TONA+ksTkEz6QPSyxPXMuk1Av1exK97/A416edgvhjhZWsIM3/xznEyPL/3c3UrFdooB0GqZ7aDHjSEwdLxIwbc1wTMogTDw9lEgFT9q7wNQsCLpueS6fJuMV6lAFclRx5mTZ/JNTIddUrteqgzQBf1o/e7OnBv3L3QEu6UuG2cNiC4z+LjOBqTd5ioGRDNm2edyxG2x7m1ILE0kgdejJR9fMDl+VrffrdehDlrdrW/yfjjcoXoeZCzNuFqxfH9g== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:15:02 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:15:02 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:47 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [Hg6QorluqkEhS8XWOKuOdewH3gw1GzzHrsNWAfnZjgw=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-8-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 7c9d8773-3931-43a6-d8eb-08dc58089266 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: l7QzbALm6e0z8ISX6/ZJkjI5UPvPxzOXMBgNTklkRtRPE8sazZJPqWa5zsO42O8iyyKFM40c6uP9ZM6Vudf1bMN2md7M5QuP25xh+BLGt6STdZidNXAdc5nzsOpN5cH0XqMDfo9hBOnb4+rGUMbIjmh+54KWHS5vjk80g8zVGwK2Xlm5klmi+qk+rKsnxEphtS/W0YMVoxtUOlGZWtKGojOodlB6wAb4wNd6h7wt0WJ6PloAlR566Sr4xm58re4DlOD+34jrEjE4X4o0f97WicEOnjlAbQWu6qo7jZvdODQKNYWOnYCUaKabTmpzqi7Ut369jYovq/ugYBGxDx//CUSnS4LEZyGlbimgMzq3oXIvG32wE7fpjQSZms9np6zSP+zaW765PPToazcVyu5J+P41cDgtKVoZnDdHk/H3THI2FR8KNilm17joEKKTwEG9SMWnaOn5Tk0MgSMahwW/FudacP04RLmM21gvoSenMxEafgj9kanJ15jCGRjATPzaqqKZt/PfDE1L6GPXVHu91lHBni4lZkUKYjpnwyzpm92HPToqMell/YMrqCG474H7xrsrKEOnZhglhFWuVKAbfeXKDbFESC9VbsrQtKg8/YyejCQ3BpNWkr0kc0fC6/EB X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: UTLy5i/ij7Yb1Vhyrt1s4QfixzlEOX8qyyH+ihWh/QQWLZMmmPrBGmYbGh4aNVj+QJqgpbpcuTXjGWe5AMKeleFesDKC1a8z9qFWTVfK5NWgoFntfah14XBDdIImz1rsTecCHA2F5uW7xv4LdZPJ3Huz/1Nj3x4HZzxkpjJ+Lp6APOW6WcLSyQwoz9X+4CVW/jLUxfiHQ8Fq1LKZU0XIXL1LyKiezRPZaRwIaq3ACquxrjrvIFodIrW2aX+kaoBFVRkNNj3ta9L+5xVMaenk04PVxduZfOCNTHJAgEe04A1U8CAzyVyFNRWRlp2kZcjvyF6hTktTIbKYSgvcfC7dNlN14f6vSFbjNWsQBHnrnYHEIg4jTFRWDeqVOZOoSt93mEdA5hrrayXnXmiQ1hF4twCBPgX+j5KASoeXDUitpT0xAwQFmHLZmfLN9riPqemWCslXhmhL+FFByNi8FJU7/5+RmjT4EGBa7MuhxPo2WAxLfvIJzdlri8YnAtVpTMiDzxK69D5w+JghEscOAnMZ5+WwjtFMq5wsaWcmrayeg2nQHgyiZM3GwpGN5clsRQUrMi/O/uEOORf/0UuRSHAznbkXHPDjuKLltkNbVSuvPzSAD1U/EQBq1x5YbqAfEa6qKIuroHE53xGqqPSa/WwNRPYGfJ7v6nvu6nPL/H84UCn6cfRmRTa2S0fRJKAOQo4+QvKokO3dpYn+KyiD3uL12s2BrTcNdIU/81qZThmKaeB3KRttnjdkxmvtxIOS345me1g9AnDbF7UhLe4n4bufYTRiMp4doV+GNymTZqcs2RMQzSX98n3ukGqAcZ0UVIA7Hgh6nRg/waIzeBH8eQ99DG4q03tg3gvdC09bN5svmSwBWgj3Ygn9b8uSeQBhTWJw290XoMTfC9Zy+Zpco17Awm9KrCFRvH4VL8WHymR2pRThafaMZU+5lSNZp/KpJ2e/h1VzC4gvbPPiZGxGitE1lOlF7ok03zHcPHLlEjwHuCfnTMfMLAbODA7STYdSgocUI5tH2MnmCLghguRjy3TtTJhlVAPvek5nMZfMyxjqubKNBuiLA9WFpzFggVgTWkubGbbwOhc9s+EhieM3YjuiWFvLdYoOqGN28MZe6g17xXhh6lgQEvbAXAbrL5PwaIRy4BtiBCKD0nEcbWVPletaEEiXSmzcMT15TP2UqBehKWP3q3O9qd2v1hxuUgrh7eolJi6jtEkWSqgwtymLBsuZjtGEzdNWbfeG2qIRgRGEHInZeJSDc0sVZU5JZv6jt5dZuPZDjACFaALSCAtFOFINuw== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 7c9d8773-3931-43a6-d8eb-08dc58089266 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:15:02.0691 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 09/27] avcodec/vp9: Replace atomic_store() by atomic_init() 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: PYaZU2hYVROh This part of the code is not slice-threaded and they are semantically an initialization, so use atomic_init() instead of the potentially expensive atomic_store() (which uses sequentially consistent memory ordering). Also remove the initial initialization directly after allocating this array. Signed-off-by: Andreas Rheinhardt --- libavcodec/vp9.c | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/libavcodec/vp9.c b/libavcodec/vp9.c index 443eb74c3c..3adfb98f2d 100644 --- a/libavcodec/vp9.c +++ b/libavcodec/vp9.c @@ -55,7 +55,6 @@ DEFINE_OFFSET_ARRAY(VP9Context, vp9_context, pthread_init_cnt, static int vp9_alloc_entries(AVCodecContext *avctx, int n) { VP9Context *s = avctx->priv_data; - int i; if (avctx->active_thread_type & FF_THREAD_SLICE) { if (s->entries) @@ -64,9 +63,6 @@ static int vp9_alloc_entries(AVCodecContext *avctx, int n) { s->entries = av_malloc_array(n, sizeof(atomic_int)); if (!s->entries) return AVERROR(ENOMEM); - - for (i = 0; i < n; i++) - atomic_init(&s->entries[i], 0); } return 0; } @@ -1661,7 +1657,7 @@ static int vp9_decode_frame(AVCodecContext *avctx, AVFrame *frame, #if HAVE_THREADS if (avctx->active_thread_type & FF_THREAD_SLICE) { for (i = 0; i < s->sb_rows; i++) - atomic_store(&s->entries[i], 0); + atomic_init(&s->entries[i], 0); } #endif From patchwork Mon Apr 8 20:13:48 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47947 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp136095pzb; Mon, 8 Apr 2024 13:15:54 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCVyGHLootm67nb8nn74Psd6aAIn3RsKOeKDzXloPtlx5rOE8tcZDBdF2itNS1cOjTyv5xP+pW+4/k4uwg/xngcw9CLfhvMzUeLYag== X-Google-Smtp-Source: AGHT+IHAjnT3BhhdVhMcGTold4yUaLpBq0y3pwi1RSzNRyro6tDpHg2Qq1y70qxV2rbMyvd6JuAH X-Received: by 2002:ac2:5215:0:b0:516:c5b1:1b21 with SMTP id a21-20020ac25215000000b00516c5b11b21mr6068866lfl.45.1712607354117; Mon, 08 Apr 2024 13:15:54 -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 e18-20020a196912000000b00516d27c7808si2381943lfc.395.2024.04.08.13.15.53; Mon, 08 Apr 2024 13:15:54 -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=@outlook.com header.s=selector1 header.b="XWxSn/eW"; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 8402968D3AF; Mon, 8 Apr 2024 23:15:14 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2044.outbound.protection.outlook.com [40.92.66.44]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 19AFF68D306 for ; Mon, 8 Apr 2024 23:15:08 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=jcesAaFYnJbNjc0ZQKYWxbM5Uwed9e/V27RlV/m9E86CbT/8ErzvhhGFrIKeUuKUm/yzPFAsNUPR8S701b8MLxtWXbW3RV69xF2g6DPR0gLwmNpJ/SgQGq7fyL+Pcswjcj5vwmv4rXj7DDkIOpeUlAjiw40+/s4AZaw37QQXwGQ+Ki51Q8dOQ1xGYtW7jE1cApfADPizflCLYQ4yoLerzBTNblJ5p85fNyU35xH2au90Bo+d1QmC9+vPhBK0iBPq+7x/AZZGVQovl6NvAb2J6iLXFlHC5CHbRk2SzgauXgRz9eOZ7kSwThRVWyCF9M6Sq8QzJThD3XVu8kqW0BtLGg== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=d8DxSTksw3xsKVwZvWq9d7izSc/GWrwettwofThgVLc=; b=jNyzTF/hpCu4O/g2aLIbn/hJCgHCGgcpfgrJmjky5NIO3naUUHuSn+BHKI6qg4d4u6dUok38KZ2I6tC4/Hxb+t9zS+ZTZhkCRoT2/HL64ZzB2O0KyjoUpGcvK1wfCUh/oF89YDY44vMbCVI6rrz4UK5T5vDwsMtR3lWy1Kcfn8x12mkVm636Us2B0KeQ24F7VyZ1oGNvh0Ys5LH8Aj9UqAaJHPzMWMHkkn06qHFYMNr8b3YmF2F+5K/jwi+5AM/vCQgkcpJ1TrJz8c6YyTmi+yymOZdAe5+JycCpr2l+H/Y7qlSsBLSxC3OLFpUKHqtFj6gFEwmib6Xwlf0qRtbefw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=d8DxSTksw3xsKVwZvWq9d7izSc/GWrwettwofThgVLc=; b=XWxSn/eW313oUPGZQNrogmw5uplPe89aNfN6LmXcg1p9oQV6EZbNIQ32tfBgpV/YrGqWms5K+U9YP+mGYS2oVdsCIAymS0zewpsCoewtNh+zMUmHovcz2jzwwRLzETahgheO/f8wAa0vh7Bas+odBPvP8Ln3HFOBr9AMaKVvGkRxFNOlr6i8rRDCK/+jAfRIWQ6y1wckUzhr/O8X5e+mkCzGXLN3Mk6g9UypovInTgHHT70WEfy3JkibinmR1HwqaDeN0VwLnDTBcUMrW78h1u5qbBZAG8FOgEfPoLn28WT3gmktbOl+0T4/elSxN7scf4Xv0ZWCGM+jsraodp+Epg== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:15:04 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:15:04 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:48 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [iz0KFAm4QZAw7vY+8ooNvY39K/gPyOKQKX4evFBC4ew=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-9-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 1e84ec53-f22b-466c-d0d8-08dc580893ab X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: DqjnhVGPT4D8Bfo27TeFxNLyRWqvlxHUyFyVOQG8wDvIQn0lXJXjjCb4NUz3jl6MsGyQUC2PszdsLEGoUIzkBFwgqVGDa5NdfiTGDUjSR52+z53YIkAWUU0SwD/rPtEpgz9AT1+HLSiXpHAnx3tgef7XaJTregURgUX/HIVZ03ODNAAqukOyeOTHaWSFIi14dPyGn6zkd7NeHnOEtsUeNCMw8Ub/L61NMP2wcpMfs2zRSFTUfep3A2ppHN7pB4LHbFcl+Nspi8N3CWgtN0CFc7e5fZH8ljsZPcXEwsiQyuMe0z8ZZYhaOWANY9XlIIuhLmOWKgZNo9sMg6t7ZroqOuE8Fj3wlQ6ZVTsv+PPXBTzQk9/l34eGs40mikTV2SFs24sEwW6FQ6IJCv+ympeT1RyDqJ52sI/xm5B/Jx9ECTF4Eyd8rLPbLlrAF4ONijp4WTfFNf8VUsRaRl7/Sh8dHXeczEd3Sx80NC7JRO+WXgBtUlI2PXrOU5uNVfCx0g3tmNrMzUdljDgfD40jPW+jsSvrM3kyc0q9VKSEdHZjK3edr56/5cIa2AxlYF1auAvqMaCpMejutH8DTjBBPwoWPDD27x02dkO+MIYH19GGKUuRZfK86nRt4TlcGMOMYg8H X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: xAlVV1h5v/zNBZEQuuoFcuByrwaPYXMuIt+pH1PZJY4/FAgxVNQXMh1XtAeuJ12nJWlmC2DD++RudEcHzcY7I43xLxaZ1BCbjbBWNU/MKqg7zX34vSVRZ7xSsSfoD/xOtOFvFLv9Tze/rHlK7ZdSkUTe6jwGo0wtAEdUjNW/STDOafA3ZX1J+xBuW3VXJ35wLQ4s1orw124KLeYso9kt4UA/HKZ3Sa2I9gZccVijTLnj+4DBlvz/tvOGQHqpufTcmf3Cn8fxS+cQPHb1RSAE2FrydOF3VTdlSAkBvXDeUZ0yaHAuv/q/JR7nQLc2jqIg1tOWx2zhCHZC255xCGATCm7OgwZGZbdd5sEEw/jRuDsLaSxGPy3EqGkCcXc/1zZC08V4M/HiSc6pOn8uqP2P5e07SF/th583J8ef1PbGwi+httTbBrBmXtLEGHs6AmDuD0zxwumV3Im3eEnjSf63JOk9feHquqDaHAddGJZNOxV8jvWr09hC8KcAwFYDNYhEbTLoBbFo38XxWWvibG2DKyWnCEZPo+tBISz+bSTYp/8l5dTNGIHPHh14QAr70duy5KgtKPGkdbdY0OsY25mxS8DGXvMICPrNyJUO5H3zzzKHS1HDYn0eDC28t8xDMLjJYAnungrEU2VclwleIruM15cqR8ZxEJbwz3L8W5JQIaCNuMys2Dvcjwj1MO+9gvhlR79TKExkl/paMkfWPAZr9o7BIXjRtiEz+CyUrAvP+FaHM75dcNnQ4mnVMlMFKM1/6gU/a+U4U6wj5sBeXKV6pgBRTJqWfZAWavj4VFdvBLXD4XuRXsJMU5mguOb+sSEUNpKi2VpYqbreOjd1u+33jy9jmiDmvsWHA4efwkj4NTovYOeBj5Du9h2hM8bnPtBzdbrthEQ+67CiE6niYTj003P+TbeCEMjy0TgoTLBB6DhUuuGk4K44w90DQ2ywyo2ueOD8LmUHPGNP5wezIV9VMzii9IMn/SyEKNj7luiaVtGF/7X27e42/zi9bdxhF8rYbtXERVQCFCtBw3QGuYWm6q0gwCi9Z+nbU2gaWhGZH6ORWY3tEouhb6G3cCzmS9q/GIlGV38Oz61G5CxzYtlpGRj1WnqIrLYzOQvN9s6K2CLhu8owe36UJerDJS8N+2h0dZK0edwz4mb/BvZA+0P3ffkIh5jpceFMEP6qwJAcx9qTq6skWS7vUFjdlv8UyzytEvijMfUK0xFr1zzOecvotKe2eMcsexWy4uU4E7mRbopwy2b5jNyzwllW/yKbKCEO/oEp6UamuAyAHsNASiPhLA== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 1e84ec53-f22b-466c-d0d8-08dc580893ab X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:15:04.2143 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 10/27] avcodec/pthread_frame: Add API to share RefStruct refs just once 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: CqBnOsSyMrL+ This is useful when the lifetime of the object to be shared is the whole decoding process as it allows to avoid having to sync them every time in update_thread_context. Signed-off-by: Andreas Rheinhardt --- libavcodec/decode.c | 7 +++++++ libavcodec/pthread_frame.c | 20 ++++++++++++++++++++ libavcodec/thread.h | 30 ++++++++++++++++++++++++++++++ 3 files changed, 57 insertions(+) diff --git a/libavcodec/decode.c b/libavcodec/decode.c index f18f85c33c..e196c05f11 100644 --- a/libavcodec/decode.c +++ b/libavcodec/decode.c @@ -1747,6 +1747,13 @@ void ff_progress_frame_await(const ProgressFrame *f, int n) ff_thread_progress_await(&f->progress->progress, n); } +#if !HAVE_THREADS +enum ThreadingStatus ff_thread_sync_ref(AVCodecContext *avctx, size_t offset) +{ + return FF_THREAD_NO_FRAME_THREADING; +} +#endif /* !HAVE_THREADS */ + static av_cold int progress_frame_pool_init_cb(FFRefStructOpaque opaque, void *obj) { const AVCodecContext *avctx = opaque.nc; diff --git a/libavcodec/pthread_frame.c b/libavcodec/pthread_frame.c index 6b2c4312e0..ee571be610 100644 --- a/libavcodec/pthread_frame.c +++ b/libavcodec/pthread_frame.c @@ -1001,3 +1001,23 @@ void ff_thread_release_ext_buffer(ThreadFrame *f) if (f->f) av_frame_unref(f->f); } + +enum ThreadingStatus ff_thread_sync_ref(AVCodecContext *avctx, size_t offset) +{ + PerThreadContext *p; + const void *ref; + + if (!avctx->internal->is_copy) + return avctx->active_thread_type & FF_THREAD_FRAME ? + FF_THREAD_IS_FIRST_THREAD : FF_THREAD_NO_FRAME_THREADING; + + p = avctx->internal->thread_ctx; + + av_assert1(memcpy(&ref, (char*)avctx->priv_data + offset, sizeof(ref)) && ref == NULL); + + memcpy(&ref, (const char*)p->parent->threads[0].avctx->priv_data + offset, sizeof(ref)); + av_assert1(ref); + ff_refstruct_replace((char*)avctx->priv_data + offset, ref); + + return FF_THREAD_IS_COPY; +} diff --git a/libavcodec/thread.h b/libavcodec/thread.h index f772d7ff18..5ab12848b4 100644 --- a/libavcodec/thread.h +++ b/libavcodec/thread.h @@ -84,4 +84,34 @@ int ff_slice_thread_init_progress(AVCodecContext *avctx); void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n); void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift); +enum ThreadingStatus { + FF_THREAD_IS_COPY, + FF_THREAD_IS_FIRST_THREAD, + FF_THREAD_NO_FRAME_THREADING, +}; + +/** + * Allows to synchronize objects whose lifetime is the whole decoding + * process among all frame threads. + * + * When called from a non-copy thread, do nothing. + * When called from another thread, place a new RefStruct reference + * at the given offset in the calling thread's private data from + * the RefStruct reference in the private data of the first decoding thread. + * The first thread must have a valid RefStruct reference at the given + * offset in its private data; the calling thread must not have + * a reference at this offset in its private data (must be NULL). + * + * @param avctx an AVCodecContext + * @param offset offset of the RefStruct reference in avctx's private data + * + * @retval FF_THREAD_IS_COPY if frame-threading is in use and the + * calling thread is a copy; in this case, the RefStruct reference + * will be set. + * @retval FF_THREAD_IS_MAIN_THREAD if frame-threading is in use + * and the calling thread is the main thread. + * @retval FF_THREAD_NO_FRAME_THREADING if frame-threading is not in use. + */ +enum ThreadingStatus ff_thread_sync_ref(AVCodecContext *avctx, size_t offset); + #endif /* AVCODEC_THREAD_H */ From patchwork Mon Apr 8 20:13:49 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47948 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp136162pzb; Mon, 8 Apr 2024 13:16:02 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCUK2If8FjvxDomwgUK2ZsE2RZJMAknvx2zqdt26eGGBHP3bn+Xt7OcI6VNccXVRX9UYdhgXt966SkeWcroN05YxG1eOFaZ3yaZ5uQ== X-Google-Smtp-Source: AGHT+IF/pr+/JqhZ2kn8pO3LPVoy5Kl4w8rrCvgK0fIoMlivFIbX3lvvEn7J9gvsAzFzHmgVLMRh X-Received: by 2002:a05:6512:401c:b0:516:be41:5092 with SMTP id br28-20020a056512401c00b00516be415092mr8598262lfb.13.1712607362065; Mon, 08 Apr 2024 13:16:02 -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 nc14-20020a1709071c0e00b00a51affc3396si3460805ejc.349.2024.04.08.13.16.01; Mon, 08 Apr 2024 13:16:02 -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=@outlook.com header.s=selector1 header.b=gU29qosh; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id A81B668D306; Mon, 8 Apr 2024 23:15:15 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2044.outbound.protection.outlook.com [40.92.66.44]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 5D0C368D306 for ; Mon, 8 Apr 2024 23:15:13 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=LdyJA5dYzWDKHMPAtRbMzSoVYqXzvqvbhD2GJwJuBFRhRYRjrYmOyO6MDsMFQDhafaBRohqEAAclb+8wtl9xENdNYvwpDD5TfK9VteS//HURlL8arWZ5yka9ytIf2E5T+VUnWu6mQTLPncsYzz4wY1JXRN4TPqOiQHchvmrEVslRLY0Cz6dPzeF2j/PalYLBx7NZ6kIa79c9ghm62hks5n1i4GlEivOU1Nn6qwIXDqWh1ggvjViMVcGFSoCvrJtjweC47irQCjYZrrxNAAWVZDTvtl5CLIlhw140zUcq1TasIFeS/QDnal+0Hiq06amoMxAD8SomfBq/Qynx1UpHKQ== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=PTNKtMdTce8/8kqJ376mjrHl/Mstvkk/bgpQB1AogPY=; b=bjwB/eP+Z2Y0kzWSW1KB+BHQoNGia5L+GxhKddDihTuPN8zhmNNfG24m90/X8ajxzX0pGnMB6gGl2fjLk4j74pwkOewYi2INJfNLpXF8u25vDkHFPuvYcs+cTKRmWE3Tfm59Fl4J1UvbKVABE8tW7aEUv2vvlNsLYRVjglPG/8ii0AI+oKybb/S5CoYxY631a+Qbq5gfIiiBCJDCtCBhYUXbOcBk0RM3iWiPaenn19l2nUYk2tP8jbJpcufU5QaqHWg/ef/ASd85NRgg5m0KqfzfClYC7wtmY3G5Cyc2uVU+PIMQB7Aee0AU1uhThM/Sxrb1x3ee84NTq2VEZCXHzA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=PTNKtMdTce8/8kqJ376mjrHl/Mstvkk/bgpQB1AogPY=; b=gU29qoshm1AoMHWdmD6PJtaiUux6I7R56uRFnmQclHAThCJ63ITN9Y0f/r5t7Gcv6nM1DY3FPDesFo0V94vhUv/ufAOI46pgIbeRv15kTwWOjy3Pd1GoI7+7Row8YWc6beulJbpyQyyXHzyQHSzGVCnESTVv40Gef1Ax5OYBaj7z6xYpGxtu7b7ww6FOKVmg6bBbO4B/db8xknQSseh/J2MjF60w8aCcYJTVgjehOvvviq2YqPd+OLlAb+l0+MCAx3vDzVuCAVewAKVbsyT4ZN3ODoxFoJ6MkFXH4n6QJH1d2q3syBzqBWsTaB3IRhzF7qCsf/HWg7SNW0n1VHtsZA== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:15:08 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:15:06 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:49 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [ErOe4/MtalqVoDvIDNezt+FyBR8Zev/S0DgW3Jyghlg=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-10-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 70434406-0f4e-4780-643b-08dc580894c8 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: +LPuEBBesJQXfNk5MG5tfb0o1mn1A09c4K3JsOxIxR2MKeYPv6E5w/Q6SH2DuROdJqVuCcbUH2dNuyn17k46BM5djp+1KNLmQ17ekbFhlFk38sPXHxXlSqybXf3C3msw68H8SAPmue7Wy25rvOlzTNlI3fKdgB0fFZWNNVKyeD4HKQTh+hK2sEaU+jABSyA0bjMy8KbV0fv+jV3ldlCB0UdsLDGfq3s+HkPVTo2B/DLF5FVsC4TLbqTHDrShU6EBCCsMRnc+ZEbvV6H653pYvrXzi90PquZmhTCdzYPia1V3tijZBRbWpXw2OqGOMq8Fq0TxX4xNAvdY0SeAgmuWbsYdEznZb3/uKW7Pj5Ma98OQ5jsmcmoAR7znlpg4CrEGjDfoVejmInKzn6I5xKag+V4sG44mgPfM4p/D9lp1rbTeRcHKbWMVwZjx4KwRq4RnfwFRkiBhY5rKcAmmbZUGIrc806JZoHxU9eeAOQO+mQqS1SRXvw++o32o7lNKbrnO+AiJyex9s8EsO1Vu7d6RXWNzTIDNVC5Rd4GLKnsIafYlmsVesqjBR9D+cdiXZZJalgTPzjFMbAAGwzSEQcyjyRIO06EPAX834uTNWJLf428agKhdJdxyGuqE8XGu0kaQ X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: TEf2Jk8w4mVvKZldjoryhjajvYwzYxh/pT5wAgp8oxXNed6uQY4ar73dVnMnarmKjUrmifCF7Vvu9i1hnrDC87xNHdOViFBHVuqnzoplnbGri41FpKebqfjGvzZM2jHZvYmz6n80MrA8tCn1Dxk5QchJPKOMEP68T71WAlB4i+rodVP06E0D31Z7PIWQG/vZ2MuBGdhYauJTByPrAwRV5jyDuNJtLAIZoqr4HzLc9IoaW/PrVjl5//ZNJ9i8mpk4j31oDnfzW8ujiGbHWi4CEbqoNXkEIQr36nmnNolrUyIhAJzbIp8qG++9Hoy9aHgskJ2PXgwl47n3RH1csFS0zJV5wan3yRCOGdv4/FFGpuWDfKqEIOp8QkSKXwO+YIrysdxxDXE/siN4ZOgvSVHVnX2ZrwSMavTpkihaoBgPzZDs62LfVN3eZdLW1I8qDgkrDH4SuVnhbvSHw9vlIAi5cdz4MCYw8c5ElgCTF1WQa4wM/JprWxJrrMSPTuNAWosf5KJAj0GEEMtnr0B0NbgxJxXvtsxAO2lXHAAD6G40HZtyuo0NvllSAzYbTYU3ATiAI/jeXgbKH2F9HWHYT+Vg3g8vx3N2B1mW9uU+wS1ah5lWe3fAvJN+4/gb/E4i5oXHau+EUs//BKJEbbQmxXTI4hq5wXO82hYSa1WphG/lytIXBBlRwP879Wq6etv6zr8Z694i1/s1rLb7N8IrqWqp09vMvZZosRA4v7uF8aPFhEBVsd5gTmn5V0YTnYQ9kO5XJFIucFWw+c8tU4vEPXKhCacFHWPQDCqnJj9oa7QE1Dy/h/LmetA5bQ6QbJSRP4PRD37rJNGXbEYeNcSfmMD6puetXT8UWPxcykdVFnfXQq4nM6OlA2ZFRJGOp2PKGC8h3UenmlmJ+vNmdbynN8A+uPasjol8++nKsE0gimMYbITxJ55KIpEMkf6tKW12qjnX89yegAk2mmBgUWNEA6Od1hJsNS7h8tkr9AgWMdrAHaafLtdwgjNjlszZ3hZVSBuX7wLmewAXIcrmME0sQ+/9wlZgMw5un9O45yU8I8zVT2pFAsS7txYhCdYWlXZT3/Z5X5dsF/Ogae+OoAyl0TvLZ+l5CavlojMglOj8y5x1lPGmTNhBahUPgXTj9QaP3d0BKIPotklkBhrTPL9pbsg0qw/A6PVa3YwHiJ0Erui1M61C+cfmV0jFKGNz7Ut1zuM/05k+JE+eyh3ccXrMa632li1Zd18kdhbgK6PxUIareOQiqBpGbqr+vRgG4up43vP32vZELuEK5U2smuweuaSa7Q== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 70434406-0f4e-4780-643b-08dc580894c8 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:15:06.0803 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 11/27] avcodec/wavpack: Use ThreadProgress API 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: EenaSuDcH6QN It is more natural given that WavPack doesn't need the data of the previous frame at all; it just needs the DSD context. Signed-off-by: Andreas Rheinhardt --- libavcodec/wavpack.c | 133 ++++++++++++++++++++++++------------------- 1 file changed, 75 insertions(+), 58 deletions(-) diff --git a/libavcodec/wavpack.c b/libavcodec/wavpack.c index 73d69d66ff..83f42f392d 100644 --- a/libavcodec/wavpack.c +++ b/libavcodec/wavpack.c @@ -30,7 +30,7 @@ #include "get_bits.h" #include "refstruct.h" #include "thread.h" -#include "threadframe.h" +#include "threadprogress.h" #include "unary.h" #include "wavpack.h" #include "dsd.h" @@ -107,11 +107,11 @@ typedef struct WavpackContext { int samples; int ch_offset; - AVFrame *frame; - ThreadFrame curr_frame, prev_frame; Modulation modulation; DSDContext *dsdctx; ///< RefStruct reference + ThreadProgress *curr_progress, *prev_progress; ///< RefStruct references + FFRefStructPool *progress_pool; ///< RefStruct reference int dsd_channels; } WavpackContext; @@ -994,6 +994,8 @@ static int wv_dsd_reset(WavpackContext *s, int channels) s->dsd_channels = 0; ff_refstruct_unref(&s->dsdctx); + ff_refstruct_unref(&s->curr_progress); + ff_refstruct_unref(&s->prev_progress); if (!channels) return 0; @@ -1017,22 +1019,31 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src) { WavpackContext *fsrc = src->priv_data; WavpackContext *fdst = dst->priv_data; - int ret; - - if (dst == src) - return 0; - - ff_thread_release_ext_buffer(&fdst->curr_frame); - if (fsrc->curr_frame.f->data[0]) { - if ((ret = ff_thread_ref_frame(&fdst->curr_frame, &fsrc->curr_frame)) < 0) - return ret; - } + ff_refstruct_replace(&fdst->curr_progress, fsrc->curr_progress); ff_refstruct_replace(&fdst->dsdctx, fsrc->dsdctx); fdst->dsd_channels = fsrc->dsd_channels; return 0; } + +static av_cold int progress_pool_init_cb(FFRefStructOpaque opaque, void *obj) +{ + ThreadProgress *progress = obj; + return ff_thread_progress_init(progress, 1); +} + +static void progress_pool_reset_cb(FFRefStructOpaque opaque, void *obj) +{ + ThreadProgress *progress = obj; + ff_thread_progress_reset(progress); +} + +static av_cold void progress_pool_free_entry_cb(FFRefStructOpaque opaque, void *obj) +{ + ThreadProgress *progress = obj; + ff_thread_progress_destroy(progress); +} #endif static av_cold int wavpack_decode_init(AVCodecContext *avctx) @@ -1043,11 +1054,17 @@ static av_cold int wavpack_decode_init(AVCodecContext *avctx) s->fdec_num = 0; - s->curr_frame.f = av_frame_alloc(); - s->prev_frame.f = av_frame_alloc(); - - if (!s->curr_frame.f || !s->prev_frame.f) - return AVERROR(ENOMEM); +#if HAVE_THREADS + if (ff_thread_sync_ref(avctx, offsetof(WavpackContext, progress_pool)) == FF_THREAD_IS_FIRST_THREAD) { + s->progress_pool = ff_refstruct_pool_alloc_ext(sizeof(*s->curr_progress), + FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR, NULL, + progress_pool_init_cb, + progress_pool_reset_cb, + progress_pool_free_entry_cb, NULL); + if (!s->progress_pool) + return AVERROR(ENOMEM); + } +#endif return 0; } @@ -1061,19 +1078,14 @@ static av_cold int wavpack_decode_end(AVCodecContext *avctx) av_freep(&s->fdec); s->fdec_num = 0; - ff_thread_release_ext_buffer(&s->curr_frame); - av_frame_free(&s->curr_frame.f); - - ff_thread_release_ext_buffer(&s->prev_frame); - av_frame_free(&s->prev_frame.f); - - ff_refstruct_unref(&s->dsdctx); + ff_refstruct_pool_uninit(&s->progress_pool); + wv_dsd_reset(s, 0); return 0; } -static int wavpack_decode_block(AVCodecContext *avctx, int block_no, - const uint8_t *buf, int buf_size) +static int wavpack_decode_block(AVCodecContext *avctx, AVFrame *frame, int block_no, + const uint8_t *buf, int buf_size, int *new_progress) { WavpackContext *wc = avctx->priv_data; WavpackFrameContext *s; @@ -1521,7 +1533,6 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no, av_log(avctx, AV_LOG_ERROR, "Error reinitializing the DSD context\n"); return ret; } - ff_thread_release_ext_buffer(&wc->curr_frame); ff_init_dsd_data(); } av_channel_layout_copy(&avctx->ch_layout, &new_ch_layout); @@ -1529,18 +1540,25 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no, avctx->sample_fmt = sample_fmt; avctx->bits_per_raw_sample = orig_bpp; - ff_thread_release_ext_buffer(&wc->prev_frame); - FFSWAP(ThreadFrame, wc->curr_frame, wc->prev_frame); - /* get output buffer */ - wc->curr_frame.f->nb_samples = s->samples; - ret = ff_thread_get_ext_buffer(avctx, &wc->curr_frame, - AV_GET_BUFFER_FLAG_REF); + frame->nb_samples = s->samples; + ret = ff_thread_get_buffer(avctx, frame, 0); if (ret < 0) return ret; - wc->frame = wc->curr_frame.f; - ff_thread_finish_setup(avctx); + av_assert1(!!wc->progress_pool == !!(avctx->active_thread_type & FF_THREAD_FRAME)); + if (wc->progress_pool) { + if (wc->dsdctx) { + ff_refstruct_unref(&wc->prev_progress); + wc->prev_progress = ff_refstruct_pool_get(wc->progress_pool); + if (!wc->prev_progress) + return AVERROR(ENOMEM); + FFSWAP(ThreadProgress*, wc->prev_progress, wc->curr_progress); + *new_progress = 1; + } + av_assert1(!!wc->dsdctx == !!wc->curr_progress); + ff_thread_finish_setup(avctx); + } } if (wc->ch_offset + s->stereo >= avctx->ch_layout.nb_channels) { @@ -1548,9 +1566,9 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no, return ((avctx->err_recognition & AV_EF_EXPLODE) || !wc->ch_offset) ? AVERROR_INVALIDDATA : 0; } - samples_l = wc->frame->extended_data[wc->ch_offset]; + samples_l = frame->extended_data[wc->ch_offset]; if (s->stereo) - samples_r = wc->frame->extended_data[wc->ch_offset + 1]; + samples_r = frame->extended_data[wc->ch_offset + 1]; wc->ch_offset += 1 + s->stereo; @@ -1602,25 +1620,27 @@ static int dsd_channel(AVCodecContext *avctx, void *frmptr, int jobnr, int threa const WavpackContext *s = avctx->priv_data; AVFrame *frame = frmptr; - ff_dsd2pcm_translate (&s->dsdctx [jobnr], s->samples, 0, + ff_dsd2pcm_translate(&s->dsdctx[jobnr], s->samples, 0, (uint8_t *)frame->extended_data[jobnr], 4, (float *)frame->extended_data[jobnr], 1); return 0; } -static int wavpack_decode_frame(AVCodecContext *avctx, AVFrame *rframe, +static int wavpack_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt) { WavpackContext *s = avctx->priv_data; const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; int frame_size, ret, frame_flags; + int new_progress = 0; + + av_assert1(!s->curr_progress || s->dsdctx); if (avpkt->size <= WV_HEADER_SIZE) return AVERROR_INVALIDDATA; - s->frame = NULL; s->block = 0; s->ch_offset = 0; @@ -1646,7 +1666,8 @@ static int wavpack_decode_frame(AVCodecContext *avctx, AVFrame *rframe, ret = AVERROR_INVALIDDATA; goto error; } - if ((ret = wavpack_decode_block(avctx, s->block, buf, frame_size)) < 0) + ret = wavpack_decode_block(avctx, frame, s->block, buf, frame_size, &new_progress); + if (ret < 0) goto error; s->block++; buf += frame_size; @@ -1659,26 +1680,23 @@ static int wavpack_decode_frame(AVCodecContext *avctx, AVFrame *rframe, goto error; } - ff_thread_await_progress(&s->prev_frame, INT_MAX, 0); - ff_thread_release_ext_buffer(&s->prev_frame); - - if (s->modulation == MODULATION_DSD) - avctx->execute2(avctx, dsd_channel, s->frame, NULL, avctx->ch_layout.nb_channels); - - ff_thread_report_progress(&s->curr_frame, INT_MAX, 0); - - if ((ret = av_frame_ref(rframe, s->frame)) < 0) - return ret; + if (s->dsdctx) { + if (s->prev_progress) + ff_thread_progress_await(s->prev_progress, INT_MAX); + avctx->execute2(avctx, dsd_channel, frame, NULL, avctx->ch_layout.nb_channels); + if (s->curr_progress) + ff_thread_progress_report(s->curr_progress, INT_MAX); + } *got_frame_ptr = 1; return avpkt->size; error: - if (s->frame) { - ff_thread_await_progress(&s->prev_frame, INT_MAX, 0); - ff_thread_release_ext_buffer(&s->prev_frame); - ff_thread_report_progress(&s->curr_frame, INT_MAX, 0); + if (new_progress) { + if (s->prev_progress) + ff_thread_progress_await(s->prev_progress, INT_MAX); + ff_thread_progress_report(s->curr_progress, INT_MAX); } return ret; @@ -1697,6 +1715,5 @@ const FFCodec ff_wavpack_decoder = { UPDATE_THREAD_CONTEXT(update_thread_context), .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_CHANNEL_CONF, - .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | - FF_CODEC_CAP_ALLOCATE_PROGRESS, + .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, }; From patchwork Mon Apr 8 20:13:50 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47962 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp139528pzb; Mon, 8 Apr 2024 13:23:27 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCU23wVqGqyV+IkD0Onj89oJPZUjIdUd24FXnjw7u8LNo3df+6keS/3VsypmOtC1vvJSFIzisU/rkr83MS3hP1ldYdmvjK/DMJeVCw== X-Google-Smtp-Source: AGHT+IF8tv0bBmmGWNTjGpwkNfw//S/HTNROAPedKLgOl/8MV31eXAwWNSLn5smR7PFMBb8xtgIB X-Received: by 2002:a17:907:980c:b0:a4e:e61:b5fa with SMTP id ji12-20020a170907980c00b00a4e0e61b5famr8811854ejc.15.1712607806922; Mon, 08 Apr 2024 13:23:26 -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 fi29-20020a170906da1d00b00a517a32eb2esi3837471ejb.467.2024.04.08.13.23.26; Mon, 08 Apr 2024 13:23:26 -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=@outlook.com header.s=selector1 header.b="Op3Xxg/3"; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id DC25368D34A; Mon, 8 Apr 2024 23:15:16 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2044.outbound.protection.outlook.com [40.92.66.44]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 7810B68D314 for ; Mon, 8 Apr 2024 23:15:13 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=f6iMs2M9fqCW6CodFQP7UWj4RovuhPpKPWNg76tAx7XlWWPcqdeF6ei7+/td1loTjhbrJm53h62i9qJILG1895UzZmf1L59HLbq1kb95u45t7oLkMqhigxxDdJ/Unz68sdXFnZjAWDqidmTNcy7gRl9eoCJv713fJXvXV7ONk8R2jVGMvWDZef0gDA5T7wYXY90sfWX39BAQDCru19O2YzuUdEkMRRh9QzGb5tr1bCAqoB8jnlIcUYO8zEOVskDtAedyxa9zVKfu9p//g1BwO9MWOycs5J7M+dyB1gu1XK9IaTyOjlhpHvJvhSeB/QCI6puEWaHgtqEjGB4gtbVgGA== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=CPUloiTIhfmcX82oXGfB9DOAuBsKs0IGf0RLHjvu5cE=; b=M8g4JrGwEmC7gelKqa/7qhnQOGVe8Ft6u2S03KrlXenS8JlRl5DtyFekCLQnpG0sGnQScD87aNoj2clgQovCNiGDRxzpaz80xNpGR8GPWiN3ouMnle2tHegX/+DypY8TqMJ50zAmuwUYqS0nc849goSJZ6ntG4xU7+Q9cwEe/XPNeCBWOv/pLRAOCOV4P2lLFbPZuG91M5JqtTECrTNpPgRgUBdqiLyjzzmRvbWL9f346ZqjG9JGW30UO2OlLaKHBtYcl6O7ZU++dlHd1/XuNwG7jZRblz3Ea8g+TFVfEMs3DpN/KX5FaaEbmqHbxReMso/z5boouWQbKwWMTZY+1w== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=CPUloiTIhfmcX82oXGfB9DOAuBsKs0IGf0RLHjvu5cE=; b=Op3Xxg/3pDcAHWK5QFHW6DFyUBJZZ9gBuIeUkLMeE8P1YyS22jenC3y1FuJr5tW119soov66HQTmr9D7RByIx+jV+NtDqLuMFxpIGdh2+z5H26WObeA2wxm4s1d9H8Ik/6X7P9MDCE+vVKKVdimfsEqAXMapnqIOJlBA/UZ+z/vDxQrP4RiWfx6OumuQQoJuLuON8Rmv9pMKfPsT2jrBMmv/jQkLIvTNV7/bbevcLP2nEyR2OjMEoHWxOkG1vjNuM841Sj7cvr3HpsBhJ+Z6iYKF5WQD1y+E/NUDPPtxbVleExYYagdKQEFVbDJHj6excMSnVUyuClxbFOekSn2OCw== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:15:08 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:15:08 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:50 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [N5J9p0gYXMHoqQ5qNqJxo3l+oU5kLB7nErJpkNJ3pmA=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-11-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 8d18b0df-b3db-4fbc-33ec-08dc5808957a X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: mbjG1hmz58rj7bZDEm5orvwVaH8dKQdr3UZTvPrxzfdZ80wbFNDYVmJmWPX2YwNG8kUUTeOIXNYqcrwyCmr2YreS5Aqjm4P8NQsG9wtlcnq56rzrSkLpCMzbUwqFvnIfBtoePD2PCt4YFhXtKV4NLpVKgK4ATnMOEujPnLtsqzL3IqvQeG2d2n27He3N6lTIE/VvooeS/8e0bC9WjCL4slCorIyvTgL8aeu+jGR2ME7Tu9w/3djYJQvuJ9rNfz8jKLFsc8kKlJP7JDRVCkjAwosO/KTUrRCbMft3vZ2k1p0KJX3azpUZI2J+McWcQU6mj5G21VMhgP0wW4lT2Tb+hC7wSsHfHn9MlGbeYHpUxPRxp1BozbVH1ShmZQmNBiS2eE8bEhIKc2PmmmyO0qxXOIgkp/ST+OceGah+E1Z9BRnsL0u0+3KxfHTSe1VsUuAPOx/xXnf3jkH0mU6kInKRJdrVTQ/eyI8j3Y2GJlVx5UbKUminSy2eyA9mRHj27wtLPuD9Dn/8iVR49DYUwgGR08MvMy3gqljygT47Lespy8xW9kaObLR/q4pTPIhUbqsmzltf6OwUfpkXHg83ensK0xmbNTANsvi8hRz8pnqL5sM7Al7tBpd5lcRrWjh0Qq3+ X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: JUI1fMa86FWAGn6klAWnPfzmSi3sAteSv1Jag4IcVFQjZwoiFsWrVs/x7LnJPWjdvkz+PHyuPtjy5mJgoqY5e2z0EZGkrcmuuvwkeYJnatBI4ptzffm1KKXhK+wVQNf7+DgXdm29btAmsRmtmnKhcRh00g8RcAl1KNVhASMA42LiEGqU3mo3gZswQzJiyaoIWgulWjcb7reTsZXq47PtNJfBeL+hXQIskNFJNajR6dUOzJXGa2/4L4OfayxKmQqNR7dBDCGE0jUKVyotLhF3DTQ6nBEGhs8YTNW7BG8pw/67+aGoTY84Pu8OXmZYbt1OwerFcrxqPZzlFfU+ysdkGik0/Mbum9kK2MCYeJNjycrZb3bxeeSmsxj+eucOf/eKwZSbKl5EbCEprHLcfmCuKnJFEuxI3BX0Uphdp/juSV3XjBAFf8sbpPlPsoP4pKjhnZTuiUsgtZE+Ttt6nK5U7h9a9B14EnKMG2NPaz2nHCTMuUddM6N+ZDZ5N5kt7XLwZlsDDsiBcQsRXSl82bb4T/0sKXG5J6TM9q8TPReFz4mcKJ1vsgfZds1oySxzAOH+yibuNY/+K9abekSZhoCg1c/gIYvzGbrjqRkBFSyMlV1PmnqsUFTQFMSD4VD/xrwPzf+eqch3tZ495oCOxC0y0HThiLM3JnJ4CshtV+EzRvwCeVJiKPd/O9FrSy1kWp5BQknAGzQxZ6M4BYqt/UAF4I0yJIWvHIi9oxNVnfXMKlFlSVEQFFWXUZ/eUU5kg6IdcHLhL7HUHcU3pJTKLrIO4KocJOBLglVZIwYvdzQuYWKGdaRQo7DEW10UaYmpcAjIExZ0uN+tSdeBG2kMewcE7Fc6SEw7uD4MADQhAtiqjIqWy9xGxytDppPMHr/KgJFB9urhJoDDORttaxACAE6cU5k/fc81eHAd3XiqgBfwOZw1M8Ryc4UDtr+yv0p0EK1ie5EhpCiWF4/bNjLmyoSJivT815e5bmFBQjFT+Ahlin5rcpVz2uhZe0TAh0fpDZAn5b4AD0fNEYd+VnE3hNor96VBUlD59250wLv1Jp/YBAw5SQoR0UKHRUGvkboB+ZFbiqghuYBENF/PwFnhBdsitHhjTdk19XrBkQ9vvgImTXjoRkRxbhEm9lHYdicTgumC3tnn9UF3tyKEqVnPRUgFoM6XhOEoMaKvHKjvjCjQOwsQTLoNRh8N4mZpAOQatz5X04iokjKmM+g+M2ujA2k/FMX3qPPpgEJGPhanVLY8iVfzXVVFwToOGHG9e4jszUHoTY9qqgIM8+2lACqwbj/2uw== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 8d18b0df-b3db-4fbc-33ec-08dc5808957a X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:15:07.2717 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 12/27] avcodec/wavpack: Move initializing DSD data to a better place 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: TREFqckW8xps Namely to code that is only executed if we are indeed initializing a DSD context. Signed-off-by: Andreas Rheinhardt --- libavcodec/wavpack.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/libavcodec/wavpack.c b/libavcodec/wavpack.c index 83f42f392d..6fd297a002 100644 --- a/libavcodec/wavpack.c +++ b/libavcodec/wavpack.c @@ -1011,6 +1011,8 @@ static int wv_dsd_reset(WavpackContext *s, int channels) for (i = 0; i < channels; i++) memset(s->dsdctx[i].buf, 0x69, sizeof(s->dsdctx[i].buf)); + ff_init_dsd_data(); + return 0; } @@ -1533,7 +1535,6 @@ static int wavpack_decode_block(AVCodecContext *avctx, AVFrame *frame, int block av_log(avctx, AV_LOG_ERROR, "Error reinitializing the DSD context\n"); return ret; } - ff_init_dsd_data(); } av_channel_layout_copy(&avctx->ch_layout, &new_ch_layout); avctx->sample_rate = new_samplerate; From patchwork Mon Apr 8 20:13:51 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47949 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp136310pzb; Mon, 8 Apr 2024 13:16:21 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCXQQ/IdBjmLJTLrHaaoNWrqPqmLImHpp6B8zl/anHOnMQlD9nbDQlAK5WfDNOvyY3M6gmbgVslGbXD9Pkah/6TAQxiIjzOeDlfR2A== X-Google-Smtp-Source: AGHT+IF5UVqtMeVhIXdWDBFPUCeZtRS3t06Dml+uvqyJTG9E5Kcl60LStZeqDCLkTfYkURumn80n X-Received: by 2002:a2e:8095:0:b0:2d6:fa0c:77b0 with SMTP id i21-20020a2e8095000000b002d6fa0c77b0mr6001039ljg.2.1712607380383; Mon, 08 Apr 2024 13:16: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 f23-20020a2e6a17000000b002d8647feb8fsi2335641ljc.579.2024.04.08.13.16.19; Mon, 08 Apr 2024 13:16: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=@outlook.com header.s=selector1 header.b=Ips1m65v; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id C314768D314; Mon, 8 Apr 2024 23:15:17 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2044.outbound.protection.outlook.com [40.92.66.44]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 93D8568D39C for ; Mon, 8 Apr 2024 23:15:13 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=N2PrGQ04AnWpeIMlSsTcr3fFN4AEgrpF+vxdsgleUP9fMVfELhzZc1l0g8+WyLCqAjjv3PPU9jwLraJTgrwrcc3auW8lxyM2hkoWPAj0TB2yXTYFoFmuF+v6k3pWgUdHVOkFOAi7xtj84YqvBMmrPfc1Xfgb/l4g0b3OpqxVX0NhEnSoVdGybdsVVhNYl6V+qrVFPffK8dbD0lDBgYy2uMbmME/6BbzNYc0TUmjVRseXRDVgRNB4qL9FeE8sEl7opZrQZJFO8L4a9jap9w8U7L/sIyOSZDo1jyyfzVT/JucBJ4zCCxfpZEuAnCMdgQuUcZtKaTk9Uz+4dEx7idrwdg== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=FfhibJFdMVH3G5qPumGLREJdk7nT0CxhW9H5bxDfEkc=; b=jjbyfJzUyAoncZHX9MBfQ/bcbxtuxCb+YNOH4085672xOJtegaE6tqHsAoobU5A++oBqvuDVcRN/qf0I9tHnLQ29ZBK0om1OgRW2o5F2FvM3ZGCA1+zRPYLzYzgx2o1KwX5bcFJJ0l7nu76LTDBheMFlh46O6t6y15UF5niV62vEQFJ9hm5kvK2LejPsM9joubZpoxGURUvs7RobcDuYNR5F346VnC6x4G2jst+F7owEdIWolD+or0Xr6PsCrMQdF9X3o/4/8gTwm7uzT/zGDE42Zm+BEx+Gcwuf8Q8tk/n/VVwGFW0lunllzwBy2+uB2Y2PspvdPfTLWqATFB3y9Q== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=FfhibJFdMVH3G5qPumGLREJdk7nT0CxhW9H5bxDfEkc=; b=Ips1m65vNBUekPuV/uwwrZKI3nT1n76/XfCgbqnWASRDK13LEj9Mka+iyTfwoTDsCa0etupRy1LzjUkX4KGZFfKwRW3nJDHS9Z34Fh8IjnqlI2dSDaoJCVmZx5lnI4wxyzQIzspcx2kRl2x+B6s69r9YVfc+HW86O3oKoTHUwe80OpXvuDIguJLGLZKod/Tms8/wBBcJeNnmqhus+Ga8h3ApXPYI0EWl7vOXpdakmiyQ43pcEOpB9AQImZjOwqR/s4mseITFp4oc/4YG0m8bUaOZmXG071hcIPYUXBno6CCTEDtHhU9Ig7+2qwZ5qVsdzatwzDfgy5x8y+D1GLCxmA== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:15:09 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:15:09 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:51 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [Ujf9seg6ETw2fIZmk6ijqlBDjUDJeKjkXwSFj3e+9HY=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-12-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 99e3502f-9d67-41b9-b146-08dc58089629 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: cAKHiELnnottnNkXHti3ccdPGjUFKiEdZUZsn1kQHh7rUBcR2KIDQ5d+QLwSdhCDXOhvy6R4WrY0zNQJFhjLA2U4vkfZecANi6f6KvBHqTZPD46vGtfhh7Kf1ID2tMQnIoqM8YKxMHZUJtOUmA/zPemErbSjbtroSznP8CY35JJZG2ddTfSCrGHcK7OeeWF5iDtX3vMs2/RMhrICyP+6E1JcGxlfxbRe7WDXQGofpaEvZWc5mpDlJ1WvDVnmLuFm6/9EDICSHprCa7/zUWZazl0euxRXaMmjv4g2q4gG+1FOAVTzCwFTFhYiYd58je+c3ViRtN8qjmuzyTUUTIbyKTWL67lmvqz7WWjNst4/bYuCUcnerM6N18iCxAGDKWDvo95slzWSPPHmiF/gycQJQifTEj/FcpToOeRU55M/qwpfC8iKhhw1Am3hqHss6Sl6WU0tsFTzW/vu6PTGlRqskJZGwapqY0+Q3/aUC0cxjCRxLEB3Ecdv8C87DFRa1vdEFle5tPS/C1MSAxNxM7thvVbYdA2xcgNWvOEq+5RxDQfd+PH7Z+DXkUyA2WAMK6D2K2dITRWGsisNWDaKQrTvb2BUs+CBwIxLZewiSulqjiWpLE0MxwirBkHhNrC2Uej8 X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: 2ZcVOQ2aMIfPdMfWi/vlAzsUePM2leYgv32UtUd3RnTyqyEEAty19CuV9RDiBFwW16rORk+VXtq6ToBvT6xtRM28WIzKbV0weN10Y+ZlBdxOtIRJNs2I0RX4IVLBwwu5fNbzpj2itOerWbQesbO2tO2DUCRADTU/RrioKq8hNgEdgDK1isCKYbI7ewgeEza67x3GKMJu5f3H49kEK4VwJIhHlIEFUZZV0qcz99rIbhUMh6CFLmHYJngRgQXIb7Qqy61F/2gQh/Or8ZnAXDiEkjOvAY4CscG3rsllqR5ZbE5LasLHYjWuhF/VCleH1udKwSCZYn4sOhUMe7a/teq2nqJ3XvppIFdar0JHywNNbQhZ6ehRCxezAF2Am2oEajEUNIZEbmwr0HckwFP6RA/46uLAeAXEqJuLoiIdf7lR1v+7puzSRrSD5ve/qIr7sBrYywYQWK5jsRw45ABAx9Lola3adZSH6HumGqD8jx7N/IYr3mPbcBe4Rozlkd4D6BheHqs+GQfgIsQ8EhLZ4Vt+8NAnQPGgYGgRwdsGCt1hrijdw/01njAqx/Y6vKTUmP4IF0BuBXijSTIlgkeblp219vJsE5Hq8RWet+PseliYB0YlhjloUkmeRzSBBvznoLglRL/Y1EuLeRCKeScH2io4F9lZBaF7mQwk14Ib2WJghfcf+fXqu5GzXDl//slkQfkKIM/ywwYiRzmXtVI++1dm9ohhBuehp2GsNQPI4UkV1Ll5FvpSoa+7ePxabPXY2TEeym1RPt2bSlSFe/Hg8l9HZRjyXb8OSl+dFaxpUx+3oUuexkbsArulhicYtvf4Zgd7Y/Ow9rU4Fr97I9x9aXcxTKy1Kb4pVhmkACzZCD6YQmAOiohJjudjIpuvRmEtQgUIF09cKYaLMPcAK+Y7u7V7XTh9OFjTMlUC3+LdYjyUL2jbHCDfQXXQBTD1l4ZRQP61g5fpA9Oq+va+NhFH2Irn05OVMiiGO/0XGRKOsyNTVEkOHUynKDHlwKVZka4ZnSgPszRZi/xQcoWfAyPmnbVzMwRK/Y1uVdosClXLLysHXVjn+jOKX8xhsUn9r7GyIKFtg9Zaj/j69Wu5/ca9eTGnLjpcL22pooIo8mW6ZJyN3jiut4FLH5G6cxoWJHNlO3A/oIRXve9qvycyMvd5egb1Tszh0tNT6fF1QdV5bPg5ZT178Ili66xKHsCCj92YmxIjlxAtftlyk0Rnno9gMB6E/Ls3Ajxk6ATeAq5gTdHOyY5AHpYv7xF2h4DB55UyKUjmwJ8/wjUpZdC9iBQejhP17w== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 99e3502f-9d67-41b9-b146-08dc58089629 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:15:08.4112 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 13/27] avcodec/wavpack: Only reset DSD context upon parameter change 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: pR9g6dYGryGj The current code resets it all the time unless we are decoding a DSD frame with identical parameters to the last frame. Signed-off-by: Andreas Rheinhardt --- libavcodec/wavpack.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/libavcodec/wavpack.c b/libavcodec/wavpack.c index 6fd297a002..51ac943fe7 100644 --- a/libavcodec/wavpack.c +++ b/libavcodec/wavpack.c @@ -1526,10 +1526,10 @@ static int wavpack_decode_block(AVCodecContext *avctx, AVFrame *frame, int block } /* clear DSD state if stream properties change */ - if (new_ch_layout.nb_channels != wc->dsd_channels || - av_channel_layout_compare(&new_ch_layout, &avctx->ch_layout) || - new_samplerate != avctx->sample_rate || - !!got_dsd != !!wc->dsdctx) { + if ((wc->dsdctx && !got_dsd) || + got_dsd && (new_ch_layout.nb_channels != wc->dsd_channels || + av_channel_layout_compare(&new_ch_layout, &avctx->ch_layout) || + new_samplerate != avctx->sample_rate)) { ret = wv_dsd_reset(wc, got_dsd ? new_ch_layout.nb_channels : 0); if (ret < 0) { av_log(avctx, AV_LOG_ERROR, "Error reinitializing the DSD context\n"); From patchwork Mon Apr 8 20:13:52 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47950 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp136379pzb; Mon, 8 Apr 2024 13:16:30 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCUDXr0LefaIu4L+LV/t0uxhZuuiW8iEewoAk340TkqogzgducU3SP6LrEevbRxV/JPv2hQAi41fSD9P3EzmidxaCyMKs69MRP0I6g== X-Google-Smtp-Source: AGHT+IGmJ2+fkV4VWccvfNpwFXi44CqKVc9MxOcDrzAb+5qU0otF1RVmpZrGAdsRcSlytV6Nm1IL X-Received: by 2002:a19:2d1d:0:b0:513:8266:f5d7 with SMTP id k29-20020a192d1d000000b005138266f5d7mr7422431lfj.3.1712607390227; Mon, 08 Apr 2024 13:16:30 -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 o15-20020ac2434f000000b00516cf12bb83si2359029lfl.547.2024.04.08.13.16.29; Mon, 08 Apr 2024 13:16:30 -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=@outlook.com header.s=selector1 header.b=A7rrYW12; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id C7C1768D3BE; Mon, 8 Apr 2024 23:15:18 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2044.outbound.protection.outlook.com [40.92.66.44]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id AC64A68D3A1 for ; Mon, 8 Apr 2024 23:15:13 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=YmG9y9QgNK06bEUkxuPgf9nhm6qfRyFdG5OxsHbd1blV9iN76swPcA7NcAFgo3tj0i5zwkjrzJdrgeqlEV2ZZlToXOjc+4zh1tnrOARBiJ9HTT+DSOxDt0HQVNgb+g9E7Gt0nPLWyxlrzfRLFgfaqLD+HOsAWdNdld15HjK85gof/QEkxjm/qr12xKJC8PTKeQMfTUrnTLxYW5PnF8A1o5DbqAP1Y8gtuD4S+CU0zyb5N/vUbDPRAE8HcXrtN4knzMDSY6DNFUP/jq3lW+nbd4NdjWiU4fPnYA8XCpAAfD41QT1RjhCSA3QeANP7yH4tfmNpVk09lSQZkwq7ecLlNQ== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=mdoOfA2/R/6W+fWU5o0VPBSo5U/3fE7H4NqdPNg9xtA=; b=nymbo04SI+XHfpnDI58jWIDq9ADe2T+0ExVra58wQiPzCsDE0xUIOALDSuyilKSwK41i+EWwRA6wVhrMXzdluIC+H30I9W0veCNZG9CT4EGAp8zH9bXRYsEXuuBJzZoDjkdKWWHR5d+/+jJ57u8lXQYtRfDRQA5q8uFq0bm+unokLsY1hroPNTyYobXUUb8GeU6+r8PFSrspOSsxZrJA75ur7GUufsgs7ZrFdLiIB6VC81zbGgTBRZOwPZ9EG1qtWcomnqM3lEt1o19Ds2tocVaeaxIyVGT7wUBVp7ERNuZ+mSsuNDca3lE2UTjDEzZhLq3UCaglgQbmWglyo3Slkg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=mdoOfA2/R/6W+fWU5o0VPBSo5U/3fE7H4NqdPNg9xtA=; b=A7rrYW12lEe2MHjI8oAeR9IC58bq3V1FjdeKeJeu0RzYZEUneM4E+1iEGu3tOJLGE6MGJXpFhKF/J31rWyvLpHzDge54pm2Gyr2sGRYpX9p/WPMRo0rtGcmyf3OGEtlWx/c0hkwR52rPugFvDSQtqjb4NYDoYsYpwr0DWuA0m5IVZJrf8n8XoGR12vIqKNlzV4b0yxkc72dbGhgz9GHhrhqo2kI6R3hYNjfu/5+caXz2ucoKzcjGvbFz03chHwMLkTLUCMAybdC+8o5sDsVoRGgzRT0XcbDdaVYhKY6lEVImRslDB/rDcodFeAIxkT4rFBJxkYsao0fkcM0CxJnVcA== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:15:10 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:15:10 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:52 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [yWAUjkxDA1P47Or9TAwgcanRYUrJmEeOVa1WHhOdms4=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-13-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 355d36b6-d86d-4b45-73bc-08dc58089745 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: ishR+hpcOks11GAFHRR/9irx1IbtqmEIjLo3p0VuGEHce3O7lM4r1Jo6zFH+9WPkcl3KkzbxsAbhsZfA7G3uIAFXMbhL3pQ4JXTZUzoeSjc7pG9iXIuVLxxfJPf56vdse179GEfI0phqXMvdpqiPnn4FWwstvBsdPwsTMVvVxtXZuP3BIyAO00c2Btz2Gb8146zEIlHxfe19CvxO1xK4yr1RStrzz+op5rU5fG3VH6nC0mNlwfyk0j+ozcMtvtIiStWbo3Q9CvcW4MlQ0LZQurIhCMBA16RdnK/a01/1J/n153P21SIXkgVf0QJRp/epJ2o4gbmAjOFxjvTzdXRRIUTY72PFyn+4EgEutW4yhVNbrf8mjWIWMbGNMMe1/BC7Ksy0TY0mRdVfvjRP10936Qer8sKZYgI319ErVegU5pu/s589l3rnMFsSHxR1Rz4POGoAPHRnwze95quqEhUsbvDXb54zp4zGzuS4gV3JxktmQrh28B7rlXRw0nWY9FyxpHFktQF0KsulOcxRjfzpuvPTh4nZ757/xwKcVseNPTyRz+KaBALwZqJDFXaDHJ9RIJ71mcMlAu6gofs42txfe2ZiLIBfXVtGraelAzJTro9tc/GDvFiosL3Pz539FHHp X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: K1zw+SZWqh5r+Ia793fHWpihqXpWT2SSq27fsnbNXaaa5uM3JW5wmHLH8Lu3ADB/irVVRnMPqlV4c5XPQ6xMxApX20lVU8X2psh9X3HTbL1cr+sDVUOM8CDqy33NYe6c3XKDdJAnscxb/hcb67KNcQyAMIZd/IC/V/1sxxDkL9BSp0sX06D/lkOO1E328RZKjAqjRxuF2KJ/ZVFUE41SFX31KZq/brYa35FJttUYD7RpBupPMLbqrFzNhjMZu9Q5d64kFWJptir0xNVB0EC5SP3pFs8BVrp1IXXz8iADH+VAcXY9B54yyt95nJTbZ65HeJgWI8Lmq4hG8T15Do8y4z+q/hCZ6jfdLl+Nzav83m2e1IrpacB7zJTr22JZlUItatUIWahd3VawhAd0HJQjrRLTetyIGn79VbeAu+dhpL6qHbi+5mIu0J34bfaUND+iCLu+kIKbv6RevlbwZ3wO3d68USpBtl8yMqHIk7w+8Fk84tXeRmur5knAVWmtECwZrlA/B0PESUA85CKdK9c9VamC5uyjpLihQS96ZZBXEFCr2ts409Wc6bor5cjVIZprubbcASOUAge5eatVF87Ntq6OmVC2BbnaJIJK9i+KGplCtqt9En48YcHbTjx9ZURUSgosaFmqd2D61FPNic+8X+8jmrizXCq8evqwKpfzRop2IABTlTA/vlMtFN0KYiS/lZ5bitBwUc5Jo9nrfrSrXKT2FsXx78vM5a4Izco8dU92FldCPLpky3AN6iGvpz76Kvijj3/7f/OXzN0rW0tlrlw0a8TLpilfR+3E7oCrR73hnWs8sQ4OVa/jGeJS6kJN5cIjo4C2xqYk+JukmxB3CsKweJ9O9lUb7QW2hm1nHgr5qTBQSFMjgPIa87VXbd21+Zkv/hujX7O8Jm2ADVhNTUQJn5NjsNR6q9OPF5UTfwTFRAbecfZtKQKPEHho+LtKmUcnexgyNHVrmlPsO4750/G8DAvw4zJ5btJd2ht7Yn6fgAWdiuipDfhv8thsHAm4/6lrR77pvjp77Qh/V6fIHw8xLivY2yNIY+eQMBpR4B8WNNu3+LaD3JA5iYagJlyu61FYtbniGXQLLbVdholIaqobaC4gq5pM+gqufniW/Wh37Jmm/aIx8pU2LGQWex5ZN8P01U//ezbZj72ZCPC5NJxolRZbvhvxVeh6u7aT21Xf8PcWrJGxmlWVDwbXOJjIbtib5dtwzZk337z1Dl327XI7gT0Umh+b/094hl0X5RNIVHpaws7a9s4ccH/eqxnffnxKgZDEEKl26Hqv4aFsrw== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 355d36b6-d86d-4b45-73bc-08dc58089745 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:15:10.2397 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 14/27] avcodec/wavpack: Optimize always-false comparison away 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: e9Vt67dYs6WV Also use the correct type limit SIZE_MAX; INT_MAX comes from a time when this used av_buffer_allocz() which used an int at the time. Signed-off-by: Andreas Rheinhardt --- libavcodec/wavpack.c | 5 ++++- libavcodec/wavpack.h | 1 + 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/libavcodec/wavpack.c b/libavcodec/wavpack.c index 51ac943fe7..6ab9088213 100644 --- a/libavcodec/wavpack.c +++ b/libavcodec/wavpack.c @@ -1000,7 +1000,8 @@ static int wv_dsd_reset(WavpackContext *s, int channels) if (!channels) return 0; - if (channels > INT_MAX / sizeof(*s->dsdctx)) + if (WV_MAX_CHANNELS > SIZE_MAX / sizeof(*s->dsdctx) && + channels > SIZE_MAX / sizeof(*s->dsdctx)) return AVERROR(EINVAL); s->dsdctx = ff_refstruct_allocz(channels * sizeof(*s->dsdctx)); @@ -1433,6 +1434,7 @@ static int wavpack_decode_block(AVCodecContext *avctx, AVFrame *frame, int block av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size); } + av_assert1(chan <= WV_MAX_CHANNELS); break; case WP_ID_SAMPLE_RATE: if (size != 3) { @@ -1524,6 +1526,7 @@ static int wavpack_decode_block(AVCodecContext *avctx, AVFrame *frame, int block } else { av_channel_layout_default(&new_ch_layout, s->stereo + 1); } + av_assert1(new_ch_layout.nb_channels <= WV_MAX_CHANNELS); /* clear DSD state if stream properties change */ if ((wc->dsdctx && !got_dsd) || diff --git a/libavcodec/wavpack.h b/libavcodec/wavpack.h index 9f62f8406d..2efbb1fd06 100644 --- a/libavcodec/wavpack.h +++ b/libavcodec/wavpack.h @@ -57,6 +57,7 @@ #define WV_FLT_ZERO_SENT 0x08 #define WV_FLT_ZERO_SIGN 0x10 +#define WV_MAX_CHANNELS (1 << 12) #define WV_MAX_SAMPLES 150000 enum WP_ID_Flags { From patchwork Mon Apr 8 20:13:53 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47951 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp136423pzb; Mon, 8 Apr 2024 13:16:38 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCUYVSQEbcKi2f4NVa5/Ee04ulWo08X0Lc+qaaYsPZ+oqNhmxB9/01pfk8hFWkhytjzcnz2lBA2sxfFAQy59Yd3C726z6oR0bRY6AA== X-Google-Smtp-Source: AGHT+IExw9b7g3D6zYXnfeMd81TgnNAuc9WZ2ccYW1bj6a9Z3DzKJZpQ6AO/LTsSohrM62tfrWFQ X-Received: by 2002:a2e:8095:0:b0:2d6:fa0c:77b0 with SMTP id i21-20020a2e8095000000b002d6fa0c77b0mr6001330ljg.2.1712607397818; Mon, 08 Apr 2024 13:16:37 -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 z19-20020a05640235d300b0056bd5d042d6si4084863edc.33.2024.04.08.13.16.37; Mon, 08 Apr 2024 13:16:37 -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=@outlook.com header.s=selector1 header.b=NLyTBNC0; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id BBE2168D3C5; Mon, 8 Apr 2024 23:15:19 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2044.outbound.protection.outlook.com [40.92.66.44]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id C2D9C68D39C for ; Mon, 8 Apr 2024 23:15:13 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=iECm7U/WbXmKy1WzzixA0FibFf3DkN2qMR8ed5WOj+1jznoRZITW+ZoQCxAydwh3yUw/N2cOQPEDjDYfUseLCyUlF1gJEE1WlX9HywkbWfmOT9oblC7PtWyLbuUW1ul8GJGfiMNdeGS6YV+yqBs31jigTZXAMmVBGZzyMFQvuBBTmMSfa8EULbuBwQ6syXLvNif8cy7gwETUW7TZrxyRClPJ6eC2hziEmr0HMfDdB3yzkqLXvkGDCmdrdJFIR5R2d0fIMgb0DqBJOD0mso3ZIGBJraZKhP7Xec9JSGzNrHy/jHGuc7eoGEuDHtw+HWl7DsoOQVoq8aMYY0Tc96UbzQ== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=tIGWLTxeNrZT351vrRnGgIzD4qq6WMUb7xfGfMSeSng=; b=ZhjFt5O5XVcQDu/c+BEzHcf/j0NB3fzOSS1SLMV485l+RhuDQW+Eh1eiuOe3fGi9GysKASLxLe2SgMFfzq54Rbzbr8apEU0V3QuSrxGHvLRxy9LkmP/SCdEyVwPDJXZN40rabvNUzFT2/q42112lVoip0Wt5DvbDZjaVLLrbrTfEJoGuW9OHA58gGupxFWn2Cjl03q4zDeIOvADGw8S8CpbFuXEM0WzxKm2ykrgmvBRImsiE8vPwQIZZENj62SHbPQq2uer4gLG9fy51nhButYGKyYf/7BMWc//MFPLfvr8m2+fhoBTiWB8eP3pUV+fxvdmBgENa8Ngj90TApz2efg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=tIGWLTxeNrZT351vrRnGgIzD4qq6WMUb7xfGfMSeSng=; b=NLyTBNC0qnxxX6i1RdhcdODW3IwQJTG3bfU2BG+32E3CdS3LypMmLdd5MledcerUMJx/AKoKrTF48OhGsqHnrHrEVi34nIt+/zedggaTjkcgNfmyFAWf7KA2+2L7gcN1vmKKVRZ3S2A9wMLB0V+cWaoBFJY8G+wbhLCyIjTwr1l0Yfi9oO5pn2WsI650fvKNGMuDwQJUzuMqgrMHmBTN7A/vM8ya/T4b+8Nz3Vg7f4Y2NRS0/HWFC1mnUB2ZKTeSEJ5MO2R84NuKi02VR3M1lUsLU02MR1GAgJ3BMoH1av/MDmnl0Ti7AxIctQXAc5fO7UqpJFRBdIaZep4RpsqzWw== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:15:11 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:15:11 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:53 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [SpL/dHe/hZ5G+aY+03LSmmgt5t2ACPUX/X8ga65HiUo=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-14-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 01be9373-bad3-4feb-0d46-08dc580897fc X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: YlbbTM6vZCidvHdtAFjeJWBF266UzzfWAs891NAeY0oBlNrMSbfQrE85s4ifxvYmuUBty1cCeiYWhXcE9OwMV08ECkUkYzZzW3FMZcOSlHP4TNHxaGykHdy8o18Gsin6U8B8zaf0qCP2JQwV8q6Hjwe7QtUqI2TK3XLsjqdgzYFEun9JRX8bpOYqyGJh6D7HSBpmG4uGU42eeVFwS1RDtgqszdwbiOh3m68FNI1D/o5E+yTj5SUVBvTKf9+eNNhX8/Gj/tFHVAs7r2fXa08JQ4lhJ/gviJJu6GalifVvVNXcr41LTJFkb7L4F+aIShnHMdIz2nPDI0N887ZWgB0+azXKfY3JPQcwpMg1TpfkIEfZgjMgIB7KFXXg35dm+CiBGfy7PLs8MKdWD4si7Jk3Dh9433e4RlzbZn5yF1jvCT79U5u5kPwE+L/TLm69R5aR7K4mTDWhEsXyaFQ5CS0H3kqzn5t9HW3Ihk5Mc7L3li50aGnR1O5rkuoRxeYRRgMm58VGS5AVeJJSXnRtv8x3Gm+PuLo32FWVtWPA3KlXOYt6qTfEsM7m/pWvniCehz9KLrmgTK45rM9fD/9nU5O61bu9u+4PPk47VyYkbg7HRi55l23xezPeyyiE3fXsJZbP X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: QhFKgS/znwzR3VNa83bw+JOrrw7lDZC1QP7MfM/xe9UjEQbiXvfBOQzBfWWSCO/ofgXnzR/gogF+b4C3k7TzKqsmIInzbvvLeFHV1Z6h/hPy78Zpw/NDMudFVQDhEJCMKJU0OPZOZPI3bCksAaiuTuOERHIlknxRupgL0+CtxbZbWjT4utPgL26Gf0IwhwsyJyfTplbOCxyzgmdOJ0C2etrJSKTJ3tXcJv7IOvCI35jLb2AppKOZjCT9q5Iy+NfF2KdAls+p2gfGuGIJxxf74cDSGo1DaFVsUE+MJ00ls6ku0wosM98k6yc7W7mHx2mRYujeOA6U2FmKBLusHGdubYeo1Br+/7s4zpOafl/i/bVcxGlbGUWI7D2sb6cqCxRASJwKp+I3+dvUMwkGWMyhUUcxYnojKVrWdsPyhE13JcmYW7av0T2U3Rm91mypzeLMxUQPGaT5mIKemAGdnWRbxUE3A3t7VhWUUp/J3u4qkBt4v2zVVvxCz8lGwVxquvaAdWHdG3yR77sNzliRZkeNSXB8TS2jdeEOITxH8YXi+DxuHJCYDbYefr4KoopQk/63rHyN7KAUVgDOTM5mCdZdVgHmKD19R0d6WusSdz4ws20Oi4GYNTvGZnTmjmJOJ7gfgTB6vZenguI52HcTRVeD2oNDqXS47qsFPYBb6FysMrPo/aYaGjQhBwcEjnLczO3oVNlYHzRl1TW0U7VlsGZcsPMK3I72UOrnPqeputx4y86elvccEOcKS0D88r6/I7L4Y5V49V0cG9JM0popONAMCcCCOlxcc2pnyVBW/O6YyQ58oB4XAGZd634S+mojTpSSKyui7RQ6imANCMIPorU+MDeDON+GbZRWDRYTLAHbusWgXnI7gtnaXQ4bAbGuhFQuSnucOULj2VsXQRBJvNEUAR80jJ+l5WcWZEYbKk7rOogwiR/14mQo2aql8DBAk5EeFHwx5VD9Ukm8IT5Cf4hQ56zx3WSTp1/FqtwyDl/cx5siNX9E7t+mXUkdR0xU/cKngQ7Ujj/CvmLE5X5Jshyb2xTa2X+ycVbj+Dq7KLujRuESqycsqddAyBolTWpXRSHoxTnFyir6+4QD+Mz2LZP5prY0nqJJu2FSSUJiHrNwUj7DU6xyxdpWNfp2RWWOPuKaVYUePT3TQqeHYnZBg2+Z2CH21hC+khvQhCjBolROevYhWtLpFuC4/Dfa9STLLm9qMn1QToGO5E6YmY1ezBLJGNbU49XpivCoCeDaEhFytDEry0zlZqb+9sPxLQyBRqRHq7FQ/UDCG3533k9Rhamnlw== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 01be9373-bad3-4feb-0d46-08dc580897fc X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:15:11.4550 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 15/27] avcodec/wavpack: Move transient variable from context to stack 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: shvSW2UDG/UF Signed-off-by: Andreas Rheinhardt --- libavcodec/wavpack.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/libavcodec/wavpack.c b/libavcodec/wavpack.c index 6ab9088213..d4cf489c0f 100644 --- a/libavcodec/wavpack.c +++ b/libavcodec/wavpack.c @@ -103,7 +103,6 @@ typedef struct WavpackContext { WavpackFrameContext **fdec; int fdec_num; - int block; int samples; int ch_offset; @@ -1638,14 +1637,13 @@ static int wavpack_decode_frame(AVCodecContext *avctx, AVFrame *frame, const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; int frame_size, ret, frame_flags; - int new_progress = 0; + int block = 0, new_progress = 0; av_assert1(!s->curr_progress || s->dsdctx); if (avpkt->size <= WV_HEADER_SIZE) return AVERROR_INVALIDDATA; - s->block = 0; s->ch_offset = 0; /* determine number of samples */ @@ -1666,14 +1664,15 @@ static int wavpack_decode_frame(AVCodecContext *avctx, AVFrame *frame, if (frame_size <= 0 || frame_size > buf_size) { av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n", - s->block, frame_size, buf_size); + block, frame_size, buf_size); ret = AVERROR_INVALIDDATA; goto error; } - ret = wavpack_decode_block(avctx, frame, s->block, buf, frame_size, &new_progress); + ret = wavpack_decode_block(avctx, frame, block, buf, + frame_size, &new_progress); if (ret < 0) goto error; - s->block++; + block++; buf += frame_size; buf_size -= frame_size; } From patchwork Mon Apr 8 20:13:54 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47941 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp136497pzb; Mon, 8 Apr 2024 13:16:46 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCWFDGWkKd/KO3RzOG493K8UqW2vv9Trj/YfoKiVwJgguqBacidmsLzuH/K/sqQkBCSa5qVKXc52dTa87TkjyTwmqUq5LBql/its4A== X-Google-Smtp-Source: AGHT+IG9+SkXV9lHnwdyI1Mv0oH9HZTaNE0f68LRZMLDfEvHeONVfFfwEOYjberGwlQSudWei1Nh X-Received: by 2002:a05:6512:51a:b0:516:d241:11f0 with SMTP id o26-20020a056512051a00b00516d24111f0mr8521709lfb.7.1712607406686; Mon, 08 Apr 2024 13:16:46 -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 a9-20020a1709064a4900b00a4e7713adfbsi3822070ejv.964.2024.04.08.13.16.46; Mon, 08 Apr 2024 13:16:46 -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=@outlook.com header.s=selector1 header.b=OsEvMIVL; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id E0AF568D367; Mon, 8 Apr 2024 23:15:20 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01olkn2071.outbound.protection.outlook.com [40.92.66.71]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 1FE3B68D307 for ; Mon, 8 Apr 2024 23:15:14 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=ogHwwu1SPKhNDbbZFmuYcH2FF5Xzgu/fp9SRdBVNGL8TC2m3jvvFsFPMsnxJcje889efac0Y6mRJsEGjInaUjE97jtWZNa1oAcAuruJsyPX2kEG4+DfiUmoTnFz2k9hy9c9TdJNKYmmWFmuCpee91oOPPTTKYPTBzQWg7LNp+m3MDPIttdm20o0sKF2Web5yqgQ8NeZ7BHfWobLp3l+mFcRN5nkWaZeKbt6lSxeMIXOVMfpoqzkQMS99IaRCp36bIzFIqh9o4JfWPrlV0P4eX6vD8hVYcTbDszFxhoEMRA7jawlRyVTv3iE1YfQ8+DuVkqsRy1JAUCgM81ce6mwJ9w== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=LHLXzN91cUd+qj53kuxQfoMopV5FzU6Hq4hwKd31bA4=; b=l+csvSQii6zdNhxq/1ut0e7ihPVoktQdE7QivpC7qdXa+bVLrgIKGL8DauNrDjr3C7qNfzn26ulpYBI+qWFCS1ksmoqMUhUFfUZ76LGQaEtkYyooQDXjsVuouHP+CPk9xEOon7pTXNJX1RbGUdPS88rY6obd5aNLJDwfs0vcPnN5hLM2KnpGn/PpZsD6i6b/lMDxykVr6NxeaBM0GvCsbwttnkiXmOG/F+T05K3a5YH0mmLO7ZWdSymTPCDjjDvpnORG5EHhs+Bor/RaWM5VUz45HXWkkMuKuLxdJWVmENOhOp8dt5SPVtxOX3WsvUm4Ngse8enPn8x89BGnDa+jMA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=LHLXzN91cUd+qj53kuxQfoMopV5FzU6Hq4hwKd31bA4=; b=OsEvMIVLE5BUHDGrt/jTubx4gwN5bCLOl9XoqR/yNEsTJ9gDJRZTeLDlG7AINWwiB2spgo2DqGAfT3KvZJ0KIpkoXp/xwHYs0B21k6QM/whJ6Rcdes+6Y/9m3P9645J+61XdZVtD2sic4NIiwMAEi97K2aTVjDQEyF7TJGueghDyHKNL7QBVno/uFZ7KrRBS5FS5zHGXhyJ/1h7qRqdyU6Nf1hL1CBEVNzZhVrPemrhttCxc8FWKRzAujJd2zZcSM3v41N8yeN6peHbVnizSLbLmkieGKznRP5XzwqRf2ZlOMe508WafClxX6b3A3muDX1Fn83rOVJWmYEdvFvtIJg== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:15:12 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:15:12 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:54 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [biuIK53c9ebkDvxTzm6uCmgi7JyWMyochUpUbYTwHEo=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-15-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 6dcdd98a-2675-47c3-c298-08dc580898c3 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 3lmIDjWhadRquKdLYSxFlfA0EQHz8co+QuauXqcpgTQT3ngd1i6RL9GDnVjzTbjXVzHpHQqiwWMHJbvJ3gldwcl41SMtGw922Fdn06l21CxtCmHq81g4Dod+0N7GfbYlmgzlEb4aGWFy4LJehghq51hHDiyl5DlDVvx07K4xtXIS6Wue2Xf6yzluB8HIe9iS4wttflGGd1f4uVniT7kBGLZ+iLfeHBvytBjt1VVUa9SZd7m2Br8Fm/Hi4F5IcFRuNVKM8jYcF7MCxu4KRXTU1DhsXvBYIjpHZ85EuQ29OHqFB0sPVhQ/CKEqMQeP/sOR+rX/6b8pVm+WRZudfMPik4ArT0N/rvPnqH+kkku7FTueqzzuNsoEmpv9vDzeyhw83SiVYi8Pxm+LdG4NtnrfqPAC2H//B9lBZXNYKuFgh42W9KYyEKF+gbViBh2z6p37Zw4WKTMpLkprEQSF2DZFjnceyprOCHUWYX+R+fYKkIGtXgS+5LH49a496KTXhygBkWSHPtyNnKaf0AeupKQznjGeb3oa0bo4c/RYACtuC87Xq8w3s2PdBFZ2FDf8RRllo9Yzrk0l3jHFX3Z/ee5DFMxRmxsCDhm1Kd+3EA9eiXi/KZSnxLN3+TMuKG5VKloL X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: K9ujdXPOxYzTGth/dxFbxTqga/z6Mb9jiw7BEBZMYxUWiu9MUccqUQhc8daVlIhm8tpYNzxI+Q8UA3XD0eY1gxKiRKrQlynS1SfjkMQd/Vv1Z7QvVVvoBwWG9/Uwp1dfgV3ZLXybaefNCH1PWlLWB5jE+EqwO62Tbpql7bcwEC7giihzdHlAHd8hqEu7JjtyItqgHZUQbbb7JwGjH5OuVztMugZOgSPBsDtRg0aact3xC7BQ0Y2Mb89sBzc85d1RJQXx+2yGCXUQhmahwv9w1Y+h0BAOcvwTbjrYej9LSbHQnfyjbUDewAfRQq/JW+mzaW/gULBnqGLxLAOAu/NeK+WavzZrMmsR/1fCvGCeWccd41eMV40gaOtEGKc8bCcO6SrN57JrnjGWZl8vAWamDgEqmkXzo2D8c6uwBk9sPEXNNkdeU7PZXa/xdzD+YOVTuG3/3myKg2uQVHETo6r7tXCNo+1601EDfVpcA48IXWn3kO11xcMs8Y3MWnii0O9bUVRI0Q/pzptaSF6xxvX7Md/NOI+ehqqTWJ7Mdg+NrcIPVnA09BFvv+SqKmMq32RfLbMYKq/tdYyfgxqHhPVllWIJE0nmB1X8VqQGewHtPhTt5dJj2eugtYwoW0NKwD9rXtEkrlyxZ0V9KrZeh4glMIMHpQbY9EaHr/JBrr0G34C9qXbC8IE4BbpAbOXgZFLtaG8mm3JO8/7+gNdrBgPUQCfI3uZtwG4NUwPmKV9GMS4zEskiX48TWXm4TcnZruJhTZcRIwHAZjEx9Za5EDQzVipj8jKLv89Lc5v/7t05afu7bl5zOq5qfK6qtF4N3is63v+A1N5PpHqM9rnI36MtGMq/y4XM3rzltC0xAY8VKw2TEZGT3ODnxYX0NViLoEbMlZJjGoLMNrCPT38c5/czvFFCnj/w9/0vvda7bcYISYJ2N6zIQkOujAUhRlJdlDEKjttU81OOT2QV5UY1Ilm0uCSZHlo0XmHJO4kSfAqYZphnHSyvJMKH1pvB7mx4JK2T8qEbgYtMdh4uMy30YKiutHJszRCyj1i4KpKq0F4IIUop3Jelyw+dS8/hv8lCs6dC7q00uxh4weminiLvph5fgNv+KOZ92TXpetJunq6rJrvQR3sw+eX/XTJMCyanfcd0Ap83yz6uztvXcDtCUWcrDSDtX2CBDBredbA1Cn90hsHpo8XkVlraXixUD/EcjsavpBUlq4x4p4dUWuYR0tNWDX81FvhrWt9HgPIa0Q+vhc8lsbXsdY+R2GnU9wW5hcRtt27HKWXi9LLzio417ir/Hg== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 6dcdd98a-2675-47c3-c298-08dc580898c3 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:15:12.7871 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 16/27] avcodec/vp8: Convert to ProgressFrame API 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: T9SH+HMXKpVV Signed-off-by: Andreas Rheinhardt --- libavcodec/pthread_frame.c | 2 +- libavcodec/vp8.c | 104 ++++++++++++------------------------- libavcodec/vp8.h | 5 +- libavcodec/webp.c | 3 +- 4 files changed, 40 insertions(+), 74 deletions(-) diff --git a/libavcodec/pthread_frame.c b/libavcodec/pthread_frame.c index ee571be610..e42a9563cd 100644 --- a/libavcodec/pthread_frame.c +++ b/libavcodec/pthread_frame.c @@ -974,7 +974,7 @@ int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags) /* Hint: It is possible for this function to be called with codecs * that don't support frame threading at all, namely in case * a frame-threaded decoder shares code with codecs that are not. - * This currently affects non-MPEG-4 mpegvideo codecs and and VP7. + * This currently affects non-MPEG-4 mpegvideo codecs. * The following check will always be true for them. */ if (!(avctx->active_thread_type & FF_THREAD_FRAME)) return ff_get_buffer(avctx, f->f, flags); diff --git a/libavcodec/vp8.c b/libavcodec/vp8.c index 539b5c5395..a1443f6571 100644 --- a/libavcodec/vp8.c +++ b/libavcodec/vp8.c @@ -35,9 +35,9 @@ #include "hwaccel_internal.h" #include "hwconfig.h" #include "mathops.h" +#include "progressframe.h" #include "refstruct.h" #include "thread.h" -#include "threadframe.h" #include "vp8.h" #include "vp89_rac.h" #include "vp8data.h" @@ -103,9 +103,9 @@ static void free_buffers(VP8Context *s) static int vp8_alloc_frame(VP8Context *s, VP8Frame *f, int ref) { - int ret; - if ((ret = ff_thread_get_ext_buffer(s->avctx, &f->tf, - ref ? AV_GET_BUFFER_FLAG_REF : 0)) < 0) + int ret = ff_progress_frame_get_buffer(s->avctx, &f->tf, + ref ? AV_GET_BUFFER_FLAG_REF : 0); + if (ret < 0) return ret; if (!(f->seg_map = ff_refstruct_allocz(s->mb_width * s->mb_height))) goto fail; @@ -117,7 +117,7 @@ static int vp8_alloc_frame(VP8Context *s, VP8Frame *f, int ref) fail: ff_refstruct_unref(&f->seg_map); - ff_thread_release_ext_buffer(&f->tf); + ff_progress_frame_unref(&f->tf); return ret; } @@ -125,26 +125,9 @@ static void vp8_release_frame(VP8Frame *f) { ff_refstruct_unref(&f->seg_map); ff_refstruct_unref(&f->hwaccel_picture_private); - ff_thread_release_ext_buffer(&f->tf); + ff_progress_frame_unref(&f->tf); } -#if CONFIG_VP8_DECODER -static int vp8_ref_frame(VP8Frame *dst, const VP8Frame *src) -{ - int ret; - - vp8_release_frame(dst); - - if ((ret = ff_thread_ref_frame(&dst->tf, &src->tf)) < 0) - return ret; - ff_refstruct_replace(&dst->seg_map, src->seg_map); - ff_refstruct_replace(&dst->hwaccel_picture_private, - src->hwaccel_picture_private); - - return 0; -} -#endif /* CONFIG_VP8_DECODER */ - static void vp8_decode_flush_impl(AVCodecContext *avctx, int free_mem) { VP8Context *s = avctx->priv_data; @@ -184,7 +167,7 @@ static VP8Frame *vp8_find_free_buffer(VP8Context *s) av_log(s->avctx, AV_LOG_FATAL, "Ran out of free frames!\n"); abort(); } - if (frame->tf.f->buf[0]) + if (frame->tf.f) vp8_release_frame(frame); return frame; @@ -1830,7 +1813,7 @@ static const uint8_t subpel_idx[3][8] = { */ static av_always_inline void vp8_mc_luma(VP8Context *s, VP8ThreadData *td, uint8_t *dst, - const ThreadFrame *ref, const VP8mv *mv, + const ProgressFrame *ref, const VP8mv *mv, int x_off, int y_off, int block_w, int block_h, int width, int height, ptrdiff_t linesize, vp8_mc_func mc_func[3][3]) @@ -1847,7 +1830,7 @@ void vp8_mc_luma(VP8Context *s, VP8ThreadData *td, uint8_t *dst, y_off += mv->y >> 2; // edge emulation - ff_thread_await_progress(ref, (3 + y_off + block_h + subpel_idx[2][my]) >> 4, 0); + ff_progress_frame_await(ref, (3 + y_off + block_h + subpel_idx[2][my]) >> 4); src += y_off * linesize + x_off; if (x_off < mx_idx || x_off >= width - block_w - subpel_idx[2][mx] || y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) { @@ -1863,7 +1846,7 @@ void vp8_mc_luma(VP8Context *s, VP8ThreadData *td, uint8_t *dst, } mc_func[my_idx][mx_idx](dst, linesize, src, src_linesize, block_h, mx, my); } else { - ff_thread_await_progress(ref, (3 + y_off + block_h) >> 4, 0); + ff_progress_frame_await(ref, (3 + y_off + block_h) >> 4); mc_func[0][0](dst, linesize, src + y_off * linesize + x_off, linesize, block_h, 0, 0); } @@ -1888,7 +1871,7 @@ void vp8_mc_luma(VP8Context *s, VP8ThreadData *td, uint8_t *dst, */ static av_always_inline void vp8_mc_chroma(VP8Context *s, VP8ThreadData *td, uint8_t *dst1, - uint8_t *dst2, const ThreadFrame *ref, const VP8mv *mv, + uint8_t *dst2, const ProgressFrame *ref, const VP8mv *mv, int x_off, int y_off, int block_w, int block_h, int width, int height, ptrdiff_t linesize, vp8_mc_func mc_func[3][3]) @@ -1905,7 +1888,7 @@ void vp8_mc_chroma(VP8Context *s, VP8ThreadData *td, uint8_t *dst1, // edge emulation src1 += y_off * linesize + x_off; src2 += y_off * linesize + x_off; - ff_thread_await_progress(ref, (3 + y_off + block_h + subpel_idx[2][my]) >> 3, 0); + ff_progress_frame_await(ref, (3 + y_off + block_h + subpel_idx[2][my]) >> 3); if (x_off < mx_idx || x_off >= width - block_w - subpel_idx[2][mx] || y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) { s->vdsp.emulated_edge_mc(td->edge_emu_buffer, @@ -1930,7 +1913,7 @@ void vp8_mc_chroma(VP8Context *s, VP8ThreadData *td, uint8_t *dst1, mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my); } } else { - ff_thread_await_progress(ref, (3 + y_off + block_h) >> 3, 0); + ff_progress_frame_await(ref, (3 + y_off + block_h) >> 3); mc_func[0][0](dst1, linesize, src1 + y_off * linesize + x_off, linesize, block_h, 0, 0); mc_func[0][0](dst2, linesize, src2 + y_off * linesize + x_off, linesize, block_h, 0, 0); } @@ -1938,7 +1921,7 @@ void vp8_mc_chroma(VP8Context *s, VP8ThreadData *td, uint8_t *dst1, static av_always_inline void vp8_mc_part(VP8Context *s, VP8ThreadData *td, uint8_t *const dst[3], - const ThreadFrame *ref_frame, int x_off, int y_off, + const ProgressFrame *ref_frame, int x_off, int y_off, int bx_off, int by_off, int block_w, int block_h, int width, int height, const VP8mv *mv) { @@ -2003,7 +1986,7 @@ void inter_predict(VP8Context *s, VP8ThreadData *td, uint8_t *const dst[3], { int x_off = mb_x << 4, y_off = mb_y << 4; int width = 16 * s->mb_width, height = 16 * s->mb_height; - const ThreadFrame *ref = &s->framep[mb->ref_frame]->tf; + const ProgressFrame *ref = &s->framep[mb->ref_frame]->tf; const VP8mv *bmv = mb->bmv; switch (mb->partitioning) { @@ -2423,7 +2406,7 @@ static av_always_inline int decode_mb_row_no_filter(AVCodecContext *avctx, void // if we re-use the same map. if (prev_frame && s->segmentation.enabled && !s->segmentation.update_map) - ff_thread_await_progress(&prev_frame->tf, mb_y, 0); + ff_progress_frame_await(&prev_frame->tf, mb_y); mb = s->macroblocks + (s->mb_height - mb_y - 1) * 2; memset(mb - 1, 0, sizeof(*mb)); // zero left macroblock AV_WN32A(s->intra4x4_pred_mode_left, DC_PRED * 0x01010101); @@ -2631,7 +2614,7 @@ int vp78_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata, int jobnr, td->mv_bounds.mv_max.y -= 64 * num_jobs; if (avctx->active_thread_type == FF_THREAD_FRAME) - ff_thread_report_progress(&curframe->tf, mb_y, 0); + ff_progress_frame_report(&curframe->tf, mb_y); } return 0; @@ -2699,7 +2682,7 @@ int vp78_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, // release no longer referenced frames for (i = 0; i < 5; i++) - if (s->frames[i].tf.f->buf[0] && + if (s->frames[i].tf.f && &s->frames[i] != prev_frame && &s->frames[i] != s->framep[VP8_FRAME_PREVIOUS] && &s->frames[i] != s->framep[VP8_FRAME_GOLDEN] && @@ -2728,14 +2711,14 @@ int vp78_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, goto err; } + if ((ret = vp8_alloc_frame(s, curframe, referenced)) < 0) + goto err; if (s->keyframe) curframe->tf.f->flags |= AV_FRAME_FLAG_KEY; else curframe->tf.f->flags &= ~AV_FRAME_FLAG_KEY; curframe->tf.f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P; - if ((ret = vp8_alloc_frame(s, curframe, referenced)) < 0) - goto err; // check if golden and altref are swapped if (s->update_altref != VP8_FRAME_NONE) @@ -2792,7 +2775,7 @@ int vp78_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, // if we re-use the same map. if (prev_frame && s->segmentation.enabled && !s->segmentation.update_map) - ff_thread_await_progress(&prev_frame->tf, 1, 0); + ff_progress_frame_await(&prev_frame->tf, 1); if (is_vp7) ret = vp7_decode_mv_mb_modes(avctx, curframe, prev_frame); else @@ -2823,7 +2806,7 @@ int vp78_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, num_jobs); } - ff_thread_report_progress(&curframe->tf, INT_MAX, 0); + ff_progress_frame_report(&curframe->tf, INT_MAX); memcpy(&s->framep[0], &s->next_framep[0], sizeof(s->framep[0]) * 4); skip_decode: @@ -2860,24 +2843,8 @@ static int vp7_decode_frame(AVCodecContext *avctx, AVFrame *frame, av_cold int ff_vp8_decode_free(AVCodecContext *avctx) { - VP8Context *s = avctx->priv_data; - int i; - vp8_decode_flush_impl(avctx, 1); - for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++) - av_frame_free(&s->frames[i].tf.f); - - return 0; -} -static av_cold int vp8_init_frames(VP8Context *s) -{ - int i; - for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++) { - s->frames[i].tf.f = av_frame_alloc(); - if (!s->frames[i].tf.f) - return AVERROR(ENOMEM); - } return 0; } @@ -2885,7 +2852,6 @@ static av_always_inline int vp78_decode_init(AVCodecContext *avctx, int is_vp7) { VP8Context *s = avctx->priv_data; - int ret; s->avctx = avctx; s->pix_fmt = AV_PIX_FMT_NONE; @@ -2909,11 +2875,6 @@ int vp78_decode_init(AVCodecContext *avctx, int is_vp7) /* does not change for VP8 */ memcpy(s->prob[0].scan, ff_zigzag_scan, sizeof(s->prob[0].scan)); - if ((ret = vp8_init_frames(s)) < 0) { - ff_vp8_decode_free(avctx); - return ret; - } - return 0; } @@ -2931,13 +2892,20 @@ av_cold int ff_vp8_decode_init(AVCodecContext *avctx) #if CONFIG_VP8_DECODER #if HAVE_THREADS +static void vp8_replace_frame(VP8Frame *dst, const VP8Frame *src) +{ + ff_progress_frame_replace(&dst->tf, &src->tf); + ff_refstruct_replace(&dst->seg_map, src->seg_map); + ff_refstruct_replace(&dst->hwaccel_picture_private, + src->hwaccel_picture_private); +} + #define REBASE(pic) ((pic) ? (pic) - &s_src->frames[0] + &s->frames[0] : NULL) static int vp8_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src) { VP8Context *s = dst->priv_data, *s_src = src->priv_data; - int i; if (s->macroblocks_base && (s_src->mb_width != s->mb_width || s_src->mb_height != s->mb_height)) { @@ -2952,13 +2920,8 @@ static int vp8_decode_update_thread_context(AVCodecContext *dst, s->lf_delta = s_src->lf_delta; memcpy(s->sign_bias, s_src->sign_bias, sizeof(s->sign_bias)); - for (i = 0; i < FF_ARRAY_ELEMS(s_src->frames); i++) { - if (s_src->frames[i].tf.f->buf[0]) { - int ret = vp8_ref_frame(&s->frames[i], &s_src->frames[i]); - if (ret < 0) - return ret; - } - } + for (int i = 0; i < FF_ARRAY_ELEMS(s_src->frames); i++) + vp8_replace_frame(&s->frames[i], &s_src->frames[i]); s->framep[0] = REBASE(s_src->next_framep[0]); s->framep[1] = REBASE(s_src->next_framep[1]); @@ -2982,6 +2945,7 @@ const FFCodec ff_vp7_decoder = { FF_CODEC_DECODE_CB(vp7_decode_frame), .p.capabilities = AV_CODEC_CAP_DR1, .flush = vp8_decode_flush, + .caps_internal = FF_CODEC_CAP_USES_PROGRESSFRAMES, }; #endif /* CONFIG_VP7_DECODER */ @@ -2997,7 +2961,7 @@ const FFCodec ff_vp8_decoder = { FF_CODEC_DECODE_CB(ff_vp8_decode_frame), .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS, - .caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS, + .caps_internal = FF_CODEC_CAP_USES_PROGRESSFRAMES, .flush = vp8_decode_flush, UPDATE_THREAD_CONTEXT(vp8_decode_update_thread_context), .hw_configs = (const AVCodecHWConfigInternal *const []) { diff --git a/libavcodec/vp8.h b/libavcodec/vp8.h index 798f67b3de..9bdef0aa88 100644 --- a/libavcodec/vp8.h +++ b/libavcodec/vp8.h @@ -31,8 +31,9 @@ #include "libavutil/mem_internal.h" #include "libavutil/thread.h" +#include "avcodec.h" #include "h264pred.h" -#include "threadframe.h" +#include "progressframe.h" #include "videodsp.h" #include "vp8dsp.h" #include "vpx_rac.h" @@ -150,7 +151,7 @@ typedef struct VP8ThreadData { } VP8ThreadData; typedef struct VP8Frame { - ThreadFrame tf; + ProgressFrame tf; uint8_t *seg_map; ///< RefStruct reference void *hwaccel_picture_private; ///< RefStruct reference diff --git a/libavcodec/webp.c b/libavcodec/webp.c index dbcc5e73eb..7c2a5f0111 100644 --- a/libavcodec/webp.c +++ b/libavcodec/webp.c @@ -1571,5 +1571,6 @@ const FFCodec ff_webp_decoder = { FF_CODEC_DECODE_CB(webp_decode_frame), .close = webp_decode_close, .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, - .caps_internal = FF_CODEC_CAP_ICC_PROFILES, + .caps_internal = FF_CODEC_CAP_ICC_PROFILES | + FF_CODEC_CAP_USES_PROGRESSFRAMES, }; From patchwork Mon Apr 8 20:13:55 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47952 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp136577pzb; Mon, 8 Apr 2024 13:16:55 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCWfO0viDCKMcTtt6aElLY98r0mcgYz3H7O4/gB9ja5oV8Vsc0gZeCkG7XVAFVNNi7hrekCZOc7sryiso75DMjl3GOKOVw/OH9iqvg== X-Google-Smtp-Source: AGHT+IG4X29P1lNCqwXeFxAXGxQP95kC7DnFxvjPM43i6tQhLRSSisCd8BVrxcFhasGeXn8ufdFe X-Received: by 2002:aa7:c2c7:0:b0:56e:5bea:56e0 with SMTP id m7-20020aa7c2c7000000b0056e5bea56e0mr2759724edp.4.1712607415348; Mon, 08 Apr 2024 13:16:55 -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 y70-20020a50bb4c000000b0056e03d5663esi3897557ede.545.2024.04.08.13.16.55; Mon, 08 Apr 2024 13:16:55 -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=@outlook.com header.s=selector1 header.b=YufvnMZ0; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 7F34168D3E3; Mon, 8 Apr 2024 23:16:00 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR03-AM7-obe.outbound.protection.outlook.com (mail-am7eur03olkn2103.outbound.protection.outlook.com [40.92.59.103]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 0EDA268D384 for ; Mon, 8 Apr 2024 23:15:57 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=M9Yz7E7+Mymofm8JqF9yyI7QJabTLo/VBmUmghHFwFYEDZFfzdvxOo7uQ017g9aAvotKEVRl4ywQBaqOTDsOctUed4aPU4kNr6iW1mUoNVnEZziypDsl1ygt6Mv+2hHe5KSMIwNsqHT4tjAVudq6N+prhFp+p/1zqsuq+IyxpHs9++ijemMzg31A8hlhjyGQW194vCGdhf2r2ANCxg2HLpRthAikdB0t2oVWyyzzCU4nzsZ7UJyRdek6HPWS65O+Gydt519ddW0nyip/cpxQiTIenNv2FdO5NqoCLQDTplcvEXUGhSRBByTSWs0GVHsd4zqS73+e8WGlLl8xJh/bEQ== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=yvckuFShUwOSN4lC6D0a9iZWu1IRS6pwy9JjCdQmMD8=; b=F7rvECKwGVDF1iiHfYbobc/W7ZKc8ITuqfx8+168MkDJiRGmgYXgFzmzbySCBYXO6zf8UVt/zXPm6/H3+5iUGKivi/fObx5zkyMLmV4bOSNqc3gP0aNJifVnSbSioi9FLrLtQ0du5kWyzzO3JtMh2N9tyPTjkYc3WUPIDOd2KIFS4/1yz40OnTB8mGdL6+asdRCIEfO/fBccQjCLYIFr1fj/kaoS7+0cDCEyEx+oyMdkTx2Em0ZHy7dKdIHKY3CAhC7hH/o1mI5DVmCR2LxwfkoCjRxqIAcs665sQDTmOAHeidr5UzaerbbB5oVQUXhzqDcBeYtD/6OCoIAV4crvgw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=yvckuFShUwOSN4lC6D0a9iZWu1IRS6pwy9JjCdQmMD8=; b=YufvnMZ0nNgXuAbU8ER5mUb/esb7KRrW/i22zBAiudQjD8d3JfwJdmB9I727AdzfAOzPNFSmG3D6G4EarqfEwWnGhAjoEk9lTx3JxDslgTTOZzUogsGLgmg2M2cXw/V5q9YraTGghrqYptVV2kS6MF4qoEswf8SIh5rspPYCVuoJlodQBlTpjVjgVyacjOt0mOfBs//ySwsne7yiB+N/kJHipwYCfHoIV3DnT83ftkdR4fyDES+h1365WAiLJvlYY1yKFx8i0IbQVxeVBr0rueYPLr0L54MwlkoSRUu4JYlf90+uTd0yHgtmRi1YBbNO+uqkoJVPiq4v5avJADjkdA== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:15:54 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:15:54 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:55 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [f98tcSUfsDcv0ESBVpQFk5DNvjxBXCSiJrWRMfZ79+A=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-16-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: ac9f06cd-c12d-4591-d130-08dc5808b16a X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: Pupm677++lTZVwehL9hTujQnS5ICaOWAus2coUwvuERzuPoqOJFNEgQpnoZc4F9oQj/cxQDNOdbSyFm8gaHpUZUvEtXbirPYYE/mdTgOWx1GDxGLqqJKDc57wwDenVwenI9334GF1u3q+2VFBuZFgid0MB9+ROeKbLBTgKWT//vww+xJoOjDhjpxS5dP9C699fDo1ggdZ3WtDukZ3A6ongn/LLz0/RdgrVrPvk84jo7a4htaNxn9RyscCWTTNYaAh9Q7jkCq76A8bFsvidw+ta9kle2rwABDZriRg430NqKvNzmLjgMWFDBEYefuUuO7fLZyRQEAh7WMjXJpWwm9enxDiLr8sjM3oHLNXm6/Ul3MGlvTHW8LT6d7d38A1hgrnRRMDAcauOTzFadaVERp0R7uak93sq3SfKfrpcjKDdQE01M27GPV9R1yKpEGJtykVOpk+nv2g/uQMJQnP9C/uLr6UVLajyhsr2OIdvL0ccICdofj1ezBoW0ZzQk370iZnyb7n44ShELKux/mTVseloNHM0Y4JvevkvcsnIeV/36mcfxIvhMnf3g3e2bhENxuA9LcBLx9XBbf3x35ai8ZOao4QSGUgtCJhQgpMlT5DnPPSkqzugOZKkqEQv7Pui2b X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: 7taZAhlD4TpOWeXfHI0wfmxrsBdnIsKouY6g9eLjUyFXjoM/hdxYXCvbvimUO3BAKcfeQGmi4dAhUPHhB/SUHAY1EZxzvXQYvCJdK0MOx1Ox6Bw8HwQLsTwLPVlUTkGzTDcfpt/tf7DB6p7Gf9AUmeNITmkAWcQVCiwnf2Ck+LVPDpUH9PjnO66esMcg2L3o40wCptNJMko97rjMyvyx/RmolxItb7/4SCZKv1yQtlNQ5YEDVEjuAIUor+eLRLiqF3Ag8YUYXbkvFhjD3CPduNYew3kJ99Pr5HSwWJfuaqKMj4KpOX/sbWnfK2PUGZUfQN2S78khOo5e5U3SMEHMdhooc+ahfnUNzPG0IlNLItkd1RoRTLni242PHYdg+2283Avny2B9OWJmrMUakJM/ET1CK8Lw9rXFZoT5CP4oOQFLCU93Fx4Y2DLffhYRB2KPYZnDEokwmSjuPx45R78F6c9n/fKAQwyqX2/ot/YDQa0bxXf3D/7SemRtiS4kNoHAqafA8b/yD4tPJEB0mjq7AY3P9amWDJcmV41OYpU0z5mkd1yh4MsHyXKMGzbxgZ9UBGVSzmvTRvtWRtUMo4/y1zKaC7krgEukUmkfSFHbHyIGrnoJBAompPbqJZz5TTF2vm0iBalDZfFsV/cn4kmaAeTfjsGr+rACxbpHSuf4YB2uffzyjk/fC7ZNMVQNfwD2ZsxgnmAXDBvhvkMa89l8lMQvSr8gub6AQfKrsZavFz+gXIxbwO8V5fxx5r7m0UwwskScEyCjcUqSk3gI9toUt8JSY4wm+2+v7z025Tza2KhG4XDFOdRLc3ohdSV8Ps9chOnKzjPezSC7hjrcFH3o06S9ESwVKoYy7cI+WJQbkEIZoCGpuzjIGB6MiDzejol+KXKiWy8I1YeYGu+rJJcFDd0xXfkhWkYj0fPkCDtrbePlcVWCmy0n8IWt1HQ76iawgLJeb1goDUlWnk2NwO12IaKGWenPKM3y81lrRxV1wkFMYBGeYEGrsSaP3xx8002bbNfPpv4aAWVGrgCe+pp4wVNzYZoYIf1Si+Ops1nbo3AIaiwJniaydXDnuJ3Is8mTiCgR6466iXWqJnx1uTKDRilO11WEoOkfC9Z8SPxcQxfHOGhqsdN/hUFXZBzq2T1laQrOBODx9H+r7nD/sAH0wnvscXKjOHX18SuRKLwHf4mL0YSZC8gUCKIfLZgg7fwFivTQaXbxstawLsqGjU3PLjzz5Vy45RZ/peIGBDc90QETHSxHGzWqCT50U0eOc69sqDrhvKQG0gExKIdSHc9wpA== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: ac9f06cd-c12d-4591-d130-08dc5808b16a X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:15:54.1512 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 17/27] avcodec/vp8: Mark flushing functions as av_cold 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: UvbhgLLvFsmA Signed-off-by: Andreas Rheinhardt --- libavcodec/vp8.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libavcodec/vp8.c b/libavcodec/vp8.c index a1443f6571..f37938ad27 100644 --- a/libavcodec/vp8.c +++ b/libavcodec/vp8.c @@ -128,7 +128,7 @@ static void vp8_release_frame(VP8Frame *f) ff_progress_frame_unref(&f->tf); } -static void vp8_decode_flush_impl(AVCodecContext *avctx, int free_mem) +static av_cold void vp8_decode_flush_impl(AVCodecContext *avctx, int free_mem) { VP8Context *s = avctx->priv_data; int i; @@ -144,7 +144,7 @@ static void vp8_decode_flush_impl(AVCodecContext *avctx, int free_mem) FF_HW_SIMPLE_CALL(avctx, flush); } -static void vp8_decode_flush(AVCodecContext *avctx) +static av_cold void vp8_decode_flush(AVCodecContext *avctx) { vp8_decode_flush_impl(avctx, 0); } From patchwork Mon Apr 8 20:13:56 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47953 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp136664pzb; Mon, 8 Apr 2024 13:17:04 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCUe9tNX5lCiOsvJ2BnC5NlSjGG0JJy7SSoz8n2ag8rYazXb9T+C+vdElC7W3mNmfMpg45U8VZnnkPIFnC5V8MLWQOLcgpODFwmpOA== X-Google-Smtp-Source: AGHT+IHin3Qxq8Wy/JvKNEE7+jOLb1abT8A7t+Bj8BYLkr5n7kgN+DQiv9qiOMcihgs4OWF4XSki X-Received: by 2002:a05:6402:4313:b0:56e:3535:9617 with SMTP id m19-20020a056402431300b0056e35359617mr8119648edc.1.1712607423912; Mon, 08 Apr 2024 13:17:03 -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 b17-20020a056402351100b0056e59978b31si1614812edd.589.2024.04.08.13.17.03; Mon, 08 Apr 2024 13:17:03 -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=@outlook.com header.s=selector1 header.b=UB+XH9qd; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id D4FF068D3F3; Mon, 8 Apr 2024 23:16:01 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR03-AM7-obe.outbound.protection.outlook.com (mail-am7eur03olkn2103.outbound.protection.outlook.com [40.92.59.103]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 4EAD268D384 for ; Mon, 8 Apr 2024 23:15:58 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=GtUDhr0eqb+xKBUOqvyuX1oHKCebIxVk1TJGvcNCaUi5UN1M3hLKV/nBfIux/ldakSJbJVfyY7TInrorCz4eHzWBxzXVa/IUwYDsOEy8BA/ZAxY5EqjsFFzYHSO13fr1jfoo8uhC942oWl0FqJKqKCkKmvGanNkTJJnKsi3HH/1PuA8kM8TCr6r1yvEktc6uOX+9C/vWIer4DbRr6/Odn2OuG/S6vIE2sXis3H168qXHIwJtfMyI464zCVEGoWXiguYT5eKWHp3sRmXpC15VO5O2Y/L4tGxwrJI/Y1Vpz2ME453kxbyW0Z2ePW8RkOK/jl5x2Ot7c8umyC9bNM7IQg== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=EsBw+ypXyv+nfPTorNsHythTsZUDLpwBbfwmEahaRbg=; b=VRqBki3kMFwlhsjCNAPPwpo0D42tfWZO3Y4ZZLjFu+/kGKNHoJRHeWW94ILiIgSs5NbQboerjlM8pDCxWfrxSSKtQSSutAsXIXRoaGThO/Cmbjfq92wopksVJk8YdWsol/nN+kPrP59VgMOP6c1PQ3AXXTuYEgQJ44ffTdL6FTnGfULCUbu3atY0yzMN3Xwmh5ULvzXlW3V+ZRRv/lKX2tsK4nIcMrS3hqn3k+BgkmeNdrgnuskWFVP257a6PJ9VItozd9Hq888voyx5Ct6UFyTv6HJ2AG7NIxDO/eYJmDUAbUMCMEH3LBDlFxRmmXB/+0gV0sYbnYEceYWyUX1HoA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=EsBw+ypXyv+nfPTorNsHythTsZUDLpwBbfwmEahaRbg=; b=UB+XH9qdOZmTaMrvwVn35RXbroO7HynKZygrTuQcQFHbxMXzkhjuvCDFtQtJCFFqj4J3ud2h25Gpun5reoOwBlWQeADE+Qz4f3GMMHVHAXdjFf/wKKSw7ABAV1VL762CisMc5aj4Q1DQ7qN981F2odQx8vTWPhnhsADyVdirOsTQ/gxvwhHSCzMLSSpw137cuJG1G6b1sFDLpfCaAiHvkuDZdKhvuAQqIlBZphGxV33u6QKe1j874is+EsmikuhJzPZaiuCz9SRpkIusbdNWQRiClSU5PVcz5UXAOK/04KttO2oSam2UAPDdmYHcMdVYwXGrxzJYiMZfqLQJ8hTYoQ== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by PAXP250MB0494.EURP250.PROD.OUTLOOK.COM (2603:10a6:102:28d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:15:56 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:15:56 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:56 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [SawCXj9wqInyRhWs0gRO0DyumyxeuXPlT98FjhXTZes=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-17-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|PAXP250MB0494:EE_ X-MS-Office365-Filtering-Correlation-Id: 5bae50ee-7403-48d6-64ed-08dc5808b2d3 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: rUEYS5qELVsxgdl+5aGzG3p4W6HMOacw4uUv4S8s62dX46rEPEInTWz0bGFuD+sKAXqu2DVYhjkvu97P2pnndnDNO1p8uGJcSKANGZS04AYb3DDpnFmA6TUoRCbsld9h/iLKPwn0KwAPX8s15TReYLiOfSuI/zgk3SJSxoS6M7pjr0bb0+x9lZG2reyV+DICqr+mMKgNWTBoJwFOXjiJm4ploX5Eaxk5oAK30w07bmwwmTfBpwKAfR/+XYtPv4PitDs3nreEzynLNj+gsExAa6CMdclTGHIt+RCdapNyNgizRpKjrfcNtLpbeOS1oNyGZ5/eJ0cfjDvFqfwYuuB6Fer6xMRW8Gt1yhfs9c5f0Eaheeugwuyp13PixVSEQpB41UMagiFQ68Q/cTZUkcdInwmzkqZHGuIDXxAfPA69Ipu8ChW9KON/f8SeV/uW6GixnryRI6HqErR1ldnSGrJWfCNUNNtCHvujDjqeRWVkX1h5BzmJnIQ1So2QZzzhw3REXiyZQLtGz3RwRlq8hl5woh3sd7221U2e1eIozTvne7LIvisU+z/3rR0LcJWF/tct9IRBHw+INBuImcMFxACDUsJHmxPbqGciAqNwa0CPi0BHl/E0TR6iEGTVKooNCYxC X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: oD1LigNeOncNXOIY6PSpbePFv3TCpw+uPNbDT8jpxjfPhJj283ImggS6kLDmWbPynnZvOD2IXhopQeYyUF7sexkDmOjMhy8oMswKk1iDGdevpVnoKxAYdsx5r5K6FpZoo8uIYepQrdQZ3TVq0DjPpahbFuLVxQyd6/i7k0lJ/C9DuOf7qTKmjXi47wlAYVzWB2MlkGqCUUUtGoEme3FXkGJUsYezvYQInHw0wjyVh7ZgemElm5O6WSzG6wYXF+/W/KUeRMDtj6P9LkRA8YGJTrk0OG6SI+HaZAXybCTGCdv8HLRCInTQJ0lCi+hpY0aVBfoHw8AzFBG4H/jHMc1FPd+dH9bzYzrKJlKA7XfLHkv0cI7a+Br/k2HYURWAB3KpdofUpqthNrj4cnwkYOjErVpEXmt939kEBP6VfxlVjEozggrrul+BaAT3GD/wLp089S1EwNtn8lh7/F47K5ZmS409iatAG9MZxrzdvNPpVn99aGlOah8yA8ED3vZHNopZcNRKWum0brQWqWtq/Ro/lBbO8/Wq38oYbUPy3NmBRQVIsurItGyNGHktQmYXpoZ/0cX3BhZZu9j2yZQWp7+QSQSwSId/X08qhhLEy/98ldL4Gvdf/WKNzD87YFiJXO/XSt8bBC80Md3UyuwO75bst3Io4H86DUlUnArDQFReOPql+rk/44RkqxkcgB92ggOb3UEOawwv50thbE+il9FtgueTgc/YU/ZVp9nZ5AzMbQpqSIO8zDLyP7Rm86VOFGinxcD3+bwTIjC0hM5WnPV2K52MEPbNs6QUMac24gy5ZwwAO4J6K7+3RIambyFvwIagTAR4l4IvaeeeXQ2PKRZFYTE9pxgR04vOl3x+1MxWuIrB3QnxOd5X/TZvIch64H9dEZt9agb/VJ8bBTPClPL0fZcU2zD8R05KCjMsg32ign9aA2+k8hiQCddnD1loDiL5lPKpKJ4I+FmUiKOJ9U8EQhz24LEIE10WzqXV5oj4F51JFQYF60rVnyn4UdLbaZLJVld8+mS9B9+oyWDCxsM8bI/Y2N8P6NtdRMjXTyFWdJffvk7USpC7lZb0UFtwWGF6ktBBbCM7Pm9D79HW4gbEWd4ZfCO/yJ71BRf0P29rznFLfG2yLsJKyues4suZ571FlCPg4g1IhC6YYXSHHbLJJjDGZH4TcQLvg3qIEXYwzYeqtmR73GDlvE7IbH9I3pAOjuupeb1YOjNl4p1DAuesmO9EoyRauCjymKkFHwGgooDzArzpMPElkwyEpwcZ7KSNWXMmbe9mvUfsmL4BxN+S5g== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 5bae50ee-7403-48d6-64ed-08dc5808b2d3 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:15:56.4515 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXP250MB0494 Subject: [FFmpeg-devel] [PATCH v2 18/27] avcodec/codec_internal: Remove FF_CODEC_CAP_ALLOCATE_PROGRESS 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: DRe4UWo9LSD/ Before commit f025b8e110b36c1cdb4fb56c4cd57aeca1767b5b, every frame-threaded decoder used ThreadFrames, even when they did not have any inter-frame dependencies at all. In order to distinguish those decoders that need the AVBuffer for progress communication from those that do not (to avoid the allocation for the latter), the former decoders were marked with the FF_CODEC_CAP_ALLOCATE_PROGRESS internal codec cap. Yet distinguishing these two can be done in a more natural way: Don't use ThreadFrames when not needed and split ff_thread_get_buffer() into a core function that calls the user's get_buffer2 callback and a wrapper around it that also allocates the progress AVBuffer. This has been done in 02220b88fc38ef9dd4f2d519f5d3e4151258b60c and since that commit the ALLOCATE_PROGRESS cap was nearly redundant. The only exception was WebP and VP8. WebP can contain VP8 and uses the VP8 decoder directly (i.e. they share the same AVCodecContext). Both decoders are frame-threaded and VP8 has inter-frame dependencies (in general, not in valid WebP) and therefore the ALLOCATE_PROGRESS cap. In order to avoid allocating progress in case of a frame-threaded WebP decoder the cap and the check for the cap has been kept in place. Yet now the VP8 decoder has been switched to use ProgressFrames and therefore there is just no reason any more for this check and the cap. This commit therefore removes both. Also change the value of FF_CODEC_CAP_USES_PROGRESSFRAMES to leave no gaps. Signed-off-by: Andreas Rheinhardt --- doc/multithreading.txt | 15 +++++++-------- libavcodec/codec_internal.h | 7 +------ libavcodec/ffv1dec.c | 3 +-- libavcodec/h264dec.c | 2 +- libavcodec/hevcdec.c | 2 +- libavcodec/mpeg4videodec.c | 3 +-- libavcodec/pngdec.c | 3 +-- libavcodec/pthread_frame.c | 12 +++++------- libavcodec/rv30.c | 1 - libavcodec/rv40.c | 1 - libavcodec/tests/avcodec.c | 5 ----- 11 files changed, 18 insertions(+), 36 deletions(-) diff --git a/doc/multithreading.txt b/doc/multithreading.txt index 6c65ca9651..842d331e4f 100644 --- a/doc/multithreading.txt +++ b/doc/multithreading.txt @@ -36,9 +36,9 @@ Frame threading - * Codecs similar to ffv1, whose streams don't reset across frames, will not work because their bitstreams cannot be decoded in parallel. -* The contents of buffers must not be read before ff_thread_await_progress() +* The contents of buffers must not be read before ff_progress_frame_await() has been called on them. reget_buffer() and buffer age optimizations no longer work. -* The contents of buffers must not be written to after ff_thread_report_progress() +* The contents of buffers must not be written to after ff_progress_frame_report() has been called on them. This includes draw_edges(). Porting codecs to frame threading @@ -53,14 +53,13 @@ thread. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. -If there are inter-frame dependencies, so the codec calls -ff_thread_report/await_progress(), set FF_CODEC_CAP_ALLOCATE_PROGRESS in -FFCodec.caps_internal and use ff_thread_get_buffer() to allocate frames. -Otherwise decode directly into the user-supplied frames. +Use ff_thread_get_buffer() (or ff_progress_frame_get_buffer() +in case you have inter-frame dependencies and use the ProgressFrame API) +to allocate frame buffers. -Call ff_thread_report_progress() after some part of the current picture has decoded. +Call ff_progress_frame_report() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn't called anywhere, as it's useful too and the implementation is trivial when you're doing this. Note that draw_edges() needs to be called before reporting progress. -Before accessing a reference frame or its MVs, call ff_thread_await_progress(). +Before accessing a reference frame or its MVs, call ff_progress_frame_await(). diff --git a/libavcodec/codec_internal.h b/libavcodec/codec_internal.h index 832e6440d7..1cd1f684f9 100644 --- a/libavcodec/codec_internal.h +++ b/libavcodec/codec_internal.h @@ -65,12 +65,7 @@ /** * The decoder might make use of the ProgressFrame API. */ -#define FF_CODEC_CAP_USES_PROGRESSFRAMES (1 << 11) -/* - * The codec supports frame threading and has inter-frame dependencies, so it - * uses ff_thread_report/await_progress(). - */ -#define FF_CODEC_CAP_ALLOCATE_PROGRESS (1 << 6) +#define FF_CODEC_CAP_USES_PROGRESSFRAMES (1 << 6) /** * Codec handles avctx->thread_count == 0 (auto) internally. */ diff --git a/libavcodec/ffv1dec.c b/libavcodec/ffv1dec.c index ba535e800d..dd594e3f9f 100644 --- a/libavcodec/ffv1dec.c +++ b/libavcodec/ffv1dec.c @@ -1129,6 +1129,5 @@ const FFCodec ff_ffv1_decoder = { UPDATE_THREAD_CONTEXT(update_thread_context), .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS, - .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | - FF_CODEC_CAP_ALLOCATE_PROGRESS, + .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, }; diff --git a/libavcodec/h264dec.c b/libavcodec/h264dec.c index 727dc1a662..6330fb9c48 100644 --- a/libavcodec/h264dec.c +++ b/libavcodec/h264dec.c @@ -1156,7 +1156,7 @@ const FFCodec ff_h264_decoder = { NULL }, .caps_internal = FF_CODEC_CAP_EXPORTS_CROPPING | - FF_CODEC_CAP_ALLOCATE_PROGRESS | FF_CODEC_CAP_INIT_CLEANUP, + FF_CODEC_CAP_INIT_CLEANUP, .flush = h264_decode_flush, UPDATE_THREAD_CONTEXT(ff_h264_update_thread_context), UPDATE_THREAD_CONTEXT_FOR_USER(ff_h264_update_thread_context_for_user), diff --git a/libavcodec/hevcdec.c b/libavcodec/hevcdec.c index 727b02f0f4..cedd09fe14 100644 --- a/libavcodec/hevcdec.c +++ b/libavcodec/hevcdec.c @@ -3715,7 +3715,7 @@ const FFCodec ff_hevc_decoder = { .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS, .caps_internal = FF_CODEC_CAP_EXPORTS_CROPPING | - FF_CODEC_CAP_ALLOCATE_PROGRESS | FF_CODEC_CAP_INIT_CLEANUP, + FF_CODEC_CAP_INIT_CLEANUP, .p.profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles), .hw_configs = (const AVCodecHWConfigInternal *const []) { #if CONFIG_HEVC_DXVA2_HWACCEL diff --git a/libavcodec/mpeg4videodec.c b/libavcodec/mpeg4videodec.c index 07de5d6d91..6a7a37e817 100644 --- a/libavcodec/mpeg4videodec.c +++ b/libavcodec/mpeg4videodec.c @@ -3861,8 +3861,7 @@ const FFCodec ff_mpeg4_decoder = { FF_CODEC_DECODE_CB(ff_h263_decode_frame), .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_FRAME_THREADS, - .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | - FF_CODEC_CAP_ALLOCATE_PROGRESS, + .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, .flush = ff_mpeg_flush, .p.max_lowres = 3, .p.profiles = NULL_IF_CONFIG_SMALL(ff_mpeg4_video_profiles), diff --git a/libavcodec/pngdec.c b/libavcodec/pngdec.c index 16e35a8cc6..5a99b4a1c4 100644 --- a/libavcodec/pngdec.c +++ b/libavcodec/pngdec.c @@ -1940,7 +1940,6 @@ const FFCodec ff_apng_decoder = { UPDATE_THREAD_CONTEXT(update_thread_context), .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | - FF_CODEC_CAP_ALLOCATE_PROGRESS | FF_CODEC_CAP_ICC_PROFILES, }; #endif @@ -1958,7 +1957,7 @@ const FFCodec ff_png_decoder = { UPDATE_THREAD_CONTEXT(update_thread_context), .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | - FF_CODEC_CAP_ALLOCATE_PROGRESS | FF_CODEC_CAP_INIT_CLEANUP | + FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_ICC_PROFILES, }; #endif diff --git a/libavcodec/pthread_frame.c b/libavcodec/pthread_frame.c index e42a9563cd..4c073d5609 100644 --- a/libavcodec/pthread_frame.c +++ b/libavcodec/pthread_frame.c @@ -979,14 +979,12 @@ int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags) if (!(avctx->active_thread_type & FF_THREAD_FRAME)) return ff_get_buffer(avctx, f->f, flags); - if (ffcodec(avctx->codec)->caps_internal & FF_CODEC_CAP_ALLOCATE_PROGRESS) { - f->progress = ff_refstruct_allocz(sizeof(*f->progress)); - if (!f->progress) - return AVERROR(ENOMEM); + f->progress = ff_refstruct_allocz(sizeof(*f->progress)); + if (!f->progress) + return AVERROR(ENOMEM); - atomic_init(&f->progress->progress[0], -1); - atomic_init(&f->progress->progress[1], -1); - } + atomic_init(&f->progress->progress[0], -1); + atomic_init(&f->progress->progress[1], -1); ret = ff_thread_get_buffer(avctx, f->f, flags); if (ret) diff --git a/libavcodec/rv30.c b/libavcodec/rv30.c index 9e13e71805..316962fbbb 100644 --- a/libavcodec/rv30.c +++ b/libavcodec/rv30.c @@ -304,5 +304,4 @@ const FFCodec ff_rv30_decoder = { AV_CODEC_CAP_FRAME_THREADS, .flush = ff_mpeg_flush, UPDATE_THREAD_CONTEXT(ff_rv34_decode_update_thread_context), - .caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS, }; diff --git a/libavcodec/rv40.c b/libavcodec/rv40.c index e48aa1f684..19d4e742df 100644 --- a/libavcodec/rv40.c +++ b/libavcodec/rv40.c @@ -582,5 +582,4 @@ const FFCodec ff_rv40_decoder = { AV_CODEC_CAP_FRAME_THREADS, .flush = ff_mpeg_flush, UPDATE_THREAD_CONTEXT(ff_rv34_decode_update_thread_context), - .caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS, }; diff --git a/libavcodec/tests/avcodec.c b/libavcodec/tests/avcodec.c index 58f54cac74..cd949f6385 100644 --- a/libavcodec/tests/avcodec.c +++ b/libavcodec/tests/avcodec.c @@ -142,7 +142,6 @@ int main(void){ } } if (codec2->caps_internal & (FF_CODEC_CAP_USES_PROGRESSFRAMES | - FF_CODEC_CAP_ALLOCATE_PROGRESS | FF_CODEC_CAP_SETS_PKT_DTS | FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | FF_CODEC_CAP_EXPORTS_CROPPING | @@ -172,10 +171,6 @@ int main(void){ AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE | AV_CODEC_CAP_ENCODER_FLUSH)) ERR("Decoder %s has encoder-only capabilities\n"); - if (codec2->caps_internal & FF_CODEC_CAP_ALLOCATE_PROGRESS && - !(codec->capabilities & AV_CODEC_CAP_FRAME_THREADS)) - ERR("Decoder %s wants allocated progress without supporting" - "frame threads\n"); if (codec2->cb_type != FF_CODEC_CB_TYPE_DECODE && codec2->caps_internal & FF_CODEC_CAP_SETS_PKT_DTS) ERR("Decoder %s is marked as setting pkt_dts when it doesn't have" From patchwork Mon Apr 8 20:13:57 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47963 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp143104pzb; Mon, 8 Apr 2024 13:31:56 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCWmsRJyxpOdi5Cr7GFNQ/rIxgb/VESIqA5N3Yk1J0bywt3g9Dr+KCEGSE05ZfIqT02wln63m9sb8YhLMAtNpCFf+sgc6CctiNGjDA== X-Google-Smtp-Source: AGHT+IHLQ4J+IbeOtdyAXvJ4XL8nfbJcB0I/ZC3M3/ZSRVZS6QlOOewc2WPm5mN8tfbFMLzj8oZs X-Received: by 2002:a17:906:6a1a:b0:a4e:5641:23d4 with SMTP id qw26-20020a1709066a1a00b00a4e564123d4mr7778978ejc.1.1712608316492; Mon, 08 Apr 2024 13:31:56 -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 di13-20020a170906730d00b00a4e25e2f089si4132974ejc.937.2024.04.08.13.31.54; Mon, 08 Apr 2024 13:31:56 -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=@outlook.com header.s=selector1 header.b="mex/fCYs"; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 9DD5B68D41D; Mon, 8 Apr 2024 23:31:51 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR02-DB5-obe.outbound.protection.outlook.com (mail-db5eur02olkn2091.outbound.protection.outlook.com [40.92.50.91]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 6D28568C4BA for ; Mon, 8 Apr 2024 23:31:44 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=Z2N15TcTzcycJYMCXOF77JsGsKH9dt1tWc6emit10h/+nTWCImc/8If5N8KEAUDzYsUfyFNx3vLBJaNm2YwkDE2PBjkwrBHFdRBQFaVepMVAdby8vnjOpzIGcv7m8jCusaEs87+I9+Dg9eWJS2VMvMJ/zlbxSaLucHwQ3LdulUiTIxs8yyjP1Z6Y7KCnaQw0gKSpecPt9Yee/nwRAlGeHzLYRVXdQ6/xRWip6BL/bvyUqp+ectuirQj6iHC7teF8kOwQ0FcdytMHor5ECgVr1h0G+kD+mcmbU8P1gafISDlg4OeTZvSTIVHwlOokWgU97NAjJWhyt+7VVQd147VI6Q== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=S2PXVpCK9edti1A1iYBkuvn/vXn1F6GKxPPPdWLwnvA=; b=QSz5KWlP4F+CfkVhP42XLjLVw/bcBENMp94lGDkBKJUPDDUjFBC3wRUJGuSMZErQZBh3yMJojx+Vc1EORM0g7ZnY7yjpkoPgWWE6PsDU11ivPaAvwBgMV9NLqERWBp41UHBwMxyfhv8wHO1vjI1OzCAFCUYXNXopcd8C41mWjaB5ch4DN2IrO//1/hZ/nGwp8w5ifpikzjM0MwBmqPsuuDDzaXruKg/QpQo4uqIQoD4INUE0IKHCDo3Z4VMFLyzksnP8of5Z3RQ483EopkkZqGpFT48S9YH5lSg/5RvBG3a94Y/fE/ZqSgwdBrXjyn6M4iIho7xBg7sxbQUU2EZ3SQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=S2PXVpCK9edti1A1iYBkuvn/vXn1F6GKxPPPdWLwnvA=; b=mex/fCYsRLftvNf+/JbAkHWHO+FjjQkiAX7O6N7KibkPzCt6OhIOvtoXxNRlZcTyYqkFOknkdk+RBvxcfXAjlgbft2PgBF24b6sHMoWrDHBrvJKzvHJ/dqBt+bQvpLD7zDglKTP4t73fdNEHxdSZTQzyr2sREQvRHNwgO8/KetRsiWOaeUhYP+oyvQOp7XVlNYYmenDq1qi32ASOZl25A7hzz7gk4wtvfD1V7uMXGAIABQbNk13AjC9hQXq5BWTZmerJ248qz4ANIvmUmNW00cx87pJUag/scGSEjni9uZItffDMg8yZrlKVLIZeW2bnUBWf1GU9w/IGJoTHMTXdmA== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by AM8P250MB0171.EURP250.PROD.OUTLOOK.COM (2603:10a6:20b:322::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:16:00 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:16:00 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:57 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [PfKa2u6j18X2hbEFT6xIG9oYmQguglxM23OQ5MZ3FOQ=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-18-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|AM8P250MB0171:EE_ X-MS-Office365-Filtering-Correlation-Id: f3460005-e8a6-45c0-3410-08dc5808b56e X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: vUB1/YHHAO/mA9rpJ4b7lc+RJ6jZoyqbfR2Fg4DrrjZJkCrbHj44ui5MYpTa5WQCmL4OYHwF6EmLHe1ULKMqs1dqSxx0qHwyOmuT2ExZYY5LBONd48lFqSKnSg3NfdGPBZV6izfkIYHCKQXA4Af/I4pbWvGy0woJ1kMKgt3f561bHd+biRig2mc2Q83JeaxzWoUVtSLrhLDmdtmoyHtkVNb/6ZOkGOLx48E5X15fImtnfwHDv/5evJb5csBvLjS7j6q9Evx4+kcPuBSOKM2zQgmPAmJYuW7H5ioxWTTJ0hrupLJGLRmGT26Y0lif12edPBfeQMwR5sRbifvA+xjVA+nvDQH7rL6pRHNGDJZ8hhXQ+wyOsj3sKrKWJrA0d1afCOxUYLnrXTN6ErqZT34pUFyRGgyEqK8+Uix6z2jp/u75aBO6iFFPbCr+2qkCRRpKnNQQKwSSZqcmpsBVXK/+PSmpitNCFQgIvQC+FGXtp78S4r8v/RwwpZh5NBYzJDY+623PLq/HYDUmWQ5zAooWOos7eYoeqIbbhwP96X0wHwIdt7IsiGAztKOvw30qKcDfLan7QuF3PZTu1hgVx0+c+SuyEdiiUMSMGykxMJC9YI/vMo+9cj4sPe8M+NleR+c2 X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: QAFtrW8pPyM0okGvpYV+qxMEA4rTRcVCTeMf56yCmK2748fzb9yVcLoB5nTza/BFNF7LdWVaY9LOQZUxEFaGr0A3WcC/vQ8i69TaL1e5l5c9+xxrXjwabFb7B+/x5XgCnLswx9w/c6GQGfTa5Uf4rdIEvHMQfFNKV51kNaZ5uwX9pI2emEGPLZt9vq1nl5PI7l1SFFrEggiXYgpnIta+XSijHFINZgPV0uJtk4q/acwLKtKbgF3VinIGEzKpI1xtusEu6ABh4XuO9QEz71l/sk8/LPvrjTOUgm0/T9Eky2EG73OC/aU2qCmCP15IklsbEwD72PkcD+Mr/S5h9XVVMPoPgCISNb5+1FEUcHtwAUMEBJ7qCAME9gLX5rPc/z6B3fYbQ2K8inXURYq1acvCmMchQCL/3ydb0BONEQDRCKGJ8At2iGzhUeFuFzbxLkwjLyC6Z0jzSDXKvkn+UJxf86tgI/55ORSi2horm1rmsIOA3hnxUs9dsplSxjS/LKliZ9WtclO/MTWRb+KhtAYC6OKa0ZrTjUtama/8NUqK+8OfL0xGxDaN+jWFEYZWAOipW+K75pinBKpPzi8ILi+T7iQf7FLx9cKNYECOzwkI3KGmMm7E7z7Zj7myr+StivGSGPOXimHQ3UgCUivqY1sAjgHFyvx5qdA6TaiwY/Vn0lpP/agl7v2A9xh1374z4VeZaOVzH0K6tUWwdHxTR/u5KeFRXsekyAfpGFodJ6fKB2nI7C14CfV4pVFdskYkk48jXyLjcR8QDj6xpkYisYnJJcmJvBfdydQSxZO9cELj9OCnUThAEicw9pCDUi66M8K7ueV5ZHNE715LKRvAesy2lfKhxa0yv5MWlheqYJxPr/bACSTGvq4qasZ/Z0/oYKRxJ7fiqvFqdUpKo5Cv3odkSbyu4+RZI6B8haIv1/DeZRydunC2ImwziLl7zbs2FAAfxIG4ttCVTAEoUk+yTsv3TpqxEbdOQo2WeI8GfpHq+0mS5y7K56PA0j/Jp94gKZYYUNd1bH1cePCTFnmYYURLJX6hRy/Z283Bn51bHciUjeZH8yxXqN3BcgQXhkrw1odZjhvb4EITZhm77MDB0HuWJCm2LRL25CW/7VjWJeJWCSArtbwWXt3iSK7nE26ym9jSph023hfT2ZCEOI1yy9QnxzukGjiiPbqOkWe+88TiXHTln6m2TzHT/rJeWGk2j+djpLj8LMzdYNhL7m6pHK/thqv5z2qZvRkmamckSMkcU4pqoG52b6E+Vzg4f21BRyY2e/xTtUVI/0yLECbNrYHXDw== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: f3460005-e8a6-45c0-3410-08dc5808b56e X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:16:00.8426 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM8P250MB0171 Subject: [FFmpeg-devel] [PATCH v2 19/27] avcodec/hevcdec: Switch to ProgressFrames 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: qU5MkmP7RVFH Avoids implicit av_frame_ref() and therefore allocations and error checks. It also avoids explicitly allocating the AVFrames (done implicitly when getting the buffer). Signed-off-by: Andreas Rheinhardt --- libavcodec/hevc_filter.c | 8 ++++---- libavcodec/hevc_mvs.c | 6 +++--- libavcodec/hevc_refs.c | 22 ++++++++++------------ libavcodec/hevcdec.c | 24 ++++++++++-------------- libavcodec/hevcdec.h | 4 ++-- 5 files changed, 29 insertions(+), 35 deletions(-) diff --git a/libavcodec/hevc_filter.c b/libavcodec/hevc_filter.c index 0c45310ea6..b1e2ea7a66 100644 --- a/libavcodec/hevc_filter.c +++ b/libavcodec/hevc_filter.c @@ -26,7 +26,7 @@ #include "libavutil/internal.h" #include "hevcdec.h" -#include "threadframe.h" +#include "progressframe.h" #define LUMA 0 #define CB 1 @@ -874,15 +874,15 @@ void ff_hevc_hls_filter(HEVCLocalContext *lc, int x, int y, int ctb_size) if (y && x_end) { sao_filter_CTB(lc, s, x, y - ctb_size); if (s->threads_type & FF_THREAD_FRAME ) - ff_thread_report_progress(&s->ref->tf, y, 0); + ff_progress_frame_report(&s->ref->tf, y); } if (x_end && y_end) { sao_filter_CTB(lc, s, x , y); if (s->threads_type & FF_THREAD_FRAME ) - ff_thread_report_progress(&s->ref->tf, y + ctb_size, 0); + ff_progress_frame_report(&s->ref->tf, y + ctb_size); } } else if (s->threads_type & FF_THREAD_FRAME && x_end) - ff_thread_report_progress(&s->ref->tf, y + ctb_size - 4, 0); + ff_progress_frame_report(&s->ref->tf, y + ctb_size - 4); } void ff_hevc_hls_filters(HEVCLocalContext *lc, int x_ctb, int y_ctb, int ctb_size) diff --git a/libavcodec/hevc_mvs.c b/libavcodec/hevc_mvs.c index 0a8cc2c43d..5591919e2e 100644 --- a/libavcodec/hevc_mvs.c +++ b/libavcodec/hevc_mvs.c @@ -23,7 +23,7 @@ #include "hevc.h" #include "hevcdec.h" -#include "threadframe.h" +#include "progressframe.h" static const uint8_t l0_l1_cand_idx[12][2] = { { 0, 1, }, @@ -248,7 +248,7 @@ static int temporal_luma_motion_vector(const HEVCContext *s, int x0, int y0, x &= ~15; y &= ~15; if (s->threads_type == FF_THREAD_FRAME) - ff_thread_await_progress(&ref->tf, y, 0); + ff_progress_frame_await(&ref->tf, y); x_pu = x >> s->ps.sps->log2_min_pu_size; y_pu = y >> s->ps.sps->log2_min_pu_size; temp_col = TAB_MVF(x_pu, y_pu); @@ -262,7 +262,7 @@ static int temporal_luma_motion_vector(const HEVCContext *s, int x0, int y0, x &= ~15; y &= ~15; if (s->threads_type == FF_THREAD_FRAME) - ff_thread_await_progress(&ref->tf, y, 0); + ff_progress_frame_await(&ref->tf, y); x_pu = x >> s->ps.sps->log2_min_pu_size; y_pu = y >> s->ps.sps->log2_min_pu_size; temp_col = TAB_MVF(x_pu, y_pu); diff --git a/libavcodec/hevc_refs.c b/libavcodec/hevc_refs.c index aed649933d..192d311696 100644 --- a/libavcodec/hevc_refs.c +++ b/libavcodec/hevc_refs.c @@ -26,18 +26,15 @@ #include "decode.h" #include "hevc.h" #include "hevcdec.h" +#include "progressframe.h" #include "refstruct.h" -#include "threadframe.h" void ff_hevc_unref_frame(HEVCFrame *frame, int flags) { - /* frame->frame can be NULL if context init failed */ - if (!frame->frame || !frame->frame->buf[0]) - return; - frame->flags &= ~flags; if (!frame->flags) { - ff_thread_release_ext_buffer(&frame->tf); + ff_progress_frame_unref(&frame->tf); + frame->frame = NULL; av_frame_unref(frame->frame_grain); frame->needs_fg = 0; @@ -83,13 +80,14 @@ static HEVCFrame *alloc_frame(HEVCContext *s) int i, j, ret; for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { HEVCFrame *frame = &s->DPB[i]; - if (frame->frame->buf[0]) + if (frame->frame) continue; - ret = ff_thread_get_ext_buffer(s->avctx, &frame->tf, - AV_GET_BUFFER_FLAG_REF); + ret = ff_progress_frame_get_buffer(s->avctx, &frame->tf, + AV_GET_BUFFER_FLAG_REF); if (ret < 0) return NULL; + frame->frame = frame->tf.f; frame->rpl = ff_refstruct_allocz(s->pkt.nb_nals * sizeof(*frame->rpl)); if (!frame->rpl) @@ -135,7 +133,7 @@ int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc) for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { HEVCFrame *frame = &s->DPB[i]; - if (frame->frame->buf[0] && frame->sequence == s->seq_decode && + if (frame->frame && frame->sequence == s->seq_decode && frame->poc == poc) { av_log(s->avctx, AV_LOG_ERROR, "Duplicate POC in a sequence: %d.\n", poc); @@ -394,7 +392,7 @@ static HEVCFrame *find_ref_idx(HEVCContext *s, int poc, uint8_t use_msb) for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { HEVCFrame *ref = &s->DPB[i]; - if (ref->frame->buf[0] && ref->sequence == s->seq_decode) { + if (ref->frame && ref->sequence == s->seq_decode) { if ((ref->poc & mask) == poc && (use_msb || ref->poc != s->poc)) return ref; } @@ -441,7 +439,7 @@ static HEVCFrame *generate_missing_ref(HEVCContext *s, int poc) frame->flags = 0; if (s->threads_type == FF_THREAD_FRAME) - ff_thread_report_progress(&frame->tf, INT_MAX, 0); + ff_progress_frame_report(&frame->tf, INT_MAX); return frame; } diff --git a/libavcodec/hevcdec.c b/libavcodec/hevcdec.c index cedd09fe14..5f0f50adf1 100644 --- a/libavcodec/hevcdec.c +++ b/libavcodec/hevcdec.c @@ -49,9 +49,9 @@ #include "hwconfig.h" #include "internal.h" #include "profiles.h" +#include "progressframe.h" #include "refstruct.h" #include "thread.h" -#include "threadframe.h" static const uint8_t hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 }; @@ -1867,7 +1867,7 @@ static void hevc_await_progress(const HEVCContext *s, const HEVCFrame *ref, if (s->threads_type == FF_THREAD_FRAME ) { int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9); - ff_thread_await_progress(&ref->tf, y, 0); + ff_progress_frame_await(&ref->tf, y); } } @@ -3238,7 +3238,7 @@ static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length) fail: if (s->ref && s->threads_type == FF_THREAD_FRAME) - ff_thread_report_progress(&s->ref->tf, INT_MAX, 0); + ff_progress_frame_report(&s->ref->tf, INT_MAX); return ret; } @@ -3416,14 +3416,15 @@ static int hevc_ref_frame(HEVCFrame *dst, HEVCFrame *src) { int ret; - ret = ff_thread_ref_frame(&dst->tf, &src->tf); - if (ret < 0) - return ret; + ff_progress_frame_ref(&dst->tf, &src->tf); + dst->frame = dst->tf.f; if (src->needs_fg) { ret = av_frame_ref(dst->frame_grain, src->frame_grain); - if (ret < 0) + if (ret < 0) { + ff_hevc_unref_frame(dst, ~0); return ret; + } dst->needs_fg = 1; } @@ -3463,7 +3464,6 @@ static av_cold int hevc_decode_free(AVCodecContext *avctx) for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { ff_hevc_unref_frame(&s->DPB[i], ~0); - av_frame_free(&s->DPB[i].frame); av_frame_free(&s->DPB[i].frame_grain); } @@ -3509,11 +3509,6 @@ static av_cold int hevc_init_context(AVCodecContext *avctx) return AVERROR(ENOMEM); for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { - s->DPB[i].frame = av_frame_alloc(); - if (!s->DPB[i].frame) - return AVERROR(ENOMEM); - s->DPB[i].tf.f = s->DPB[i].frame; - s->DPB[i].frame_grain = av_frame_alloc(); if (!s->DPB[i].frame_grain) return AVERROR(ENOMEM); @@ -3545,7 +3540,7 @@ static int hevc_update_thread_context(AVCodecContext *dst, for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { ff_hevc_unref_frame(&s->DPB[i], ~0); - if (s0->DPB[i].frame->buf[0]) { + if (s0->DPB[i].frame) { ret = hevc_ref_frame(&s->DPB[i], &s0->DPB[i]); if (ret < 0) return ret; @@ -3715,6 +3710,7 @@ const FFCodec ff_hevc_decoder = { .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS, .caps_internal = FF_CODEC_CAP_EXPORTS_CROPPING | + FF_CODEC_CAP_USES_PROGRESSFRAMES | FF_CODEC_CAP_INIT_CLEANUP, .p.profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles), .hw_configs = (const AVCodecHWConfigInternal *const []) { diff --git a/libavcodec/hevcdec.h b/libavcodec/hevcdec.h index e65a6180ca..24fcbf440a 100644 --- a/libavcodec/hevcdec.h +++ b/libavcodec/hevcdec.h @@ -40,7 +40,7 @@ #include "hevc_sei.h" #include "hevcdsp.h" #include "h274.h" -#include "threadframe.h" +#include "progressframe.h" #include "videodsp.h" #define SHIFT_CTB_WPP 2 @@ -354,7 +354,7 @@ typedef struct DBParams { typedef struct HEVCFrame { AVFrame *frame; AVFrame *frame_grain; - ThreadFrame tf; + ProgressFrame tf; int needs_fg; /* 1 if grain needs to be applied by the decoder */ MvField *tab_mvf; ///< RefStruct reference RefPicList *refPicList; From patchwork Mon Apr 8 20:13:58 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47954 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp136733pzb; Mon, 8 Apr 2024 13:17:12 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCWE/9UpyEaOgPBQL2VVbSESqrGKLNXcKQqfDNuVc54AtGno/Kd+sUQvWYet6j8jYwaaT4oUvnBIVfZE59vofVHpQE2ZNvGs7Ao1kQ== X-Google-Smtp-Source: AGHT+IFx36iGcWlSMjSVc0mxHQD4rz6X8t1d1y8vrbd7dLt9zpSN70tQoV8mAtThDKw5XmUrUQJA X-Received: by 2002:a50:8e55:0:b0:56d:c721:d0b2 with SMTP id 21-20020a508e55000000b0056dc721d0b2mr7534296edx.33.1712607432488; Mon, 08 Apr 2024 13:17:12 -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 z22-20020a05640240d600b0056c3ae53842si3976051edb.263.2024.04.08.13.17.12; Mon, 08 Apr 2024 13:17:12 -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=@outlook.com header.s=selector1 header.b=gNWgD5RB; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id F231668D3E1; Mon, 8 Apr 2024 23:16:05 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05olkn2068.outbound.protection.outlook.com [40.92.89.68]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 67CA868D3B8 for ; Mon, 8 Apr 2024 23:16:04 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=KU3vIuQ0nRKhsJJ1dpncy8bNqqOXBSAl2HALXIuo4NEYAqWFD9OnRTLV/ZoatWWzUKtICyO9HbV7icQHL7vl9x3IDvuwg8WgqjWZDDJXSASq6183hpY7K8y1Q+MJp95TuHUYsWx8AGElxHgI6ZrgJtZJ/7bYkgP5JQsmv6ELKFNCIruVO0ZdUtnpWJVnAdoTWwont1/nYGGj1giiPykN9UmKbK8Fhku3dB6uSnGVE+sD0KtotQ74neTsZvO9BCROTcCPbHJJqy360x92h3vJVdGslyRe8mbhXHBxrMYtemjeK0NBdv/PoYqNu56piIec057zvaMO5io9zcIFOKNbrw== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=CF/kcKZmITjEMC5XYUhrDW/tn1caAHY7O5c1UfVGFoc=; b=EiQQyK/f5pvBWIMjQ7vc9WrhvRGy6stTrgWx8UmRICIqO49byw0oc4/95Bd+Mebon9eZYhzromUnrV+6VeRTqLydsQjlmreGwhtC1NScfp+deEvO5+08jjkLQBrsW90rs0ChxLxyMhAcUmRl9hfelDxlqODbJlWrTLCnhFPd9ZfzpBCnPX9wLnmQ7rsc/2E9qLtbqQ/yyFr6cBUO0kM7wLpvDzoooBICZoaL6RSHSPWvkQBQbs3rYMxwiGmvfcppX3gPnPcRrjFsNlirBHvYefdPkymH/lzEPpQizA0qMZVvwflsbZjsMSaBWYfWd6mTmeJpiqqwRI2SA34PMBYJlQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=CF/kcKZmITjEMC5XYUhrDW/tn1caAHY7O5c1UfVGFoc=; b=gNWgD5RBi6WEU2ESLAfAGLK9Wr5fsipxTi3/lg29llYFnvo48+k7Asto0JCek9dfwnM8tdAaobbS76mclrk2MKVfxbkvNCVlPOvlNNI+npqnG3m4e9v8t2mopTq0ybCOexIzjE1Vm5UyBuHWJwRp8LRHYmtli7HqTYvW8r/ueIityEiLcpZDMRR+K5rV4YwCqVZd8xPLs4n0ClJu5BVvLpPdhPXgrq1oAcaTcXLv93DOzpWqMyRU0g/DFLlGyxCN7Kah4wCrvGWFBtUGZoe9K9Xg501qhqfEXNNsI98oUX28MRkNhveVHfz7PEK6M4yUI/0Z/x7iV3MfqIabvhCLHw== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by AM8P250MB0171.EURP250.PROD.OUTLOOK.COM (2603:10a6:20b:322::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:16:02 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:16:02 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:58 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [zFCDuV5+fvGiaXx5AN3OTrXejzgSgPcMg5LzBwltmIY=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-19-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|AM8P250MB0171:EE_ X-MS-Office365-Filtering-Correlation-Id: 94f74e8d-eec5-46d2-f3d2-08dc5808b664 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: Fo7VLYb9ncv9QnS25f/shp1UUgX1As0mPlVp7xd/sLxGes32DrtGWRuko5/4r0SmITfNiemRFWq1NT2oOdR8LZmNjfXMhXWt/YeDQd0WwgTU+bOhYIJDgrGjc6xKHPUyeWmDPXeFlvKWyXc9eo6lCrPoy9mdCCl+25sUqMxNFg8VxMbiztH2jiq2IIlHNol+CVuWnQX1MGZJBIsdbIVcTJBxkESGEaxiwMzDz8YfQwcy64fPIVPlUqnVv5X4H0QQdTptmy/laymtxF45yRj1WV/GuhwpLv9hAifhcXbWxPykuVDJKcHRDCA/4Bp/70BARa1XIM4Pajd4eYoL3yClGYys4PL/IdG/zusN3vkOLGUZjUtEfqvmOlmKnSb5xUXbwSp6iETmd5ue+fEdCfEnhcCcSGvF5+s21xPw3CwFCaqzRY2iCMrFsMoawzBrrxbIWhVcsXkagIfX0EShs/c37v7aXHoUh2LvZnBAL5BHirhij2/VE9sF2xC/uRN7QM31a/3crCirNthFWIggi5fnkRbnKcb57FcABNTiHwdvZgndGJT0pStpMGmvBPiqiRQDmzBqeRugewEIevzbv6Hf9DM8d0WVyVYB/o6OdN3uOZ40pEDA5H03XD/sDp5t1080 X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: t0QOX6NDNAru6RBzjSmhC7ovdh3Y2NotQXxMhLgsT50FLZilJV+Iw2Y2sq/kqbWSad3P0fuxr2pBzUghUapkuZrCp7aVw+Hw3bmWw/zwwJ+FfSV+3cOLaZ8skzOdAFBKjhu1DtoSxxcX6PiBz1rpBEznfv8utJJYBxeDrcaNWY8TdRAgBH1skRyDfmjIRuq62+S/PYoxeqB0vOENM75mMnOsxQnzaRKoauWsOR+DXMRF/uzCI223kGQ1MXpHQT1sJuGHzKF2VjAqTxiIbPaqAb7kDBrOEFkOzQcW7BdIG+0/N5iGA9lnQsdSiYYc4uA1zAeLP6nq1XYWjMZwRipfEXc8EfoGkEdDfvjqrnBb6KbdqQaf44UQPmOtH681KELxN20Mb3zWFp8qGUqHbClYF3C5RYjACrrbjHEIagDSzl5gU3yXrYHhzM02GJWTSHsGfCaDCzGznfOhGBsPN/Qw9ddGs12sDmqLQ4l66WeG46qmsip1o+HDy2OaxGyNzXQI/K4MQA8GqWddAQJHI7kSabbf06kKnNe2HTweesONS/ILrQFHtGuWnXuTGueGbrcLJmsuVM1HQP7BrlDOv+b5V4jW3E7g9BLAh8/t3LuwXN99MwbqWPq43zMu3xWlTD3LeeyErMJlXzU/3I9Kmo7dd+CzNALPDkZMJ3V1ymqaANSfpydvwWJvLOWZtu+uJqG4HLtz7XzZpdoUjmO/AFHJ6nVw5Fb1XPAVb3RBI4l5afmt5ISsVaxjE8iolxESxz/OF1qaAdwJLnLEx89ioHS1M4Ua+171IPjN5wHqbPR5z6rzf72XslCvlyCVQtixciRBiEE68N/5ew1yHm2YRsEOkrooM/nanwbfCrV1aLvfes+IW75KKQBazA51/up4mDH/R19Bf0uN2mwnEaLsPASM+MDO9O8gm1u55+z3hrMOftYQEt1H37ZU6aSTi64QeBwY6yIuMv/onmiHVIRD/5JtvHs6bkZybp9KhHHTYubJI+5u8sNnRdG9Jf+q251rmHQFrw4v1sfog5seSx1WUW02rFUF/MJiiM/LKWVCCkt7y1xrXQRVNWkmQGSGtx+3caI8KIHNbF6fLnKqt1TUmDy/iZqTyeYzPIGnk8QjsvPRn4ERYJEp1hUJ5v1KpyyY/OZJavq8TUEfVUw1sb5ObClZoF1cmiss6AHBrX4HBR8QN04OrNsbzmRx0vOn0h9MUXGoRIXDSUpLxlo94LMSea/8vC2r4iF+nt1DWwXDeR9AEpJ5wyV6vqGHjgFCmjqT0QJMvY/+7W5NDyMpkBQ6wexq9Q== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 94f74e8d-eec5-46d2-f3d2-08dc5808b664 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:16:02.4407 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM8P250MB0171 Subject: [FFmpeg-devel] [PATCH v2 20/27] avcodec/pngdec: Switch to ProgressFrames 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: n8gdK0HdyBOF Avoids implicit av_frame_ref() and therefore allocations and error checks. It also avoids explicitly allocating the AVFrames (done implicitly when getting the buffer). Signed-off-by: Andreas Rheinhardt --- libavcodec/pngdec.c | 67 ++++++++++++++++++--------------------------- 1 file changed, 27 insertions(+), 40 deletions(-) diff --git a/libavcodec/pngdec.c b/libavcodec/pngdec.c index 5a99b4a1c4..f7751223b8 100644 --- a/libavcodec/pngdec.c +++ b/libavcodec/pngdec.c @@ -42,8 +42,8 @@ #include "apng.h" #include "png.h" #include "pngdsp.h" +#include "progressframe.h" #include "thread.h" -#include "threadframe.h" #include "zlib_wrapper.h" #include @@ -63,8 +63,8 @@ typedef struct PNGDecContext { AVCodecContext *avctx; GetByteContext gb; - ThreadFrame last_picture; - ThreadFrame picture; + ProgressFrame last_picture; + ProgressFrame picture; AVDictionary *frame_metadata; @@ -874,7 +874,7 @@ static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s, s->bpp += byte_depth; } - ff_thread_release_ext_buffer(&s->picture); + ff_progress_frame_unref(&s->picture); if (s->dispose_op == APNG_DISPOSE_OP_PREVIOUS) { /* We only need a buffer for the current picture. */ ret = ff_thread_get_buffer(avctx, p, 0); @@ -883,8 +883,8 @@ static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s, } else if (s->dispose_op == APNG_DISPOSE_OP_BACKGROUND) { /* We need a buffer for the current picture as well as * a buffer for the reference to retain. */ - ret = ff_thread_get_ext_buffer(avctx, &s->picture, - AV_GET_BUFFER_FLAG_REF); + ret = ff_progress_frame_get_buffer(avctx, &s->picture, + AV_GET_BUFFER_FLAG_REF); if (ret < 0) return ret; ret = ff_thread_get_buffer(avctx, p, 0); @@ -892,8 +892,9 @@ static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s, return ret; } else { /* The picture output this time and the reference to retain coincide. */ - if ((ret = ff_thread_get_ext_buffer(avctx, &s->picture, - AV_GET_BUFFER_FLAG_REF)) < 0) + ret = ff_progress_frame_get_buffer(avctx, &s->picture, + AV_GET_BUFFER_FLAG_REF); + if (ret < 0) return ret; ret = av_frame_ref(p, s->picture.f); if (ret < 0) @@ -1254,7 +1255,7 @@ static void handle_p_frame_png(PNGDecContext *s, AVFrame *p) ls = FFMIN(ls, s->width * s->bpp); - ff_thread_await_progress(&s->last_picture, INT_MAX, 0); + ff_progress_frame_await(&s->last_picture, INT_MAX); for (j = 0; j < s->height; j++) { for (i = 0; i < ls; i++) pd[i] += pd_last[i]; @@ -1286,7 +1287,7 @@ static int handle_p_frame_apng(AVCodecContext *avctx, PNGDecContext *s, return AVERROR_PATCHWELCOME; } - ff_thread_await_progress(&s->last_picture, INT_MAX, 0); + ff_progress_frame_await(&s->last_picture, INT_MAX); // copy unchanged rectangles from the last frame for (y = 0; y < s->y_offset; y++) @@ -1674,7 +1675,7 @@ exit_loop: } /* handle P-frames only if a predecessor frame is available */ - if (s->last_picture.f->data[0]) { + if (s->last_picture.f) { if ( !(avpkt->flags & AV_PKT_FLAG_KEY) && avctx->codec_tag != AV_RL32("MPNG") && s->last_picture.f->width == p->width && s->last_picture.f->height== p->height @@ -1691,12 +1692,11 @@ exit_loop: if (CONFIG_APNG_DECODER && s->dispose_op == APNG_DISPOSE_OP_BACKGROUND) apng_reset_background(s, p); - ff_thread_report_progress(&s->picture, INT_MAX, 0); - - return 0; - + ret = 0; fail: - ff_thread_report_progress(&s->picture, INT_MAX, 0); + if (s->picture.f) + ff_progress_frame_report(&s->picture, INT_MAX); + return ret; } @@ -1783,8 +1783,8 @@ static int decode_frame_png(AVCodecContext *avctx, AVFrame *p, goto the_end; if (!(avctx->active_thread_type & FF_THREAD_FRAME)) { - ff_thread_release_ext_buffer(&s->last_picture); - FFSWAP(ThreadFrame, s->picture, s->last_picture); + ff_progress_frame_unref(&s->last_picture); + FFSWAP(ProgressFrame, s->picture, s->last_picture); } *got_frame = 1; @@ -1835,12 +1835,9 @@ static int decode_frame_apng(AVCodecContext *avctx, AVFrame *p, return ret; if (!(avctx->active_thread_type & FF_THREAD_FRAME)) { - if (s->dispose_op == APNG_DISPOSE_OP_PREVIOUS) { - ff_thread_release_ext_buffer(&s->picture); - } else { - ff_thread_release_ext_buffer(&s->last_picture); - FFSWAP(ThreadFrame, s->picture, s->last_picture); - } + if (s->dispose_op != APNG_DISPOSE_OP_PREVIOUS) + FFSWAP(ProgressFrame, s->picture, s->last_picture); + ff_progress_frame_unref(&s->picture); } *got_frame = 1; @@ -1853,8 +1850,7 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src) { PNGDecContext *psrc = src->priv_data; PNGDecContext *pdst = dst->priv_data; - ThreadFrame *src_frame = NULL; - int ret; + const ProgressFrame *src_frame; if (dst == src) return 0; @@ -1879,12 +1875,7 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src) src_frame = psrc->dispose_op == APNG_DISPOSE_OP_PREVIOUS ? &psrc->last_picture : &psrc->picture; - ff_thread_release_ext_buffer(&pdst->last_picture); - if (src_frame && src_frame->f->data[0]) { - ret = ff_thread_ref_frame(&pdst->last_picture, src_frame); - if (ret < 0) - return ret; - } + ff_progress_frame_replace(&pdst->last_picture, src_frame); return 0; } @@ -1895,10 +1886,6 @@ static av_cold int png_dec_init(AVCodecContext *avctx) PNGDecContext *s = avctx->priv_data; s->avctx = avctx; - s->last_picture.f = av_frame_alloc(); - s->picture.f = av_frame_alloc(); - if (!s->last_picture.f || !s->picture.f) - return AVERROR(ENOMEM); ff_pngdsp_init(&s->dsp); @@ -1909,10 +1896,8 @@ static av_cold int png_dec_end(AVCodecContext *avctx) { PNGDecContext *s = avctx->priv_data; - ff_thread_release_ext_buffer(&s->last_picture); - av_frame_free(&s->last_picture.f); - ff_thread_release_ext_buffer(&s->picture); - av_frame_free(&s->picture.f); + ff_progress_frame_unref(&s->last_picture); + ff_progress_frame_unref(&s->picture); av_freep(&s->buffer); s->buffer_size = 0; av_freep(&s->last_row); @@ -1940,6 +1925,7 @@ const FFCodec ff_apng_decoder = { UPDATE_THREAD_CONTEXT(update_thread_context), .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | + FF_CODEC_CAP_USES_PROGRESSFRAMES | FF_CODEC_CAP_ICC_PROFILES, }; #endif @@ -1958,6 +1944,7 @@ const FFCodec ff_png_decoder = { .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | FF_CODEC_CAP_INIT_CLEANUP | + FF_CODEC_CAP_USES_PROGRESSFRAMES | FF_CODEC_CAP_ICC_PROFILES, }; #endif From patchwork Mon Apr 8 20:13:59 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47955 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp136811pzb; Mon, 8 Apr 2024 13:17:21 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCUagyhhik+G5jLoDssBHkQdvBjX82PN5bWN4oX/puA/2QCDy9X5lK3P+zqEMM68ekWMtXWtj2pDqHMj1NpBRe2VyDflTcBo+nIiQA== X-Google-Smtp-Source: AGHT+IG0TQyndnIkRCkdlxiitmEYO31Oi8s8jS/OrKgd0wq1Vz9T6OZfVexw6p9RtDK0T3HTfSjP X-Received: by 2002:a50:bb05:0:b0:56d:f3f3:f61f with SMTP id y5-20020a50bb05000000b0056df3f3f61fmr8004879ede.9.1712607440819; Mon, 08 Apr 2024 13:17: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 y10-20020a056402270a00b0056e5c6a72d0si1405592edd.614.2024.04.08.13.17.20; Mon, 08 Apr 2024 13:17: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=@outlook.com header.s=selector1 header.b=QaM22GfS; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 2B97668D357; Mon, 8 Apr 2024 23:16:15 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05olkn2086.outbound.protection.outlook.com [40.92.89.86]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 9D37868D357 for ; Mon, 8 Apr 2024 23:16:08 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=Rm7Qw3akKoKFY+K5Iupyccri6V6/zJ/0bYXsZnvLyshvuiV+MZ24EVXj6HPwXx2m0jLqueHOt1J6XB4v1eGLe/HYmJTQxW+jsY6tu5r0D1bVBxut2sKWUs9wJs5G8wLv6AlGz9CZhYhIWo/lB3fiVhKuWwPEEbsysC6YdmdppPhelcmWfk5Aao4wIaYGKu8EciVSAjnJLb3ehyg1gl+derV6xaURcrHTx7wKfxbZAG0DzYkp+DQILT7EQkKg3jQFzfvz5nAIvBfjzki1AXy8L5o/UOl/X+lMgnLX9nQfpTmYLa6VeDNB9N83K//9/3C17fz5VndRxMxAcmDR+dJkkQ== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=df80nxRCFkkbHKo6U5P6gMZm/Ui7+rnVtVzn2t5YSyA=; b=LmiVkBcroSIrPtsoLkZmdIN7ZE9E5TRPMq5Oyplhw4R1BqEev7TxXeoUoyBJ3aZ8KyS6EIMfPuGvkhnkbdHmxBdlRV/t/jtU/zsMkZ6NPtpZuydM2wbTfOR/wKA3A+CvuhVka6u+MOUrjHkeZ/NHLpBRJPGPDCzQQM318WcWCMkIED28Y0rW23769vBr/dSOQY+gmiAK4LAZPK/hQh5QPIp+UoCrnJpmaswKVU3va0681IeKVFj1FmuAOnHxqphmrHpSL63w0+w6UYd7Ut1+xvdNJz5okVG+7HyTm0+FF5PwVVtL3FRUHRWAllVqAVgvs0/EdV5AH154SEa0e3WwHw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=df80nxRCFkkbHKo6U5P6gMZm/Ui7+rnVtVzn2t5YSyA=; b=QaM22GfSS2PCZeFYVOctd5YpZUTHekLXJiLcBr/3ej/tpbkYO+hfrpvtz0XLDEiPFHGbqj1imFtabSAvdbM7cgBm4AKFNFrW+lfFpawv5ujn9cfYdsXOmowzftsgTvdEXaVnkZuJjCtz+GA5BG/EXihybCIHjO1LLAAbjPbfKgzatbtysLP6EPwBH9vf62FO4fDI9gAU5O2qyqaNv72MRr5S1KsiPQjJVU02KpJx20uZHHabYK9EFjY6qT7xTuQ/TLWYld4h1VgDbp7QWzuhaE/zDVNqeMgPkl8Qxb/IdTFFTfsN5ao5GlV8Vo5Opt1iWcW+rcM9SmttKGxa7K8vkQ== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by AM8P250MB0171.EURP250.PROD.OUTLOOK.COM (2603:10a6:20b:322::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:16:06 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:16:06 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:13:59 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [wCohs+JsW4VRFGNLfPs1Pmd0IIoSg6A+CQUgqJ/xZTs=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-20-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|AM8P250MB0171:EE_ X-MS-Office365-Filtering-Correlation-Id: bd16f64a-c848-408f-d8fe-08dc5808b8b4 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: Fsdpj2IGvjpC7HDUKSoamYeVuRXNQssJQ9O7cuExIchbUIJpIXptOSqo5uHslUirRAUMnZAtFqNMhqrEzPHZQUZAXJgKL3cE95wr6evJTBle996PD7ffH8kOu2YzwsasNiCxElXorednBzPA6WKKoX6R11iDb5ePdEhfzNgvj2y4wy+5EdIVgKlg5q3Rmkf1bJwMBFaXMmcctigGGT+D24XUusNXu23Y3HXKMz4O/6e1fibx6gRa3LWRwq8Z2b8QjrC5Uz/XBN0Zxq4ryW1ET7s/G6N9GX1rHZQWKIZYJnGZ3nU3g9tbksQ4dZkXRopel6D8aWZEToXV4Ls2ij6+VXm5okLJmsje6cfnWpi6kVuI1GeBLgsvD4F9gS/Kcn5Gyj/2QQlJ1NxLc8MmKfn8g1jvVNtn1atmDSL0KMckaqLdzwDd7SnwcsyBY7A9jfHHhoNU1tRMgbjOooRd6lrwZxTIlu0av/kKl2zJN0cc5UapJSXE3lfXKVq66cL1KdFjQNC5VlGiwgYAbzlvqzm8wTdhGvJmUdvWtLTkavNCkvp1N1CRH2LGVzAwFe7sAjRSGdW+HERpVv1ru0ltb/cUfDx4iXhk6/CfRBGsLBJacxkvJ2as+Rp0f3L9x+Z0R/nB X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: nPgyc0XG6djvvJZdWcqBWwIKgd3NvmM9d8/UDl28kNd9IPyYn0daInGT2FIqZu+EYFqhycy4kj7DBpAW6+UVekxD9Meec1BBW2c56GaixzLSy5ZsWiTljZDGr+1qQhVt7sDyy7GjVvhPexUzI2CiAY2B2EFvAGIYUX6olDFfmo+I/RO/smXqUqPadUoPz251Mq0QUchaqe/Pppjn1dZHhBadYSCMQdufiXue1DMYmRju2LkT0KDtuB6IEywwyxhluLeQkbu4b5G6UjOahTdT+0R1Q6UI0Bi/Y2RdO4mlVePD80ACFeFE5aCrVDR5IzVu/lqcit2mODVSc7XoGHhfs8g2hFOgCi0ekrsKs+NIt2kLu2vgSEDl67qX8s2gHRqjzmN2TgRoRN0N0AS/t20x4nVscctt9MNKgbSqs3SAWbsg/sWSvZXVCNP35hGncM8DieLODsV1PBhSPUzc2aVXdKGdzm1vI2agaB14EJt36/NqESxpjA9uhlPPrZf0rg9d23YK40KvoZehlBv91wC2OYy/9zSWNOGGryYrYvRuB01zMQ5/aulnpohlcx8/VaZbL9sZrhThPoKaIwAkS9FQW9gOCJHAAKdwfLw+fjW9KuPGgfNHjj5FO7BdpJSFyt3W6B+ZPzrKlhvWEpYFwRVSbIUKMGcQPcYgrCEHERRPDXpx/Xab1yo/ae6EfD2/DiAe4EoTFYYiMXdxWxUlIawjkHJZ+D6Es4O+iSIPjfIKp8k3+hFmkoWp6UrD0w4fAk1PsfyM7tMYzTBFU730sU0grJHi4c6/H0PSc38ikmnEzbR1rzbKXblJ+N/7imIxFSkIzHuTQiDYWjkOpcDXBgjh/r4MhwV1FYHAUdJk/ta3oTJFQa/WRUavmRUvziCpE6KPqxLdR9mCkJ8Z36DzgOUtcht0mEJ9plc9AigO9GKHhI6UXLWu37+wOlsDwUqvmGp4sIpF6mHDpwd0CONokADe4Bgbb/uFnz0hm6q4c5R3u3e/FgiL0tCxq1mz7a7ZrxQzaTs/vFHcxA9qfMAZsDYtD80yQ8mpi7IzpQx+8kddKKswLALAE1PInThWyWAkXxBPcOuh0qckvQ6QEaTBMR2YCh1c6jjmSUbhK/2JGBY94jTFfdsQA0WlJg3DKYoYoSmdktaVWIAGHhhLzTNXI3MZTc5fJQ4P+QwC+Ju4mzjB62zyapVUg/WNSwcFYIzJINKJCH/IjXkJDp/Eqc+D55D1V5pIaNgYS0vbgMeNUcojO7vjZWaNYPR/q0XRyUdZCW5Sl5mRFsKVRcTQLKQ+xALnPQ== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: bd16f64a-c848-408f-d8fe-08dc5808b8b4 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:16:06.3243 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM8P250MB0171 Subject: [FFmpeg-devel] [PATCH v2 21/27] avcodec/ffv1dec: Switch to ProgressFrames 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: jdpRo2xkikdl Avoids implicit av_frame_ref() and therefore allocations and error checks. It also avoids explicitly allocating the AVFrames (done implicitly when getting the buffer). It also fixes a data race: The AVFrame's sample_aspect_ratio is currently updated after ff_thread_finish_setup() and this write is unsynchronized with the read in av_frame_ref(). Removing the implicit av_frame_ref() fixed this. Signed-off-by: Andreas Rheinhardt --- libavcodec/ffv1.h | 5 ++- libavcodec/ffv1dec.c | 81 +++++++++++++++++++------------------------- 2 files changed, 36 insertions(+), 50 deletions(-) diff --git a/libavcodec/ffv1.h b/libavcodec/ffv1.h index 04869da5c9..acec22e83e 100644 --- a/libavcodec/ffv1.h +++ b/libavcodec/ffv1.h @@ -28,13 +28,12 @@ * FF Video Codec 1 (a lossless codec) */ -#include "libavutil/imgutils.h" #include "avcodec.h" #include "get_bits.h" #include "mathops.h" +#include "progressframe.h" #include "put_bits.h" #include "rangecoder.h" -#include "threadframe.h" #ifdef __INTEL_COMPILER #undef av_flatten @@ -87,7 +86,7 @@ typedef struct FFV1Context { int flags; int64_t picture_number; int key_frame; - ThreadFrame picture, last_picture; + ProgressFrame picture, last_picture; struct FFV1Context *fsrc; AVFrame *cur; diff --git a/libavcodec/ffv1dec.c b/libavcodec/ffv1dec.c index dd594e3f9f..7a0d1909aa 100644 --- a/libavcodec/ffv1dec.c +++ b/libavcodec/ffv1dec.c @@ -37,8 +37,8 @@ #include "golomb.h" #include "mathops.h" #include "ffv1.h" +#include "progressframe.h" #include "thread.h" -#include "threadframe.h" static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed) @@ -264,8 +264,8 @@ static int decode_slice(AVCodecContext *c, void *arg) for( si=0; fs != f->slice_context[si]; si ++) ; - if(f->fsrc && !(p->flags & AV_FRAME_FLAG_KEY)) - ff_thread_await_progress(&f->last_picture, si, 0); + if (f->fsrc && !(p->flags & AV_FRAME_FLAG_KEY) && f->last_picture.f) + ff_progress_frame_await(&f->last_picture, si); if(f->fsrc && !(p->flags & AV_FRAME_FLAG_KEY)) { FFV1Context *fssrc = f->fsrc->slice_context[si]; @@ -370,7 +370,7 @@ static int decode_slice(AVCodecContext *c, void *arg) } } - ff_thread_report_progress(&f->picture, si, 0); + ff_progress_frame_report(&f->picture, si); return 0; } @@ -858,11 +858,6 @@ static av_cold int decode_init(AVCodecContext *avctx) if ((ret = ff_ffv1_common_init(avctx)) < 0) return ret; - f->picture.f = av_frame_alloc(); - f->last_picture.f = av_frame_alloc(); - if (!f->picture.f || !f->last_picture.f) - return AVERROR(ENOMEM); - if (avctx->extradata_size > 0 && (ret = read_extra_header(f)) < 0) return ret; @@ -879,31 +874,21 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe, int buf_size = avpkt->size; FFV1Context *f = avctx->priv_data; RangeCoder *const c = &f->slice_context[0]->c; - int i, ret; + int i, ret, key_frame; uint8_t keystate = 128; uint8_t *buf_p; AVFrame *p; - if (f->last_picture.f) - ff_thread_release_ext_buffer(&f->last_picture); - FFSWAP(ThreadFrame, f->picture, f->last_picture); - - f->cur = p = f->picture.f; + ff_progress_frame_unref(&f->last_picture); + FFSWAP(ProgressFrame, f->picture, f->last_picture); - if (f->version < 3 && avctx->field_order > AV_FIELD_PROGRESSIVE) { - /* we have interlaced material flagged in container */ - p->flags |= AV_FRAME_FLAG_INTERLACED; - if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB) - p->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST; - } f->avctx = avctx; ff_init_range_decoder(c, buf, buf_size); ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8); - p->pict_type = AV_PICTURE_TYPE_I; //FIXME I vs. P if (get_rac(c, &keystate)) { - p->flags |= AV_FRAME_FLAG_KEY; + key_frame = AV_FRAME_FLAG_KEY; f->key_frame_ok = 0; if ((ret = read_header(f)) < 0) return ret; @@ -914,7 +899,7 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe, "Cannot decode non-keyframe without valid keyframe\n"); return AVERROR_INVALIDDATA; } - p->flags &= ~AV_FRAME_FLAG_KEY; + key_frame = 0; } if (f->ac != AC_GOLOMB_RICE) { @@ -932,10 +917,23 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe, return AVERROR_INVALIDDATA; } - ret = ff_thread_get_ext_buffer(avctx, &f->picture, AV_GET_BUFFER_FLAG_REF); + ret = ff_progress_frame_get_buffer(avctx, &f->picture, + AV_GET_BUFFER_FLAG_REF); if (ret < 0) return ret; + f->cur = p = f->picture.f; + + p->pict_type = AV_PICTURE_TYPE_I; //FIXME I vs. P + p->flags = (p->flags & ~AV_FRAME_FLAG_KEY) | key_frame; + + if (f->version < 3 && avctx->field_order > AV_FIELD_PROGRESSIVE) { + /* we have interlaced material flagged in container */ + p->flags |= AV_FRAME_FLAG_INTERLACED; + if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB) + p->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST; + } + if (avctx->debug & FF_DEBUG_PICT_INFO) av_log(avctx, AV_LOG_DEBUG, "ver:%d keyframe:%d coder:%d ec:%d slices:%d bps:%d\n", f->version, !!(p->flags & AV_FRAME_FLAG_KEY), f->ac, f->ec, f->slice_count, f->avctx->bits_per_raw_sample); @@ -954,7 +952,7 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe, } else v = buf_p - c->bytestream_start; if (buf_p - c->bytestream_start < v) { av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n"); - ff_thread_report_progress(&f->picture, INT_MAX, 0); + ff_progress_frame_report(&f->picture, INT_MAX); return AVERROR_INVALIDDATA; } buf_p -= v; @@ -996,11 +994,11 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe, for (i = f->slice_count - 1; i >= 0; i--) { FFV1Context *fs = f->slice_context[i]; int j; - if (fs->slice_damaged && f->last_picture.f->data[0]) { + if (fs->slice_damaged && f->last_picture.f) { const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt); const uint8_t *src[4]; uint8_t *dst[4]; - ff_thread_await_progress(&f->last_picture, INT_MAX, 0); + ff_progress_frame_await(&f->last_picture, INT_MAX); for (j = 0; j < desc->nb_components; j++) { int pixshift = desc->comp[j].depth > 8; int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0; @@ -1022,10 +1020,9 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *rframe, fs->slice_height); } } - ff_thread_report_progress(&f->picture, INT_MAX, 0); + ff_progress_frame_report(&f->picture, INT_MAX); - if (f->last_picture.f) - ff_thread_release_ext_buffer(&f->last_picture); + ff_progress_frame_unref(&f->last_picture); if ((ret = av_frame_ref(rframe, f->picture.f)) < 0) return ret; @@ -1067,7 +1064,7 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src) { FFV1Context *fsrc = src->priv_data; FFV1Context *fdst = dst->priv_data; - int i, ret; + int i; if (dst == src) return 0; @@ -1088,12 +1085,7 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src) av_assert1(fdst->max_slice_count == fsrc->max_slice_count); - - ff_thread_release_ext_buffer(&fdst->picture); - if (fsrc->picture.f->data[0]) { - if ((ret = ff_thread_ref_frame(&fdst->picture, &fsrc->picture)) < 0) - return ret; - } + ff_progress_frame_replace(&fdst->picture, &fsrc->picture); fdst->fsrc = fsrc; @@ -1105,15 +1097,9 @@ static av_cold int ffv1_decode_close(AVCodecContext *avctx) { FFV1Context *const s = avctx->priv_data; - if (s->picture.f) { - ff_thread_release_ext_buffer(&s->picture); - av_frame_free(&s->picture.f); - } + ff_progress_frame_unref(&s->picture); + ff_progress_frame_unref(&s->last_picture); - if (s->last_picture.f) { - ff_thread_release_ext_buffer(&s->last_picture); - av_frame_free(&s->last_picture.f); - } return ff_ffv1_close(avctx); } @@ -1129,5 +1115,6 @@ const FFCodec ff_ffv1_decoder = { UPDATE_THREAD_CONTEXT(update_thread_context), .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS, - .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, + .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | + FF_CODEC_CAP_USES_PROGRESSFRAMES, }; From patchwork Mon Apr 8 20:14:00 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47956 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp136894pzb; Mon, 8 Apr 2024 13:17:29 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCWi1GLH3IoXF4oMNMVKokZrlXZVvJ5IieC/gzy8CRfZb00ADlG+pm3zU0klPtvyePaLeMcDNOQSFGhY8fjn8pLBscA+tQE7OYeyrA== X-Google-Smtp-Source: AGHT+IFmNlGYY4RjzD2kHqPtPQoP/GKcW9qeRRGSAXDr4BGNNyTT/v7eYn1WT5V6RCM1sfFKt6A3 X-Received: by 2002:a17:907:72c2:b0:a4e:4ed4:5efb with SMTP id du2-20020a17090772c200b00a4e4ed45efbmr7808399ejc.3.1712607449560; Mon, 08 Apr 2024 13:17:29 -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 n4-20020a170906840400b00a463c3828besi3793248ejx.491.2024.04.08.13.17.29; Mon, 08 Apr 2024 13:17:29 -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=@outlook.com header.s=selector1 header.b=SjUoSF6C; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 3453B68D436; Mon, 8 Apr 2024 23:16:16 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05olkn2086.outbound.protection.outlook.com [40.92.89.86]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 0145068D357 for ; Mon, 8 Apr 2024 23:16:13 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=NkWDS8WbwNHEaric7yqzOL3bguZfIQMiZC657BtRxjj6X6AFTGPyYBflpj9Xj1MYxMMPWHDdDSYwij2xXYY/k4OSWDpBF/aKvyMZJJ4K4K7XfE5viJUerDh//fcDbAMwdv+HcPBSf+6O2MVbFFxOXdNJhjhF4iTmIwZjp/JUW2nBRXJ5uPgEhtp599aLWAi/aVBCNHJlXVDQSSlTCi/VyNlKJ4tEwbc3I7WTJVmpiL+yPUiHLXLV8k2k3FNg72RwI0Ud1/9Y5e8wBmKK9paZoTJ3DyiukL/7blF37EpdttvlJS2fRZC4n/KA3o+EWhgw8XEG/kq7QJdraoUpGN/UdA== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=AM8CJ3H5WtKdSMGddSm+DBsPwNgMe0KKqok2xgYSH9g=; b=MzjIpaayx9aXK7SvtaPkohTKXy59qeWH6VWi6NDduRMsnZXyZwHIBEdAqmOdgZxnHCwng1s8E6Igqv2CxodFXtWBdjWHmA9OrArOkH9t5QRa3I7+TSWNI+rqRtpQnLO/R0KGh90ws6nszTA7adkB1Gj/O4qYwkGhGob078Wf3PG8XXSf3/PpLK37PaBfhXCl8dE2sL6+IDggGQek7IGDqTyJPZlTdqLRfpX7kjLUhVQPSLIr040fbsM5u+5U3cXCEuGO2lr1GPIslUWHAMa2XoBFrGYkeP+lO5NLKOdWGOI/8Nlx3HAlvQGQ6Xyp2nHiAmZ4+v92EJKbEn6hC8eEDA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=AM8CJ3H5WtKdSMGddSm+DBsPwNgMe0KKqok2xgYSH9g=; b=SjUoSF6CTlFVLqdf6msWmSKVXW7+kmT6sMSyTIoj76dTpH7SeDkJpIgOMiOyKxSD7vZ/iAEw1CVb7cEqOZkU7E9+LgmiHFU4odLyYj9zQAlsVKaZgVFfphRmOrrvnsATn0+P62zsArXw83bV0b3FApKo3kuNGvoxol+DNtgCLiFxKsJqQVGrMK5iiGHitUcsKAIR5cppHEc2ew/Hr/2MbsGNlAxI0nljEw1t/pH2L9M5UC1KrgukYM5yAKAVfmGQBAs0HBZuFLZm3neQkywjdDVw0qY2AybHrgoqXlJrR6rL25C/VCIalNxJcw5gVpUM2W6sn6AgrpnVKK9ZTRl2Ow== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by AM8P250MB0171.EURP250.PROD.OUTLOOK.COM (2603:10a6:20b:322::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:16:08 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:16:08 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:14:00 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [SHI3YkZK4Mca7OXCYW4IB0s9lvsGBQGAQ/HOWhHc6Y0=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-21-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|AM8P250MB0171:EE_ X-MS-Office365-Filtering-Correlation-Id: 4d2d3e68-2f7c-41cb-127a-08dc5808b9e3 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: TkTNkTH2piA25IMEFjTc8wHcJElMLGdy3KCeFqiERl+2cQB+aPs+dGgCh2ujvBVd6gvRNY3atCNwyeqlHvLnRMs3fujYE/qDNnUVRBgJLH/bGlcvhZqvQs1FaKMz9ljXv+ystwK0sgtdTw6/thphYUGlbxfWyt5VP7d+iTmytBH7UbxeRQLSbIvBkg7BvbHEp7hREv7sLMZQHgAB2WUFO8Cli7t3zOL4vpd7ONmYegU55QupnUOJdocdxIBjmGYZmClaQFtQJ7cuaOeT6KBpnz67n7a1N2BJDQtDUnGG+QU4pjPNkFDHjSi2PTNPeMey2OciHI2nJNmHhvYEFGowuVQSmcSOdBE52UJK9gFn8BGJWW0Mygy67tT7ZBLdfE+pdo7IQYRSftHh/9p4at+mafSWQ+QVriYPfEqG3SzL/hNVO7Yd/DLJDUH++/diYKehGFRYEwDTv7wCozHijv3HqwsOgJLmDL0bIQBuuen1GeG3+pLB0z4sTErBhQIn8c2QJdB5TbL9DRynRRRI/r3WUE9UQMAGf91s5Nb4nc7pA25Jx3m3bVJcorbQyzj61wFgZAR6EPCYOHVidXfYWfeHG31tMNrt03C8jIzj3ChBoeBBWneWPhQu6QBaCKTWRSVt X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: XopMlH7sfZ+5zHzMlzEQtt036Gaj4lG4p2KijenZx9NbJXY1vbL2vXE/pKkM2Hhybm7/GYkjzGZuF7DsWM7VKw8QkGArAOxGHpdqjt8Vmy9WttLP8D8gOQoOxDyccTegdauNwTdjH8zcLyeAHSjUw9jRoHGR/R17MT8aAOMBOW+2mKwsfsx715e06E+dub+Pj7mmaiCqxy3WcGi91ziqOfLfSGI5FWsxV1A25lkvC82FBqI16LzM46DBrHpEqFoqlRUZv5hF6zC7UbCQLhiX3uvZgoIH+j4hBjeln26xenFd/ce8wMuN82zzZMWIMRdSYkkztUSyq6GQ66WUITz4I0MQl11BclHeYhoutvGkF1s/nGyqYWbMZB99rkHlcxkTAIihkzAGE3ztbEsyXDOm1cfVZUWafiZ4/tWQ3/bcnU1atncgPOW4WR44c8dPRUV7sqggPdG1AF8pXGnTZoORGLwk5h97edTkZ/HR8cwp3R69jzJlehrk0AyxrbRKZ1ieVWJ1sewGVYnrslmAKy4/6Cwu+2NwZyZknTPYh9dW6vhB2THzzssK/dNbZxQF2RYfAuRHqyXQ4jLek+Cm0f7f+O13ckkDrWOBYkIP1NZPWXYuAdQPZjmRtJnMYHCy1CQ7O56RpVq9JEk4pjB4jl6nNBqFV+6OVacT4OkihT4zeqVe9EWoRVtCp/ReSWpN0e+/Oz38STyDXkMK3GaeUQBf9dZnMkX/3UKZ5+1U99KdBtrCaca/jNGIDYjHs+XIVbONukGkQCYv7Et+lfxlnWW8WM0O5ttFiPlFgZLhD7bSrdylFYuH8xLP0KXLCAZmYjSH5XNDgCgtybtaeudB4aVEH3z9X6MsqNTjVLEhbHhRtiAIr1UOcCKUH+nVl6N4Of6G7MdamgEXk0KnaBvqk+C2MzlmBhAZBKkRnNtKK56hbVQ5Q2RJEk1z4kDrjLXJCWpxbY2lZpMD682s/T/ZyuSs6fE9908XgncC7dhWodnKCPf78iJvh8JVF9zhBQbblJkgS87Fm4NpelBlHSvOvzBPy04CTGyWMDbBFTd2nAmeUKK2WzlsdjWtP5UNXPhVi/cwVvyD0JnKUQdskkUR/vdddtQ2JYED+LJZKJHNHUzAKlyl1SwLGBIdAa13mGP2SlCSGOAPjhMY/CGNijkF4nHRMZerQl4RNLjLnAy6gOipVbsvXu860c5W+XchBH0ra/wZOZiCvq/zWPk7/gPOLH+WLYySl1HeMrre71CPCunebTaQO3HvYmiSxoEBv40DFbR1sPdY+6OT59hK8xe6QnBb8Q== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 4d2d3e68-2f7c-41cb-127a-08dc5808b9e3 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:16:08.3152 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM8P250MB0171 Subject: [FFmpeg-devel] [PATCH v2 22/27] avcodec/qsv: Use RefStruct API for memory id (mids) array 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: EVKQyeoUEX24 Avoids allocations and therefore error checks and cleanup code; also avoids indirections. Signed-off-by: Andreas Rheinhardt --- libavcodec/qsv.c | 55 +++++++++++++++------------------------ libavcodec/qsv_internal.h | 11 ++++---- libavcodec/qsvdec.c | 3 ++- libavcodec/qsvenc.c | 3 ++- 4 files changed, 31 insertions(+), 41 deletions(-) diff --git a/libavcodec/qsv.c b/libavcodec/qsv.c index d9c81b7158..b07302cdf6 100644 --- a/libavcodec/qsv.c +++ b/libavcodec/qsv.c @@ -35,6 +35,7 @@ #include "avcodec.h" #include "qsv_internal.h" +#include "refstruct.h" #define MFX_IMPL_VIA_MASK(impl) (0x0f00 & (impl)) #define QSV_HAVE_USER_PLUGIN !QSV_ONEVPL @@ -740,20 +741,19 @@ int ff_qsv_init_internal_session(AVCodecContext *avctx, QSVSession *qs, return 0; } -static void mids_buf_free(void *opaque, uint8_t *data) +static void mids_buf_free(FFRefStructOpaque opaque, void *obj) { - AVBufferRef *hw_frames_ref = opaque; + AVBufferRef *hw_frames_ref = opaque.nc; av_buffer_unref(&hw_frames_ref); - av_freep(&data); } -static AVBufferRef *qsv_create_mids(AVBufferRef *hw_frames_ref) +static QSVMid *qsv_create_mids(AVBufferRef *hw_frames_ref) { AVHWFramesContext *frames_ctx = (AVHWFramesContext*)hw_frames_ref->data; AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx; int nb_surfaces = frames_hwctx->nb_surfaces; - AVBufferRef *mids_buf, *hw_frames_ref1; + AVBufferRef *hw_frames_ref1; QSVMid *mids; int i; @@ -761,35 +761,27 @@ static AVBufferRef *qsv_create_mids(AVBufferRef *hw_frames_ref) if (!hw_frames_ref1) return NULL; - mids = av_calloc(nb_surfaces, sizeof(*mids)); + mids = ff_refstruct_alloc_ext(nb_surfaces * sizeof(*mids), 0, + hw_frames_ref1, mids_buf_free); if (!mids) { av_buffer_unref(&hw_frames_ref1); return NULL; } - mids_buf = av_buffer_create((uint8_t*)mids, nb_surfaces * sizeof(*mids), - mids_buf_free, hw_frames_ref1, 0); - if (!mids_buf) { - av_buffer_unref(&hw_frames_ref1); - av_freep(&mids); - return NULL; - } - for (i = 0; i < nb_surfaces; i++) { QSVMid *mid = &mids[i]; mid->handle_pair = (mfxHDLPair*)frames_hwctx->surfaces[i].Data.MemId; mid->hw_frames_ref = hw_frames_ref1; } - return mids_buf; + return mids; } static int qsv_setup_mids(mfxFrameAllocResponse *resp, AVBufferRef *hw_frames_ref, - AVBufferRef *mids_buf) + QSVMid *mids) { AVHWFramesContext *frames_ctx = (AVHWFramesContext*)hw_frames_ref->data; AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx; - QSVMid *mids = (QSVMid*)mids_buf->data; int nb_surfaces = frames_hwctx->nb_surfaces; int i; @@ -810,12 +802,7 @@ static int qsv_setup_mids(mfxFrameAllocResponse *resp, AVBufferRef *hw_frames_re return AVERROR(ENOMEM); } - resp->mids[resp->NumFrameActual + 1] = av_buffer_ref(mids_buf); - if (!resp->mids[resp->NumFrameActual + 1]) { - av_buffer_unref((AVBufferRef**)&resp->mids[resp->NumFrameActual]); - av_freep(&resp->mids); - return AVERROR(ENOMEM); - } + resp->mids[resp->NumFrameActual + 1] = ff_refstruct_ref(mids); return 0; } @@ -849,7 +836,7 @@ static mfxStatus qsv_frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req, return MFX_ERR_UNSUPPORTED; } - ret = qsv_setup_mids(resp, ctx->hw_frames_ctx, ctx->mids_buf); + ret = qsv_setup_mids(resp, ctx->hw_frames_ctx, ctx->mids); if (ret < 0) { av_log(ctx->logctx, AV_LOG_ERROR, "Error filling an external frame allocation request\n"); @@ -860,7 +847,8 @@ static mfxStatus qsv_frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req, AVHWFramesContext *ext_frames_ctx = (AVHWFramesContext*)ctx->hw_frames_ctx->data; mfxFrameInfo *i = &req->Info; - AVBufferRef *frames_ref, *mids_buf; + AVBufferRef *frames_ref; + QSVMid *mids; AVHWFramesContext *frames_ctx; AVQSVFramesContext *frames_hwctx; @@ -888,14 +876,14 @@ static mfxStatus qsv_frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req, return MFX_ERR_MEMORY_ALLOC; } - mids_buf = qsv_create_mids(frames_ref); - if (!mids_buf) { + mids = qsv_create_mids(frames_ref); + if (!mids) { av_buffer_unref(&frames_ref); return MFX_ERR_MEMORY_ALLOC; } - ret = qsv_setup_mids(resp, frames_ref, mids_buf); - av_buffer_unref(&mids_buf); + ret = qsv_setup_mids(resp, frames_ref, mids); + ff_refstruct_unref(&mids); av_buffer_unref(&frames_ref); if (ret < 0) { av_log(ctx->logctx, AV_LOG_ERROR, @@ -912,7 +900,7 @@ static mfxStatus qsv_frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req, static mfxStatus qsv_frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp) { av_buffer_unref((AVBufferRef**)&resp->mids[resp->NumFrameActual]); - av_buffer_unref((AVBufferRef**)&resp->mids[resp->NumFrameActual + 1]); + ff_refstruct_unref(&resp->mids[resp->NumFrameActual + 1]); av_freep(&resp->mids); return MFX_ERR_NONE; } @@ -1104,11 +1092,10 @@ int ff_qsv_init_session_frames(AVCodecContext *avctx, mfxSession *psession, qsv_frames_ctx->logctx = avctx; /* allocate the memory ids for the external frames */ - av_buffer_unref(&qsv_frames_ctx->mids_buf); - qsv_frames_ctx->mids_buf = qsv_create_mids(qsv_frames_ctx->hw_frames_ctx); - if (!qsv_frames_ctx->mids_buf) + ff_refstruct_unref(&qsv_frames_ctx->mids); + qsv_frames_ctx->mids = qsv_create_mids(qsv_frames_ctx->hw_frames_ctx); + if (!qsv_frames_ctx->mids) return AVERROR(ENOMEM); - qsv_frames_ctx->mids = (QSVMid*)qsv_frames_ctx->mids_buf->data; qsv_frames_ctx->nb_mids = frames_hwctx->nb_surfaces; err = MFXVideoCORE_SetFrameAllocator(session, &frame_allocator); diff --git a/libavcodec/qsv_internal.h b/libavcodec/qsv_internal.h index c2d301b4a2..d970cd20f0 100644 --- a/libavcodec/qsv_internal.h +++ b/libavcodec/qsv_internal.h @@ -115,11 +115,12 @@ typedef struct QSVFramesContext { AVBufferRef *hw_frames_ctx; void *logctx; - /* The memory ids for the external frames. - * Refcounted, since we need one reference owned by the QSVFramesContext - * (i.e. by the encoder/decoder) and another one given to the MFX session - * from the frame allocator. */ - AVBufferRef *mids_buf; + /** + * The memory ids for the external frames. + * Refcounted (via the RefStruct API), since we need one reference + * owned by the QSVFramesContext (i.e. by the encoder/decoder) and + * another one given to the MFX session from the frame allocator. + */ QSVMid *mids; int nb_mids; } QSVFramesContext; diff --git a/libavcodec/qsvdec.c b/libavcodec/qsvdec.c index fd9267c6f4..5528bcdc8c 100644 --- a/libavcodec/qsvdec.c +++ b/libavcodec/qsvdec.c @@ -50,6 +50,7 @@ #include "hwconfig.h" #include "qsv.h" #include "qsv_internal.h" +#include "refstruct.h" #if QSV_ONEVPL #include @@ -885,7 +886,7 @@ static void qsv_decode_close_qsvcontext(QSVContext *q) ff_qsv_close_internal_session(&q->internal_qs); av_buffer_unref(&q->frames_ctx.hw_frames_ctx); - av_buffer_unref(&q->frames_ctx.mids_buf); + ff_refstruct_unref(&q->frames_ctx.mids); av_buffer_pool_uninit(&q->pool); } diff --git a/libavcodec/qsvenc.c b/libavcodec/qsvenc.c index 3a8607fca6..018d193495 100644 --- a/libavcodec/qsvenc.c +++ b/libavcodec/qsvenc.c @@ -41,6 +41,7 @@ #include "qsv.h" #include "qsv_internal.h" #include "qsvenc.h" +#include "refstruct.h" struct profile_names { mfxU16 profile; @@ -2649,7 +2650,7 @@ int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q) ff_qsv_close_internal_session(&q->internal_qs); av_buffer_unref(&q->frames_ctx.hw_frames_ctx); - av_buffer_unref(&q->frames_ctx.mids_buf); + ff_refstruct_unref(&q->frames_ctx.mids); cur = q->work_frames; while (cur) { From patchwork Mon Apr 8 20:14:01 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47957 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp136950pzb; Mon, 8 Apr 2024 13:17:37 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCX1Bt7Pzoj12X/wL+MMlpo7Dx9WP+ulvgdNeQ/YrmMT8X/0wuw1vQq8RnVCLfRwp/zKqMrHCoMeKIYqGTckPGdNSxdMNuo82yGRdg== X-Google-Smtp-Source: AGHT+IFJgPGlDJSweywcoXurrYC73N2+9XNw6vOJEt7MqqpQ1fnYicyuKS6jzZmz2fbzYdDwQDhu X-Received: by 2002:a50:d587:0:b0:56e:df1:53e2 with SMTP id v7-20020a50d587000000b0056e0df153e2mr7062370edi.22.1712607457645; Mon, 08 Apr 2024 13:17:37 -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 i11-20020a50d74b000000b0056dfc9fccf4si4187558edj.472.2024.04.08.13.17.37; Mon, 08 Apr 2024 13:17:37 -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=@outlook.com header.s=selector1 header.b=g6ZHbKee; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 3E99668D437; Mon, 8 Apr 2024 23:16:17 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05olkn2086.outbound.protection.outlook.com [40.92.89.86]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 4A63268D41E for ; Mon, 8 Apr 2024 23:16:14 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=l8Rpn/YIYv9vLcPGQj2z9VVMvcNcIStVdk1efOXFTd/qlVSDhq0FtU/Bg7fYdTJBigl27jxUTlzSLpykZoi2wKFlHsQDGUE/pEEwzQT4g3tUkXjo2/Cy1KgOhsAxy8YApd6Uj/1MSpSVE66dC6m6EXWI1/sbkddNtGseTzzbRlepE8b3223nDzrCW32iNEJuhINctQZfHUelK7DTnSWMug5cvqTKh5HMUg7LXFrJxIjNDka52ctSF0sqINNyVFDULEzNOjfRUgrRy0ajzNxg/M+7cwRDqPwwl99qvmpzd9AsLvpZWtB4nY5JMTiNMRQM21DfYEtumbFjqJzzEfcgSw== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=GPa7ox3JT4ZEboPb/OHQu9h3vkJZNmKQGA29YMKSii0=; b=PhZFZI1FzV/i2N6iMWTJs8dvLwyrfk3Usuq5gxHRP7uIsxrcrWVl2n1NoZnPFxX0SsCgP7YvN/GqLRw+9PgBzwbVpw6bnlibfhvuFLaVtFx1sjH3T25+Ouvbm3VsCJ0L6S6CfZpmZJ2TTJxGt5fOCEiLLFXdURm/zX6Uy3kY8zkA/e+XV911MnzsfbFo/gXCDXMWQmQ4yQeTyEmYMYypB/pRMvTAVWJ4HLTEsYGYSejGBBLdPcVoU77efMYQ/uBrJapk6rY9Gqor1jxfqq19UHvF2jMG/FVxjCdiP3buMM3VqKhbAoquQXUh85lHnVX13QwWrZbW2dp4K33b+YWvFw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=GPa7ox3JT4ZEboPb/OHQu9h3vkJZNmKQGA29YMKSii0=; b=g6ZHbKeelrI5V2Ja127lvvc3Ur0KxCaZnd/1umIib3WzMNqNae2HC6X8Zhs5gCQgxoNjeILWhP2XMF4IQdWPcxPZ6t5bOlG6D3zYhzP2h/YakIbbdUsKoxVEwKH1NnFANPqqpzC4pxj7qRkuDrFpwbudED+Nm6qFRUtFBIRCJ27N1aZZfmCbi5MUklzAIDX+R8RreouhZHBf8hv6lieI2tbTLH3rkVv/UeqI4/2neDx1+PeL1btFU8TUf1DtyvhgxSfGxhE8uoFLPTbOd89Sh/7qQUsH768Ws0h0Y5/vG034V5syMbw4LEnvCcVhpBgCCWHngsTjN5lqrbaFNlpgjQ== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by AM8P250MB0171.EURP250.PROD.OUTLOOK.COM (2603:10a6:20b:322::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:16:11 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:16:11 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:14:01 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [zUYjPGkk1FbY1TCznpNA7QcJXyfgo8V11R25SS+l5VE=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-22-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|AM8P250MB0171:EE_ X-MS-Office365-Filtering-Correlation-Id: e70c86bc-0040-46df-2833-08dc5808bb71 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: Ix2xciQs6bOzKQuCaQC1gjjfDRCrhQFBF8sLDdFRMLFSe1Vtc+TjVF/Wwgxp+7wae1ZcWhWxftXpq6jaqkwZ3TiYKDcy0sDlCpUa/Ejv9cS1yTJa+oiqmmmj05NV16LZCLj1QlCkWOtVZJ5lBg+fqlLMFc8XpaxPpK2ru1LsjWmYDs61euU8rwT4Zux9Q5E6IUtZgdOUox/l5cwGsw2GEdWTShaFHFO94SlLZ7YHMc7V9z2JQnB7GfTrzEsE5F3X96U+ugC0+H/sSLKTmTPCIg1SSm8CFQLd1RQdSIHQDAJwZPsNeoTQGF2X2HD1aZPwqVDIVluS/awOPFBUIBhn8JdTTh3sQKPTqhX1U1M+vkUvzCyf2Jd0s45ws8ZBJ7k6HoZxndOoJOazf9GTLqbRe1HLQQIyBkhyWLkCyK+ELSvHPMtMQbx+es9kKK/aUB5vhzAILnQ7arU1BHQrm0jNXfhIHlXu/mctjnAl8cvrgvvHqt1xEOZ2aVwtUf/2mdoxgGnSg9BV8rO/13qiPlKJPSXnbHhxfe09g7TDFsBEcoujLOvkwS2zVr5JcJDQ+5ko8Z6PT8PM5iQw83sJ25JTvQgDxe1ei96ze35isSWBdkLJ5Dg0fKsSxar0kDyRUv+J X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: fwN9rbe4QNmIEIBt5PvhP0phHVuTAyU6AIq0Gah6q2p6VZcR29i2uMmgXtgoSu0HSXQ8G+zYTNY6pSf/CjB4/zqLl0vY11Rxo8LPQaCltCZ4rBhU/V4sggvwlsNWB6BFIj5SgkulEYJpnU64/NNLZ8Kn30Of8QlqKAfgQA3bEF8337pfeXUvo0AswP6newHT/0udx7lUeGa6IcDLuBgxturDj8zPoFlootSqobhD8sOclKjlEbuqlDj+caVfmLD2zx/v5U1kQOkQiG8tLdPawYx50GtDC5QXJOfb5Otzq79SkZQKXH4PgvaAA4piHg4gK7NmbghypJ7M/gauF6XeWqevdfXwvDTkRMVIGkmlXVxtVgrfaVrJrZSWzdY1FKAbmX9m28h0pE7NEuR8UtY0+YwEH3DujeSHf08P2VS5a1xSPawTvVqmz7cnW/larN83sHONHnBFBpWbwZihCUBO5LtPLJQ+ciEo7mbHM4QulBKIKqCgeZ9+Kj8iF6X5kfvbVKvTJOQMQ5pf9WYsFaaAyCBn8pBfktI9joI359qXkdmjMg0LXgItF+IcKjXewVEvRgA7E8F87DDM4Xoxjzj03HD8TfuR3tQvP3mytI7MXb9AG4oaa33qZgytS0dSJalRjbTnNN/fEmMHkoh4JWLOLrPM7V+XpqcxGYhtmaYVTU/NqhXvVomZw6wSWrAyLdIDj2B5edyXO6ckANvzG+Fc5+63dY4aJdvSz5xM5Ffw4a7e4SZmc+v7wCFceuilKeLilPIjbkdps5pqmUb2ulC/c2z5fKVFQz0+fIR9YCO+e4wYHaQnUQhhYVOUh1qgHyk9jTsoMZEVJ6Mmhjbn+dFlM9/bKMcEk+zt3oIxTLLXGqtJY5NE8iu21lnmG9YDnrhfWrOX1cEBkeaiHhkadIBqG+jnGq7bsX2tx8uUaSFEeQFtvWY03osWfDctQVN3sBepq7I/BEAlTMs3RDH6fBXK50ajTTWLvAFMKau0DhFrDDvsw811NuI/S+RwSmWyVX+M5XV4xkLUv4+zNt4HVI7dsh02B/b5NSLGagfuex/iKIsgrvJde+P5ELhshL5FFHqkdzQ1Z65LDUvXoO37ATvtDpyJj1uBPSUANIQPRL+rOaNnwxb+mXrAS+Z62AiRp0TrQPrUfTJdGpTCNe+R6Azqpo7yl+rcbpxT3bke0uz6KYKowMMKrBArJaJcsqZYLxBXWIwIo8nuhZmN+zxmX2fTOYKm8PxvvNQ57vNNa5xY5Td72u8E7s/B2W5i+5xjGVNEiq0FGkxLlP8KUz8kkXELxw== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: e70c86bc-0040-46df-2833-08dc5808bb71 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:16:10.9706 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM8P250MB0171 Subject: [FFmpeg-devel] [PATCH v2 23/27] avcodec/rkmppdec: Fix double-free on error 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: ux/gh3Tq5hul After having created the AVBuffer that is put into frame->buf[0], ownership of several objects (namely an AVDRMFrameDescriptor, an MppFrame and some AVBufferRefs framecontextref and decoder_ref) has passed to the AVBuffer and therefore to the frame. Yet it has nevertheless been freed manually on error afterwards, which would lead to a double-free as soon as the AVFrame is unreferenced. Signed-off-by: Andreas Rheinhardt --- The rockchip patches are still untested (except for compilation). libavcodec/rkmppdec.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libavcodec/rkmppdec.c b/libavcodec/rkmppdec.c index 7665098c6a..6889545b20 100644 --- a/libavcodec/rkmppdec.c +++ b/libavcodec/rkmppdec.c @@ -463,8 +463,8 @@ static int rkmpp_retrieve_frame(AVCodecContext *avctx, AVFrame *frame) frame->hw_frames_ctx = av_buffer_ref(decoder->frames_ref); if (!frame->hw_frames_ctx) { - ret = AVERROR(ENOMEM); - goto fail; + av_frame_unref(frame); + return AVERROR(ENOMEM); } return 0; From patchwork Mon Apr 8 20:14:02 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47958 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp137029pzb; Mon, 8 Apr 2024 13:17:45 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCVJiv/cNieyVNMfNyfzZIZ+wx5XPFZWSv7Pr9ZU8EaKjavN6egh6+jepoOBz/Yz1sCO2Gfsk68icVPdCvevtHOg4DvUiM6U2aAF/Q== X-Google-Smtp-Source: AGHT+IHCPez2zyQ/P/9j/YIA2tQz6snKekkSjutLqLyabtmxeJ+0eWVVidV4e4+ivE9AJvapgh9H X-Received: by 2002:ac2:5612:0:b0:513:bf92:79ad with SMTP id v18-20020ac25612000000b00513bf9279admr7435992lfd.45.1712607465300; Mon, 08 Apr 2024 13:17:45 -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 g3-20020a170906394300b00a519d2c0340si3879901eje.302.2024.04.08.13.17.44; Mon, 08 Apr 2024 13:17:45 -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=@outlook.com header.s=selector1 header.b=BPURgCRU; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 3D14068D41C; Mon, 8 Apr 2024 23:16:18 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05olkn2086.outbound.protection.outlook.com [40.92.89.86]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 6F82268D413 for ; Mon, 8 Apr 2024 23:16:14 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=HZItcJCBANhhIdxPvuJ1xmt/bq5OMpt2svYcIUsAY6lCvsk0exfsB9KOE2lf1ziiQ26H0mzNLryQa5aQEpEK82oYXcnZxfHl15Aq63WvLWahUczCD2tEKXvapKW9JXZLZB69AhiMmz8brO2m7bFD6KLCkBcHlUMjF7CguFdA+WbqVNjzVBNuEOoNbmLniAbLdSv/4O3tvREYl2IBOXJDdLRYbu2MwtzTs+iaGMyzdu21WM+zWErysQ9rijl93+HSTnkSqoYdT1rZFL6r5GA6m6LgnL7ZXmuk8seYlXccrN2gGFSVG7z4v8ch9myyCkk/pEDF8IjCuKzzj2YmqldpXQ== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=O5RL7VVeViaYT2bVecT3hz/o6C55WITsVVeKkETRDf4=; b=i7nDjTOaYcFEJLA4JStKydASbdqwPxIv+knznlabNvYOyQlJ1ReT5xdFmiewPgtntWwXXbQhMeheQMkV4BYdwVQJnzEO0oltcuu5WO90yKgPi6M03E/2l/qvteU5bucYnbIvj5eTyVQOA0+dsZa/1dMvET7NvF4iar0L0dKKC1jUA+zHcxd30GOYUd/Pp67OOC/vuLErrM7ZRJ+3c1MOVtVIRSWSVJZYKvPqxbT/pVfJxg0424aocFQfxaaBHSzxEPUEI4B1INx2v+d18SsIjRr5d3AQTUbkYkyDzwnyO+VFMOPQjr5+62qt/Z1Ux5et0FzkoBusnYsCLaWJ1v4I8w== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=O5RL7VVeViaYT2bVecT3hz/o6C55WITsVVeKkETRDf4=; b=BPURgCRUS65UWBoHaPHqnxQjRIyWnN6Bqd5gl5ig2wVexwBIL5UQfw58oSBRGa7PfQOxxNxFBlhBN+hynUFYhgj155WlhxwLzFAiwFbD9x8xbNL3cMMV1Q0K9rjnuqqYqv6SdYxU7q+fYYjpzHohruMKnyjXuylx7bzRMJHGVFUAJiodjfzwmaqeEb3GZo3tI48//c0zvyZ+Am1WnBoGBY51izlqps2sYh4N+v15V/piVRqDT4mT+Hnrb3BqSPou/758QMCatCzOetoRUkrqbI0nuaHnTf2HmoUiR9NKevg8QQu7bBEUyWDysAmov0J9Uj3Q9zReQHcgYyo4pMcjeQ== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by AM8P250MB0171.EURP250.PROD.OUTLOOK.COM (2603:10a6:20b:322::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:16:13 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:16:13 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:14:02 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [RwEXoUQEIN885v/30VXykHfPa0SjO6lT1KDGEo/lUh8=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-23-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|AM8P250MB0171:EE_ X-MS-Office365-Filtering-Correlation-Id: c779f5c5-bbee-4626-668b-08dc5808bcdc X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: eVaMXmZEJJHILhf3Ih+I29wGm0fi/WUtBxkL3ycT2pBDbROztcxar3Nf39o/OFuqoEiuFzhpiECCeasDEwQdqN0ProQ5c9rZJs2LXvfZ+5WbrOWWOpNNOypakt9SF3RqJ0mLmVy1XlQULwZgRVsZmIyezEMtgDvHq4xYUCg1upFhNzY6A2cfrTt9rSY/wAilfey5xvl+jY8re1gW7enYWEabc/opD6PhZpxLVwGrNDIqauF8lDz5UgrB4SXIxRjjN3UzgK6rqLpV7/I87zYsua5JeelpcRl7JhYk54PwgwUWNNbPUmX+HdoMZQ7L/HK7tcwJx5AX2r2UO2bxWP8CZpmm3fdAqyTNfnI5UKz3QR+etyMkIVeIuqxGRX7lo1Fyqcwh6wl19W8t3jEtkCPd7Pky4cZwniL5mRsQQqoWDJztuJPnyuXUPYRD7UBlakzxhwDGyODxijkx4LqcO6HAglL0b/nigtQ+D48T7HYvgEMPFgPEeCGR6Y4vtN7RyicbuyseU0r+zBGV9gVjDV3MOdPghHWpOxOsjvssaCTSwUDrvRHDYpb+4G1MAxQEH9EegkCO/ttjRJtL5MT9njjrLjMSBzKG7Qxk1wh19xkHojpHXtia/YJFBztTuCZ8MWDF X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: DzAErQu4FiZoDohK8P3XCg5e7Dk1K8N/rf5pzr0f0AhPrf6vE2QMRalz44K+FeSp+oCuvVxHaIkI+pjy/sgJArWlwHgztakNXz2rpDniJgFj0OyoWyNv4pptwyLXCzyvYasTh4abU/PKfSDCS/CKtrAb1fD/8XcP4VnvdrmUaUEQtDvwgK2PDK/2tmH/6+a5btD4l66ar4NHGD2JtQG4m7nBhHIRUVE7zpmEBXhWJnWe5XrQRIUZT4Jq7XkD8iyjbUm8LqZ052zYDTH8fuTOTjt3KC/BiKIcAyt9qEVYL9Zk05hXRt9t1i7ag5Igj9ctq9qQPydsPVkw0y1/TWG0LAdAPIB2oXlnETm9wy8LPuKjs43wOJCUfW0n68L+zuBCOCzVD2c5ZOXKz97bCcR5GOyUc/fNe4Z22i64ars0NPW6d5BMUq+zPALuuKrDi0YvZrtSX0JusDaWy8L0uEVMJfGV39oQ9iaHTV7IjRitrPIwdx5ulW/0HUMpOWv73+DySSVn1H/RtX0IqGZVQGE096ts1+nmmXMuhZx/WwBOha13QkYRVIAsJpJXEfjwX7y7m0fJ4LaMCDoHfp5U7M3ltxQ5Z1d73qFHVW/OweXz0pCWUxZ+vcFe7AyHumTM3ltjc+GYN7M0zOkGaqgD8nJXF/My0HPZiOipQih0bUKrz7kpBuzlG1+ywDm4AFEqdpoJ72atlaHxXM8P1IPyl1LcHU/912hhF0RAVzDao44RtCTNtwxN3E+L08RFpbKguFJpTz4toHPPmVysyQZiHn8ZuUfsTR+ks2LovLPnlcI4N3M3U2hxzDyu7nz/BH51JBi6zMroBaZ0tjhXofFcB8YmEi6OVtHr1WBWrUvnsyR4q5sUtPfRIm7kbdRMIBcVc3TcfJIeNNQEpDjevsYrHNwMpJ3gkp28dgWGaFl4uKtivjXRCenZRlQWpcFOTZ0P1viSCt4uowq4yIENQSfi5QDjmWsGjcZRMJMstFMp0SzEyWQb62zHHHdI8eMmfH24T9i73//oKrQuNlBtSFElx4bYw6OrKKZjiz4wXy+LylnKMAOoXNNTqlvCoTiSOdWXfFOkx0g91Brmc91+NGsRl9TMt4+p6gfMzllLuQ9xTyBXS9HuFjECDHJpNevN+lAcMxDK1HAM0/KRVEVI6TMs0+QdagcJlOwgQilUzVPTXGSxLmItou9p2pDoRexq3h8Ey0S3eNMwXrhzmUOJoDlNnAwTmQPZl8ibOyoO3DcIwOPFb8BQqeEFNNCDnhnbLMyymqsMgWi+J+oO4qnn8DGnBvEUOw== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: c779f5c5-bbee-4626-668b-08dc5808bcdc X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:16:13.3370 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM8P250MB0171 Subject: [FFmpeg-devel] [PATCH v2 24/27] avcodec/rkmppdec: Check av_buffer_ref() 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: cPsMrVvaQnHR Signed-off-by: Andreas Rheinhardt --- libavcodec/rkmppdec.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/libavcodec/rkmppdec.c b/libavcodec/rkmppdec.c index 6889545b20..4e14d09c7c 100644 --- a/libavcodec/rkmppdec.c +++ b/libavcodec/rkmppdec.c @@ -450,6 +450,10 @@ static int rkmpp_retrieve_frame(AVCodecContext *avctx, AVFrame *frame) // MPP decoder needs to be closed only when all frames have been released. framecontext = (RKMPPFrameContext *)framecontextref->data; framecontext->decoder_ref = av_buffer_ref(rk_context->decoder_ref); + if (!framecontext->decoder_ref) { + ret = AVERROR(ENOMEM); + goto fail; + } framecontext->frame = mppframe; frame->data[0] = (uint8_t *)desc; From patchwork Mon Apr 8 20:14:03 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47959 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp137125pzb; Mon, 8 Apr 2024 13:17:54 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCVabpqDVqb08m9hFQBWxEE1xqr+arc0mMuGZA5FJKhW/sfkg8U1JlLguUWJcL4kJaKNG7pRnAAVUqBBcIbPGRxHa0Ff8g8C6BYDlQ== X-Google-Smtp-Source: AGHT+IEs8WFGJc+ezL4VC6E/rWmfP3h5w83bOuNm9x3uKoye08/J2P0dm5NN/IbCsO+RSCs9hIPX X-Received: by 2002:a05:6512:3106:b0:516:d30c:7236 with SMTP id n6-20020a056512310600b00516d30c7236mr8232912lfb.18.1712607474070; Mon, 08 Apr 2024 13:17:54 -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 b28-20020a19645c000000b00513d1aafc0dsi2419774lfj.171.2024.04.08.13.17.53; Mon, 08 Apr 2024 13:17:54 -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=@outlook.com header.s=selector1 header.b=kq6HJKUb; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 4B82768D45D; Mon, 8 Apr 2024 23:16:20 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05olkn2058.outbound.protection.outlook.com [40.92.89.58]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 35A7668D433 for ; Mon, 8 Apr 2024 23:16:16 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=iOgNmrvM/bU+ntAquCgjCdoX2rGmOJtlKJiTbV0e9P/c49hWDjziYR+zvMD8awd2/itFmvrUy3V3bGJRsB+VNSChw4tINLHbbvR/997zDwbymku/I5SFmpcoAuwabBzHDkoI0Ic6UfVbU80ubLNkOzqds+wK+yahA/3QS1RuorQGf68ieY2NUkCKh3HR/y+1h3kZHG+TDGyNZzUmjBP+5M4TUcOumvDjYsFANwp8ooW7lrmeg5ha186DD4yL1pPNgJVTfyPsvCOQ2mb80MtEkSC7lix/2h8hmOKG6DjlFpsrYo+rzyPwxeV+HfSGyKxeX2dG/gQ1OoFa4UlwO/GGIA== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=wY5bzXq6wU/pEmcj5E01nJz3X+MnDM493jsjmNmcRnE=; b=NyOhcndFwFsirio9iu6Cidw4xomvYUtP4tu36Xt71i+g364AmMwHR56An3XPQbkR4wPP2eYObdBkzGozHUzsJ5ekRcIJJQj6LTWrjhcgaCq/eTHXY4qajxtoprQf1Qu4mJLvJfb/sYNic6jESmZp9RnMe3VR6/QEmSyzi0FfnLhGZj7gcNLh1c+rBih1bjhqX5RUfN6Fa+WNUbBhY8+T3pb3hvQi8M7Fq50mha/UL57ips3YXqkz3k33sfYJ0JTyF+oSoy9pNwA5VYAvtn8r+J365tsSsL8O5xSukmZAGvWnaEVsVfbQW3uewB7FOpFk+7gu9KXCBnDouh11MEqJLw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=wY5bzXq6wU/pEmcj5E01nJz3X+MnDM493jsjmNmcRnE=; b=kq6HJKUbr6p/SGaAlJSE+/7Gzq5uvTYqOW2jVaEIyOWKNQMpPIh0F0SDsGug5HKELKhzf01u9fuokeLZPPf/pK7Ptr+knVMX4dPhkGfoZJ+lhtObQnArarD2QT8uuUYoZ8psSy2s7cYyFXTc9IbyXIsAL+1Ypqsnx2l7XNEbQL6/T9eL/O5u5geza3FrYVrQpkQ2Y6vE5GB3j0EHtUNCb4yq2EuZsllEgPcdbolRfDUj8LR1Y29JogA2ErgYuBHj4KUB49u5QnseWsn9tiztgAEPZ3+i3lUp7K3VNEu3syXri2IKf6H6wqPW4jHi4xEKzczvj1OeZeaKOBrBiGrYLw== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by AM8P250MB0171.EURP250.PROD.OUTLOOK.COM (2603:10a6:20b:322::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:16:15 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:16:15 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:14:03 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [s9EkLI8e+B/N09PxAYLOerhR2qazrnRc9Bu1Zjws2+M=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-24-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|AM8P250MB0171:EE_ X-MS-Office365-Filtering-Correlation-Id: b377652b-d518-4c6b-8a1a-08dc5808bde6 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 3w1gPfFXq0h+UTpgdv0CMyw2SWPS9dkJ86tQXm9c6VnB6+7pvWZVVdim9h05goEARPNsvn/qeaZvRHdXx2CY52BRshX9ZIgYd9Ld6cNaCIOBx4tYHMQFjPtxCkwBOfJEQH4O5c9NfrZEPX5Cdq5DKKU7XoCw2WoTnrdcQFRN13TUKOBlHcwL//+S00bAeGFhD2U7+ZCyl0tdr6MoP7H8m/2V6ygyG5yx+rtpbZI1PyLfPdaDvCauk+tt5R7Y2RffJqO4nup2wkOmqGaBOg4nUcYmQOSheJwvj7Tmz4nBFAwgg9nmfAY1aDB3tDRNW5M+MIQ44SSviFeN0R9znXktAhOG3o9xF7BAAZDjYfh0jNmNQqI5RL6GHpykWUPAdEogvz6FrfCFnm+SYd/Uhp5a7BSBbXXJbeDdp6zyt8X4EQ4YU+AR1h5eJ+iB+JQu4jZtjbacv2DpiEsTkVX2QED0bwdL4DsFXsX9tGqtN5igI9wBAXyfJOAr2qc/cleBqZJnFNmyaBgl+f6HL1k2YTe4kCAwGds59BThJUGisfG3nv519bihYQUDNCQGh4AYZpmv/jv4adP8vAtdmAaO7etg8sZxkXTqi5WyMsWlm7Vdj97E7hniNOJeV9Cb7TgxXEWV X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: OjB8XXCDym98jFDuJLYCusaKjg1PRfSHCGrzm9Qt9Au9P4WNoI2h7q3NK+BW3dQz9CmjyxZ0cdW3WohDZSYhPCcunBVr60ctJMQCxnwN+ZDhBQlINxMQwJcDE3NZJjhlVbgDeS9pveFM00RW53xlQT91lah+OlqXxL4c/Q13wjzVpY0iGzWT3Ma1L+abMvhxeFdNVDyWOwpoOFAIk462ARyycQYSLIPEvnSa/RbYgqL+XOSAQCxPIuzrRlETifHEuj1HUVpUxJGb8EObpmqpLWnd0a7ZGAl5AUp9iORWJmo8IzwnlCHA0+tkqmHAMwi7pLLIWKQX9TtP9Z5ZGnGQ/CQVeYfNtI25z6X+DeDlXVUjl20kdzuEnC9GIVCQjq2CyfOrRBE142heGhcgg+udrG05u17n7iXjaaXouDJ23zqpcaa2U86sRhqWIDwjPgC54ORkEyTAw7tAqsRR/tCVZGKZ4V5TZpxh+KjFVmMs6ziSZo6TSZPNOK2+rnk/N5NuHIz7MYrq8VhzlsK+wnpyDZafZ3vpwFe7e9O667pXjFbiZJg+S+zL9BBORkW4k9ZUnc4Xv52TFzZhxN7nFiMSa/pMiw7R5nthR2tAnovN9Qqxg2r7zFq0grURk0zu4b4N8diq6VEki/6EAgWH5npuqGSLIf1yCDDsjJQegduMA7B+5CGgE8LEcymkqfZca3ydd8M0MgXfxODR7HQnnrf41SkVlPSZ6OBDwpIkmLC6LD3ePbD3EU6akzSg52w8Fac0xJqScMJDSlc+dICTpYSgOJBjfIkZAp4zRoFlRxKlSmt1g3JhDiHzmbygD7+I+JdafKbNntXpcjzBGpuoPw0+76Y0DxAG88hQK0WcjiIRY2bgHY6xopQQ/CMAfdMShide/0o7pFlW4usarmrx2olk0SpLKOIfnPlFAwElh5T+FWxDaQ/xxvcfo39/79ClCM+xp04PFJk5wHw4FQ2i1P7v3Y+3WLmODYoEYfxUjBBAeDQsVl7vhX7dV1v3mdFHtablXQjMX+NtZD2vBHNZE2zM60xSN4oTjIeaRrL40gRRu2o/c2u2ApfyezXQQl8GMcwdOwGYjdRznKuEYruivsN3Gv23y/B+urhnrEdX0arAM/eLXIQoR/5YGoKSBEpmsjcQZjObpfsVP5mNwFIqONqQc5ENoLECA0d706zNzpwfeyyqtLISocEzzsAN1121jMqneio0BuuWOsQDqDGChGcoUbbdPt4uBvLBawnRuOvvlq57kl72UnKvXyb5A5GwOzea6YLyI4EGngCtn0rW6Agy9g== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: b377652b-d518-4c6b-8a1a-08dc5808bde6 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:16:15.0661 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM8P250MB0171 Subject: [FFmpeg-devel] [PATCH v2 25/27] avcodec/rkmppdec: Use RefStruct API for references to decoder itself 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: T3A54hCNcq9Z Avoids boilerplate code when creating the context and avoids allocations and therefore whole error paths when creating references to it. Also avoids an indirection and improves type-safety. Signed-off-by: Andreas Rheinhardt --- libavcodec/rkmppdec.c | 46 +++++++++++++++---------------------------- 1 file changed, 16 insertions(+), 30 deletions(-) diff --git a/libavcodec/rkmppdec.c b/libavcodec/rkmppdec.c index 4e14d09c7c..e137e7e820 100644 --- a/libavcodec/rkmppdec.c +++ b/libavcodec/rkmppdec.c @@ -30,6 +30,7 @@ #include "codec_internal.h" #include "decode.h" #include "hwconfig.h" +#include "refstruct.h" #include "libavutil/buffer.h" #include "libavutil/common.h" #include "libavutil/frame.h" @@ -57,12 +58,12 @@ typedef struct { typedef struct { AVClass *av_class; - AVBufferRef *decoder_ref; + RKMPPDecoder *decoder; ///< RefStruct reference } RKMPPDecodeContext; typedef struct { MppFrame frame; - AVBufferRef *decoder_ref; + const RKMPPDecoder *decoder_ref; ///< RefStruct reference } RKMPPFrameContext; static MppCodingType rkmpp_get_codingtype(AVCodecContext *avctx) @@ -90,7 +91,7 @@ static uint32_t rkmpp_get_frameformat(MppFrameFormat mppformat) static int rkmpp_write_data(AVCodecContext *avctx, uint8_t *buffer, int size, int64_t pts) { RKMPPDecodeContext *rk_context = avctx->priv_data; - RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data; + RKMPPDecoder *decoder = rk_context->decoder; int ret; MppPacket packet; @@ -125,13 +126,13 @@ static int rkmpp_write_data(AVCodecContext *avctx, uint8_t *buffer, int size, in static int rkmpp_close_decoder(AVCodecContext *avctx) { RKMPPDecodeContext *rk_context = avctx->priv_data; - av_buffer_unref(&rk_context->decoder_ref); + ff_refstruct_unref(&rk_context->decoder); return 0; } -static void rkmpp_release_decoder(void *opaque, uint8_t *data) +static void rkmpp_release_decoder(FFRefStructOpaque unused, void *obj) { - RKMPPDecoder *decoder = (RKMPPDecoder *)data; + RKMPPDecoder *decoder = obj; if (decoder->mpi) { decoder->mpi->reset(decoder->ctx); @@ -146,8 +147,6 @@ static void rkmpp_release_decoder(void *opaque, uint8_t *data) av_buffer_unref(&decoder->frames_ref); av_buffer_unref(&decoder->device_ref); - - av_free(decoder); } static int rkmpp_init_decoder(AVCodecContext *avctx) @@ -162,19 +161,13 @@ static int rkmpp_init_decoder(AVCodecContext *avctx) avctx->pix_fmt = AV_PIX_FMT_DRM_PRIME; // create a decoder and a ref to it - decoder = av_mallocz(sizeof(RKMPPDecoder)); + decoder = ff_refstruct_alloc_ext(sizeof(*decoder), 0, + NULL, rkmpp_release_decoder); if (!decoder) { ret = AVERROR(ENOMEM); goto fail; } - - rk_context->decoder_ref = av_buffer_create((uint8_t *)decoder, sizeof(*decoder), rkmpp_release_decoder, - NULL, AV_BUFFER_FLAG_READONLY); - if (!rk_context->decoder_ref) { - av_free(decoder); - ret = AVERROR(ENOMEM); - goto fail; - } + rk_context->decoder = decoder; av_log(avctx, AV_LOG_DEBUG, "Initializing RKMPP decoder.\n"); @@ -270,7 +263,7 @@ fail: static int rkmpp_send_packet(AVCodecContext *avctx, const AVPacket *avpkt) { RKMPPDecodeContext *rk_context = avctx->priv_data; - RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data; + RKMPPDecoder *decoder = rk_context->decoder; int ret; // handle EOF @@ -312,7 +305,7 @@ static void rkmpp_release_frame(void *opaque, uint8_t *data) RKMPPFrameContext *framecontext = (RKMPPFrameContext *)framecontextref->data; mpp_frame_deinit(&framecontext->frame); - av_buffer_unref(&framecontext->decoder_ref); + ff_refstruct_unref(&framecontext->decoder_ref); av_buffer_unref(&framecontextref); av_free(desc); @@ -321,7 +314,7 @@ static void rkmpp_release_frame(void *opaque, uint8_t *data) static int rkmpp_retrieve_frame(AVCodecContext *avctx, AVFrame *frame) { RKMPPDecodeContext *rk_context = avctx->priv_data; - RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data; + RKMPPDecoder *decoder = rk_context->decoder; RKMPPFrameContext *framecontext = NULL; AVBufferRef *framecontextref = NULL; int ret; @@ -449,11 +442,6 @@ static int rkmpp_retrieve_frame(AVCodecContext *avctx, AVFrame *frame) // MPP decoder needs to be closed only when all frames have been released. framecontext = (RKMPPFrameContext *)framecontextref->data; - framecontext->decoder_ref = av_buffer_ref(rk_context->decoder_ref); - if (!framecontext->decoder_ref) { - ret = AVERROR(ENOMEM); - goto fail; - } framecontext->frame = mppframe; frame->data[0] = (uint8_t *)desc; @@ -464,6 +452,7 @@ static int rkmpp_retrieve_frame(AVCodecContext *avctx, AVFrame *frame) ret = AVERROR(ENOMEM); goto fail; } + framecontext->decoder_ref = ff_refstruct_ref(rk_context->decoder); frame->hw_frames_ctx = av_buffer_ref(decoder->frames_ref); if (!frame->hw_frames_ctx) { @@ -488,9 +477,6 @@ fail: if (mppframe) mpp_frame_deinit(&mppframe); - if (framecontext) - av_buffer_unref(&framecontext->decoder_ref); - if (framecontextref) av_buffer_unref(&framecontextref); @@ -503,7 +489,7 @@ fail: static int rkmpp_receive_frame(AVCodecContext *avctx, AVFrame *frame) { RKMPPDecodeContext *rk_context = avctx->priv_data; - RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data; + RKMPPDecoder *decoder = rk_context->decoder; int ret = MPP_NOK; AVPacket pkt = {0}; RK_S32 usedslots, freeslots; @@ -543,7 +529,7 @@ static int rkmpp_receive_frame(AVCodecContext *avctx, AVFrame *frame) static void rkmpp_flush(AVCodecContext *avctx) { RKMPPDecodeContext *rk_context = avctx->priv_data; - RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data; + RKMPPDecoder *decoder = rk_context->decoder; int ret = MPP_NOK; av_log(avctx, AV_LOG_DEBUG, "Flush.\n"); From patchwork Mon Apr 8 20:14:04 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47960 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp137169pzb; Mon, 8 Apr 2024 13:18:02 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCUJS5l7gWTZg6XViZ/iZZFMaRrqlnijG8gaiFMYIHrLmw6UJo4KB1O1woFzVC1d36Z7NGeqdMhq4JprsCjUuLj9bzyUdANR9vPFog== X-Google-Smtp-Source: AGHT+IHhwtwl9kz5IlQia/ndlFfcZvnELa29WYgCu7sRCHGfwcM30T+rB1pQ3OrrkobJylsvb28L X-Received: by 2002:a17:907:9483:b0:a51:ce40:39e3 with SMTP id dm3-20020a170907948300b00a51ce4039e3mr3495961ejc.0.1712607481854; Mon, 08 Apr 2024 13:18:01 -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 gn39-20020a1709070d2700b00a51c9872c6asi2121495ejc.63.2024.04.08.13.18.01; Mon, 08 Apr 2024 13:18:01 -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=@outlook.com header.s=selector1 header.b=PoVrPHxl; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 6196D68D469; Mon, 8 Apr 2024 23:16:21 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05olkn2092.outbound.protection.outlook.com [40.92.89.92]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id BFBB168D448 for ; Mon, 8 Apr 2024 23:16:18 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=J9sY7nx62D5G365TN974vfb9X/Lj9OSF897Yg2WDG0zkgWZjpvg5SE4UeBL8R73WRbnbASVBvD5bpSmKR43/FCobWtd1bGaPxZInqZ8cRVeLi3BzJksfDZECZqKzxA6hXA2f/EIguvI2aSP2YX2n5CGyfoUZk5uOP816bRGG50B4yCjMCeo+yvzpFzHFs+ZtdxQQL47VmhLi/JIuStiXvSDO8LCQyir3X1yKhOcI/QB8QBlo977WCIMuU0TfWh0GFfS22ZTFCi1TduzdxnG6oqgZRXKVBVg5O5XHFBP+LPr0rMuwv956t7fk6cNPUwGMNl6GH02rL3oia8eMK+5T6Q== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=TkagonTbqZQVcS5Omu2gONxkh/mJj6hIocQbsBum90s=; b=AoqtJvmpcR/i8uVhrQgd5EPUIoLkiqOr+6C6uNjLNMvXD6Mi/hySwKh2yf5zONF/kixcOUJ0rkOkYvYQZITlTGzuIACevDafiyi3x/Zc15g+Eggd4P0lJhnrAvMc7RFdn/oCnhAG5+GxVgIySq7N2jaU3L6v/ziOs2epapff9obdXDnVMGf9LyOwc+uFK4WbcRk5WiWyGfxa5I32Iw5fNVWqhKGHUKtpGFNmR6AO9GaOoPlBxd32sySmmir0vSTcQKw4MgAK5RHK6x4haHwyzjzXPbWhUOQXmN/DKBUHmiLdarBjeZh5k/gNVVXoj+zRXO1ay6T0gnI51D9PJeurqw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=TkagonTbqZQVcS5Omu2gONxkh/mJj6hIocQbsBum90s=; b=PoVrPHxlTiwkOgQx/qNhWgqrg3jJRAxwx//ROLHG2L85RcwFnr9Kc7AWddwjNhePAoNdiaugLVO0mwUHH6/wbvnkIDT/125OrLSejZ0apKA6JGv8TifEUps1lwMerb9goM48z3xt/hmV5gwb/qjhp0fJtWtKQ85B8t7rdqxyR6+HTXOx00AbCRurSWZhlADzlK/JRjpIvHkJd7F1XrGSqAoFyAvqsE2FeHzhrVzYST2+0duigBiLX0DrTWCVfPgb/1VvGBKWx86bDu5RUfdAHWKMxRaplXZAPNXijot3fWarVKp7noW1w/ESV8I8P3600QntpTytO74uEBBCZb4Qyg== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by AM8P250MB0171.EURP250.PROD.OUTLOOK.COM (2603:10a6:20b:322::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:16:16 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:16:16 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:14:04 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [4StgTiKMC/Skcgn65FD+H5q+GFRbko5Hm/8Mjym04tM=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-25-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|AM8P250MB0171:EE_ X-MS-Office365-Filtering-Correlation-Id: 98d8be66-ccdf-4a97-1708-08dc5808bee5 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: ZA4KtGKhuy8fx9xS+qYrmar/a2ejLOKx42K73bQcv5CItVT+cm5KZRY3TKvpKLa4cfUmcauzl7siLRyluxjRtaKqae1RlGYy5vIHY1oyiEHTduxyPwi/f2SkTMqvE6rMQT3+rtPTyOAjs2Y17H9L0IzH9GO6K//yHvXUEJy+b8VzUNMDvgoqXOfyuPv0Ngr4WMXsdaVLc42a1pzY55ndr1eZ2KLGNPADVGfC3DaKVFWfHd3awl+9BG3xKcvEHtefLy6gkvWKgYNNcwZrUhgkaPg8QMWIPo+Ur2Ua3OtFe+GlwlSByWsZQCM7XXH7uzZcfTzl+MLcKMLNTErQtep4q3KfhA3/cTE9f5AzjQoFPsE7VvIsTruZ3V4IHxuEwpVFfymtqNLDYjY864M8e0uKB6fXWxSu/03Q/O37F2YpAUzo2bADV5gG6AyiTDAwPcd1CH9D+dTjqZGmyNj22Z60v4YzSPJ1x2vWLymSFpWIF1ASaPbaqXKeZyh8zE0xJSG8qAG5U9e3H5xNzrFtxRUWpBq9BU6vTtGZCI+x7KtH4sjYjh6mGGcs00JPtFSFz/LVS6w6jSAlth55c4LR8KIOQ9RygYcnfAH6fvthe29J2qmsPdP0ScCOF77oMbIX7dJV X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: 7M82M1pXeXM4AKDA3Aa/v0TazDtPfmcmKe8XYZabCaiI+I25/xB4IC69WvdlApQtMNWRm6HBu3+cp75dSwixLy/8wsJhnsIZUVi8sQkdoHGwk0aJ2QqMViUVjdbh7nEWAaMnvb0IvJCW4KNFDCS57Pv4DuglaJt8bP2E2vnhtSg3nG+HSSeDcbaWzXLIUTPlvWT5hoEjVVwNroQSmLbRBBsA4ZjAgjuwyDji1Uym8l21UthlU8wxkb/PIxjTDuHBhxSVQxgsQ5GVrONnXlLxJURkPaoRQYoeEC8rbOQpyA3mTtLKAFljkqq9tyc/ngWXhfwQHGY1CW3nujKu+NdEDP0csXDY+d3NyIc4xk2OcnQbKQB/XKA9b5gaY6sfQNmfApkbG7VA4IBSl3G6pQtBDsDL8Gu03vX+6tWo3Ae4Fjo7Ov0S+LZHhEJEZy8eI/5YhKaQIast0NJfCzmf4T0NWqNwiVjmLLHi9eb5n35WmO3tSRP91Joy18CvH2wPRusHRdqZlFizOPktF05xPym8DULZqMxx3XxseB9UmgR15qLD0iHJDdqpI+qyzCNWVF5nBpDAF4u7YPmafYcDDUEkxOhkCTH3wHzf8GX4i1wQF3+3nNSxditWI/C4ELQ8L3UURU5oJv0u6Dd3IhcLF9AnHRIQ1JhY5axNaROCK1mkWtzsR4G0Xw1/wqm09ScLnVceKW4nulw91eAgLZm47UqXn/18hrYsBfckr5ewdBFRQ5qt4h2i4moBYJFoi6t6ab/f2tLSxQA1v2Jb50o6PxaZEfABLhfzUZuiu7ojg0AN6QFxVvnq7iils/VP+oCJIVJIRC0SJj0IUJl1W6fgAi4EvPE2VtY6MUs8codzApPE0Fm+1dlwoA/sCcJqpyIUyj+3FL6VJ2gNqXyryfVzcElUxoG9uwSU+CM8UDxBdmEAjvnS9q6ku5xUvTYH3tDzyAK1/GopBFUtxTfadXH11tImw9p32aGNTw2xoR/KUBDV/d20iwvxPYfVzN8Holv8hdz/cV4a2NFdQyviY1B726N0ydheQCFmzTaQIskLr2jDwJEY/Cc8OdyHS25V7Q9xNOrEyM6hpXCEZDUb32w96uTi18KWaPA6MR1qa4u7aP6hD41fUse/z4KW//bF2NEIqv8IWDLqTyCPWmtnyBOZrpHpSUuAktgGez4oWGbCIcj102fMSkZBSgWbYwUQ5Q3gwGmxWEakihFVvsBCRw/jlgLf+DPi4mjkidDSoTnLi8WpFQ01v8kENDLYJTO4lrW1El8PGngkrgVp+snbD4mVWY0BnQ== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 98d8be66-ccdf-4a97-1708-08dc5808bee5 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:16:16.7226 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM8P250MB0171 Subject: [FFmpeg-devel] [PATCH v2 26/27] avcodec/rkmppdec: Allocate AVDRMFrameDescriptor and frame ctx jointly 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: m7TTBVfNUjrL Avoids an allocation and therefore one error path. Signed-off-by: Andreas Rheinhardt --- libavcodec/rkmppdec.c | 39 +++++++++++++++------------------------ 1 file changed, 15 insertions(+), 24 deletions(-) diff --git a/libavcodec/rkmppdec.c b/libavcodec/rkmppdec.c index e137e7e820..47b076dbd8 100644 --- a/libavcodec/rkmppdec.c +++ b/libavcodec/rkmppdec.c @@ -301,12 +301,10 @@ static int rkmpp_send_packet(AVCodecContext *avctx, const AVPacket *avpkt) static void rkmpp_release_frame(void *opaque, uint8_t *data) { AVDRMFrameDescriptor *desc = (AVDRMFrameDescriptor *)data; - AVBufferRef *framecontextref = (AVBufferRef *)opaque; - RKMPPFrameContext *framecontext = (RKMPPFrameContext *)framecontextref->data; + RKMPPFrameContext *framecontext = opaque; mpp_frame_deinit(&framecontext->frame); ff_refstruct_unref(&framecontext->decoder_ref); - av_buffer_unref(&framecontextref); av_free(desc); } @@ -315,12 +313,9 @@ static int rkmpp_retrieve_frame(AVCodecContext *avctx, AVFrame *frame) { RKMPPDecodeContext *rk_context = avctx->priv_data; RKMPPDecoder *decoder = rk_context->decoder; - RKMPPFrameContext *framecontext = NULL; - AVBufferRef *framecontextref = NULL; int ret; MppFrame mppframe = NULL; MppBuffer buffer = NULL; - AVDRMFrameDescriptor *desc = NULL; AVDRMLayerDescriptor *layer = NULL; int mode; MppFrameFormat mppformat; @@ -409,11 +404,21 @@ static int rkmpp_retrieve_frame(AVCodecContext *avctx, AVFrame *frame) // now setup the frame buffer info buffer = mpp_frame_get_buffer(mppframe); if (buffer) { - desc = av_mallocz(sizeof(AVDRMFrameDescriptor)); - if (!desc) { + RKMPPFrameContext *framecontext; + AVDRMFrameDescriptor *desc; + // We allocate the descriptor in buf[0] jointly with a structure + // that will allow to hold additional information + // for properly releasing MPP frames and decoder. + struct { + AVDRMFrameDescriptor desc; + RKMPPFrameContext framecontext; + } *combined_desc = av_mallocz(sizeof(*combined_desc)); + if (!combined_desc) { ret = AVERROR(ENOMEM); goto fail; } + desc = &combined_desc->desc; + framecontext = &combined_desc->framecontext; desc->nb_objects = 1; desc->objects[0].fd = mpp_buffer_get_fd(buffer); @@ -432,23 +437,15 @@ static int rkmpp_retrieve_frame(AVCodecContext *avctx, AVFrame *frame) layer->planes[1].offset = layer->planes[0].pitch * mpp_frame_get_ver_stride(mppframe); layer->planes[1].pitch = layer->planes[0].pitch; - // we also allocate a struct in buf[0] that will allow to hold additionnal information - // for releasing properly MPP frames and decoder - framecontextref = av_buffer_allocz(sizeof(*framecontext)); - if (!framecontextref) { - ret = AVERROR(ENOMEM); - goto fail; - } - // MPP decoder needs to be closed only when all frames have been released. - framecontext = (RKMPPFrameContext *)framecontextref->data; framecontext->frame = mppframe; frame->data[0] = (uint8_t *)desc; frame->buf[0] = av_buffer_create((uint8_t *)desc, sizeof(*desc), rkmpp_release_frame, - framecontextref, AV_BUFFER_FLAG_READONLY); + framecontext, AV_BUFFER_FLAG_READONLY); if (!frame->buf[0]) { + av_free(combined_desc); ret = AVERROR(ENOMEM); goto fail; } @@ -477,12 +474,6 @@ fail: if (mppframe) mpp_frame_deinit(&mppframe); - if (framecontextref) - av_buffer_unref(&framecontextref); - - if (desc) - av_free(desc); - return ret; } From patchwork Mon Apr 8 20:14:05 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 47961 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:3f98:b0:1a7:a0dc:8de5 with SMTP id ay24csp137244pzb; Mon, 8 Apr 2024 13:18:09 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCU/SGZ4D4ty4ad46eHyI3BkY8FQeqxyc9fLyn3WAWOYiFWvpVdiL4zCngHB0pgz1QQF7iuPKxr/mi5BKWIQ5c7DVPgMcs2rx1d9WA== X-Google-Smtp-Source: AGHT+IGFpMj7XOr+PmfBsGrYhRsyyU34BvbPW/Xsj0+OB1jcgLPAUbA47+fUK2j+IMZj9tuC/nbA X-Received: by 2002:a50:bac6:0:b0:56e:bad:36b with SMTP id x64-20020a50bac6000000b0056e0bad036bmr6366158ede.21.1712607489645; Mon, 08 Apr 2024 13:18:09 -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 w11-20020a056402268b00b0056df1b8285asi3918997edd.654.2024.04.08.13.18.09; Mon, 08 Apr 2024 13:18:09 -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=@outlook.com header.s=selector1 header.b=B9c2yMao; 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=QUARANTINE dis=NONE) header.from=outlook.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 8AC2868D476; Mon, 8 Apr 2024 23:16:22 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05olkn2079.outbound.protection.outlook.com [40.92.89.79]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 94F7468D466 for ; Mon, 8 Apr 2024 23:16:21 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=LZyZqYgCsBPqbPwZxplfeIhpE4fYho3jbMrJv5Ee2UB/s4LgAbmV8eflj0K1ItNkyMbW/25yGhytjBxEFJWMBivYayYGDJrMjc9Qx00sKD/2ZZf6fMgc0tdV0oX6xZi32GJrPW9Slv9VR9XMfbBzX2Mqe3LG0mE4tpRPGhE2C4THBBH4Wya/sDJXFEO3JMN6s2lQUiIEdw2H6lsSIu3OAJkXhe37LJolQXaNppTC59T5oyiQcF1piYxEIm5f8rLv5jye/z9ndkAGE+V6MWufrNtqDzu7+/PVnDzzjoTARWRyQ91kb72DH1ayPlj+u2VMbzbIvZv15Gjc8iv5wUE4Nw== 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:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=/MxzTsJx6gaw+drrNvTkS7xwCnUS/66RskecfEa9Yv4=; b=djTFZ/AnMJrO+QRXODg/ZIh0evNaa+0TTEeAzInm8MSmo51aF2k1p9tfnk4ne+bWr8NunTGnMadJ2ap+Pr3wQtkg9Vt2gRKKxrra/fXILLundMKb1Plr6Da4zvRfd70dgtZN3saE1HCOzvi1MEjkiaJyUg7h9DRGiPitv+bADoi4NbMIRfxqMsBoBsT8YAYWSE5ASGVxUNUkysmsljv8fna33P/LPKRA3BDEukZoUfbRqdwxjImpR3Pcu4fkLRI5xu+luwfPCwN9mmfD+/0PgKFRwqKOgornc1/4PkoE8CzUIGzURvZNT2ce+O3LV3tjdctCpsPOCF/zCzUPTuFW7A== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=outlook.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=/MxzTsJx6gaw+drrNvTkS7xwCnUS/66RskecfEa9Yv4=; b=B9c2yMaoVTKpTEfbjOQ0HcvFvhClX4KLbskr8Nlt/KP8Cv1HdHAXkudDTRM85JreUXgnW9aRB1/dZTkkqE41aF2ox7K2oj9doNjoXxMQThplxld7j9rYwqIM6tNknwL27XbTHPm05mgwbz7kN3J85LZW6UuLlIYKY88vWh4hjbmuJEmsrBsrxB58rQGH3X5U22DyagqTOHLikv4yMpC8CkHZT4acOGtuLOVgYlh0JhanuJJ0rsMXlPc8aEgTqJbcnyeCiAhlOvFP1r1LtiPmvnEGB60cV5sXqSEkneW09IkEcowNsrHcDfLQfYmO4FWTKNCPRQY1zDY4LDTI3VNkMQ== Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) by AM8P250MB0171.EURP250.PROD.OUTLOOK.COM (2603:10a6:20b:322::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7409.46; Mon, 8 Apr 2024 20:16:19 +0000 Received: from GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d]) by GV1P250MB0737.EURP250.PROD.OUTLOOK.COM ([fe80::4a3b:cf76:cddc:c68d%4]) with mapi id 15.20.7409.042; Mon, 8 Apr 2024 20:16:19 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Mon, 8 Apr 2024 22:14:05 +0200 Message-ID: X-Mailer: git-send-email 2.40.1 In-Reply-To: References: X-TMN: [89RToO9Hb64rxubprC1+uQF2f5+XI6HofbfQn9BY5ts=] X-ClientProxiedBy: ZR0P278CA0124.CHEP278.PROD.OUTLOOK.COM (2603:10a6:910:20::21) To GV1P250MB0737.EURP250.PROD.OUTLOOK.COM (2603:10a6:150:8e::17) X-Microsoft-Original-Message-ID: <20240408201405.2136840-26-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV1P250MB0737:EE_|AM8P250MB0171:EE_ X-MS-Office365-Filtering-Correlation-Id: 84ef59ba-f5ec-42dc-3b36-08dc5808c092 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: PLnapEz0ieyciUK+iRpa2vfigoexLCtD2aBtux+hYsE9yU0tmKv//bCo5XblPEzRoZxn0TRToisOYAHUT/BRWrgAWZiRkSXmGBlzk+TFEN3wLmsAQu+yF379g6juUMsO4kcwwnVRYe5IOzC8BRDcg+dg91jzY1l43VIzB9mDhQDTIGspKcpdFSqqjEwMJvEoyc0zv7x/RdxN6FDRK1aE8iEFOO1AXJj1R/SudMWbdsYd1qWq9I6JUBFKMMz9mVuBEkeqerPcKckRB94Zned45yotNqZR0R61PLr/mlUlHmTQyuiznj3n4DLPIZRqJb7kHShJUPgETbb5VcmD6t+gm8FNNmMqqP6JhfjjZHJj894HS+ik0WgNEOnrq+Vh12lm+GVOK5g0UQsnQJStjbJLqCC9reoFHEvYM3r7FJOM3W0EpNx/8vFX0kz8L953y8lmzPm7RfyFfNlmVD2LQpbdv2dLK3+EW3FpvN1Ohx7Wt+qrxdteiwMMYWnlHHxBivjMrnwcurXSg1xjXTrfjsGCbobpWrcz+Q3Q63yHE0JKAMKYMPmiYtauzRh8U/6LhcI8LNTUUPyVp4UC69yeVhsgFhON6t4AaXDciVILchNuvw88nJyZP//5I88EebfSnYDr X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: 9jYavwBlVSK8vKrzY06Cl2bzDB8s3hEnNdU7ezychIMGFMx1FdG5Z6FueqpfDLVytU9lOYdN/eAoSiyIaqyLQwM3jDLug8iqjRe4VR9E0wfbKVStszRs3xlzNnBApmzy9PZAurBFtGRkT3kHYGatwXZXVZTYxez+49AvQs5onWyFUjbO7hbfLvHsF5rgCeGOgpI8Qq7BGW79WSVxEJD4joQB71vn6QUQBF+J204bkAdL34DBMQnNLJ/ncp7TLL3ZSsA43Jbu2gQk2df3vazCnytoXS0IpDQQA9GlfBhhAVijaWOBjoRpZvxFXRKHesRYXyruKLmr0SIfasisH8aihGG3nNzmsrxGUlaOq1mXZF9M9tMgRVQ47Q0Aoe70Xx7yfO71cnP6pWjtYn45Yct10RIEuzVd/26nF0p0v4LVexIbaG4e2as53Dlf7nz5LS5pSP8nRMrGM904hJuxUvGXJKn/36TkQBb9uffCjtXuJzvNSD0HEvoG6c+gCa/yd5zue7wL9omlSRKIiEirgHxxFC/vPB2pbO8b8jl7wYYTPSvfmeWWxCUn2/hBYP/VOVyoBVrGXXfHj2KVVNnn+xhFq2mB67Rs5Wzyax3hG4dZLTZOm8/Fd5bxp0/nvaMWzl3hfPWpRm1iUJqqa5udHhrr1V2K0/uDDh4ybMfoRMJ1fCjRL05K/sQnejThvSsuDUyMCBlKwbG05VgWp+EoVnLJ6XKThNDWwdDTj2WbF2HdJHm7u5d6goiD0p/f/f9T7/CvJqCiUjuHrb9DXG22KdS2RLH0IaUdbFNnxEA8VFi4E2uWrOLG2zXDv2/ahZKqy1D0hZ4D7P2mZdsnWE3PczpxlkaHJCuyxIixfFcJKmQ67pwvD2H7/i2D2eEYjb2yYnPLhMufCl9/ojKt1le/dCjiHtQJvI+67eohjv+PBHdxgEjFt3ZklMOhMfaku7v5gzUU4X5+uA1MtoW6KMHuhIeGGQtOtEG8CwcNYtz7+jdvyJ5DsebNLFM8fD9TuBMb4H8CAKjVyclLdfVcHdu38kb2mPbJ+fQ4c9PVC52ynqMHDpb+93r1Y4GTLAcUoDAFkzsKBGU2qy7586HWU+TafdQ3mdzVgSIiNZmhjgzd+jObyuT56KZp8ctzNYHzdtpYyRZDt0iy6MdxjDveEYCCTOazbsObUyUO+4Ph/0oThG0Kk8c3M7WJr47UjxH6K3jrk7uVXnCdXRJ6gAlxPq8wjPr8vp809za4EQt2+7MtNRfvsdJMFkVwn6CH1RXdzPKOVp/NaN1IKSrllKstaifnh+NYzg== X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 84ef59ba-f5ec-42dc-3b36-08dc5808c092 X-MS-Exchange-CrossTenant-AuthSource: GV1P250MB0737.EURP250.PROD.OUTLOOK.COM X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Apr 2024 20:16:19.5550 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 84df9e7f-e9f6-40af-b435-aaaaaaaaaaaa X-MS-Exchange-CrossTenant-RMS-PersistedConsumerOrg: 00000000-0000-0000-0000-000000000000 X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM8P250MB0171 Subject: [FFmpeg-devel] [PATCH v2 27/27] avcodec/v4l2_(m2m|buffers): Use RefStruct API for context references 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 Cc: Andreas Rheinhardt Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: bWWS59yjN3cF Avoids allocations and therefore error checks; also avoids indirections and allows to remove the boilerplate code for creating an object with a dedicated free function. Signed-off-by: Andreas Rheinhardt --- This patch is also still untested. libavcodec/v4l2_buffers.c | 7 +++---- libavcodec/v4l2_buffers.h | 6 +++--- libavcodec/v4l2_m2m.c | 25 +++++++++---------------- libavcodec/v4l2_m2m.h | 5 ++--- 4 files changed, 17 insertions(+), 26 deletions(-) diff --git a/libavcodec/v4l2_buffers.c b/libavcodec/v4l2_buffers.c index 2277135699..23474ee143 100644 --- a/libavcodec/v4l2_buffers.c +++ b/libavcodec/v4l2_buffers.c @@ -29,6 +29,7 @@ #include #include "libavcodec/avcodec.h" #include "libavutil/pixdesc.h" +#include "refstruct.h" #include "v4l2_context.h" #include "v4l2_buffers.h" #include "v4l2_m2m.h" @@ -229,7 +230,7 @@ static void v4l2_free_buffer(void *opaque, uint8_t *unused) ff_v4l2_buffer_enqueue(avbuf); } - av_buffer_unref(&avbuf->context_ref); + ff_refstruct_unref(&avbuf->context_ref); } } @@ -240,9 +241,7 @@ static int v4l2_buf_increase_ref(V4L2Buffer *in) if (in->context_ref) atomic_fetch_add(&in->context_refcount, 1); else { - in->context_ref = av_buffer_ref(s->self_ref); - if (!in->context_ref) - return AVERROR(ENOMEM); + in->context_ref = ff_refstruct_ref(s->self_ref); in->context_refcount = 1; } diff --git a/libavcodec/v4l2_buffers.h b/libavcodec/v4l2_buffers.h index 3d2ff1b9a5..e35b161309 100644 --- a/libavcodec/v4l2_buffers.h +++ b/libavcodec/v4l2_buffers.h @@ -28,7 +28,6 @@ #include #include -#include "libavutil/buffer.h" #include "libavutil/frame.h" #include "packet.h" @@ -46,8 +45,9 @@ typedef struct V4L2Buffer { struct V4L2Context *context; /* This object is refcounted per-plane, so we need to keep track - * of how many context-refs we are holding. */ - AVBufferRef *context_ref; + * of how many context-refs we are holding. + * This pointer is a RefStruct reference. */ + const struct V4L2m2mContext *context_ref; atomic_uint context_refcount; /* keep track of the mmap address and mmap length */ diff --git a/libavcodec/v4l2_m2m.c b/libavcodec/v4l2_m2m.c index ac086a7913..15415cfc4e 100644 --- a/libavcodec/v4l2_m2m.c +++ b/libavcodec/v4l2_m2m.c @@ -32,6 +32,7 @@ #include "libavutil/pixdesc.h" #include "libavutil/imgutils.h" #include "libavutil/pixfmt.h" +#include "refstruct.h" #include "v4l2_context.h" #include "v4l2_fmt.h" #include "v4l2_m2m.h" @@ -247,9 +248,9 @@ int ff_v4l2_m2m_codec_reinit(V4L2m2mContext *s) return 0; } -static void v4l2_m2m_destroy_context(void *opaque, uint8_t *context) +static void v4l2_m2m_destroy_context(FFRefStructOpaque unused, void *context) { - V4L2m2mContext *s = (V4L2m2mContext*)context; + V4L2m2mContext *s = context; ff_v4l2_context_release(&s->capture); sem_destroy(&s->refsync); @@ -258,8 +259,6 @@ static void v4l2_m2m_destroy_context(void *opaque, uint8_t *context) close(s->fd); av_frame_free(&s->frame); av_packet_unref(&s->buf_pkt); - - av_free(s); } int ff_v4l2_m2m_codec_end(V4L2m2mPriv *priv) @@ -283,7 +282,7 @@ int ff_v4l2_m2m_codec_end(V4L2m2mPriv *priv) ff_v4l2_context_release(&s->output); s->self_ref = NULL; - av_buffer_unref(&priv->context_ref); + ff_refstruct_unref(&priv->context); return 0; } @@ -328,17 +327,11 @@ int ff_v4l2_m2m_codec_init(V4L2m2mPriv *priv) int ff_v4l2_m2m_create_context(V4L2m2mPriv *priv, V4L2m2mContext **s) { - *s = av_mallocz(sizeof(V4L2m2mContext)); + *s = ff_refstruct_alloc_ext(sizeof(**s), 0, NULL, + &v4l2_m2m_destroy_context); if (!*s) return AVERROR(ENOMEM); - priv->context_ref = av_buffer_create((uint8_t *) *s, sizeof(V4L2m2mContext), - &v4l2_m2m_destroy_context, NULL, 0); - if (!priv->context_ref) { - av_freep(s); - return AVERROR(ENOMEM); - } - /* assign the context */ priv->context = *s; (*s)->priv = priv; @@ -346,13 +339,13 @@ int ff_v4l2_m2m_create_context(V4L2m2mPriv *priv, V4L2m2mContext **s) /* populate it */ priv->context->capture.num_buffers = priv->num_capture_buffers; priv->context->output.num_buffers = priv->num_output_buffers; - priv->context->self_ref = priv->context_ref; + priv->context->self_ref = priv->context; priv->context->fd = -1; priv->context->frame = av_frame_alloc(); if (!priv->context->frame) { - av_buffer_unref(&priv->context_ref); - *s = NULL; /* freed when unreferencing context_ref */ + ff_refstruct_unref(&priv->context); + *s = NULL; /* freed when unreferencing context */ return AVERROR(ENOMEM); } diff --git a/libavcodec/v4l2_m2m.h b/libavcodec/v4l2_m2m.h index 04d86d7b92..4ba33dc335 100644 --- a/libavcodec/v4l2_m2m.h +++ b/libavcodec/v4l2_m2m.h @@ -62,7 +62,7 @@ typedef struct V4L2m2mContext { AVFrame *frame; /* Reference to self; only valid while codec is active. */ - AVBufferRef *self_ref; + struct V4L2m2mContext *self_ref; /* reference back to V4L2m2mPriv */ void *priv; @@ -71,8 +71,7 @@ typedef struct V4L2m2mContext { typedef struct V4L2m2mPriv { AVClass *class; - V4L2m2mContext *context; - AVBufferRef *context_ref; + V4L2m2mContext *context; ///< RefStruct reference int num_output_buffers; int num_capture_buffers;