From patchwork Sun Aug 4 05:27:04 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Osamu Watanabe X-Patchwork-Id: 50883 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:612c:1f5a:b0:489:2eb3:e4c4 with SMTP id jm26csp749756vqb; Sat, 3 Aug 2024 22:27:31 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCXceTY3yci0g0DIdXZ4f+xttQMyZepI34hmJjcaDVI7jwsLf45BcanJZ1+R46gborefXs/NYwwvjHXowrvR9d+l7M8bElSwleNTjw== X-Google-Smtp-Source: AGHT+IGmJS4Mtam+pqW++Zyto6I+1XN2KFRQMXk9JXYacZDvbKchUGWlB4kaLMqRlcEa2saX+VIA X-Received: by 2002:a05:6512:ac6:b0:52c:d5b3:1a6a with SMTP id 2adb3069b0e04-530bb3a1d61mr5270099e87.28.1722749251313; Sat, 03 Aug 2024 22:27:31 -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 a640c23a62f3a-a7dc9d708d6si283341466b.441.2024.08.03.22.27.29; Sat, 03 Aug 2024 22:27: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=@takushoku.onmicrosoft.com header.s=selector2-takushoku-onmicrosoft-com header.b=ZlgdpG5E; 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 Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id F117968D5E6; Sun, 4 Aug 2024 08:27:24 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from OS0P286CU011.outbound.protection.outlook.com (mail-japanwestazon11020088.outbound.protection.outlook.com [52.101.228.88]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 7C5D268D5E6 for ; Sun, 4 Aug 2024 08:27:15 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=u24P+GN2+CV9qhRc6DFCK7KRsDzpZBULUc7wis5zVxEBJRFFIQYP8LgkhiVqKjpUzPlrk9JfZr1pkRC/HaK3oV5u2vzXmsztOXQASnMZgJrl9n3qItiNoElMR8NF0+VxOq3X+mk0QWi8qFmF/KdRA6JkcapHYvf343KhVFYsLrkW3zrSEgkFAGUEDkFOIS+lsGsWT7b3mnLiuGMpJQqXxx2DQGzf8JhG1X0LhsmHPp9sZNEuFAvVUQVOFQMvG3V8YUMjVsl3+6FtBFZ6ozbwpXpi+oE9qZg3URJCQ13VnJiab0FOtkKykjVBoUsEqVKJGCrCvo78vbEFb0h8G2GAdQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; 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=yJKzhgvWxgwEhFw8eOwcDEt/H4RR+nZ46merwOuxWAc=; b=HenlkSos69auWz5nSLlR33FGAeNPNSDYSqS/Zzr6JLlAoSdkz5QNoWNBuBiXR2KLShUUKFjpVqU65dDtkCLnAPLN+qwvupeODQOXiQhCK7MEFvz8cMMfzZnDZZROATDLAlfTBjuuFpese9jbC1pKg8kfMXR8cxtT7IYgmBteeS4Fb3RWD9g8CbWcA3DWHS3YoIPk7wqJyBtS7cwMepmrjjbmJC84ciUzWec01yjUvDShATlt355oxzMhTuRxBCR2sYupxH8qL26GwdpqcqM2fhtFt2nn/HZvC0CzN2JndjgdvG+Gb2e2x/RUjwGP86ohpktteTwdaMUKJNi+M3ax7g== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=es.takushoku-u.ac.jp; dmarc=pass action=none header.from=es.takushoku-u.ac.jp; dkim=pass header.d=es.takushoku-u.ac.jp; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=takushoku.onmicrosoft.com; s=selector2-takushoku-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=yJKzhgvWxgwEhFw8eOwcDEt/H4RR+nZ46merwOuxWAc=; b=ZlgdpG5ErY9SYF5iRUO762e7AjcjnN06G53MluYri368dAWmNiSJz/pQOAddMuAEr9uHLP5JD0KoYmGuNEg5W3qsqcSJD9mWjNywlTaOAWbPNwJEt1urJxRruiLpbEny/sgAsKiNWu1iPdPb0YIxpQmKegQWBE/j4ayE627xZQA= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=es.takushoku-u.ac.jp; Received: from OS0PR01MB6001.jpnprd01.prod.outlook.com (2603:1096:604:b7::12) by TY3PR01MB11348.jpnprd01.prod.outlook.com (2603:1096:400:3d0::11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7828.22; Sun, 4 Aug 2024 05:27:10 +0000 Received: from OS0PR01MB6001.jpnprd01.prod.outlook.com ([fe80::181c:c1f4:9b58:f6cc]) by OS0PR01MB6001.jpnprd01.prod.outlook.com ([fe80::181c:c1f4:9b58:f6cc%3]) with mapi id 15.20.7828.023; Sun, 4 Aug 2024 05:27:10 +0000 From: Osamu Watanabe To: ffmpeg-devel@ffmpeg.org Date: Sun, 4 Aug 2024 14:27:04 +0900 Message-Id: <20240804052706.292107-1-owatanab@es.takushoku-u.ac.jp> X-Mailer: git-send-email 2.34.1 X-ClientProxiedBy: TYCP286CA0266.JPNP286.PROD.OUTLOOK.COM (2603:1096:400:455::19) To OS0PR01MB6001.jpnprd01.prod.outlook.com (2603:1096:604:b7::12) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: OS0PR01MB6001:EE_|TY3PR01MB11348:EE_ X-MS-Office365-Filtering-Correlation-Id: 76a93cc6-a589-4aca-886f-08dcb4461648 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; ARA:13230040|41320700013|366016|1800799024|376014|52116014|38350700014; X-Microsoft-Antispam-Message-Info: 5PC7AFJbU6uDMhlWwyHSSp3DbXRJUhilXCdXEexcT+9FmFrNksE9SRDC51ZvvnEUxeQBkkHEGzNbk4QBAfbdoiO9fhKtphFn7XAKRR3ZZ05NSnWFD1rl6PKE+GDNsVXWDfLuUNu5e6/vZeA5AfynHJbXMOYaqpGwFyg48qyzLAWKoO6mOPlbLIBXChYxKI+FmeSxRglTgVHekrO0DQ9MmNVG1o7Mx6T7z1sgP3oaUhdwp77YvZb9Pn1k3O6RbyyUKWE9YZAszsN3nJfiLjpVT+bhi5W3zf3MR35+/t4fyJWyMxDO9vx0+WbdO61ZXTEZ/C1yO67y0WbtVBDGTGzsScv2ieZx/aP9IP3NLCATK92DGjFlDHstIzkloikh16Fw/GCF06TNL36+SDDkAH5OOKCPZUXPOKxXj7BAhmrnmQr19GVQKN/lggs1EaOcMJmfCTm8wHgj+v0mfH43ttxlwSnq173KpKoNBWZPiTxEBo2eiUjPGnHo2OX5LymcfYrxMbXphk9u+991JAJcRdRQoQx49DmOcCyGby59DSHOI9WxsC7z2PSnpTqyta854i+KmC5lSwG1f7tcac/HufkutbGelFny1Lp9098ODLi1BYnaQj15qc/Ez56a+izwDHnfxQLtp9+mpwXRhFpBnTndCI+nNWSqDNWGN6yj3IdONMjIsie/t0NbbLt+UYgJ/v6zQRL9phKElU8IyKQODv6hNlQuXcMGheTF3j4ysz/R0sfvqh6F2oqe73j29nACvpo1ZHbgtg9YIOMkTqqJSJzIlQ7A+/XRiBgjh85tkVgpMALfiml3uVEPYeVlS4wOfWbSFvmLR5hfd43YsDpKZ8SbMnPHO1RFGfeHtrgaxJhHGDQDRieBfYhGOspBdo+cDvPZayo+CRi635sriBUotKJwpREzUAxjhYlg2pNEdTtWMZjaOEnchLC8fppnC9Mh2mblQN4pO8kjEMAhplIpt4ko3+nj5GexnIVRvbGiknfzaSwLETS6S8RYh9ggj7Qmlt1DclzHI/8Eap114ohFk5bCi5PRTVT/as0kuaHiy8XfyQ05wKyay1sewvurbV9OmiNO5t1Z+jcyNu5BSA16461L1NVO3hZW/YbvfWWd+qjSpZT64mnrC9fXQcLU0XC/R6nbsh6PdVEpVE5T0gBX3wtVkpG4vWiC/vB8m4wZiIgj1jbC7a6c8na92i7SYYCvRv9boF2Q9beRbg1qaVi1E1E4twPUmO+0j08Eu5SSAp95zE221i7VItIJqFNipo5/ro46zTKZNeY+HURniO5BqNq0IHxX0FZ3MhG+DWCoJGcli490riDqJ+WRdNpJQhYxuBsDX+NapSVA1GXJxXl3XT6hXQz387xUQPtp+RYNrttV2lr8VE2dg5EhSkrr0h9viHqyV8ORwGekSFi1N9atHMGJFg== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:OS0PR01MB6001.jpnprd01.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230040)(41320700013)(366016)(1800799024)(376014)(52116014)(38350700014); DIR:OUT; SFP:1102; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: 7rhO5gHrw1NYMCU1CjixzxzBH0kL6w9EPPVmvac+Qv6XyXnPacKLchnA6b5GESY0mCf9U+FgH7EEc1bNZLCTxYEPq3572/PR3OIePgve1CZOda2lx3FfksaIMoHLaZWnW+hdqn36iAtPnGSX4n3y7fahGUhe/ICeMAIvCUD6PGw4kAoIEsA+G3igQ4SfrlRiMCJJvWqokePwG7WVfYUyosRVEaBXGYNoWPvLVSRHygwktspEGF95ZqbKlemXbD85wlUljntuP7HBpgORF8sE9sIHY4W9YrYXY4NqHFcrh01fMdz7hLAN7J/qnzEStYkgb7t1pv3AgfOUhgj5DbIBfwUnocZ+3TpUv3NLxkOX26qr7Yu055z5hWo13N/dRzmHj7wmojZCbxDOPoftbsdgqNx1i8l7HrQSKYKOKCKfmRsl59IUc/nP7SdUSEfuIygc9Gx+U/Laznw+rJ6LISuxJ4J3YMZVZmgJN0glZ9YrYuqsBKTLldoJuGt6eDM/mRfBlfRxG/qzOfQmP7ri1EDnnCPZoP56WCkx16fTaUZ0Dpd/tqXPQYsoJHGYIny6j/P8GuFudbu3TI7Qbqf31IVZJ2jvyIDwAyIC/OWwRxt1mrbZY3m5yFy7blj2rvJzFH7kL0NyCpYpjNwferGKZuYuOmRK9sbUdwXy8wBsPDyq4sDz+ANxVxgzuDHOpKyfYiMN7WLbJZabpfG8NOe2vIqoVMRsAL/Bj08+8URkaTyRD5zEtxccp6u30GBBjIGRccmc7wPU9QJ6GX0sc+M9xkaMYXsPkjGevXy4xOkO8faueytvJeZx3ZM9H0dLL+iFHI0WUNTrJbFOIwhldIdpxXjJ0b3nLytHiqY+SweMi3BGlXZETxgKEAL2cVu9Gd/TSxVygqA2gdASqmGZOFGkkVtJS7+bIcMP0xekEP7jBBLHh9Rg1Uqs5c4hA+E8Y3sTyQ0AwPhDx4aHDtpVuKrmnkHSFQsKrxRg6hIyIy0CFRzL747l0Dkl1eH1YLJ8HgYNqsBn682pgsbuUkoka+eSwlg+HIJzcAGA/BzO40AeC3JxX8prvPIodwvqj79XIbdBfdG8KiD3VzDNz0k2wgd+M9UPFzbRL1UB47qlnt+hqgqK2vHUnO+gXoQVRHL9wfJbtBL0rTEEFheI/WJwBwXcHc/6RH2bKDaWoPrDNyxjDG6PBxXjKO6yOl1/pFNkEJjcJtXIfOIgRfST5D5XHDkTbmSCo5sVREI5htOBvLqrW35qzGPNPntNgCsfUpkGCq3e6VLaZcD2w3KP47SMYSJhr7YLtK6R1yYrPL8w34vrPmAx+SN+WT4aFU2Ko3n2KKBkyuVNgDUbjFdTF12w4PG6sa/SJLswOHI8sW+8CXv04Sy2NBRgd7XZEFqWdCvi4k3g2Dzz5DStThsPmYirqxOqSr0GLNpqGG7WHZEAuRoakNE+paknHezgAHyMmeLk1VoneIhDcAut4VvS78I/OwWo5HDBbswqoX2kYSR0PhdrGJrr7H+nkJp6VL/ZGCmMRk8TIQogiH4PYT6NIbgBhvneClzv5NMOQOHk/Jozjjld/5rZP5p1ZxrQWHGjPmXoTd1l8sgvPNqBjTyyULCRuVjM53bl0A== X-OriginatorOrg: es.takushoku-u.ac.jp X-MS-Exchange-CrossTenant-Network-Message-Id: 76a93cc6-a589-4aca-886f-08dcb4461648 X-MS-Exchange-CrossTenant-AuthSource: OS0PR01MB6001.jpnprd01.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 Aug 2024 05:27:10.5309 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 853333e5-13b1-4738-ae04-bfb589cf2665 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: t8PJ+LVOrXriWFtRCe7YFHCm1LQ4UimRb0Sf0bindbvS4H2Xmd2ggw80agEMozRKBeLyViD5mon+i6InUWNsctoQyZVjlCEIaIjoO1ZM7ok= X-MS-Exchange-Transport-CrossTenantHeadersStamped: TY3PR01MB11348 Subject: [FFmpeg-devel] [PATCH v7 1/3] avcodec/jpeg2000dec: Add support for CAP and CPF markers 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: Osamu Watanabe , pal@sandflow.com Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: Ji1RSYGHY+pQ This commit adds support for CAP and CPF markers. Decoding will exit when encountering Ilegal input codestreams. The variable `Jpeg2000DecoderContext->HT_MAGB` has been changed to `HT_B` according to the definition in the spec (ISO/IEC 15444-15). Signed-off-by: Osamu Watanabe --- libavcodec/jpeg2000.h | 8 +++ libavcodec/jpeg2000dec.c | 128 ++++++++++++++++++++++++++++++++++++++- libavcodec/jpeg2000dec.h | 7 +++ 3 files changed, 142 insertions(+), 1 deletion(-) diff --git a/libavcodec/jpeg2000.h b/libavcodec/jpeg2000.h index d004c08f10..4bdc38df7c 100644 --- a/libavcodec/jpeg2000.h +++ b/libavcodec/jpeg2000.h @@ -37,12 +37,14 @@ enum Jpeg2000Markers { JPEG2000_SOC = 0xff4f, // start of codestream + JPEG2000_CAP = 0xff50, // extended capabilities JPEG2000_SIZ = 0xff51, // image and tile size JPEG2000_COD, // coding style default JPEG2000_COC, // coding style component JPEG2000_TLM = 0xff55, // tile-part length, main header JPEG2000_PLM = 0xff57, // packet length, main header JPEG2000_PLT, // packet length, tile-part header + JPEG2000_CPF, // corresponding profile JPEG2000_QCD = 0xff5c, // quantization default JPEG2000_QCC, // quantization component JPEG2000_RGN, // region of interest @@ -58,6 +60,12 @@ enum Jpeg2000Markers { JPEG2000_EOC = 0xffd9, // end of codestream }; +enum JPEG2000_Ccap15_b14_15_params { + HTJ2K_HTONLY = 0, // HTONLY, bit 14 and 15 are 0 + HTJ2K_HTDECLARED, // HTDECLARED, bit 14 = 1 and bit 15 = 0 + HTJ2K_MIXED = 3, // MIXED, bit 14 and 15 are 1 +}; + #define JPEG2000_SOP_FIXED_BYTES 0xFF910004 #define JPEG2000_SOP_BYTE_LENGTH 6 diff --git a/libavcodec/jpeg2000dec.c b/libavcodec/jpeg2000dec.c index 091931b1ff..44db131d77 100644 --- a/libavcodec/jpeg2000dec.c +++ b/libavcodec/jpeg2000dec.c @@ -408,6 +408,73 @@ static int get_siz(Jpeg2000DecoderContext *s) s->avctx->bits_per_raw_sample = s->precision; return 0; } +/* get extended capabilities (CAP) marker segment */ +static int get_cap(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c) +{ + uint32_t Pcap; + uint16_t Ccap_i[32] = { 0 }; + uint16_t Ccap_15; + uint8_t P; + + if (bytestream2_get_bytes_left(&s->g) < 6) { + av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for CAP\n"); + return AVERROR_INVALIDDATA; + } + + Pcap = bytestream2_get_be32u(&s->g); + s->isHT = (Pcap >> (31 - (15 - 1))) & 1; + for (int i = 0; i < 32; i++) { + if ((Pcap >> (31 - i)) & 1) + Ccap_i[i] = bytestream2_get_be16u(&s->g); + } + Ccap_15 = Ccap_i[14]; + if (s->isHT == 1) { + av_log(s->avctx, AV_LOG_INFO, "This is an HTJ2K codestream.\n"); + // Bits 14-15 + switch ((Ccap_15 >> 14) & 0x3) { + case 0x3: + s->Ccap15_b14_15 = HTJ2K_MIXED; + break; + case 0x1: + s->Ccap15_b14_15 = HTJ2K_HTDECLARED; + break; + case 0x0: + s->Ccap15_b14_15 = HTJ2K_HTONLY; + break; + default: + av_log(s->avctx, AV_LOG_ERROR, "Unknown CCap value.\n"); + return AVERROR(EINVAL); + break; + } + // Bit 13 + if ((Ccap_15 >> 13) & 1) { + av_log(s->avctx, AV_LOG_ERROR, "MULTIHT set is not supported.\n"); + return AVERROR_PATCHWELCOME; + } + // Bit 12 + s->Ccap15_b12 = (Ccap_15 >> 12) & 1; + // Bit 11 + s->Ccap15_b11 = (Ccap_15 >> 11) & 1; + // Bit 5 + s->Ccap15_b05 = (Ccap_15 >> 5) & 1; + // Bit 0-4 + P = Ccap_15 & 0x1F; + if (!P) + s->HT_B = 8; + else if (P < 20) + s->HT_B = P + 8; + else if (P < 31) + s->HT_B = 4 * (P - 19) + 27; + else + s->HT_B = 74; + + if (s->HT_B > 31) { + av_log(s->avctx, AV_LOG_ERROR, "Available internal precision is exceeded (MAGB> 31).\n"); + return AVERROR_PATCHWELCOME; + } + } + return 0; +} /* get common part for COD and COC segments */ static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c) @@ -802,6 +869,15 @@ static int read_crg(Jpeg2000DecoderContext *s, int n) bytestream2_skip(&s->g, n - 2); return 0; } + +static int read_cpf(Jpeg2000DecoderContext *s, int n) +{ + if (bytestream2_get_bytes_left(&s->g) < (n - 2)) + return AVERROR_INVALIDDATA; + bytestream2_skip(&s->g, n - 2); + return 0; +} + /* Tile-part lengths: see ISO 15444-1:2002, section A.7.1 * Used to know the number of tile parts and lengths. * There may be multiple TLMs in the header. @@ -965,6 +1041,14 @@ static int init_tile(Jpeg2000DecoderContext *s, int tileno) comp->roi_shift = s->roi_shift[compno]; if (!codsty->init) return AVERROR_INVALIDDATA; + if (s->isHT && (!s->Ccap15_b05) && (!codsty->transform)) { + av_log(s->avctx, AV_LOG_ERROR, "Transformation = 0 (lossy DWT) is found in HTREV HT set\n"); + return AVERROR_INVALIDDATA; + } + if (s->isHT && s->Ccap15_b14_15 != (codsty->cblk_style >> 6) && s->Ccap15_b14_15 != HTJ2K_HTONLY) { + av_log(s->avctx, AV_LOG_ERROR, "SPcod/SPcoc value does not match bit 14-15 values of Ccap15\n"); + return AVERROR_INVALIDDATA; + } if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty, s->cbps[compno], s->cdx[compno], s->cdy[compno], s->avctx)) @@ -2187,22 +2271,57 @@ static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s) if (!s->tile) s->numXtiles = s->numYtiles = 0; break; + case JPEG2000_CAP: + if (!s->ncomponents) { + av_log(s->avctx, AV_LOG_ERROR, "CAP marker segment shall come after SIZ\n"); + return AVERROR_INVALIDDATA; + } + ret = get_cap(s, codsty); + break; case JPEG2000_COC: + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) { + av_log(s->avctx, AV_LOG_ERROR, "COC marker is found in HOMOGENEOUS HT set\n"); + return AVERROR_INVALIDDATA; + } ret = get_coc(s, codsty, properties); break; case JPEG2000_COD: + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) { + av_log(s->avctx, AV_LOG_ERROR, "COD marker is found in HOMOGENEOUS HT set\n"); + return AVERROR_INVALIDDATA; + } ret = get_cod(s, codsty, properties); break; case JPEG2000_RGN: + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) { + av_log(s->avctx, AV_LOG_ERROR, "RGB marker is found in HOMOGENEOUS HT set\n"); + return AVERROR_INVALIDDATA; + } ret = get_rgn(s, len); + if ((!s->Ccap15_b12) && s->isHT) { + av_log(s->avctx, AV_LOG_ERROR, "RGN marker is found in RGNFREE HT set\n"); + return AVERROR_INVALIDDATA; + } break; case JPEG2000_QCC: + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) { + av_log(s->avctx, AV_LOG_ERROR, "QCC marker is found in HOMOGENEOUS HT set\n"); + return AVERROR_INVALIDDATA; + } ret = get_qcc(s, len, qntsty, properties); break; case JPEG2000_QCD: + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) { + av_log(s->avctx, AV_LOG_ERROR, "QCD marker is found in HOMOGENEOUS HT set\n"); + return AVERROR_INVALIDDATA; + } ret = get_qcd(s, len, qntsty, properties); break; case JPEG2000_POC: + if (s->in_tile_headers == 1 && s->isHT && (!s->Ccap15_b11)) { + av_log(s->avctx, AV_LOG_ERROR, "POC marker is found in HOMOGENEOUS HT set\n"); + return AVERROR_INVALIDDATA; + } ret = get_poc(s, len, poc); break; case JPEG2000_SOT: @@ -2252,9 +2371,16 @@ static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s) "Cannot have both PPT and PPM marker.\n"); return AVERROR_INVALIDDATA; } - + if ((!s->Ccap15_b11) && s->isHT) { + av_log(s->avctx, AV_LOG_ERROR, "PPT marker is found in HOMOGENEOUS HT set\n"); + return AVERROR_INVALIDDATA; + } ret = get_ppt(s, len); break; + case JPEG2000_CPF: + // Corresponding profile marker + ret = read_cpf(s, len); + break; default: av_log(s->avctx, AV_LOG_ERROR, "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n", diff --git a/libavcodec/jpeg2000dec.h b/libavcodec/jpeg2000dec.h index d0ca6e7a79..166cce9eba 100644 --- a/libavcodec/jpeg2000dec.h +++ b/libavcodec/jpeg2000dec.h @@ -112,6 +112,13 @@ typedef struct Jpeg2000DecoderContext { Jpeg2000Tile *tile; Jpeg2000DSPContext dsp; + uint8_t isHT; // HTJ2K? + uint8_t Ccap15_b14_15; // HTONLY(= 0) or HTDECLARED(= 1) or MIXED(= 3) ? + uint8_t Ccap15_b12; // RGNFREE(= 0) or RGN(= 1)? + uint8_t Ccap15_b11; // HOMOGENEOUS(= 0) or HETEROGENEOUS(= 1) ? + uint8_t Ccap15_b05; // HTREV(= 0) or HTIRV(= 1) ? + uint8_t HT_B; // MAGB value + /*options parameters*/ int reduction_factor; } Jpeg2000DecoderContext; From patchwork Sun Aug 4 05:27:05 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Osamu Watanabe X-Patchwork-Id: 50884 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:612c:1f5a:b0:489:2eb3:e4c4 with SMTP id jm26csp749801vqb; Sat, 3 Aug 2024 22:27:44 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCUXHwiMRXorhozaqOkJv9jiaFE7nUX6+++El8SYgUz1JjvZycEQJd1PQCUaWF7Bf5o3BaNGmAF8X6dgyEs+dJFC63w+7aSAdsS6pg== X-Google-Smtp-Source: AGHT+IFcNHyGrxBB/GKUZ8N/FSgzI/M8aD+VMNduuShj6OTUBle5p32mzmGaRL1gZWjZJ6mHa79c X-Received: by 2002:a05:6512:3a93:b0:52e:ff72:38f0 with SMTP id 2adb3069b0e04-530bb36bb71mr6153736e87.1.1722749263795; Sat, 03 Aug 2024 22:27:43 -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 2adb3069b0e04-530bba46790si1532062e87.612.2024.08.03.22.27.43; Sat, 03 Aug 2024 22:27:43 -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=@takushoku.onmicrosoft.com header.s=selector2-takushoku-onmicrosoft-com header.b=oEvI97JR; 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 Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 31F9768D655; Sun, 4 Aug 2024 08:27:29 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from OS0P286CU011.outbound.protection.outlook.com (mail-japanwestazon11020088.outbound.protection.outlook.com [52.101.228.88]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 49CF568D655 for ; Sun, 4 Aug 2024 08:27:22 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=UJvx6ozdeVx9lTPayRQFc5ocY2V8N8yBzbXUGtwtP/58ufT9n57KT+pVrm3kXO6QN/Ya6t85AnFnfCRDb1AXEI0zc1WZgBNgR0lD5UIAa2ZrGLh8+NuMMI7+XiDuNfv6Q0xsZctHiGfgdrcntvUuM4+sLWOQol4Whuw1kXembpfRFKQIqIW/bpy2+ZMN3F7G/Lw9UmJfvHRf5TC52g9ZV88r5dXNjJgLpW4inmBjdt6gtWtHXgFUXmut8wXLftUw3hJcRuKxuJYdL2EWRAVO9wwzNh0o12CMOPGM7zT3p4jNjk6m7v153v+FUEO1TJpB4Q0iyqqweyiiSFzwCVGfIg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; 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=HajqVhOoB1GkuxFRf6os8UEg3gGESwvZn278CIfEZxw=; b=T1tHCNmIDKtKQ1SnZWoHmihUpZAGv5xPCV/bYcWD4F32Gv5nC7p5U+AEBiVdLeiXD9jqAGeh8pRZvIF7Udp4Z2ewmXJXd1N2yhsKMOzUdGo38v/qYgZjANpf8Rj3C2udSiKCClPF/oUn/ZfYgGfP3KOZ7xZcPNcsKiMV4cKjAFYCVO6ew5HBMgF7mWGOzAAmCrYdkIunCS3V5rrLmC40AeiqPgBCchiU5BH+yVwTq9N0hmpzmlNgj/eYpYK3oxq7brwLUYrH0Q0UxJ2gvDGl4vC38jH64B7wc88xVt6puZX6WFqzFE4Kz/vfBksoZEPOfWq+ZByYmqCly7NMXq93JQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=es.takushoku-u.ac.jp; dmarc=pass action=none header.from=es.takushoku-u.ac.jp; dkim=pass header.d=es.takushoku-u.ac.jp; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=takushoku.onmicrosoft.com; s=selector2-takushoku-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=HajqVhOoB1GkuxFRf6os8UEg3gGESwvZn278CIfEZxw=; b=oEvI97JRoEJmoWi4xH7CVrgtqMv24H1LAvcNS6HBZzkj+5p0C0PuFLMp6TmAlQkxEnMGAPj4cws3ZAtXxMTXhhrfMZmM9h42H3F+x1J9cOHBM9BEK19KeffreYxJA8ufN0dQqd1CyrEeh7j8UMsCf1XNJv831zPLf/v2wCDtBUI= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=es.takushoku-u.ac.jp; Received: from OS0PR01MB6001.jpnprd01.prod.outlook.com (2603:1096:604:b7::12) by TY3PR01MB11348.jpnprd01.prod.outlook.com (2603:1096:400:3d0::11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7828.22; Sun, 4 Aug 2024 05:27:12 +0000 Received: from OS0PR01MB6001.jpnprd01.prod.outlook.com ([fe80::181c:c1f4:9b58:f6cc]) by OS0PR01MB6001.jpnprd01.prod.outlook.com ([fe80::181c:c1f4:9b58:f6cc%3]) with mapi id 15.20.7828.023; Sun, 4 Aug 2024 05:27:12 +0000 From: Osamu Watanabe To: ffmpeg-devel@ffmpeg.org Date: Sun, 4 Aug 2024 14:27:05 +0900 Message-Id: <20240804052706.292107-2-owatanab@es.takushoku-u.ac.jp> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20240804052706.292107-1-owatanab@es.takushoku-u.ac.jp> References: <20240804052706.292107-1-owatanab@es.takushoku-u.ac.jp> X-ClientProxiedBy: TYCP286CA0032.JPNP286.PROD.OUTLOOK.COM (2603:1096:400:29d::10) To OS0PR01MB6001.jpnprd01.prod.outlook.com (2603:1096:604:b7::12) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: OS0PR01MB6001:EE_|TY3PR01MB11348:EE_ X-MS-Office365-Filtering-Correlation-Id: 8706bae0-4e0f-413d-185c-08dcb446173f X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; ARA:13230040|41320700013|366016|1800799024|376014|52116014|38350700014; X-Microsoft-Antispam-Message-Info: PBt5+mp5kyTjo/y4OFWbDO7B0gOylz9islPe/H+nF0pVe2lO85Q3mT149JafUKm37rJK1rwJ9ivrpXKyK1K8DOi0bJJGGPlUo1hDjcNW9ubOYxJqwTgenNZWyILMsIkcWiaefQP416vhsgHQwR1BBe77sFYcf4Xeg90Y3b8zBac3cPxfsJaJrbFb4/XDrksIPRAykZpV/x3Nx5SEPimknkBB5Wpg8u+8G7sSTvz3g6bXXRYm0FnxXPu1mB29UCw2homQwTMYDgka9BW1cl3oqtMgT5/GwE3CUHVNX1BcEPnVIs/yZK1amgxQqpKvgmhz5dMgCnlqkYxOSn7pAYSJUYf/CFdlbYYczrwSyAA+QlcUhRVL4bP98xjx1piGXQXh2vykIQiQRB7fwX+Ca8inReN/N6QA47JhuIjDxBxemYyUYpP9AIfG7OvH0iwV53I1DV4b3qvE33hsTe8zF/5RP0k2tSJ+RHdKXDc5oEaYkWz7xqKJq8sfsIW66QJVpaI/XiAY7Vnwd04skXZpn5WT2BfJnBaOWBjgvkx9em6UCM4Uq3ZqnBSHTlnhe2sWUIJnqKKH46NHu9NWjRV+ghfxBMpLweJFbOIK4XL06Cp5xVReBOZEtw7ngaSMxjOwNw7HtXMERQVQxgPJ4tWjSwo5CCeoBUvfZuLST2eM5XHk1vPntIb4oUP68jMSA5HTVSkqNLiwWUfcCkRIov7NqWap9jhngHNORPMzHhlh/SfKT2d2T5eXl3Xc+qyGYVqGZScU/ZGHB7SSvTXF3yc7gGnWdf4FepOr0kh+jsuYe02Fq7zPANQAnBfDV9Tobe7sqmiT6GwBZQsz55qJAQuxhRsDDvNaRIy1SbhsIprb2NY72VbOYN4BQu+BfdeM04lryj7ERbKjku2HO0MIighEILZ7QZvZMueHe3YLYqXqGSd0uL3bjd0xDHB03iMaMMFoffo9tVMJh26t3k9+7agTYE6HDD2o7csJfIV3Y1UgdxB0VqCP9UJcLpYNl47dNVJyirpb4Dsn/oehto2t/0ugQzKDd59Bx+DBolTm7u6XziRjY0l3HoZNhWLU6/o8heX6q/7QB65vdBI2sASBRnhFpwOVSPpP341c+NtBxe3xd9tPaNkIhvn2x+vz9iPGJyXC6dI/OsdTz3ioNd0r9uFCy9X8QYNf7ZiD3UzqdYXN/rBlHkLJ2X+8xlaklQZ7JHi0F1fJuOvnu2ziVyaHWwUCIOns6v+UdNmq7vt0iBYE8MiOT1GhVgLFpg0jDegVIgTwoNcY7ixPTAk2OfYz4FSOpsoMf6XiAxHKSKtQL/mChzbOKxVSvBaQ1ZgcRe6njMAHABYzDetC1PwOJpfaOwDnahx18Mar1bprjec1hamsX0fRkA8z0vzsUkBNO1h1Sp9VvV7vgR6+cPwaZILIEUWxK0DrIg== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:OS0PR01MB6001.jpnprd01.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230040)(41320700013)(366016)(1800799024)(376014)(52116014)(38350700014); DIR:OUT; SFP:1102; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: 2t/mKfe5MVa0/tkjX+nTCeP9Ij0P+eLg5xzZSCglHzd8HsCJ4Jk2eNE0hpc3KU8gMOVsC6lEdKWOrN0j55u7E1p+hnZUJqTtqdwWDSJkQ0KwtURzYKmzDrT0bCNXlYwrWad+1MIGfb88CgF+PE6P/aB7LMWoP94b1TinQZAS9ilUU7R0vt7zEAOwWMxPvuGwJvr/Aeiei54cIul0l8hc/iFE4FWA8iX2FhldrKP4JmhJpHd7+2Pu8ZTiNDQd4TNrQurYIRgRcCcYigMCqI5wNXJWaa31es3ROT9AbycGLE/qnn+yyjOES+e6oKBjhodmdMrTIE4CVvV01Cm2UXls6R7/jpCAOWkSQYEX9s8X2WvSu1/pT635uxBVkYk4l2jctptSKYzJtWKZ7yb43jN9FGBIx5AnMf6QfhzTEeUhFac/8On4Av04lLsmAWPqJpKjPGQM1494b07QjJbLiq0nXLrL87uw9/nCqtL4GBMSfcSgMH9/itEpgxJf5k7YZhLmYKtCk5gcbqqUVIrqRccom02qQCc0GpSDn/4D/phrKIul2ek4uGnioYdfcN+WVmqb34937LhQOD9E0zKlTPVp8V9Jvy39s+L3UcNRA7vWkBU0o7cNRd61iITt11I5ruL9KLdkLC/pWjD84K8Vli+TVXH08cqjzXxw69KRWUzZwzlNpLfUmObxACCO9Pi8wn844vbN1rVBGX+MiuWSqTaA9ALTI+ndFl0BDBoCGgy+WXCEheY+OgbaufwWqLbCxqLVvGgA9zEfUMujpE1ctYdvkLooskeU7SjZtMJkE1+we3/mDjuY4+YLmq4nn9T5HhB2RmHFedkSAQdKjpaz7trpTuv4aMj0nQwLlSd5G5AI1ZXCth2/ttzr3jLuknclxlSKZtUwESelw5VQPBx10fGebkQnVvDRcVIr89cyk/ycG5qaifoVfdzE/N1ZrFAeoX76FI//USCoCO9BNnBA0TxRqP0EWtnfY01sSMWkH2b/Yy3l3eboPikqNtWf+VyrceRZryAfLUQVMMi6MUeQSaoiUNgD2AXPEhL4o5pLQBOMA1uwwxWajK+snjTD2PQQ+fYFd+Vc1AuEvzg7DiSjmSbgwEb7KdxPsJMixrCSM7WIJakW/dEYLrP3PHbfgL2ERNLsWbtuStjOYSFv9Jwb9uCeRtzKLTRmh7QW0C+d9LJpZgw59fXneJtXBgtcrjNcSvkOpJXTphgznHrHfR6qjxuJdXwArtvxrpPHYsHrulDXbcgvCaXJIxXl3USy4CeLWfrM/cANsFDLSeEEw0GJ41In/PyElyrWooIPp8wWIIdN2nIa5aX5oL8H/tinyu+5VoRxUbG+OgmdhYWXGLN5qbcOOtVrLb7gswhirzZolwaaFRpgYiAPkWLHTM7YthV8NB941/I2hV8klfbZuXYPRUBJ6eBBV3NVYYIxMwkKuzwTp5oQOb71C7gx41Kd7c4SKBnLdbqywZPmOAGwt3E1OZtnBAuIlmymh0UfcbCbb5M+0cNhWHz/XOrts3iwSDhQQINCNKk8i8d5rB+qpR+N5Ego4X1by12vU49fskmnHYbhXazWA3LY3XuXb7UKWF9COg+uw/4Q3reE3SpWbQNrQiLl/w== X-OriginatorOrg: es.takushoku-u.ac.jp X-MS-Exchange-CrossTenant-Network-Message-Id: 8706bae0-4e0f-413d-185c-08dcb446173f X-MS-Exchange-CrossTenant-AuthSource: OS0PR01MB6001.jpnprd01.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 Aug 2024 05:27:12.1381 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 853333e5-13b1-4738-ae04-bfb589cf2665 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: g6EDZjJVd4oF5d06grqn80waVuYxWUsz56Vzf+cpHdqbpHMkN4WhZas3A/kDytb+A9AhWJp3KcYXY4VaoioZkANiZedPQj9u0OuxO8Xr0jE= X-MS-Exchange-Transport-CrossTenantHeadersStamped: TY3PR01MB11348 Subject: [FFmpeg-devel] [PATCH v7 2/3] avcodec/jpeg2000dec: Add support for placeholder passes 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: Osamu Watanabe , pal@sandflow.com Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: fN+wZa6iB9ql This commit adds support for placeholder pass parsing. Signed-off-by: Osamu Watanabe --- libavcodec/jpeg2000.h | 2 + libavcodec/jpeg2000dec.c | 352 +++++++++++++++++++++++++++++-------- libavcodec/jpeg2000htdec.c | 90 +++++----- 3 files changed, 326 insertions(+), 118 deletions(-) diff --git a/libavcodec/jpeg2000.h b/libavcodec/jpeg2000.h index 4bdc38df7c..93221d90ca 100644 --- a/libavcodec/jpeg2000.h +++ b/libavcodec/jpeg2000.h @@ -200,6 +200,8 @@ typedef struct Jpeg2000Cblk { /* specific to HT code-blocks */ int zbp; int pass_lengths[2]; + uint8_t modes; // copy of SPcod/SPcoc field to parse HT-MIXED mode + uint8_t ht_plhd; // are we looking for HT placeholder passes? } Jpeg2000Cblk; // code block typedef struct Jpeg2000Prec { diff --git a/libavcodec/jpeg2000dec.c b/libavcodec/jpeg2000dec.c index 44db131d77..c8759b6d51 100644 --- a/libavcodec/jpeg2000dec.c +++ b/libavcodec/jpeg2000dec.c @@ -54,6 +54,15 @@ #define HAD_COC 0x01 #define HAD_QCC 0x02 +// Values of flag for placeholder passes +enum HT_PLHD_STATUS { + HT_PLHD_OFF, + HT_PLHD_ON +}; + +#define HT_MIXED 0x80 // bit 7 of SPcod/SPcoc + + /* get_bits functions for JPEG2000 packet bitstream * It is a get_bit function with a bit-stuffing routine. If the value of the * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB. @@ -1160,100 +1169,293 @@ static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int incl, newpasses, llen; void *tmp; - if (cblk->npasses) - incl = get_bits(s, 1); - else + if (!cblk->incl) { + incl = 0; + cblk->modes = codsty->cblk_style; + if (cblk->modes >= JPEG2000_CTSY_HTJ2K_F) + cblk->ht_plhd = HT_PLHD_ON; + if (layno > 0) + incl = tag_tree_decode(s, prec->cblkincl + cblkno, 0 + 1) == 0; incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno; - if (!incl) - continue; - else if (incl < 0) - return incl; - - if (!cblk->npasses) { - int zbp = tag_tree_decode(s, prec->zerobits + cblkno, 100); - int v = expn[bandno] + numgbits - 1 - zbp; - if (v < 0 || v > 30) { - av_log(s->avctx, AV_LOG_ERROR, - "nonzerobits %d invalid or unsupported\n", v); - return AVERROR_INVALIDDATA; + if (incl) { + int zbp = tag_tree_decode(s, prec->zerobits + cblkno, 100); + int v = expn[bandno] + numgbits - 1 - (zbp - tile->comp->roi_shift); + if (v < 0 || v > 30) { + av_log(s->avctx, AV_LOG_ERROR, + "nonzerobits %d invalid or unsupported\n", v); + return AVERROR_INVALIDDATA; + } + cblk->incl = 1; + cblk->nonzerobits = v; + cblk->zbp = zbp; + cblk->lblock = 3; } - cblk->zbp = zbp; - cblk->nonzerobits = v; - } - if ((newpasses = getnpasses(s)) < 0) - return newpasses; - av_assert2(newpasses > 0); - if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) { - avpriv_request_sample(s->avctx, "Too many passes"); - return AVERROR_PATCHWELCOME; - } - if ((llen = getlblockinc(s)) < 0) - return llen; - if (cblk->lblock + llen + av_log2(newpasses) > 16) { - avpriv_request_sample(s->avctx, - "Block with length beyond 16 bits"); - return AVERROR_PATCHWELCOME; + } else { + incl = get_bits(s, 1); } - cblk->lblock += llen; - - cblk->nb_lengthinc = 0; - cblk->nb_terminationsinc = 0; - av_free(cblk->lengthinc); - cblk->lengthinc = av_calloc(newpasses, sizeof(*cblk->lengthinc)); - if (!cblk->lengthinc) - return AVERROR(ENOMEM); - tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start)); - if (!tmp) - return AVERROR(ENOMEM); - cblk->data_start = tmp; - do { - int newpasses1 = 0; + if (incl) { + uint8_t bypass_term_threshold = 0; + uint8_t bits_to_read = 0; + uint32_t segment_bytes = 0; + int32_t segment_passes = 0; + uint8_t next_segment_passes = 0; + int32_t href_passes, pass_bound; + uint32_t tmp_length = 0; + int32_t newpasses_copy, npasses_copy; + + if ((newpasses = getnpasses(s)) <= 0) + return newpasses; + if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) { + avpriv_request_sample(s->avctx, "Too many passes"); + return AVERROR_PATCHWELCOME; + } + if ((llen = getlblockinc(s)) < 0) + return llen; + if (cblk->lblock + llen + av_log2(newpasses) > 16) { + avpriv_request_sample(s->avctx, + "Block with length beyond 16 bits"); + return AVERROR_PATCHWELCOME; + } + cblk->nb_lengthinc = 0; + cblk->nb_terminationsinc = 0; + av_free(cblk->lengthinc); + cblk->lengthinc = av_calloc(newpasses, sizeof(*cblk->lengthinc)); + if (!cblk->lengthinc) + return AVERROR(ENOMEM); + tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, + sizeof(*cblk->data_start)); + if (!tmp) + return AVERROR(ENOMEM); + cblk->data_start = tmp; + cblk->lblock += llen; + + // Count number of necessary terminations for non HT code block + newpasses_copy = newpasses; + npasses_copy = cblk->npasses; + if (!(cblk->modes & JPEG2000_CTSY_HTJ2K_F)) { + do { + int newpasses1 = 0; + + while (newpasses1 < newpasses_copy) { + newpasses1++; + if (needs_termination(codsty->cblk_style, npasses_copy + newpasses1 - 1)) { + cblk->nb_terminationsinc++; + break; + } + } + npasses_copy += newpasses1; + newpasses_copy -= newpasses1; + } while (newpasses_copy); + } - while (newpasses1 < newpasses) { - newpasses1 ++; - if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) { - cblk->nb_terminationsinc ++; - break; + if (cblk->ht_plhd) { + href_passes = (cblk->npasses + newpasses - 1) % 3; + segment_passes = newpasses - href_passes; + pass_bound = 2; + bits_to_read = cblk->lblock; + if (segment_passes < 1) { + // No possible HT Cleanup pass here; may have placeholder passes + // or an original J2K block bit-stream (in MIXED mode). + segment_passes = newpasses; + while (pass_bound <= segment_passes) { + bits_to_read++; + pass_bound += pass_bound; + } + segment_bytes = get_bits(s, bits_to_read); + if (segment_bytes) { + if (cblk->modes & HT_MIXED) { + cblk->ht_plhd = HT_PLHD_OFF; + cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F)); + } + else { + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); + } + } + } else { + while (pass_bound <= segment_passes) { + bits_to_read++; + pass_bound += pass_bound; + } + segment_bytes = get_bits(s, bits_to_read); + if (segment_bytes) { + // No more placeholder passes + if (!(cblk->modes & HT_MIXED)) { + // Must be the first HT Cleanup pass + if (segment_bytes < 2) + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); + next_segment_passes = 2; + cblk->ht_plhd = HT_PLHD_OFF; + // Write length information for HT CleanUp segment + cblk->pass_lengths[0] = segment_bytes; + } else if (cblk->lblock > 3 && segment_bytes > 1 + && (segment_bytes >> (bits_to_read - 1)) == 0) { + // Must be the first HT Cleanup pass, since length MSB is 0 + next_segment_passes = 2; + cblk->ht_plhd = HT_PLHD_OFF; + // Write length information for HT CleanUp segment + cblk->pass_lengths[0] = segment_bytes; + } else { + // Must have an original (non-HT) block coding pass + cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F)); + cblk->ht_plhd = HT_PLHD_OFF; + segment_passes = newpasses; + while (pass_bound <= segment_passes) { + bits_to_read++; + pass_bound += pass_bound; + segment_bytes <<= 1; + segment_bytes += get_bits(s, 1); + } + } + } else { + // Probably parsing placeholder passes, but we need to read an + // extra length bit to verify this, since prior to the first + // HT Cleanup pass, the number of length bits read for a + // contributing code-block is dependent on the number of passes + // being included, as if it were a non-HT code-block. + segment_passes = newpasses; + if (pass_bound <= segment_passes) { + while (1) { + bits_to_read++; + pass_bound += pass_bound; + segment_bytes <<= 1; + segment_bytes += get_bits(s, 1); + if (pass_bound > segment_passes) + break; + } + if (segment_bytes) { + if (cblk->modes & HT_MIXED) { + cblk->modes &= (uint8_t) (~(JPEG2000_CTSY_HTJ2K_F)); + cblk->ht_plhd = HT_PLHD_OFF; + } else { + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); + } + } + } + } + } + } else if (cblk->modes & JPEG2000_CTSY_HTJ2K_F) { + // Quality layer commences with a non-initial HT coding pass + if(bits_to_read != 0) + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); + segment_passes = cblk->npasses % 3; + if (segment_passes == 0) { + // newpasses is a HT Cleanup pass; next segment has refinement passes + segment_passes = 1; + next_segment_passes = 2; + if (segment_bytes == 1) + av_log(s->avctx, AV_LOG_WARNING, "Length information for a HT-codeblock is invalid\n"); + } else { + // newpasses = 1 means npasses is HT SigProp; 2 means newpasses is + // HT MagRef pass + segment_passes = newpasses > 1 ? 3 - segment_passes : 1; + next_segment_passes = 1; + bits_to_read = av_log2(segment_passes); + } + bits_to_read = (uint8_t) (bits_to_read + cblk->lblock); + segment_bytes = get_bits(s, bits_to_read); + // Write length information for HT Refinment segment + cblk->pass_lengths[1] += segment_bytes; + } else if (!(cblk->modes & (JPEG2000_CBLK_TERMALL | JPEG2000_CBLK_BYPASS))) { + // Common case for non-HT code-blocks; we have only one segment + bits_to_read = (uint8_t) cblk->lblock + av_log2((uint8_t) newpasses); + segment_bytes = get_bits(s, bits_to_read); + segment_passes = newpasses; + } else if (cblk->modes & JPEG2000_CBLK_TERMALL) { + // RESTART MODE + bits_to_read = cblk->lblock; + segment_bytes = get_bits(s, bits_to_read); + segment_passes = 1; + next_segment_passes = 1; + } else { + // BYPASS MODE + bypass_term_threshold = 10; + if(bits_to_read != 0) + av_log(s->avctx, AV_LOG_WARNING, "Length information for a codeblock is invalid\n"); + if (cblk->npasses < bypass_term_threshold) { + // May have from 1 to 10 uninterrupted passes before 1st RAW SigProp + segment_passes = bypass_term_threshold - cblk->npasses; + if (segment_passes > newpasses) + segment_passes = newpasses; + while ((2 << bits_to_read) <= segment_passes) + bits_to_read++; + next_segment_passes = 2; + } else if ((cblk->npasses - bypass_term_threshold) % 3 < 2) { + // 0 means newpasses is a RAW SigProp; 1 means newpasses is a RAW MagRef pass + segment_passes = newpasses > 1 ? 2 - (cblk->npasses - bypass_term_threshold) % 3 : 1; + bits_to_read = av_log2(segment_passes); + next_segment_passes = 1; + } else { + // newpasses is an isolated Cleanup pass that precedes a RAW SigProp pass + segment_passes = 1; + next_segment_passes = 2; } + bits_to_read = (uint8_t) (bits_to_read + cblk->lblock); + segment_bytes = get_bits(s, bits_to_read); } - - if (newpasses > 1 && (codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F)) { - // Retrieve pass lengths for each pass - int href_passes = (cblk->npasses + newpasses - 1) % 3; - int eb = av_log2(newpasses - href_passes); - int extra_bit = newpasses > 2 ? 1 : 0; - if ((ret = get_bits(s, llen + eb + 3)) < 0) - return ret; - cblk->pass_lengths[0] = ret; - if ((ret = get_bits(s, llen + 3 + extra_bit)) < 0) - return ret; - cblk->pass_lengths[1] = ret; - ret = cblk->pass_lengths[0] + cblk->pass_lengths[1]; + // Update cblk->npasses and write length information + cblk->npasses = (uint8_t) (cblk->npasses + segment_passes); + cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes; + + if ((cblk->modes & JPEG2000_CTSY_HTJ2K_F) && cblk->ht_plhd == HT_PLHD_OFF) { + newpasses -= (uint8_t) segment_passes; + while (newpasses > 0) { + segment_passes = newpasses > 1 ? next_segment_passes : 1; + next_segment_passes = (uint8_t) (3 - next_segment_passes); + bits_to_read = (uint8_t) (cblk->lblock + av_log2(segment_passes)); + segment_bytes = get_bits(s, bits_to_read); + newpasses -= (uint8_t) (segment_passes); + // This is a FAST Refinement pass + // Write length information for HT Refinement segment + cblk->pass_lengths[1] += segment_bytes; + // Update cblk->npasses and write length information + cblk->npasses = (uint8_t) (cblk->npasses + segment_passes); + cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes; + } } else { - if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0) - return ret; - cblk->pass_lengths[0] = ret; + newpasses -= (uint8_t) (segment_passes); + while (newpasses > 0) { + if (bypass_term_threshold != 0) { + segment_passes = newpasses > 1 ? next_segment_passes : 1; + next_segment_passes = (uint8_t) (3 - next_segment_passes); + bits_to_read = (uint8_t) (cblk->lblock + av_log2(segment_passes)); + } else { + if ((cblk->modes & JPEG2000_CBLK_TERMALL) == 0) + av_log(s->avctx, AV_LOG_WARNING, "Corrupted packet header is found.\n"); + segment_passes = 1; + bits_to_read = cblk->lblock; + } + segment_bytes = get_bits(s, bits_to_read); + newpasses -= (uint8_t) (segment_passes); + + // Update cblk->npasses and write length information + cblk->npasses = (uint8_t) (cblk->npasses + segment_passes); + cblk->lengthinc[cblk->nb_lengthinc++] = segment_bytes; + } } - if (ret > cblk->data_allocated) { - size_t new_size = FFMAX(2*cblk->data_allocated, ret); + + for (int i = 0; i < cblk->nb_lengthinc; ++i) + tmp_length = (tmp_length < cblk->lengthinc[i]) ? cblk->lengthinc[i] : tmp_length; + + if (tmp_length > cblk->data_allocated) { + size_t new_size = FFMAX(2 * cblk->data_allocated, tmp_length); void *new = av_realloc(cblk->data, new_size); if (new) { cblk->data = new; cblk->data_allocated = new_size; } } - if (ret > cblk->data_allocated) { + if (tmp_length > cblk->data_allocated) { avpriv_request_sample(s->avctx, "Block with lengthinc greater than %"SIZE_SPECIFIER"", cblk->data_allocated); return AVERROR_PATCHWELCOME; } - cblk->lengthinc[cblk->nb_lengthinc++] = ret; - cblk->npasses += newpasses1; - newpasses -= newpasses1; - } while(newpasses); + } else { + // This codeblock has no contribution to the current packet + continue; + } } } jpeg2000_flush(s); @@ -1788,7 +1990,7 @@ static int decode_cblk(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *cod Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, int width, int height, int bandpos, uint8_t roi_shift) { - int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1 + roi_shift; + int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1; int pass_cnt = 0; int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC; int term_cnt = 0; @@ -2028,7 +2230,7 @@ static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile Jpeg2000Cblk *cblk = prec->cblk + cblkno; - if (codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F) + if (cblk->modes & JPEG2000_CTSY_HTJ2K_F) ret = ff_jpeg2000_decode_htj2k(s, codsty, &t1, cblk, cblk->coord[0][1] - cblk->coord[0][0], cblk->coord[1][1] - cblk->coord[1][0], diff --git a/libavcodec/jpeg2000htdec.c b/libavcodec/jpeg2000htdec.c index eba0936089..9b473e11d3 100644 --- a/libavcodec/jpeg2000htdec.c +++ b/libavcodec/jpeg2000htdec.c @@ -1032,25 +1032,31 @@ static void jpeg2000_calc_mbr(uint8_t *mbr, const uint16_t i, const uint16_t j, static void jpeg2000_process_stripes_block(StateVars *sig_prop, int i_s, int j_s, int width, int height, int stride, int pLSB, int32_t *sample_buf, uint8_t *block_states, - uint8_t *magref_segment, uint32_t magref_length) + uint8_t *magref_segment, uint32_t magref_length, + uint8_t is_causal) { for (int j = j_s; j < j_s + width; j++) { uint32_t mbr_info = 0; for (int i = i_s; i < i_s + height; i++) { - int modify_state, cond; + int modify_state; uint8_t bit; - uint8_t causal_cond = i != (i_s + height - 1); + uint8_t causal_cond = (is_causal == 0) || (i != (i_s + height - 1)); int32_t *sp = &sample_buf[j + (i * (stride))]; uint8_t mbr = 0; - if (jpeg2000_get_state(i, j, stride - 2, HT_SHIFT_SIGMA, block_states) == 0) + if (jpeg2000_get_state(i, j, stride, HT_SHIFT_SIGMA, block_states) == 0) jpeg2000_calc_mbr(&mbr, i, j, mbr_info & 0x1EF, causal_cond, block_states, stride); mbr_info >>= 3; - cond = mbr != 0; - bit = jpeg2000_peek_bit(sig_prop, magref_segment, magref_length); - *sp |= (bit * cond) << pLSB; - sig_prop->bits -= cond; - modify_state = (((1 << HT_SHIFT_REF_IND) | (1 << HT_SHIFT_REF)) * cond) | 1 << HT_SHIFT_SCAN; + + modify_state = block_states[(i + 1) * stride + (j + 1)]; + modify_state |= 1 << HT_SHIFT_SCAN; + if (mbr != 0) { + modify_state |= 1 << HT_SHIFT_REF_IND; + bit = jpeg2000_peek_bit(sig_prop, magref_segment, magref_length); + modify_state |= bit << HT_SHIFT_REF; + *sp |= bit << pLSB; + *sp |= bit << (pLSB - 1); // Add 0.5 (reconstruction parameter = 1/2) + } jpeg2000_modify_state(i, j, stride, modify_state, block_states); } } @@ -1074,6 +1080,7 @@ static void jpeg2000_decode_sigprop_segment(Jpeg2000Cblk *cblk, uint16_t width, int last_width; uint16_t i = 0, j = 0; + uint8_t is_causal = cblk->modes & JPEG2000_CBLK_VSC; jpeg2000_init_zero(&sp_dec); @@ -1082,14 +1089,14 @@ static void jpeg2000_decode_sigprop_segment(Jpeg2000Cblk *cblk, uint16_t width, for (int n2 = 0; n2 < num_h_stripe; n2++) { jpeg2000_process_stripes_block(&sp_dec, i, j, b_width, b_height, stride, pLSB, sample_buf, block_states, magref_segment, - magref_length); + magref_length, is_causal); j += 4; } last_width = width % 4; if (last_width) jpeg2000_process_stripes_block(&sp_dec, i, j, last_width, b_height, stride, pLSB, sample_buf, block_states, magref_segment, - magref_length); + magref_length, is_causal); i += 4; } @@ -1099,20 +1106,20 @@ static void jpeg2000_decode_sigprop_segment(Jpeg2000Cblk *cblk, uint16_t width, for (int n2 = 0; n2 < num_h_stripe; n2++) { jpeg2000_process_stripes_block(&sp_dec, i, j, b_width, b_height, stride, pLSB, sample_buf, block_states, magref_segment, - magref_length); + magref_length, is_causal); j += 4; } last_width = width % 4; if (last_width) jpeg2000_process_stripes_block(&sp_dec, i, j, last_width, b_height, stride, pLSB, sample_buf, block_states, magref_segment, - magref_length); + magref_length, is_causal); } /** * See procedure decodeSigPropMag at Rec. ITU-T T.814, 7.5. */ -static int +static void jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int stride, uint8_t *magref_segment,uint32_t magref_length, uint8_t pLSB, int32_t *sample_buf, uint8_t *block_states) @@ -1152,15 +1159,14 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int } } } - return 1; } int ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, - int width, int height, int magp, uint8_t roi_shift) + int width, int height, int M_b, uint8_t roi_shift) { - uint8_t p0 = 0; // Number of placeholder passes + uint8_t p0 = 0; // 3 * p0 = Number of placeholder passes uint32_t Lcup; // Length of HT cleanup segment uint32_t Lref; // Length of Refinement segment uint32_t Scup; // HT cleanup segment suffix length @@ -1174,7 +1180,7 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c int z_blk; // Number of ht coding pass - uint8_t empty_passes; + uint8_t num_plhd_passes; // Number of placeholder passes StateVars mag_sgn; // Magnitude and Sign StateVars mel; // Adaptive run-length coding @@ -1190,8 +1196,9 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c uint8_t *block_states = NULL; int32_t n, val; // Post-processing - - int32_t M_b = magp; + const uint32_t mask = UINT32_MAX >> (M_b + 1); // bit mask for ROI detection + + uint8_t num_rempass; const int quad_buf_width = width + 4; const int quad_buf_height = height + 4; @@ -1201,22 +1208,17 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c av_assert0(width * height <= 4096); av_assert0(width * height > 0); - if (roi_shift) - avpriv_report_missing_feature(s->avctx, "ROI shift"); - memset(t1->data, 0, t1->stride * height * sizeof(*t1->data)); memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags)); if (cblk->npasses == 0) return 0; - if (cblk->npasses > 3) - p0 = 0; - else if (cblk->length == 0) - p0 = 1; - - empty_passes = p0 * 3; - z_blk = cblk->npasses - empty_passes; + num_rempass = cblk->npasses % 3; // Number of remainder passes + num_plhd_passes = num_rempass ? cblk->npasses - num_rempass : cblk->npasses - 3; + av_assert0(num_plhd_passes % 3 == 0); + p0 = num_plhd_passes / 3; + z_blk = cblk->npasses - num_plhd_passes; if (z_blk <= 0) return 0; // No passes within this set, continue @@ -1232,6 +1234,7 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c Dcup = cblk->data; Dref = cblk->data + Lcup; // Dref comes after the refinement segment S_blk = p0 + cblk->zbp; + cblk->zbp = S_blk - 1; pLSB = 30 - S_blk; Scup = (Dcup[Lcup - 1] << 4) + (Dcup[Lcup - 2] & 0x0F); @@ -1277,31 +1280,32 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c goto free; } - if (cblk->npasses > 1) + if (z_blk > 1) jpeg2000_decode_sigprop_segment(cblk, width, height, quad_buf_width, Dref, Lref, pLSB - 1, sample_buf, block_states); - if (cblk->npasses > 2) { - - if (Lref < 2){ - av_log(s->avctx,AV_LOG_ERROR,"Invalid magnitude refinement length\n"); - ret = AVERROR_INVALIDDATA; - goto free; - } - if ((ret = jpeg2000_decode_magref_segment(width, height, quad_buf_width, Dref, Lref, - pLSB - 1, sample_buf, block_states)) < 0) - goto free; - } + if (z_blk > 2) + jpeg2000_decode_magref_segment(width, height, quad_buf_width, Dref, Lref, + pLSB - 1, sample_buf, block_states); pLSB = 31 - M_b; /* Reconstruct the sample values */ for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { + int32_t sign; + n = x + (y * t1->stride); val = sample_buf[x + (y * quad_buf_width)]; + sign = val & INT32_MIN; + val &= INT32_MAX; + /* ROI shift, if necessary */ + if (roi_shift && (((uint32_t)val & ~mask) == 0)) + val <<= roi_shift; /* Convert sign-magnitude to two's complement. */ - val = val >> 31 ? 0x80000000 - val : val; + if (sign) + val = -val; + /* Shift down to 1 bit upper from decimal point for reconstruction value (= 0.5) */ val >>= (pLSB - 1); t1->data[n] = val; } From patchwork Sun Aug 4 05:27:06 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Osamu Watanabe X-Patchwork-Id: 50885 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:612c:1f5a:b0:489:2eb3:e4c4 with SMTP id jm26csp749827vqb; Sat, 3 Aug 2024 22:27:53 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCUFn1D4WBv6EB2g4zR1s7pwP7cf+A9J6Y9LFBl5fADMQypyntUcz/Yzf3Yo/HqL1VEk158va/rvkuy9L4ECyxiLZVyL/KEjyictKw== X-Google-Smtp-Source: AGHT+IHD3mn7msAUkcEsBEm/4CpLS5M6/bTFLa7rbu0XD1UpbhgwTbXeviEsVHJcAdqdw3KuN1Hc X-Received: by 2002:a17:906:6a08:b0:a7a:a7b8:ada6 with SMTP id a640c23a62f3a-a7dc4ffa91dmr642325566b.39.1722749273188; Sat, 03 Aug 2024 22:27:53 -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 a640c23a62f3a-a7dc9c2777csi293447866b.273.2024.08.03.22.27.52; Sat, 03 Aug 2024 22:27:53 -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=@takushoku.onmicrosoft.com header.s=selector2-takushoku-onmicrosoft-com header.b=LrKsJZID; 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 Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 5012968D969; Sun, 4 Aug 2024 08:27:31 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from OS0P286CU011.outbound.protection.outlook.com (mail-japanwestazon11020088.outbound.protection.outlook.com [52.101.228.88]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 7961A68D664 for ; Sun, 4 Aug 2024 08:27:28 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=B/mTDP4QcwYU5oxo0QiNMKC5rI7Agf/mpbYSNBGgESbBYvKedZvTz2UedxUMUMxCzJfXgnzC9rry6R0xPB3XbCMAHBnVXu4ZOnpZx9+W5al7FvHjiyPIFX+upSTzBj4p+Pftzoi33AROoWtXdm2yq0tNSrrAGr2J+8ESCRFPR2SEOyTFlYBkHIEfmYDZh/WuoInF5LN7c2Kmg2E0gW0QXBZwjk1+UaikgPGb+NvNykAm4J61n6ibHJ/eC5Nl1IPGnFgr9zAMLvp8hf/VDHIE4B0aAG6GxfoLbJrCxAXB0SsOQXE+PESlRK37LdOthOFZZsY3lnnIpLq0BM4XU0Ptjw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; 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=pToajkh6llkNQsvoEWPt8lUemZbkHS+6w3nHwA0gbe4=; b=l/+tj21hpF0vz1ClvZmDT9uVP2a5oyQMEN81oX9/DBIrw6BIp0glWhaxI3HVHd6ReWgF+NVncXaYd1jhO6HhFQNyW6/GYwi7H3kBaKrRwPIjCmrAKKOxrGerU+FEO+eCKRl95cLg8sY6jCRbWen4mE0A2pafo5dttCpfj+9EFTSIGVjFdVCapd6DqmpnXXXakbJqQo+8vUvuBl9w9VS9Osk8nw/96DrrRSp7AcOFfs2KhAPzRnsRYOYHLNcC+JBukMek8HxuxRFD+tOqKkX3VkK+jDy43e4vMeRJxNVsZZzgbYlJHjnHX5Ty4BtYK5a0GKyrmX1IFL5XX/MegIsWdA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=es.takushoku-u.ac.jp; dmarc=pass action=none header.from=es.takushoku-u.ac.jp; dkim=pass header.d=es.takushoku-u.ac.jp; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=takushoku.onmicrosoft.com; s=selector2-takushoku-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=pToajkh6llkNQsvoEWPt8lUemZbkHS+6w3nHwA0gbe4=; b=LrKsJZIDSp/xtirBlikV+cQIwEZtT450KzsGFke9cMZijHipBtwtj6KDdZyCtFSsq0O4nURy6nqY2/ls0gMQgqAYINzYQjzdTs8wVTitfNX6hsr1nsD/nMREt5P8kr05+B+yYZWgWCS5eJBBD+IKbyM9yVtTrmaXd8IuJ2dBmiU= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=es.takushoku-u.ac.jp; Received: from OS0PR01MB6001.jpnprd01.prod.outlook.com (2603:1096:604:b7::12) by TY3PR01MB11348.jpnprd01.prod.outlook.com (2603:1096:400:3d0::11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7828.22; Sun, 4 Aug 2024 05:27:13 +0000 Received: from OS0PR01MB6001.jpnprd01.prod.outlook.com ([fe80::181c:c1f4:9b58:f6cc]) by OS0PR01MB6001.jpnprd01.prod.outlook.com ([fe80::181c:c1f4:9b58:f6cc%3]) with mapi id 15.20.7828.023; Sun, 4 Aug 2024 05:27:13 +0000 From: Osamu Watanabe To: ffmpeg-devel@ffmpeg.org Date: Sun, 4 Aug 2024 14:27:06 +0900 Message-Id: <20240804052706.292107-3-owatanab@es.takushoku-u.ac.jp> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20240804052706.292107-1-owatanab@es.takushoku-u.ac.jp> References: <20240804052706.292107-1-owatanab@es.takushoku-u.ac.jp> X-ClientProxiedBy: TYCPR01CA0149.jpnprd01.prod.outlook.com (2603:1096:400:2b7::9) To OS0PR01MB6001.jpnprd01.prod.outlook.com (2603:1096:604:b7::12) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: OS0PR01MB6001:EE_|TY3PR01MB11348:EE_ X-MS-Office365-Filtering-Correlation-Id: e4bc84a4-90f8-4142-25d2-08dcb4461846 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; ARA:13230040|41320700013|366016|1800799024|376014|52116014|38350700014; X-Microsoft-Antispam-Message-Info: dAcHUzJIhnytLGPfb5ocT5GZHUDafaaS0/p3RxEGX/lMULeEMFj/oA1+p1Fbw0tXz3AcFY/jipNiFpMcICF3l6TfCuvIomQQ6dDw699x2pdN5kID+KXpQjKraiAmkXKyEws+lfT3usMjv1vMLjYKWC/+ZxmUu/+uqZcYRPodwzBVPG53wcDNjj0pIEVJdtg0iCGRj6J7YTqFLPfYw8VAbn3YmuxOm8ox5YT/UiioKFTRmMBv3qeXC/+0kjQJ7DnkM86PbE1mRoPQaBeWCQ7yVhyFyGVdQ9Ps+cjajts2xHGosLMpIuQDnP7iI2tF7TC1bTT3ina3U2Qq6s4q07DdIC/sMIf0vjgCncB0yMDlK7EGDqMgeHxwcRFEPoUBUEmhXRCBmp0OScxBqX8Ff4RmC6gGRHagYIxsqtlyNeQ+wMvWX5n7YT5vvv2ZXsUK9FokCOfsqTFWLpvn9sqIRGxK9pJdyx7oTnufsnkYHzL9/efPHpx1kMs1bW4S7iBW3XNeThgfaYWrjeiBOALhrEohqfHoH/qpwE4/zJnH6ahFWvyjfrMIWh3AUJHwb6ysdiC4mdxYnIpkkcLfmp+MtIPEdC3eJk7uKnaB71xhJjNdALNQ7fGDf9dPmp9hRNtfnvIEOto7sl0Idm5aCrp3Zz7G788HRj6A4tfaLraevW2v9SqrYDh92FiLblAIyglURcPyfWKWQBk0zvAtuUKtY9BcIZ1zwU2Aik4vHXHOh7GH2WmnkSik0SEycdalGRd/vVVDEaaggdfzsipZWrRMrvWi8cLDRd5KkkrZoTfxcXvjvYNIrwyyjg5miW9gNSJ5nxvNFzHzPqcPF9OthX3imhDXiJshXzT8EhzzPufOzwCEl5VZdxcaM0ETfcjD7vXuipb/EYX4exFt3jMyqtKR1VfTpuFUMNkDTC0WZEyIyEVKnvnX2lK/9GIyb/P93Re6TJmM9E9ub6/dvKkabYqJNsfChx72oB59k7MtrTWSA5txQgLj3a0pSL7O0XFt1C4I7jASq3oh9d8QJJhvwtA0CStzsHM3fR+6tbXq15GgbXLAf7bKKUj3HEmdtvgOA9KkjRPdNGpbNfJjk4QBK32ZMPKSPnaGRzbVDlB+7RJYwKv/VFrzFt2mlTPDFLVrE3+u76QW+5cUrFVYgpgKbqhQMCsbs4fK5u1yuFdlndxi4ZMyQ9AXwZ3rqTjmg8T/ykryXyrqUtNKNJzATYf/9tH8szy5wXgQc3j1DxIlHlrX0ll5a/LwOJAfzGgzoR2fyiqmUqkVmEii78WgYuIedcvQJMkyH1IPWAb9BMcrvtlK9KqnibHs4i80fYpqLNk95tP/lDck4UMfcH/OkmmqayW2Eqjo/6GYTyU5ekp7Z08ooAiq1RojvvDBS7elA6RQTgJCp45EVl+1gT06GT4g2qb5INbDdg== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:OS0PR01MB6001.jpnprd01.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230040)(41320700013)(366016)(1800799024)(376014)(52116014)(38350700014); DIR:OUT; SFP:1102; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: 3P74jG5ziQ6Jz+dqeBEkJ42I5ENZdYP82oq48Dx8VKsX6dRqvYtx3NJ13nN5xDVtDLXi7vXlZ5YVtZw8Z5LinqpxBzpgvrKYZksQCOX/xNVnvcQUYYxfDLcjz+WxqZp0Mbl5srRye0QwHqnRCe/3P9KMkEDbuX4kO6iPA6aT/qzwPTmIXe8ObKlYqhrQZ7rAbVydNHKAZP3poGG7pqJvxWKXHW+mdSW8F/xYBer02vXlWnlPANW/+wlN5nhbsppEbB4Ui1SIsGf1Ydmpq7ONbFUXFEZHI7MS7CeSUfbZ8oz0QW6T/zOgPifL2KFh08GAFKhNNPJc4d7W6qDxepZt2LJ7nfXItZqpKInA5h2957jmxyI3aMGlcXk94iAxm4hlYhYXj9GpO94RZf83OEVg7pl2xP9w974kgLTnWG8B/HX8PspPNBJG3E0wKpVtLElgRiN/hlctEtBv0TuLpRYCcCh3YDZDAiSW5rs1cDlaoes6eTKvfTOTfgVnmGaBSigRRW4nHWXfKgFubGAWgYnaw3zzH0y8ZVuLzz/tPmlVB6MtVGQVk/V8mys8i/CuHuyeht4VSDynFoNRGvnPFdLJnOueHgpD4BC2woaaACXp22mb/BVh3fgtf36kYqOvGgbfdpQuCJAh9ishfjOmnmC9gGiu4sFcMEmIQfLBPpcB9obpIXXFZXs47b7JpxzOXqy7jX/xXf8stlqeqNFoigbuAPbiC1CmOAou+2s2NiyjqedewWvCqvAqgsyrat4R2dfGlai1DNBAAGrzyiBIU0I5uOxt+JD2JKUQyjl4VRgDO05xFXsc7BgsNJoKWAwLtjAH4j0QcMu03UiWOYwg/5O0Mm5nbVh6EseciPabGA13PqFxBkxu9LK5cWoXl3e2ln9Z0DKHN41Nhcx2iNYrhNOIjFW2Iexx1nNxzHdsSXx3N1+Ncu0HwAkJMfQpBYwSc1/yrNQUELwc4r0L3OHrqXX47WfZUFxpQQupPzaYIXfOn2a7W8Jxzn/t/sa6OkVMFBJUnIWCAV7xruIRkeV7y/WHj8G5zGfULDr77+4D5mD269IUtqJHnnyPFL5Lohf2x3KkuIgnwx/am3OW9jMNNRUkQ2S4TJsTUEPEqs076SP1TGEZRTldKx6ZiXsMjU5laVIdgitJ7yt1rRpgjolD8+Djw5t2LfQLjDQWYqePZjFg+8q3fYIjNJ1GtMNan2dP7AQ9psV73rc8Ii8SZ38Gwk0GPu+VjggF8o07Aln6qVI57AXpYv0Be3YRQzirgjQwObi0PKfaZ7/dgRFag6Qb2uZak7cA1jl1XKC9tuOyPVj+HkVf7P27AmJ5fM/s0uFh6XB6cf6XLCjbZ7ZSwKxjDUbC+PvWye5EphnMlSeRFwfly/8SuszrT6tuc6o+Yk5Brh8UT2dRTavg18aF2h5LRXBzQd95jiSg8Etu+voZdn2CwzGQw1vM6KKRbErOV1WUnDmzPMBuMeoXEbCE88IBnhGued3rpwRqOm/ml9KqvbbzCS9rhbYUL5+U5aQTMRrk0dYZjWVD4V7MFu/bpzJWblnQ2vITAe2gcu5npA7TpU0qgxtbz92phoobSqJl3MkphkUjne6Fxx9mqe5JecNzdgKBAw== X-OriginatorOrg: es.takushoku-u.ac.jp X-MS-Exchange-CrossTenant-Network-Message-Id: e4bc84a4-90f8-4142-25d2-08dcb4461846 X-MS-Exchange-CrossTenant-AuthSource: OS0PR01MB6001.jpnprd01.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 Aug 2024 05:27:13.8461 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 853333e5-13b1-4738-ae04-bfb589cf2665 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: QnSybbjVfOwpzHNOWiUIwxeOIC4Ud7bkVmmZ+1jflN/g7Y5djBnbO8sE1+y+UX/Ao8EUqF0SKBSJaDg6fTc55zmHok7Cl032d32Klc9guJU= X-MS-Exchange-Transport-CrossTenantHeadersStamped: TY3PR01MB11348 Subject: [FFmpeg-devel] [PATCH v7 3/3] avcodec/jpeg2000dec: Fix HT decoding 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: Osamu Watanabe , pal@sandflow.com Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: YALAIDvftST0 This commit fixes wrong treatment of MAGBP value in Ccap15 and bugs in HT block decoding. Signed-off-by: Osamu Watanabe --- libavcodec/jpeg2000dec.c | 11 +-- libavcodec/jpeg2000htdec.c | 136 ++++++++++++++++++++++--------------- libavcodec/jpeg2000htdec.h | 2 +- 3 files changed, 89 insertions(+), 60 deletions(-) diff --git a/libavcodec/jpeg2000dec.c b/libavcodec/jpeg2000dec.c index c8759b6d51..fe6b542110 100644 --- a/libavcodec/jpeg2000dec.c +++ b/libavcodec/jpeg2000dec.c @@ -391,6 +391,9 @@ static int get_siz(Jpeg2000DecoderContext *s) } else if (ncomponents == 1 && s->precision == 8) { s->avctx->pix_fmt = AV_PIX_FMT_GRAY8; i = 0; + } else if (ncomponents == 1 && s->precision == 12) { + s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE; + i = 0; } } @@ -2204,7 +2207,7 @@ static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile Jpeg2000Band *band = rlevel->band + bandno; int cblkno = 0, bandpos; /* See Rec. ITU-T T.800, Equation E-2 */ - int magp = quantsty->expn[subbandno] + quantsty->nguardbits - 1; + int M_b = quantsty->expn[subbandno] + quantsty->nguardbits - 1; bandpos = bandno + (reslevelno > 0); @@ -2212,8 +2215,8 @@ static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile band->coord[1][0] == band->coord[1][1]) continue; - if ((codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F) && magp >= 31) { - avpriv_request_sample(s->avctx, "JPEG2000_CTSY_HTJ2K_F and magp >= 31"); + if ((codsty->cblk_style & JPEG2000_CTSY_HTJ2K_F) && M_b >= 31) { + avpriv_request_sample(s->avctx, "JPEG2000_CTSY_HTJ2K_F and M_b >= 31"); return AVERROR_PATCHWELCOME; } @@ -2234,7 +2237,7 @@ static inline int tile_codeblocks(const Jpeg2000DecoderContext *s, Jpeg2000Tile ret = ff_jpeg2000_decode_htj2k(s, codsty, &t1, cblk, cblk->coord[0][1] - cblk->coord[0][0], cblk->coord[1][1] - cblk->coord[1][0], - magp, comp->roi_shift); + M_b, comp->roi_shift); else ret = decode_cblk(s, codsty, &t1, cblk, cblk->coord[0][1] - cblk->coord[0][0], diff --git a/libavcodec/jpeg2000htdec.c b/libavcodec/jpeg2000htdec.c index 9b473e11d3..0296792a6a 100644 --- a/libavcodec/jpeg2000htdec.c +++ b/libavcodec/jpeg2000htdec.c @@ -122,7 +122,7 @@ static void jpeg2000_init_mel(StateVars *s, uint32_t Pcup) static void jpeg2000_init_mag_ref(StateVars *s, uint32_t Lref) { - s->pos = Lref - 2; + s->pos = Lref - 1; s->bits = 0; s->last = 0xFF; s->tmp = 0; @@ -145,9 +145,10 @@ static void jpeg2000_init_mel_decoder(MelDecoderState *mel_state) static int jpeg2000_bitbuf_refill_backwards(StateVars *buffer, const uint8_t *array) { uint64_t tmp = 0; - int32_t position = buffer->pos - 4; uint32_t new_bits = 32; + buffer->last = array[buffer->pos + 1]; + if (buffer->bits_left >= 32) return 0; // enough data, no need to pull in more bits @@ -157,9 +158,24 @@ static int jpeg2000_bitbuf_refill_backwards(StateVars *buffer, const uint8_t *ar * the bottom most bits. */ - for(int i = FFMAX(0, position + 1); i <= buffer->pos + 1; i++) - tmp = 256*tmp + array[i]; - + if (buffer->pos >= 3) { // Common case; we have at least 4 bytes available + tmp = array[buffer->pos - 3]; + tmp = (tmp << 8) | array[buffer->pos - 2]; + tmp = (tmp << 8) | array[buffer->pos - 1]; + tmp = (tmp << 8) | array[buffer->pos]; + tmp = (tmp << 8) | buffer->last; // For stuffing bit detection + buffer->pos -= 4; + } else { + if (buffer->pos >= 2) + tmp = array[buffer->pos - 2]; + if (buffer->pos >= 1) + tmp = (tmp << 8) | array[buffer->pos - 1]; + if (buffer->pos >= 0) + tmp = (tmp << 8) | array[buffer->pos]; + buffer->pos = 0; + tmp = (tmp << 8) | buffer->last; // For stuffing bit detection + } + // Now remove any stuffing bits, shifting things down as we go if ((tmp & 0x7FFF000000) > 0x7F8F000000) { tmp &= 0x7FFFFFFFFF; new_bits--; @@ -176,13 +192,11 @@ static int jpeg2000_bitbuf_refill_backwards(StateVars *buffer, const uint8_t *ar tmp = (tmp & 0x0000007FFF) + ((tmp & 0xFFFFFF0000) >> 1); new_bits--; } - - tmp >>= 8; // Remove temporary byte loaded + tmp >>= 8; // Shifts away the extra byte we imported /* Add bits to the MSB of the bit buffer */ buffer->bit_buf |= tmp << buffer->bits_left; buffer->bits_left += new_bits; - buffer->pos = FFMAX(0, position); return 0; } @@ -406,6 +420,7 @@ static void recover_mag_sgn(StateVars *mag_sgn, uint8_t pos, uint16_t q, int32_t E[n] = 32 - ff_clz(v[pos][i] | 1); mu_n[n] = (v[pos][i] >> 1) + 1; mu_n[n] <<= pLSB; + mu_n[n] |= (1 << (pLSB - 1)); // Add 0.5 (reconstruction parameter = 1/2) mu_n[n] |= ((uint32_t) (v[pos][i] & 1)) << 31; // sign bit. } } @@ -414,7 +429,7 @@ static void recover_mag_sgn(StateVars *mag_sgn, uint8_t pos, uint16_t q, int32_t static int jpeg2000_import_bit(StateVars *stream, const uint8_t *array, uint32_t length) { int cond = stream->pos < length; - int pos = FFMIN(stream->pos, length); + int pos = FFMIN(stream->pos, length - 1); if (stream->bits == 0) { stream->bits = (stream->tmp == 0xFF) ? 7 : 8; stream->pos += cond; @@ -426,14 +441,22 @@ static int jpeg2000_import_bit(StateVars *stream, const uint8_t *array, uint32_t static int jpeg2000_peek_bit(StateVars *stream, const uint8_t *array, uint32_t length) { + uint8_t bit; + if (stream->bits == 0) { - int cond = stream->pos < length; - int pos = FFMIN(stream->pos, length); - stream->bits = (stream->tmp == 0xFF) ? 7 : 8; - stream->pos += cond; - stream->tmp = cond ? array[pos] : 0xFF; + stream->bits = (stream->last == 0xFF) ? 7 : 8; + if (stream->pos < length) { + stream->tmp = array[stream->pos]; + stream->pos++; + } else { + stream->tmp = 0; + } + stream->last = stream->tmp; } - return (stream->tmp >> stream->bits) & 1; + bit = stream->tmp & 1; + stream->tmp >>= 1; + stream->bits--; + return bit; } static int jpeg2000_decode_mel_sym(MelDecoderState *mel_state, @@ -994,39 +1017,18 @@ static void jpeg2000_calc_mbr(uint8_t *mbr, const uint16_t i, const uint16_t j, const uint32_t mbr_info, uint8_t causal_cond, uint8_t *block_states, int stride) { - int local_mbr = 0; - - local_mbr |= jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_SIGMA, block_states); - local_mbr |= jpeg2000_get_state(i - 1, j + 0, stride, HT_SHIFT_SIGMA, block_states); - local_mbr |= jpeg2000_get_state(i - 1, j + 1, stride, HT_SHIFT_SIGMA, block_states); - - local_mbr |= jpeg2000_get_state(i + 0, j - 1, stride, HT_SHIFT_SIGMA, block_states); - local_mbr |= jpeg2000_get_state(i + 0, j + 1, stride, HT_SHIFT_SIGMA, block_states); - - local_mbr |= jpeg2000_get_state(i + 1, j - 1, stride, HT_SHIFT_SIGMA, block_states) * causal_cond; - local_mbr |= jpeg2000_get_state(i + 1, j + 0, stride, HT_SHIFT_SIGMA, block_states) * causal_cond; - local_mbr |= jpeg2000_get_state(i + 1, j + 1, stride, HT_SHIFT_SIGMA, block_states) * causal_cond; - - local_mbr |= jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_SCAN, block_states); - local_mbr |= jpeg2000_get_state(i - 1, j + 0, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i - 1, j - 1, stride, HT_SHIFT_SCAN, block_states); - local_mbr |= jpeg2000_get_state(i - 1, j + 1, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i - 1, j + 1, stride, HT_SHIFT_SCAN, block_states); - - local_mbr |= jpeg2000_get_state(i + 0, j - 1, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i + 0, j - 1, stride, HT_SHIFT_SCAN, block_states); - local_mbr |= jpeg2000_get_state(i + 0, j + 1, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i + 0, j + 1, stride, HT_SHIFT_SCAN, block_states); - - local_mbr |= jpeg2000_get_state(i + 1, j - 1, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i + 1, j - 1, stride, HT_SHIFT_SCAN, block_states) * causal_cond; - local_mbr |= jpeg2000_get_state(i + 1, j + 0, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i + 1, j + 0, stride, HT_SHIFT_SCAN, block_states) * causal_cond; - local_mbr |= jpeg2000_get_state(i + 1, j + 1, stride, HT_SHIFT_REF, block_states) * - jpeg2000_get_state(i + 1, j + 1, stride, HT_SHIFT_SCAN, block_states) * causal_cond; - - *mbr |= local_mbr; + uint8_t *state_p0 = block_states + i * stride + j; + uint8_t *state_p1 = block_states + (i + 1) * stride + j; + uint8_t *state_p2 = block_states + (i + 2) * stride + j; + + uint8_t mbr0 = state_p0[0] | state_p0[1] | state_p0[2]; + uint8_t mbr1 = state_p1[0] | state_p1[2]; + uint8_t mbr2 = state_p2[0] | state_p2[1] | state_p2[2]; + *mbr = mbr0 | mbr1 | (mbr2 & causal_cond); + *mbr |= (mbr0 >> HT_SHIFT_REF) & (mbr0 >> HT_SHIFT_SCAN); + *mbr |= (mbr1 >> HT_SHIFT_REF) & (mbr1 >> HT_SHIFT_SCAN); + *mbr |= (mbr2 >> HT_SHIFT_REF) & (mbr2 >> HT_SHIFT_SCAN) & causal_cond; + *mbr &= 1; } static void jpeg2000_process_stripes_block(StateVars *sig_prop, int i_s, int j_s, @@ -1060,6 +1062,18 @@ static void jpeg2000_process_stripes_block(StateVars *sig_prop, int i_s, int j_s jpeg2000_modify_state(i, j, stride, modify_state, block_states); } } + // decode sign + for (int j = j_s; j < j_s + width; j++) { + for (int i = i_s; i < i_s + height; i++) { + uint8_t bit; + int32_t *sp = &sample_buf[j + (i * (stride))]; + uint8_t *state_p = block_states + (i + 1) * stride + (j + 1); + if ((state_p[0] >> HT_SHIFT_REF) & 1) { + bit = jpeg2000_peek_bit(sig_prop, magref_segment, magref_length); + *sp |= (int32_t)bit << 31; + } + } + } } /** @@ -1130,7 +1144,8 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int uint16_t height = 4; uint16_t i_start = 0; int32_t *sp; - + int32_t bit; + int32_t tmp; jpeg2000_init_mag_ref(&mag_ref, magref_length); for (int n1 = 0; n1 < num_v_stripe; n1++) { @@ -1141,9 +1156,13 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int * Rec. ITU-T T.814, Figure 7. */ sp = &sample_buf[j + i * stride]; - if (jpeg2000_get_state(i, j, width, HT_SHIFT_SIGMA, block_states) != 0) { - jpeg2000_modify_state(i, j, width, 1 << HT_SHIFT_REF_IND, block_states); - *sp |= jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length) << pLSB; + if (jpeg2000_get_state(i, j, stride, HT_SHIFT_SIGMA, block_states) != 0) { + jpeg2000_modify_state(i, j, stride, 1 << HT_SHIFT_REF_IND, block_states); + bit = jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length); + tmp = 0xFFFFFFFE | (uint32_t)bit; + tmp <<= pLSB; + sp[0] &= tmp; + sp[0] |= 1 << (pLSB - 1); // Add 0.5 (reconstruction parameter = 1/2) } } } @@ -1153,9 +1172,13 @@ jpeg2000_decode_magref_segment( uint16_t width, uint16_t block_height, const int for (int j = 0; j < width; j++) { for (int i = i_start; i < i_start + height; i++) { sp = &sample_buf[j + i * stride]; - if (jpeg2000_get_state(i, j, width, HT_SHIFT_SIGMA, block_states) != 0) { - jpeg2000_modify_state(i, j, width, 1 << HT_SHIFT_REF_IND, block_states); - *sp |= jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length) << pLSB; + if (jpeg2000_get_state(i, j, stride, HT_SHIFT_SIGMA, block_states) != 0) { + jpeg2000_modify_state(i, j, stride, 1 << HT_SHIFT_REF_IND, block_states); + bit = jpeg2000_import_magref_bit(&mag_ref, magref_segment, magref_length); + tmp = 0xFFFFFFFE | (uint32_t)bit; + tmp <<= pLSB; + sp[0] &= tmp; + sp[0] |= 1 << (pLSB - 1); // Add 0.5 (reconstruction parameter = 1/2) } } } @@ -1233,6 +1256,9 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c } Dcup = cblk->data; Dref = cblk->data + Lcup; // Dref comes after the refinement segment + + cblk->data[cblk->length] = 0xFF; // an extra byte for refinement segment (buffer->last) + S_blk = p0 + cblk->zbp; cblk->zbp = S_blk - 1; pLSB = 30 - S_blk; diff --git a/libavcodec/jpeg2000htdec.h b/libavcodec/jpeg2000htdec.h index 572d095c92..8d6919a0de 100644 --- a/libavcodec/jpeg2000htdec.h +++ b/libavcodec/jpeg2000htdec.h @@ -29,6 +29,6 @@ int ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, int width, - int height, int magp, uint8_t roi_shift); + int height, int M_b, uint8_t roi_shift); #endif /* AVCODEC_JPEG2000HTDEC_H */