From patchwork Thu Jun 30 22:29:41 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Rheinhardt X-Patchwork-Id: 36567 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:8b27:b0:88:1bbf:7fd2 with SMTP id l39csp620956pzh; Thu, 30 Jun 2022 15:31:46 -0700 (PDT) X-Google-Smtp-Source: AGRyM1v4S8AbjHTsJFk4ZMTjFyaBnkq8xJ7vuqEuBbnHjXqQ0h3GzYA064yIIBwkvUVeu2+S7D4A X-Received: by 2002:a05:6402:51ca:b0:437:79a9:4dd with SMTP id r10-20020a05640251ca00b0043779a904ddmr14488264edd.319.1656628305790; Thu, 30 Jun 2022 15:31: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 l3-20020a170906794300b00711bc35fedfsi10304487ejo.957.2022.06.30.15.31.45; Thu, 30 Jun 2022 15:31: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=VEZEtzHF; 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 7C9AC68B7F0; Fri, 1 Jul 2022 01:30:49 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from EUR05-AM6-obe.outbound.protection.outlook.com (mail-am6eur05olkn2076.outbound.protection.outlook.com [40.92.91.76]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id D749568B7E7 for ; Fri, 1 Jul 2022 01:30:47 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=CMCitlgwKPpfhjn+giom5Hmss6p5IfdI1SqCBfLZPWatV5y0ZwlNlPWRLq/OabJ5e3SNCar/xABHyRrGvZr72fWer3PRtQzRRNl4K8Sw7CkfksB6qPOS9IrtLezLbcEWV2/F5CxTapDghzm+eE3vC9OEXFtYXOl3fvM667CrjLzuqFQzCkk+7Ls5aB/dHTqyytBgvMhNWb2e+czAMP5gS97/cOUZKA/Y4GaOmmKyI0/YTtyZCO3bZI4Aq7TckZMMIYlwq18/Q7t/2Iwe9GElNhXnK9+n4D2NXspClQmH184IFWlm4PjHJ9PG48+Mv6jJiLP4kv9PdtXQ9hc/phfCow== 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=QI1WYOLI+czAydrrD0j5mSZfs9LyvoIqvx4pOHXv11Q=; b=aol8zNXE8TN9RdB5tfI37ZINfQRdeliYMmN5jiHvozsl8g5jIQCsRxUL5O4f6ubKxpYsb97ddWeqLxcQhEOhdY4bEW4zmBjjWKVxIDHjgYJl4hCbb29WDylf9SjfJOpiVlXfppbuiLzEpShyHJRxFr2fjvwQ9Rc9+RHDjqoU3HMQpkPacHMPcHaUqg7TtfRpu0wB183lf2Ja7yuNgm64k+IkC3NCEFOzC8HsxDip5HAzkcQGBRmu6LOx0rOxPY9vzwCk3ExrD5zMWKjqONLGpeRdY85m4DjKDFeHq031pdBlHrqzUzpT9EzksEZ4Cc5oRQWHWkhZavtsTfJ6CkW4ZA== 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=QI1WYOLI+czAydrrD0j5mSZfs9LyvoIqvx4pOHXv11Q=; b=VEZEtzHFQWiosTZOcw9gx1EZqB7pN+RpeC74OBT34GBfhQ8NhIQpEWM5XWy13xax3jxknbWi3D02HBzXgL97F2DY+i5MXZSiT7UGqdvnIntrPl5+C80/XcBvKt7LiwTnqPA5Z04XCcbSxY4yX8KBaBHTVMoWKydZb13TK2KDlVNeAHcUZHhfWNwd6nmRt80xWQBUwnxgSTRd3HGr/5pa2viJiXdhMw0FyyYQ6mQQFex0qCKAjs6uzq+eRM0EalA0L/mGN6ei6tHqyQwMBTW2zWMuFWElzdHKJ3DeMUqP8gkPeVk7Zpsl0iJk1odvg93iViFhF+jSPkVE06/h5KMikw== Received: from DB6PR0101MB2214.eurprd01.prod.exchangelabs.com (2603:10a6:4:42::27) by DB3PR0102MB3546.eurprd01.prod.exchangelabs.com (2603:10a6:8:d::28) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5395.15; Thu, 30 Jun 2022 22:30:45 +0000 Received: from DB6PR0101MB2214.eurprd01.prod.exchangelabs.com ([fe80::60b9:9f29:40cc:f01c]) by DB6PR0101MB2214.eurprd01.prod.exchangelabs.com ([fe80::60b9:9f29:40cc:f01c%10]) with mapi id 15.20.5373.018; Thu, 30 Jun 2022 22:30:45 +0000 From: Andreas Rheinhardt To: ffmpeg-devel@ffmpeg.org Date: Fri, 1 Jul 2022 00:29:41 +0200 Message-ID: X-Mailer: git-send-email 2.34.1 In-Reply-To: References: X-TMN: [HPwTAfRRD8kPZVtxJ/62nCxniH4/R6e6] X-ClientProxiedBy: FR0P281CA0099.DEUP281.PROD.OUTLOOK.COM (2603:10a6:d10:a9::17) To DB6PR0101MB2214.eurprd01.prod.exchangelabs.com (2603:10a6:4:42::27) X-Microsoft-Original-Message-ID: <20220630222949.1758625-9-andreas.rheinhardt@outlook.com> MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: eeb10c6f-886e-4d32-877d-08da5ae82cad X-MS-Exchange-SLBlob-MailProps: S/btQ8cKWiSAA+E0K/sYrHNnfsWcYQJjFXfNsALll8Zgu7UyVlbg2BZ+gvrcAP20VfUbbyQEd67XmlOaRjzPTBR5kgeudZi11g+f14MDekfJS6dok9YwyCnuVYivNep/BHQL9EwkeQLJv6xQziWVzDYnTVaw1xgXY0bF2telIkf1raBfMesBYYADR0EvyhsNa2iv9tdq5d2cVjSkhRdy9zLUq9GJRsZfjaPwLqgdTaeqOgA6Es3nvxP2oCiHyBm1vPe7Ogtno2CLNwxUqMRL+4WqbQ6sVCLsXlT4IMncdRSELpMCNB1zudIomCEW8Z2ezJ4+DMzeZF17Nle6KJ0TttZJDKaBftfwTO4vFtXcfQcLC59ktYtjp2Al4GU8MjmSPUxJRgG6LVQNBujuYp8iDs6tvxwByCd0RaxpJnl5tuH+Te2MQgYy8EQ5liD+xS0CiVmBNr6RBF4c4/2Pg2wiyBNhT1W3HIFMBLLE8qaP1d4aocMDelDuLgd+jp5M1rrSYcBQB8vgkF+ozWFCUTKRm6CbGAnzRfxoQnxzcZBYe8tFr/vLMxxLfPcmEVSvj4s3UUPzP54c8XAVlJpE1viwxkYNaBdxWDgS6Vtle8jr/RxLGJCeRcoHr2JkFl4VpZdt3W63pXcvc8d0DObdeJKuDOjddwLcnqYGGY30PeB9D0jVb4GrbEJ3u6vsLIie3AVMfLasByV7dUHMBFX1yC20bFSZ2JhbE8WH+7SsOpRAA/K5V8TpXvpweZV9b2L1A6bOU+0TYFmXppw= X-MS-TrafficTypeDiagnostic: DB3PR0102MB3546:EE_ X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: VLeHJ4Vp4T1h3966SURPwAyZmJO4rB860tcR1qQVbsV0vWiBO99MbKBP1mVwTc1UaQR6WjDPGF22Mr9AI/DJWS6v6piqK7Bagb5PRhPvZ9ORQIJGUZQJ1p5SBGt9oxWLnZTb7lv4CXCb1fEkzYoZfW5vnxChiRnxSXPEwAea18G4ScSSB5cIrj7mw3sJS26RVpDDUWtmh9+SJC5XqDvI4iBz/9Wwm/J041e7e8qfp6IIPWQ/ml303NlsgfmgRN3ojh3O6mIhipZvBcgsMrAn0DEehL46Lu3nIswJrGd6Oyfy9ye0wJGxysY0SiKldrxP5PjF/W6k4Cc3Ql+JyupTUfEVLtf8mWYiFXLNzLswiC7OX2E+nFpTj1PPveVVYU/EZKSKZQXhvu1WRROtK1Vwqk7/VA28klS2d1sn8hmDcqjsE3YExk3SxKiEhY6vmp0NWhni/of7cQiPPjAkTYLEEZfSL7Dyk4Yqzp1UQDdwt42bSOEA1Ip2NyPJQdMEjmEz5iogaaBEcmKv9Bp0LZkC1Ffm3Hbmv7fTKWEV3b3bl+TJC3zIy5IPBFjdHKCZvyffq5IGU6+DnGD+Gt8L7sqiMeonBRv8Ui00+hoQVMWb+8a6MnuDaaYXIkb6WKehnI8UOGb46ravJ/MG50lHgwNss2+gkvjOsW0wVKbj+B7GLXZtqNCmi3UOEK51Ws5rMLPpx4gs6wq/AVxWzKIN7SDGTA== X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: brAPw9Eg3YcNSkhZEewW82tRGXp7y7rjMhSdptnmmXGovbWBI56P3glkPhXac0RU+lXil5z9MQJIkD1rLqi8xMx0ttC+Usi+h3NvwCMKivpUO/nlCqp9DKgX9gxU/2/6Ir/RiBGl+/o2+UGtOaKnFXI+WQ5wEEUsxp8baqw0oPgWJ6H5iKbQPvixnQJoCDlCJFmIzpf3HDA/+0tlIqVPR4A+6UhJ+QQt/EQ3uCJrYqipAemPSYLSR2BMAKkVFYWpIcFr7I99Y+g+AG2j+Sx0xZbur8pxF6redvrs27fbO5/uAYzJHjcF2trbJITEEuOmyhP/Pjh+CBp8OiuXGAFFdQlFw1xDl2r6FIKWStJAGE3lUcGULsI0lAxonuvpWuGAQyH7C75Sxxys4ppaJuuUYSafCnjFY4T946wvRygGh5iq/y60oCOlhiAi/EV1J9JXRxVMKgMsec1ds+lHBgK+UqgkxWrv71CIPUfjINGjrvEG43b4W8u3h4GaGb5tHE1lJEsJmHRd5lqfnl6bBMsqsstvr4cayr6Y6QxanCyMTmI1W+Z6ZtEd3KLpZe+kr12N3b9KzcbUafvAU9AdyY5Ip0v24yvzoUM8xdpQxwSdIR/K9hvUfc9lPOE7eWcATuIjRRnhxwiRDtETvBR6KcfSZpL5DmVpx+c1B9Tx6mN6PDuMAgGJ2vZkh9P6nIJaqQse831oZBX0zEk25iFbqYMIoAUupWZe3bfEbSQiT4ABCiLFgTnQw+DHsd4Uyi9bR/bcmIMagHsLaOCvHzyYR+l/CHa8GKcshFfp+SNsjY83noD3vE5qKSHLYkRW+QsbX6uvCHBbRy3H7Kahwq4/tXOpfBDLK/44QFloTP3IhIz/RmF8Bpx8sZUgRmWgm4IL96x13AFWas1zNgqQZStok5kqHHwlnN4xfrBHVZOd2/yepAQ1DtIyvcorDLB+KWvqrAtUp9H/4RsXQnnC5UndtriP8rHgYwsiuoS6qk/U4+A++NofvknmJztCoCmPhgNMWEncnx4VRdXlh3ATbtZj6H1CGI0SYGpNsjtskvGx/X6p5JUF3z8Di+rxQYmNFuBK1hbkpdpsv7LspNEtVp5+O2PgoWE1qVGBTny0kRFU+lsC2Ii73S6Ud5MMfeGceVLMHerfGW1d5UeRGOCXH3+dV/RMK0ppbZZ3oTrTvO/QAFKPXydD4/4jSEqKK3eKNxSPAKjHHdFvf1zZmUH4IjcrQKByJYly04mm9a67C1dRt4YyH+YYzgnhzfqLy6RpHyXYJozAqF/0xUzSJfzNN5ab7llk33iSI6CqWEiTRnFIN2h1SqM= X-OriginatorOrg: outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: eeb10c6f-886e-4d32-877d-08da5ae82cad X-MS-Exchange-CrossTenant-AuthSource: DB6PR0101MB2214.eurprd01.prod.exchangelabs.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 30 Jun 2022 22:30:45.7953 (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: DB3PR0102MB3546 Subject: [FFmpeg-devel] [PATCH 10/18] avcodec/hevc_cabac: Pass HEVCLocalContext when slice-threading 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: YhVKiVq5NZOF The HEVC decoder has both HEVCContext and HEVCLocalContext structures. The latter is supposed to be the structure containing the per-slicethread state. Yet that is not how it is handled in practice: Each HEVCLocalContext has a unique HEVCContext allocated for it and each of these coincides except in exactly one field: The corresponding HEVCLocalContext. This makes it possible to pass the HEVCContext everywhere where logically a HEVCLocalContext should be used. This commit stops doing this for lavc/hevc_cabac.c; it also constifies everything that is possible in order to ensure that no slice thread accidentally modifies the main HEVCContext state. Signed-off-by: Andreas Rheinhardt --- libavcodec/hevc_cabac.c | 310 +++++++++++++++++++++------------------- libavcodec/hevcdec.c | 102 ++++++------- libavcodec/hevcdec.h | 72 +++++----- 3 files changed, 246 insertions(+), 238 deletions(-) diff --git a/libavcodec/hevc_cabac.c b/libavcodec/hevc_cabac.c index 985c97ef2a..f8f349dc4c 100644 --- a/libavcodec/hevc_cabac.c +++ b/libavcodec/hevc_cabac.c @@ -447,24 +447,26 @@ static const uint8_t diag_scan8x8_inv[8][8] = { { 28, 36, 43, 49, 54, 58, 61, 63, }, }; -void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts) +void ff_hevc_save_states(HEVCLocalContext *lc, int ctb_addr_ts) { + const HEVCContext *const s = lc->parent; + if (s->ps.pps->entropy_coding_sync_enabled_flag && (ctb_addr_ts % s->ps.sps->ctb_width == 2 || (s->ps.sps->ctb_width == 2 && ctb_addr_ts % s->ps.sps->ctb_width == 0))) { - memcpy(s->cabac->state, s->HEVClc->cabac_state, HEVC_CONTEXTS); + memcpy(s->cabac->state, lc->cabac_state, HEVC_CONTEXTS); if (s->ps.sps->persistent_rice_adaptation_enabled_flag) { - memcpy(s->cabac->stat_coeff, s->HEVClc->stat_coeff, HEVC_STAT_COEFFS); + memcpy(s->cabac->stat_coeff, lc->stat_coeff, HEVC_STAT_COEFFS); } } } -static void load_states(HEVCContext *s) +static void load_states(HEVCLocalContext *lc, const HEVCContext *s) { - memcpy(s->HEVClc->cabac_state, s->cabac->state, HEVC_CONTEXTS); + memcpy(lc->cabac_state, s->cabac->state, HEVC_CONTEXTS); if (s->ps.sps->persistent_rice_adaptation_enabled_flag) { - memcpy(s->HEVClc->stat_coeff, s->cabac->stat_coeff, HEVC_STAT_COEFFS); + memcpy(lc->stat_coeff, s->cabac->stat_coeff, HEVC_STAT_COEFFS); } } @@ -473,17 +475,17 @@ static int cabac_reinit(HEVCLocalContext *lc) return skip_bytes(&lc->cc, 0) == NULL ? AVERROR_INVALIDDATA : 0; } -static int cabac_init_decoder(HEVCContext *s) +static int cabac_init_decoder(HEVCLocalContext *lc) { - GetBitContext *gb = &s->HEVClc->gb; + GetBitContext *gb = &lc->gb; skip_bits(gb, 1); align_get_bits(gb); - return ff_init_cabac_decoder(&s->HEVClc->cc, + return ff_init_cabac_decoder(&lc->cc, gb->buffer + get_bits_count(gb) / 8, (get_bits_left(gb) + 7) / 8); } -static void cabac_init_state(HEVCContext *s) +static void cabac_init_state(HEVCLocalContext *lc, const HEVCContext *s) { int init_type = 2 - s->sh.slice_type; int i; @@ -500,31 +502,33 @@ static void cabac_init_state(HEVCContext *s) pre ^= pre >> 31; if (pre > 124) pre = 124 + (pre & 1); - s->HEVClc->cabac_state[i] = pre; + lc->cabac_state[i] = pre; } for (i = 0; i < 4; i++) - s->HEVClc->stat_coeff[i] = 0; + lc->stat_coeff[i] = 0; } -int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts) +int ff_hevc_cabac_init(HEVCLocalContext *lc, int ctb_addr_ts) { + const HEVCContext *const s = lc->parent; + if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) { - int ret = cabac_init_decoder(s); + int ret = cabac_init_decoder(lc); if (ret < 0) return ret; if (s->sh.dependent_slice_segment_flag == 0 || (s->ps.pps->tiles_enabled_flag && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1])) - cabac_init_state(s); + cabac_init_state(lc, s); if (!s->sh.first_slice_in_pic_flag && s->ps.pps->entropy_coding_sync_enabled_flag) { if (ctb_addr_ts % s->ps.sps->ctb_width == 0) { if (s->ps.sps->ctb_width == 1) - cabac_init_state(s); + cabac_init_state(lc, s); else if (s->sh.dependent_slice_segment_flag == 1) - load_states(s); + load_states(lc, s); } } } else { @@ -532,111 +536,112 @@ int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts) s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) { int ret; if (s->threads_number == 1) - ret = cabac_reinit(s->HEVClc); + ret = cabac_reinit(lc); else { - ret = cabac_init_decoder(s); + ret = cabac_init_decoder(lc); } if (ret < 0) return ret; - cabac_init_state(s); + cabac_init_state(lc, s); } if (s->ps.pps->entropy_coding_sync_enabled_flag) { if (ctb_addr_ts % s->ps.sps->ctb_width == 0) { int ret; - get_cabac_terminate(&s->HEVClc->cc); + get_cabac_terminate(&lc->cc); if (s->threads_number == 1) - ret = cabac_reinit(s->HEVClc); + ret = cabac_reinit(lc); else { - ret = cabac_init_decoder(s); + ret = cabac_init_decoder(lc); } if (ret < 0) return ret; if (s->ps.sps->ctb_width == 1) - cabac_init_state(s); + cabac_init_state(lc, s); else - load_states(s); + load_states(lc, s); } } } return 0; } -#define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx]) +#define GET_CABAC(ctx) get_cabac(&lc->cc, &lc->cabac_state[ctx]) -int ff_hevc_sao_merge_flag_decode(HEVCContext *s) +int ff_hevc_sao_merge_flag_decode(HEVCLocalContext *lc) { return GET_CABAC(elem_offset[SAO_MERGE_FLAG]); } -int ff_hevc_sao_type_idx_decode(HEVCContext *s) +int ff_hevc_sao_type_idx_decode(HEVCLocalContext *lc) { if (!GET_CABAC(elem_offset[SAO_TYPE_IDX])) return 0; - if (!get_cabac_bypass(&s->HEVClc->cc)) + if (!get_cabac_bypass(&lc->cc)) return SAO_BAND; return SAO_EDGE; } -int ff_hevc_sao_band_position_decode(HEVCContext *s) +int ff_hevc_sao_band_position_decode(HEVCLocalContext *lc) { int i; - int value = get_cabac_bypass(&s->HEVClc->cc); + int value = get_cabac_bypass(&lc->cc); for (i = 0; i < 4; i++) - value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc); + value = (value << 1) | get_cabac_bypass(&lc->cc); return value; } -int ff_hevc_sao_offset_abs_decode(HEVCContext *s) +int ff_hevc_sao_offset_abs_decode(HEVCLocalContext *lc) { int i = 0; - int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1; + int length = (1 << (FFMIN(lc->parent->ps.sps->bit_depth, 10) - 5)) - 1; - while (i < length && get_cabac_bypass(&s->HEVClc->cc)) + while (i < length && get_cabac_bypass(&lc->cc)) i++; return i; } -int ff_hevc_sao_offset_sign_decode(HEVCContext *s) +int ff_hevc_sao_offset_sign_decode(HEVCLocalContext *lc) { - return get_cabac_bypass(&s->HEVClc->cc); + return get_cabac_bypass(&lc->cc); } -int ff_hevc_sao_eo_class_decode(HEVCContext *s) +int ff_hevc_sao_eo_class_decode(HEVCLocalContext *lc) { - int ret = get_cabac_bypass(&s->HEVClc->cc) << 1; - ret |= get_cabac_bypass(&s->HEVClc->cc); + int ret = get_cabac_bypass(&lc->cc) << 1; + ret |= get_cabac_bypass(&lc->cc); return ret; } -int ff_hevc_end_of_slice_flag_decode(HEVCContext *s) +int ff_hevc_end_of_slice_flag_decode(HEVCLocalContext *lc) { - return get_cabac_terminate(&s->HEVClc->cc); + return get_cabac_terminate(&lc->cc); } -int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s) +int ff_hevc_cu_transquant_bypass_flag_decode(HEVCLocalContext *lc) { return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]); } -int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb) +int ff_hevc_skip_flag_decode(HEVCLocalContext *lc, int x0, int y0, int x_cb, int y_cb) { + const HEVCContext *const s = lc->parent; int min_cb_width = s->ps.sps->min_cb_width; int inc = 0; int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size); int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size); - if (s->HEVClc->ctb_left_flag || x0b) + if (lc->ctb_left_flag || x0b) inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb); - if (s->HEVClc->ctb_up_flag || y0b) + if (lc->ctb_up_flag || y0b) inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1); return GET_CABAC(elem_offset[SKIP_FLAG] + inc); } -int ff_hevc_cu_qp_delta_abs(HEVCContext *s) +int ff_hevc_cu_qp_delta_abs(HEVCLocalContext *lc) { int prefix_val = 0; int suffix_val = 0; @@ -648,34 +653,34 @@ int ff_hevc_cu_qp_delta_abs(HEVCContext *s) } if (prefix_val >= 5) { int k = 0; - while (k < 7 && get_cabac_bypass(&s->HEVClc->cc)) { + while (k < 7 && get_cabac_bypass(&lc->cc)) { suffix_val += 1 << k; k++; } if (k == 7) { - av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k); + av_log(lc->logctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k); return AVERROR_INVALIDDATA; } while (k--) - suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k; + suffix_val += get_cabac_bypass(&lc->cc) << k; } return prefix_val + suffix_val; } -int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s) +int ff_hevc_cu_qp_delta_sign_flag(HEVCLocalContext *lc) { - return get_cabac_bypass(&s->HEVClc->cc); + return get_cabac_bypass(&lc->cc); } -int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s) +int ff_hevc_cu_chroma_qp_offset_flag(HEVCLocalContext *lc) { return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]); } -int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s) +int ff_hevc_cu_chroma_qp_offset_idx(HEVCLocalContext *lc) { - int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1); + int c_max= FFMAX(5, lc->parent->ps.pps->chroma_qp_offset_list_len_minus1); int i = 0; while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX])) @@ -684,23 +689,25 @@ int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s) return i; } -int ff_hevc_pred_mode_decode(HEVCContext *s) +int ff_hevc_pred_mode_decode(HEVCLocalContext *lc) { return GET_CABAC(elem_offset[PRED_MODE_FLAG]); } -int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0) +int ff_hevc_split_coding_unit_flag_decode(HEVCLocalContext *lc, int ct_depth, int x0, int y0) { + const HEVCContext *const s = lc->parent; + const HEVCSPS *const sps = s->ps.sps; int inc = 0, depth_left = 0, depth_top = 0; - int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size); - int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size); - int x_cb = x0 >> s->ps.sps->log2_min_cb_size; - int y_cb = y0 >> s->ps.sps->log2_min_cb_size; + int x0b = av_mod_uintp2(x0, sps->log2_ctb_size); + int y0b = av_mod_uintp2(y0, sps->log2_ctb_size); + int x_cb = x0 >> sps->log2_min_cb_size; + int y_cb = y0 >> sps->log2_min_cb_size; - if (s->HEVClc->ctb_left_flag || x0b) - depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1]; - if (s->HEVClc->ctb_up_flag || y0b) - depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb]; + if (lc->ctb_left_flag || x0b) + depth_left = s->tab_ct_depth[(y_cb) * sps->min_cb_width + x_cb - 1]; + if (lc->ctb_up_flag || y0b) + depth_top = s->tab_ct_depth[(y_cb - 1) * sps->min_cb_width + x_cb]; inc += (depth_left > ct_depth); inc += (depth_top > ct_depth); @@ -708,12 +715,12 @@ int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc); } -int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size) +int ff_hevc_part_mode_decode(HEVCLocalContext *lc, int log2_cb_size) { if (GET_CABAC(elem_offset[PART_MODE])) // 1 return PART_2Nx2N; - if (log2_cb_size == s->ps.sps->log2_min_cb_size) { - if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0 + if (log2_cb_size == lc->parent->ps.sps->log2_min_cb_size) { + if (lc->cu.pred_mode == MODE_INTRA) // 0 return PART_NxN; if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01 return PART_2NxN; @@ -724,7 +731,7 @@ int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size) return PART_NxN; // 000 } - if (!s->ps.sps->amp_enabled_flag) { + if (!lc->parent->ps.sps->amp_enabled_flag) { if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01 return PART_2NxN; return PART_Nx2N; @@ -733,84 +740,84 @@ int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size) if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011 return PART_2NxN; - if (get_cabac_bypass(&s->HEVClc->cc)) // 0101 + if (get_cabac_bypass(&lc->cc)) // 0101 return PART_2NxnD; return PART_2NxnU; // 0100 } if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001 return PART_Nx2N; - if (get_cabac_bypass(&s->HEVClc->cc)) // 0001 + if (get_cabac_bypass(&lc->cc)) // 0001 return PART_nRx2N; return PART_nLx2N; // 0000 } -int ff_hevc_pcm_flag_decode(HEVCContext *s) +int ff_hevc_pcm_flag_decode(HEVCLocalContext *lc) { - return get_cabac_terminate(&s->HEVClc->cc); + return get_cabac_terminate(&lc->cc); } -int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s) +int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCLocalContext *lc) { return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]); } -int ff_hevc_mpm_idx_decode(HEVCContext *s) +int ff_hevc_mpm_idx_decode(HEVCLocalContext *lc) { int i = 0; - while (i < 2 && get_cabac_bypass(&s->HEVClc->cc)) + while (i < 2 && get_cabac_bypass(&lc->cc)) i++; return i; } -int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s) +int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCLocalContext *lc) { int i; - int value = get_cabac_bypass(&s->HEVClc->cc); + int value = get_cabac_bypass(&lc->cc); for (i = 0; i < 4; i++) - value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc); + value = (value << 1) | get_cabac_bypass(&lc->cc); return value; } -int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s) +int ff_hevc_intra_chroma_pred_mode_decode(HEVCLocalContext *lc) { int ret; if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE])) return 4; - ret = get_cabac_bypass(&s->HEVClc->cc) << 1; - ret |= get_cabac_bypass(&s->HEVClc->cc); + ret = get_cabac_bypass(&lc->cc) << 1; + ret |= get_cabac_bypass(&lc->cc); return ret; } -int ff_hevc_merge_idx_decode(HEVCContext *s) +int ff_hevc_merge_idx_decode(HEVCLocalContext *lc) { int i = GET_CABAC(elem_offset[MERGE_IDX]); if (i != 0) { - while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc)) + while (i < lc->parent->sh.max_num_merge_cand-1 && get_cabac_bypass(&lc->cc)) i++; } return i; } -int ff_hevc_merge_flag_decode(HEVCContext *s) +int ff_hevc_merge_flag_decode(HEVCLocalContext *lc) { return GET_CABAC(elem_offset[MERGE_FLAG]); } -int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH) +int ff_hevc_inter_pred_idc_decode(HEVCLocalContext *lc, int nPbW, int nPbH) { if (nPbW + nPbH == 12) return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4); - if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct_depth)) + if (GET_CABAC(elem_offset[INTER_PRED_IDC] + lc->ct_depth)) return PRED_BI; return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4); } -int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx) +int ff_hevc_ref_idx_lx_decode(HEVCLocalContext *lc, int num_ref_idx_lx) { int i = 0; int max = num_ref_idx_lx - 1; @@ -819,87 +826,88 @@ int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx) while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i)) i++; if (i == 2) { - while (i < max && get_cabac_bypass(&s->HEVClc->cc)) + while (i < max && get_cabac_bypass(&lc->cc)) i++; } return i; } -int ff_hevc_mvp_lx_flag_decode(HEVCContext *s) +int ff_hevc_mvp_lx_flag_decode(HEVCLocalContext *lc) { return GET_CABAC(elem_offset[MVP_LX_FLAG]); } -int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s) +int ff_hevc_no_residual_syntax_flag_decode(HEVCLocalContext *lc) { return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]); } -static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s) +static av_always_inline int abs_mvd_greater0_flag_decode(HEVCLocalContext *lc) { return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]); } -static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s) +static av_always_inline int abs_mvd_greater1_flag_decode(HEVCLocalContext *lc) { return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1); } -static av_always_inline int mvd_decode(HEVCContext *s) +static av_always_inline int mvd_decode(HEVCLocalContext *lc) { int ret = 2; int k = 1; - while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) { + while (k < CABAC_MAX_BIN && get_cabac_bypass(&lc->cc)) { ret += 1U << k; k++; } if (k == CABAC_MAX_BIN) { - av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k); + av_log(lc->logctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k); return 0; } while (k--) - ret += get_cabac_bypass(&s->HEVClc->cc) << k; - return get_cabac_bypass_sign(&s->HEVClc->cc, -ret); + ret += get_cabac_bypass(&lc->cc) << k; + return get_cabac_bypass_sign(&lc->cc, -ret); } -static av_always_inline int mvd_sign_flag_decode(HEVCContext *s) +static av_always_inline int mvd_sign_flag_decode(HEVCLocalContext *lc) { - return get_cabac_bypass_sign(&s->HEVClc->cc, -1); + return get_cabac_bypass_sign(&lc->cc, -1); } -int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size) +int ff_hevc_split_transform_flag_decode(HEVCLocalContext *lc, int log2_trafo_size) { return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size); } -int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth) +int ff_hevc_cbf_cb_cr_decode(HEVCLocalContext *lc, int trafo_depth) { return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth); } -int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth) +int ff_hevc_cbf_luma_decode(HEVCLocalContext *lc, int trafo_depth) { return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth); } -static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx) +static int hevc_transform_skip_flag_decode(HEVCLocalContext *lc, int c_idx) { return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx); } -static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx) +static int explicit_rdpcm_flag_decode(HEVCLocalContext *lc, int c_idx) { return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx); } -static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx) +static int explicit_rdpcm_dir_flag_decode(HEVCLocalContext *lc, int c_idx) { return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx); } -int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) { +int ff_hevc_log2_res_scale_abs(HEVCLocalContext *lc, int idx) +{ int i =0; while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i)) @@ -908,11 +916,12 @@ int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) { return i; } -int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) { +int ff_hevc_res_scale_sign_flag(HEVCLocalContext *lc, int idx) +{ return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx); } -static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx, +static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCLocalContext *lc, int c_idx, int log2_size, int *last_scx_prefix, int *last_scy_prefix) { int i = 0; @@ -938,19 +947,19 @@ static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *last_scy_prefix = i; } -static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s, +static av_always_inline int last_significant_coeff_suffix_decode(HEVCLocalContext *lc, int last_significant_coeff_prefix) { int i; int length = (last_significant_coeff_prefix >> 1) - 1; - int value = get_cabac_bypass(&s->HEVClc->cc); + int value = get_cabac_bypass(&lc->cc); for (i = 1; i < length; i++) - value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc); + value = (value << 1) | get_cabac_bypass(&lc->cc); return value; } -static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg) +static av_always_inline int significant_coeff_group_flag_decode(HEVCLocalContext *lc, int c_idx, int ctx_cg) { int inc; @@ -958,19 +967,19 @@ static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc); } -static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c, +static av_always_inline int significant_coeff_flag_decode(HEVCLocalContext *lc, int x_c, int y_c, int offset, const uint8_t *ctx_idx_map) { int inc = ctx_idx_map[(y_c << 2) + x_c] + offset; return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc); } -static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset) +static av_always_inline int significant_coeff_flag_decode_0(HEVCLocalContext *lc, int c_idx, int offset) { return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset); } -static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc) +static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCLocalContext *lc, int c_idx, int inc) { if (c_idx > 0) @@ -979,7 +988,7 @@ static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc); } -static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc) +static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCLocalContext *lc, int c_idx, int inc) { if (c_idx > 0) inc += 4; @@ -987,47 +996,47 @@ static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc); } -static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param) +static av_always_inline int coeff_abs_level_remaining_decode(HEVCLocalContext *lc, int rc_rice_param) { int prefix = 0; int suffix = 0; int last_coeff_abs_level_remaining; int i; - while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) + while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&lc->cc)) prefix++; if (prefix < 3) { for (i = 0; i < rc_rice_param; i++) - suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc); + suffix = (suffix << 1) | get_cabac_bypass(&lc->cc); last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix; } else { int prefix_minus3 = prefix - 3; if (prefix == CABAC_MAX_BIN || prefix_minus3 + rc_rice_param > 16 + 6) { - av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix); + av_log(lc->logctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix); return 0; } for (i = 0; i < prefix_minus3 + rc_rice_param; i++) - suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc); + suffix = (suffix << 1) | get_cabac_bypass(&lc->cc); last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1) << rc_rice_param) + suffix; } return last_coeff_abs_level_remaining; } -static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb) +static av_always_inline int coeff_sign_flag_decode(HEVCLocalContext *lc, uint8_t nb) { int i; int ret = 0; for (i = 0; i < nb; i++) - ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc); + ret = (ret << 1) | get_cabac_bypass(&lc->cc); return ret; } -void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, +void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0, int log2_trafo_size, enum ScanType scan_idx, int c_idx) { @@ -1036,7 +1045,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, x_c = (x_cg << 2) + scan_x_off[n]; \ y_c = (y_cg << 2) + scan_y_off[n]; \ } while (0) - HEVCLocalContext *lc = s->HEVClc; + const HEVCContext *const s = lc->parent; int transform_skip_flag = 0; int last_significant_coeff_x, last_significant_coeff_y; @@ -1091,7 +1100,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, if (s->ps.pps->transform_skip_enabled_flag && log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) { - transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx); + transform_skip_flag = hevc_transform_skip_flag_decode(lc, c_idx); } if (c_idx == 0) { @@ -1150,24 +1159,24 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag && (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) { - explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx); + explicit_rdpcm_flag = explicit_rdpcm_flag_decode(lc, c_idx); if (explicit_rdpcm_flag) { - explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx); + explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(lc, c_idx); } } - last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size, + last_significant_coeff_xy_prefix_decode(lc, c_idx, log2_trafo_size, &last_significant_coeff_x, &last_significant_coeff_y); if (last_significant_coeff_x > 3) { - int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x); + int suffix = last_significant_coeff_suffix_decode(lc, last_significant_coeff_x); last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) * (2 + (last_significant_coeff_x & 1)) + suffix; } if (last_significant_coeff_y > 3) { - int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y); + int suffix = last_significant_coeff_suffix_decode(lc, last_significant_coeff_y); last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) * (2 + (last_significant_coeff_y & 1)) + suffix; @@ -1246,7 +1255,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1]; significant_coeff_group_flag[x_cg][y_cg] = - significant_coeff_group_flag_decode(s, c_idx, ctx_cg); + significant_coeff_group_flag_decode(lc, c_idx, ctx_cg); implicit_non_zero_coeff = 1; } else { significant_coeff_group_flag[x_cg][y_cg] = @@ -1313,7 +1322,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, for (n = n_end; n > 0; n--) { x_c = scan_x_off[n]; y_c = scan_y_off[n]; - if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) { + if (significant_coeff_flag_decode(lc, x_c, y_c, scf_offset, ctx_idx_map_p)) { significant_coeff_flag_idx[nb_significant_coeff_flag] = n; nb_significant_coeff_flag++; implicit_non_zero_coeff = 0; @@ -1337,7 +1346,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, scf_offset = 2 + scf_offset; } } - if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) { + if (significant_coeff_flag_decode_0(lc, c_idx, scf_offset) == 1) { significant_coeff_flag_idx[nb_significant_coeff_flag] = 0; nb_significant_coeff_flag++; } @@ -1381,7 +1390,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) { int inc = (ctx_set << 2) + greater1_ctx; coeff_abs_level_greater1_flag[m] = - coeff_abs_level_greater1_flag_decode(s, c_idx, inc); + coeff_abs_level_greater1_flag_decode(lc, c_idx, inc); if (coeff_abs_level_greater1_flag[m]) { greater1_ctx = 0; if (first_greater1_coeff_idx == -1) @@ -1402,12 +1411,12 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4); if (first_greater1_coeff_idx != -1) { - coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set); + coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(lc, c_idx, ctx_set); } if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) { - coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag); + coeff_sign_flag = coeff_sign_flag_decode(lc, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag); } else { - coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1)); + coeff_sign_flag = coeff_sign_flag_decode(lc, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1)); } for (m = 0; m < n_end; m++) { @@ -1416,7 +1425,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, if (m < 8) { trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m]; if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) { - int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param); + int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(lc, c_rice_param); trans_coeff_level += last_coeff_abs_level_remaining; if (trans_coeff_level > (3 << c_rice_param)) @@ -1432,7 +1441,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, } } } else { - int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param); + int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(lc, c_rice_param); trans_coeff_level = 1 + last_coeff_abs_level_remaining; if (trans_coeff_level > (3 << c_rice_param)) @@ -1537,26 +1546,25 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride); } -void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size) +void ff_hevc_hls_mvd_coding(HEVCLocalContext *lc, int x0, int y0, int log2_cb_size) { - HEVCLocalContext *lc = s->HEVClc; - int x = abs_mvd_greater0_flag_decode(s); - int y = abs_mvd_greater0_flag_decode(s); + int x = abs_mvd_greater0_flag_decode(lc); + int y = abs_mvd_greater0_flag_decode(lc); if (x) - x += abs_mvd_greater1_flag_decode(s); + x += abs_mvd_greater1_flag_decode(lc); if (y) - y += abs_mvd_greater1_flag_decode(s); + y += abs_mvd_greater1_flag_decode(lc); switch (x) { - case 2: lc->pu.mvd.x = mvd_decode(s); break; - case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break; + case 2: lc->pu.mvd.x = mvd_decode(lc); break; + case 1: lc->pu.mvd.x = mvd_sign_flag_decode(lc); break; case 0: lc->pu.mvd.x = 0; break; } switch (y) { - case 2: lc->pu.mvd.y = mvd_decode(s); break; - case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break; + case 2: lc->pu.mvd.y = mvd_decode(lc); break; + case 1: lc->pu.mvd.y = mvd_sign_flag_decode(lc); break; case 0: lc->pu.mvd.y = 0; break; } } diff --git a/libavcodec/hevcdec.c b/libavcodec/hevcdec.c index 7d4de414cd..b3965932e9 100644 --- a/libavcodec/hevcdec.c +++ b/libavcodec/hevcdec.c @@ -1017,11 +1017,11 @@ static void hls_sao_param(HEVCContext *s, int rx, int ry) s->sh.slice_sample_adaptive_offset_flag[1]) { if (rx > 0) { if (lc->ctb_left_flag) - sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s); + sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(lc); } if (ry > 0 && !sao_merge_left_flag) { if (lc->ctb_up_flag) - sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s); + sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(lc); } } @@ -1038,27 +1038,27 @@ static void hls_sao_param(HEVCContext *s, int rx, int ry) sao->type_idx[2] = sao->type_idx[1]; sao->eo_class[2] = sao->eo_class[1]; } else { - SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s)); + SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(lc)); } if (sao->type_idx[c_idx] == SAO_NOT_APPLIED) continue; for (i = 0; i < 4; i++) - SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s)); + SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(lc)); if (sao->type_idx[c_idx] == SAO_BAND) { for (i = 0; i < 4; i++) { if (sao->offset_abs[c_idx][i]) { SET_SAO(offset_sign[c_idx][i], - ff_hevc_sao_offset_sign_decode(s)); + ff_hevc_sao_offset_sign_decode(lc)); } else { sao->offset_sign[c_idx][i] = 0; } } - SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s)); + SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(lc)); } else if (c_idx != 2) { - SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s)); + SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(lc)); } // Inferred parameters @@ -1081,10 +1081,10 @@ static void hls_sao_param(HEVCContext *s, int rx, int ry) static int hls_cross_component_pred(HEVCContext *s, int idx) { HEVCLocalContext *lc = s->HEVClc; - int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx); + int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(lc, idx); if (log2_res_scale_abs_plus1 != 0) { - int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx); + int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(lc, idx); lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) * (1 - 2 * res_scale_sign_flag); } else { @@ -1120,9 +1120,9 @@ static int hls_transform_unit(HEVCContext *s, int x0, int y0, (cbf_cb[1] || cbf_cr[1])); if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) { - lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s); + lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(lc); if (lc->tu.cu_qp_delta != 0) - if (ff_hevc_cu_qp_delta_sign_flag(s) == 1) + if (ff_hevc_cu_qp_delta_sign_flag(lc) == 1) lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta; lc->tu.is_cu_qp_delta_coded = 1; @@ -1142,11 +1142,11 @@ static int hls_transform_unit(HEVCContext *s, int x0, int y0, if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma && !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) { - int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s); + int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(lc); if (cu_chroma_qp_offset_flag) { int cu_chroma_qp_offset_idx = 0; if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) { - cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s); + cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(lc); av_log(s->avctx, AV_LOG_ERROR, "cu_chroma_qp_offset_idx not yet tested.\n"); } @@ -1180,7 +1180,7 @@ static int hls_transform_unit(HEVCContext *s, int x0, int y0, lc->tu.cross_pf = 0; if (cbf_luma) - ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0); + ff_hevc_hls_residual_coding(lc, x0, y0, log2_trafo_size, scan_idx, 0); if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) { int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]); int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]); @@ -1197,7 +1197,7 @@ static int hls_transform_unit(HEVCContext *s, int x0, int y0, s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1); } if (cbf_cb[i]) - ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c), + ff_hevc_hls_residual_coding(lc, x0, y0 + (i << log2_trafo_size_c), log2_trafo_size_c, scan_idx_c, 1); else if (lc->tu.cross_pf) { @@ -1227,7 +1227,7 @@ static int hls_transform_unit(HEVCContext *s, int x0, int y0, s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2); } if (cbf_cr[i]) - ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c), + ff_hevc_hls_residual_coding(lc, x0, y0 + (i << log2_trafo_size_c), log2_trafo_size_c, scan_idx_c, 2); else if (lc->tu.cross_pf) { @@ -1256,7 +1256,7 @@ static int hls_transform_unit(HEVCContext *s, int x0, int y0, s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1); } if (cbf_cb[i]) - ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size), + ff_hevc_hls_residual_coding(lc, xBase, yBase + (i << log2_trafo_size), log2_trafo_size, scan_idx_c, 1); } for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) { @@ -1266,7 +1266,7 @@ static int hls_transform_unit(HEVCContext *s, int x0, int y0, s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2); } if (cbf_cr[i]) - ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size), + ff_hevc_hls_residual_coding(lc, xBase, yBase + (i << log2_trafo_size), log2_trafo_size, scan_idx_c, 2); } } @@ -1355,7 +1355,7 @@ static int hls_transform_tree(HEVCContext *s, int x0, int y0, log2_trafo_size > s->ps.sps->log2_min_tb_size && trafo_depth < lc->cu.max_trafo_depth && !(lc->cu.intra_split_flag && trafo_depth == 0)) { - split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size); + split_transform_flag = ff_hevc_split_transform_flag_decode(lc, log2_trafo_size); } else { int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 && lc->cu.pred_mode == MODE_INTER && @@ -1369,16 +1369,16 @@ static int hls_transform_tree(HEVCContext *s, int x0, int y0, if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) { if (trafo_depth == 0 || cbf_cb[0]) { - cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth); + cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(lc, trafo_depth); if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) { - cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth); + cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(lc, trafo_depth); } } if (trafo_depth == 0 || cbf_cr[0]) { - cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth); + cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(lc, trafo_depth); if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) { - cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth); + cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(lc, trafo_depth); } } } @@ -1412,7 +1412,7 @@ do { if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 || cbf_cb[0] || cbf_cr[0] || (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) { - cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth); + cbf_luma = ff_hevc_cbf_luma_decode(lc, trafo_depth); } ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase, @@ -1825,15 +1825,15 @@ static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW, ff_hevc_set_neighbour_available(lc, x0, y0, nPbW, nPbH); mv->pred_flag = 0; if (s->sh.slice_type == HEVC_SLICE_B) - inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH); + inter_pred_idc = ff_hevc_inter_pred_idc_decode(lc, nPbW, nPbH); if (inter_pred_idc != PRED_L1) { if (s->sh.nb_refs[L0]) - mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]); + mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(lc, s->sh.nb_refs[L0]); mv->pred_flag = PF_L0; - ff_hevc_hls_mvd_coding(s, x0, y0, 0); - mvp_flag = ff_hevc_mvp_lx_flag_decode(s); + ff_hevc_hls_mvd_coding(lc, x0, y0, 0); + mvp_flag = ff_hevc_mvp_lx_flag_decode(lc); ff_hevc_luma_mv_mvp_mode(lc, x0, y0, nPbW, nPbH, log2_cb_size, part_idx, merge_idx, mv, mvp_flag, 0); mv->mv[0].x += lc->pu.mvd.x; @@ -1842,16 +1842,16 @@ static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW, if (inter_pred_idc != PRED_L0) { if (s->sh.nb_refs[L1]) - mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]); + mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(lc, s->sh.nb_refs[L1]); if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) { AV_ZERO32(&lc->pu.mvd); } else { - ff_hevc_hls_mvd_coding(s, x0, y0, 1); + ff_hevc_hls_mvd_coding(lc, x0, y0, 1); } mv->pred_flag += PF_L1; - mvp_flag = ff_hevc_mvp_lx_flag_decode(s); + mvp_flag = ff_hevc_mvp_lx_flag_decode(lc); ff_hevc_luma_mv_mvp_mode(lc, x0, y0, nPbW, nPbH, log2_cb_size, part_idx, merge_idx, mv, mvp_flag, 1); mv->mv[1].x += lc->pu.mvd.x; @@ -1888,11 +1888,11 @@ static void hls_prediction_unit(HEVCContext *s, int x0, int y0, int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb); if (!skip_flag) - lc->pu.merge_flag = ff_hevc_merge_flag_decode(s); + lc->pu.merge_flag = ff_hevc_merge_flag_decode(lc); if (skip_flag || lc->pu.merge_flag) { if (s->sh.max_num_merge_cand > 1) - merge_idx = ff_hevc_merge_idx_decode(s); + merge_idx = ff_hevc_merge_idx_decode(lc); else merge_idx = 0; @@ -2096,14 +2096,14 @@ static void intra_prediction_unit(HEVCContext *s, int x0, int y0, for (i = 0; i < side; i++) for (j = 0; j < side; j++) - prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s); + prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(lc); for (i = 0; i < side; i++) { for (j = 0; j < side; j++) { if (prev_intra_luma_pred_flag[2 * i + j]) - lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s); + lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(lc); else - lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s); + lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(lc); lc->pu.intra_pred_mode[2 * i + j] = luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size, @@ -2114,7 +2114,7 @@ static void intra_prediction_unit(HEVCContext *s, int x0, int y0, if (s->ps.sps->chroma_format_idc == 3) { for (i = 0; i < side; i++) { for (j = 0; j < side; j++) { - lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s); + lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(lc); if (chroma_mode != 4) { if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode]) lc->pu.intra_pred_mode_c[2 * i + j] = 34; @@ -2127,7 +2127,7 @@ static void intra_prediction_unit(HEVCContext *s, int x0, int y0, } } else if (s->ps.sps->chroma_format_idc == 2) { int mode_idx; - lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s); + lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(lc); if (chroma_mode != 4) { if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode]) mode_idx = 34; @@ -2138,7 +2138,7 @@ static void intra_prediction_unit(HEVCContext *s, int x0, int y0, } lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx]; } else if (s->ps.sps->chroma_format_idc != 0) { - chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s); + chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(lc); if (chroma_mode != 4) { if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode]) lc->pu.intra_pred_mode_c[0] = 34; @@ -2196,14 +2196,14 @@ static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size) for (x = 0; x < 4; x++) lc->pu.intra_pred_mode[x] = 1; if (s->ps.pps->transquant_bypass_enable_flag) { - lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s); + lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(lc); if (lc->cu.cu_transquant_bypass_flag) set_deblocking_bypass(s, x0, y0, log2_cb_size); } else lc->cu.cu_transquant_bypass_flag = 0; if (s->sh.slice_type != HEVC_SLICE_I) { - uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb); + uint8_t skip_flag = ff_hevc_skip_flag_decode(lc, x0, y0, x_cb, y_cb); x = y_cb * min_cb_width + x_cb; for (y = 0; y < length; y++) { @@ -2229,10 +2229,10 @@ static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size) int pcm_flag = 0; if (s->sh.slice_type != HEVC_SLICE_I) - lc->cu.pred_mode = ff_hevc_pred_mode_decode(s); + lc->cu.pred_mode = ff_hevc_pred_mode_decode(lc); if (lc->cu.pred_mode != MODE_INTRA || log2_cb_size == s->ps.sps->log2_min_cb_size) { - lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size); + lc->cu.part_mode = ff_hevc_part_mode_decode(lc, log2_cb_size); lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN && lc->cu.pred_mode == MODE_INTRA; } @@ -2241,7 +2241,7 @@ static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size) if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag && log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size && log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) { - pcm_flag = ff_hevc_pcm_flag_decode(s); + pcm_flag = ff_hevc_pcm_flag_decode(lc); } if (pcm_flag) { intra_prediction_unit_default_value(s, x0, y0, log2_cb_size); @@ -2298,7 +2298,7 @@ static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size) if (lc->cu.pred_mode != MODE_INTRA && !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) { - rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s); + rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(lc); } if (rqt_root_cbf) { const static int cbf[2] = { 0 }; @@ -2348,7 +2348,7 @@ static int hls_coding_quadtree(HEVCContext *s, int x0, int y0, if (x0 + cb_size <= s->ps.sps->width && y0 + cb_size <= s->ps.sps->height && log2_cb_size > s->ps.sps->log2_min_cb_size) { - split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0); + split_cu = ff_hevc_split_coding_unit_flag_decode(lc, cb_depth, x0, y0); } else { split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size); } @@ -2411,7 +2411,7 @@ static int hls_coding_quadtree(HEVCContext *s, int x0, int y0, (!((y0 + cb_size) % (1 << (s->ps.sps->log2_ctb_size))) || (y0 + cb_size >= s->ps.sps->height))) { - int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s); + int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(lc); return !end_of_slice_flag; } else { return 1; @@ -2501,7 +2501,7 @@ static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread) y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size; hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts); - ret = ff_hevc_cabac_init(s, ctb_addr_ts); + ret = ff_hevc_cabac_init(lc, ctb_addr_ts); if (ret < 0) { s->tab_slice_address[ctb_addr_rs] = -1; return ret; @@ -2521,7 +2521,7 @@ static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread) ctb_addr_ts++; - ff_hevc_save_states(s, ctb_addr_ts); + ff_hevc_save_states(lc, ctb_addr_ts); ff_hevc_hls_filters(lc, x_ctb, y_ctb, ctb_size); } @@ -2579,7 +2579,7 @@ static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int return 0; } - ret = ff_hevc_cabac_init(s, ctb_addr_ts); + ret = ff_hevc_cabac_init(lc, ctb_addr_ts); if (ret < 0) goto error; hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size); @@ -2592,7 +2592,7 @@ static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int ctb_addr_ts++; - ff_hevc_save_states(s, ctb_addr_ts); + ff_hevc_save_states(lc, ctb_addr_ts); ff_thread_report_progress2(s->avctx, ctb_row, thread, 1); ff_hevc_hls_filters(lc, x_ctb, y_ctb, ctb_size); diff --git a/libavcodec/hevcdec.h b/libavcodec/hevcdec.h index b97b7d1354..b33e8ae0f6 100644 --- a/libavcodec/hevcdec.h +++ b/libavcodec/hevcdec.h @@ -604,38 +604,38 @@ int ff_hevc_frame_rps(HEVCContext *s); */ int ff_hevc_slice_rpl(HEVCContext *s); -void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts); -int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts); -int ff_hevc_sao_merge_flag_decode(HEVCContext *s); -int ff_hevc_sao_type_idx_decode(HEVCContext *s); -int ff_hevc_sao_band_position_decode(HEVCContext *s); -int ff_hevc_sao_offset_abs_decode(HEVCContext *s); -int ff_hevc_sao_offset_sign_decode(HEVCContext *s); -int ff_hevc_sao_eo_class_decode(HEVCContext *s); -int ff_hevc_end_of_slice_flag_decode(HEVCContext *s); -int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s); -int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, +void ff_hevc_save_states(HEVCLocalContext *lc, int ctb_addr_ts); +int ff_hevc_cabac_init(HEVCLocalContext *lc, int ctb_addr_ts); +int ff_hevc_sao_merge_flag_decode(HEVCLocalContext *lc); +int ff_hevc_sao_type_idx_decode(HEVCLocalContext *lc); +int ff_hevc_sao_band_position_decode(HEVCLocalContext *lc); +int ff_hevc_sao_offset_abs_decode(HEVCLocalContext *lc); +int ff_hevc_sao_offset_sign_decode(HEVCLocalContext *lc); +int ff_hevc_sao_eo_class_decode(HEVCLocalContext *lc); +int ff_hevc_end_of_slice_flag_decode(HEVCLocalContext *lc); +int ff_hevc_cu_transquant_bypass_flag_decode(HEVCLocalContext *lc); +int ff_hevc_skip_flag_decode(HEVCLocalContext *lc, int x0, int y0, int x_cb, int y_cb); -int ff_hevc_pred_mode_decode(HEVCContext *s); -int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, +int ff_hevc_pred_mode_decode(HEVCLocalContext *lc); +int ff_hevc_split_coding_unit_flag_decode(HEVCLocalContext *lc, int ct_depth, int x0, int y0); -int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size); -int ff_hevc_pcm_flag_decode(HEVCContext *s); -int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s); -int ff_hevc_mpm_idx_decode(HEVCContext *s); -int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s); -int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s); -int ff_hevc_merge_idx_decode(HEVCContext *s); -int ff_hevc_merge_flag_decode(HEVCContext *s); -int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH); -int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx); -int ff_hevc_mvp_lx_flag_decode(HEVCContext *s); -int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s); -int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size); -int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth); -int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth); -int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx); -int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx); +int ff_hevc_part_mode_decode(HEVCLocalContext *lc, int log2_cb_size); +int ff_hevc_pcm_flag_decode(HEVCLocalContext *lc); +int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCLocalContext *lc); +int ff_hevc_mpm_idx_decode(HEVCLocalContext *lc); +int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCLocalContext *lc); +int ff_hevc_intra_chroma_pred_mode_decode(HEVCLocalContext *lc); +int ff_hevc_merge_idx_decode(HEVCLocalContext *lc); +int ff_hevc_merge_flag_decode(HEVCLocalContext *lc); +int ff_hevc_inter_pred_idc_decode(HEVCLocalContext *lc, int nPbW, int nPbH); +int ff_hevc_ref_idx_lx_decode(HEVCLocalContext *lc, int num_ref_idx_lx); +int ff_hevc_mvp_lx_flag_decode(HEVCLocalContext *lc); +int ff_hevc_no_residual_syntax_flag_decode(HEVCLocalContext *lc); +int ff_hevc_split_transform_flag_decode(HEVCLocalContext *lc, int log2_trafo_size); +int ff_hevc_cbf_cb_cr_decode(HEVCLocalContext *lc, int trafo_depth); +int ff_hevc_cbf_luma_decode(HEVCLocalContext *lc, int trafo_depth); +int ff_hevc_log2_res_scale_abs(HEVCLocalContext *lc, int idx); +int ff_hevc_res_scale_sign_flag(HEVCLocalContext *lc, int idx); /** * Get the number of candidate references for the current frame. @@ -686,15 +686,15 @@ void ff_hevc_set_qPy(HEVCLocalContext *lc, int xBase, int yBase, int log2_cb_size); void ff_hevc_deblocking_boundary_strengths(HEVCLocalContext *lc, int x0, int y0, int log2_trafo_size); -int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s); -int ff_hevc_cu_qp_delta_abs(HEVCContext *s); -int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s); -int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s); -void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, +int ff_hevc_cu_qp_delta_sign_flag(HEVCLocalContext *lc); +int ff_hevc_cu_qp_delta_abs(HEVCLocalContext *lc); +int ff_hevc_cu_chroma_qp_offset_flag(HEVCLocalContext *lc); +int ff_hevc_cu_chroma_qp_offset_idx(HEVCLocalContext *lc); +void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0, int log2_trafo_size, enum ScanType scan_idx, int c_idx); -void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size); +void ff_hevc_hls_mvd_coding(HEVCLocalContext *lc, int x0, int y0, int log2_cb_size); extern const uint8_t ff_hevc_qpel_extra_before[4]; extern const uint8_t ff_hevc_qpel_extra_after[4];