From patchwork Mon Jun 24 06:19:46 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Osamu Watanabe X-Patchwork-Id: 50111 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a59:ae71:0:b0:482:c625:d099 with SMTP id w17csp1811866vqz; Sun, 23 Jun 2024 23:20:32 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCV7iy3/vPkjCuD01ZGIpwryoklQ733LtUwTbbyGWf1trgwBWnr0HqKBBeok3ifrn7RroKdM/nyFHEXz5P4opeWliqFqLkIN8D/5DQ== X-Google-Smtp-Source: AGHT+IHh+U94sxDA9I7WnZ2gETJjOW4s4iTkz1W/QGZrlG2IpXeCJyiBTVtBNBRiMZkKnNELUwSn X-Received: by 2002:a17:907:104b:b0:a72:554d:82af with SMTP id a640c23a62f3a-a72554d8570mr110518466b.20.1719210031980; Sun, 23 Jun 2024 23:20: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-a704215405esi209492366b.180.2024.06.23.23.20.31; Sun, 23 Jun 2024 23:20:31 -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=SM50ic6x; 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 F10BA68D410; Mon, 24 Jun 2024 09:20:28 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from JPN01-TYC-obe.outbound.protection.outlook.com (mail-tycjpn01on2102.outbound.protection.outlook.com [40.107.114.102]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id E9C6D68D410 for ; Mon, 24 Jun 2024 09:20:21 +0300 (EEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=gLCmvRuXYyqJNzy52b55QzreNsIGWQEHnlJ3VYRodtsQFTUtOj6h4RENUz3iUIiRAoEz3MjC6LJCVqLY+MbjgwVhhzXlX4u+/F68HOree3cBe2QMRAsjSIWcAaxLdLPLrXgf4n4jjMjnuFU9rKjEqsWiTbdZeFHIhs5zSo9zPap7GvJo/d2MCqBMfSj+kn4gDIBUgQ+Hwb1g+jG+r9Z4yryQADXkP/XurXWbw1D0Ds7qZ770QTKWFam/DsgudajnKnbEPMw9j6svwzLvT5SJ2k1rWBytIn6jJvQFPA5Xg4eComfKipMBMB+Nx2VNmpfuzc4T6zNOCFdenOivARTQzA== 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=AfWh1XxUgcd2IU3tZTiCzTDTHya95jY3yjyC4YQSmU0=; b=JuLRJ9inQctacqhHcbEuqyliupfKN65Hqv7GbhY8/FdWSAEvKAqbnDrbPq1ICsy1ZZPUGlcESVWMxmbz3oE+emg7p+VS9ZW7N9CBHAuXCSQMTP5aJshlpj5ovmoNFIUY8s09pEys0YmzJPfMD6CAqA+oibLgCRrTVtvqy+U/srg6qs50KDKwTT6OcemRlIqmNiSE1Tvl6aFeR8IZrb+BQfUh1dbNe+0kY6dHLCJoONvKyUQqhGfecSOF+qaUYlLXk0WdgTThuOkvJImw1PcF9Az4E28wbhORPEUSx5dLsaTEdRm51wA/Tf7DrpTxchR2IUf5PxMK0H86nmcEGj89lA== 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=AfWh1XxUgcd2IU3tZTiCzTDTHya95jY3yjyC4YQSmU0=; b=SM50ic6xlaUivVZ7XaoTfiLdn9hKAoeKXnW5TiHN/pVmne1UcgVuMLNVhgaUXDSNiZsD8ADGi2RqKJJy9SyIIty58P+B2T3QaneyS3EklFGIvQMNTNokY39ZqRooXzb5F5SHG71M2aBWnL89Z8SJh/YY8tHp+/1JrNcCszB8ijQ= 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 OS3PR01MB9317.jpnprd01.prod.outlook.com (2603:1096:604:1c7::11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7698.28; Mon, 24 Jun 2024 06:20:17 +0000 Received: from OS0PR01MB6001.jpnprd01.prod.outlook.com ([fe80::181c:c1f4:9b58:f6cc]) by OS0PR01MB6001.jpnprd01.prod.outlook.com ([fe80::181c:c1f4:9b58:f6cc%6]) with mapi id 15.20.7698.025; Mon, 24 Jun 2024 06:20:17 +0000 From: Osamu Watanabe To: ffmpeg-devel@ffmpeg.org Date: Mon, 24 Jun 2024 15:19:46 +0900 Message-Id: <20240624061947.1354109-2-owatanab@es.takushoku-u.ac.jp> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20240624061947.1354109-1-owatanab@es.takushoku-u.ac.jp> References: <20240624061947.1354109-1-owatanab@es.takushoku-u.ac.jp> X-ClientProxiedBy: TYCPR01CA0111.jpnprd01.prod.outlook.com (2603:1096:405:4::27) To OS0PR01MB6001.jpnprd01.prod.outlook.com (2603:1096:604:b7::12) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: OS0PR01MB6001:EE_|OS3PR01MB9317:EE_ X-MS-Office365-Filtering-Correlation-Id: 5b62d361-240d-4db0-b58a-08dc9415b6dc X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; ARA:13230037|376011|41320700010|366013|52116011|1800799021|38350700011; X-Microsoft-Antispam-Message-Info: WH/yGZ4AN3sPaurvMhASDr9NMwBHVfvwj9bLuyicLI1tzLaaMtNt+wvH5YbaUm89GJGC2SzM9GytlHwPhBJYoxC/dkZrTkx7h7WsPqJPf8O3cvntNX2Awu3H/leDNNlCfuzwzYF7CK+ZEL+Ygn7PCSun6ImxgQ1KZYpT0YCb0OyVobeE48Dl22RET3MSe1GfKGkbOB+OF0H49IDwcCsOKzAkDSxQpwYjiRuuXxIIlvgx0iO21VYvYYphVz6NaCAaEKzO+U246AxxqHlJndwI+gdT4mYz2pPXCFoaLSp9ECWUmNB8LSnPkKoM8EyPRZFObd5FeH9ZK9VOcN7Lm2QYP5+HYvf9L7QRFi69A2dbhwYm9jsArSijqaUoB2oG1EB0/enrXHP+UyYbTMNVMlU0a6ccgBGk6Dn4zWBjUSboQVf1D12QpCpNufh1tejmF4J1RzFmYN/cMjvLBM9YoxfheqRteKVqTqWULiz0dhlAs0eToVBQ9R6h2XDvGJRNMZs/Y6kUbyHXoyndyeD8aXa86oharFflxeKkBRvNIUYGrIrMij2siBePIk9A6i6GTSrw2qAiYZrPSHQ5cxkkyuZLhFUdBnyd7zY+J8aCxAqdOjeFKkW77R+RCBrMPovMOtMXANkk5Pa63Fn+Iyco0xxkaR2Qb9WRIID8oxSO8Dr3F9TRr1yDMQsjGeDH/S6+cmISqvCjxNl/uoDRbF35pSt8/su+EkhcLw0XkAZW8l1cvtVXUoixz+iObc9FKD7TAC3x4swtSyZyVSDQbbUd3wo1zjCOAQcx5y3uvjk6BkqSfBJ19eEOgFy9RtNx/YG7dkZKDvE/B5VFv78unXtQlWLy3i/eaF4TZG8Sf7JPR9z2rOPma7Nj5YGttNxPiHkGMD44xwvpvyq5kwogF9QKuchKPcKYS4I5xsW+GmI2TnFdvpV7kEre/WmrD+KkUIlKuDzV9qbT9frzw2SaeS6pBI0TrysG97vzW0n/f9sgRO/p1AQQQNVGfZP+j7TbjVPfh3/ObiDiWO711u1j+RUxNv1yq2LIrK2j30HeBGobhOhZ0mg8BQ69qPpumlDHmMtjQ9yyDV79d3SCLp0aIhz6wFDbbTYGdYCmdiBCz7gY2RSfmKNi/NcOD80/H38Nhr6AB5B1/8hv3aTkHxo5kgqbFbpauoS3W3NB3jRhyr4NpHIyf0cgUz7R7jjtW2o1/ACsCFOHae440vjvAfBFkh8fqgGuXW6JprFVSi7AEKOg4Q7uDhS9etZfqEaGb3gEOvkezmZW1rb85C2pgDDHJw/0HRMg3nPEycljKGEhjabLCZVz9efZOMXapfM4ndbDjiuB3iW6ik57MiNCb7+BfBGBaj3fOHbwKPVgh2dbRsqf0TImQ2E= 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:(13230037)(376011)(41320700010)(366013)(52116011)(1800799021)(38350700011); DIR:OUT; SFP:1102; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: na9Fn/nxh/PdYRjJyoRn8UZWvxgEj9OIAXMpyaXyxHlXbzqfa38Xkynb2VoHu5Iv4MgPMMgV+DJnAioWM8ImYhdJuSbHNRzmTXh7A2PPNu8hsPv7w7JnYpGT5EPDcGZNQpMIyNN1+y6zirGpVLoDS/g761nKkOsJd15IY9JfPen/xSMo2THKA63N6rsOywuX4+F8UjBdLm/WIjPxB6qlhPZT8GM0RgDgrn/rYW/vzkYxg+5Bbf5U5FG3A8vJP3FXW6/y1UAAqr9ejs0oIlzjCHrjymPDQ5PXWi4b9qpcxi8dsyUd2RFhe45N5HjRC4khyizy4KyBwrzQltb2kC/1tlgTTxNi981nFkK3Tkmci/bVb34FoICigbFbdIUex4CB6xGHKp3R0LAZ6OhKFFCt2ARyRHCncCyaTpb4cyLu0BEa1t6mXz6ghOEeZ2nKtpzfGb8rGn+aGjREeo0igX3OlhwrRchCINtzTaTzh6w8Rvmxl0uUpIMQyBWdhgThQ9fRKz/Bu3TrEn7rOeAgHZnzyW7XYHS9oCbZh3z8oOUVY4IFWQlJqQpTNVxU4QUy3g1yjf3M5O1FtmkAGM8+EdC42YmUnu4G+Yx3wQeVJ4UD8NRIK63VIBagt7Tg5PfdLlkFqNXxjsOqQ0jUgXz2u3xs35e6ZcXPOsRYFANJg9TnOo9Zll63VYMIov77QswauRN0yh45Dn567qBucpYnNiicHTg9B0fs974JS12PCCWD9xPbP1f7VTU9tQUlIN7jVy71k1Zo1/nRo3sNXJEN1We74j+piKlZ8sO1xUXTRsD89CePNWQTCL/efUKM2kt4HCz9kG4yGKs6a/ZcR55IrPofbdoJSAzRKFk7Lp+ki/y9xpwPPMpye3swl8W2McnIW0Ag0yMxwl5xYrRtSG+vVo1fibKJ8WgkFpA0pq2bZmoI72YYpwUaUJ+z1W4DEq17xsM7HJeFNbPrOPqoAcLcoRkhWYKX/FAjl87UiVKjteQdKD3D64Ejp/g/GmOKAZ+F78u86i2R2aAEJr3jWZmGEqIRxj9nJmiVVC/0tklvlTWR+cnxsKu5dcrCeaqk9spRSZuGGg+ffxFRXvzfMrMuvQfCuNC3vrzQGQYG7Dguc2I/jUGwRcKaSFZSMXE3SlwN1rQZRRalqHhTacapPgVkq0uYe6iVdraS7kufLvd4/DvjVvWu63c4vsvUIA3K6+CBwGJmnh2abWGvCBhI65tY+k6sLtgZ+K6v85E48omkXjIv9rEdrzHEXrCOVk13GuCOX/vxSaAH7TAlSDZ+s6u4J+r1Pp7rL8VW5JCZles8T8mrh6Zs/+CFmCoiN8RLI9CGeOqCPKJ1eA5e09Quf6vo3cjUgUvzSO2n2sxzxr68p1pFw3sp3V7yYlzoJFXn3J0g5/Kip5NS7lI35YA/kR13clgodKgYuH4SOpVrANIox9bKf/IfbovbwJPW53+1ud9eWIdSwOqlUh/u+7QcwUXwTig1nlyNnmtPpfXT3IyquImaSMmHefeY7vqs9ej8PcHGUTOndg/6jk6QNQn9cWe79PWUmBSXrus68bzkcV9B7ZYHh+LU6oUVYTVTH/qqvwSO6ZcyKfEgMttH90n0KTpnpxKhBA== X-OriginatorOrg: es.takushoku-u.ac.jp X-MS-Exchange-CrossTenant-Network-Message-Id: 5b62d361-240d-4db0-b58a-08dc9415b6dc X-MS-Exchange-CrossTenant-AuthSource: OS0PR01MB6001.jpnprd01.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 24 Jun 2024 06:20:17.3997 (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: /b+8c6OF9Z3flWYcVG3sNnf+3ycVdTIgLthVDbRg19kxBKJGyss3ARmd2F5th3jqlb17OekAUjSY4dUHZXP2YcA9Q5s2PzArhlSgzb3slus= X-MS-Exchange-Transport-CrossTenantHeadersStamped: OS3PR01MB9317 Subject: [FFmpeg-devel] [PATCH v3 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: mqCk/xpxSF1z This commit adds support for placeholder pass parsing Signed-off-by: Osamu Watanabe --- libavcodec/jpeg2000.h | 2 + libavcodec/jpeg2000dec.c | 292 +++++++++++++++++++++++++++++++------ libavcodec/jpeg2000htdec.c | 18 +-- 3 files changed, 257 insertions(+), 55 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 d1046661c4..60756db05c 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,30 +1169,44 @@ 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) { + if (incl) { int zbp = tag_tree_decode(s, prec->zerobits + cblkno, 100); - int v = expn[bandno] + numgbits - 1 - zbp; - + 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->zbp = zbp; + cblk->incl = 1; cblk->nonzerobits = v; + cblk->zbp = zbp; + cblk->lblock = 3; + } + } else { + incl = get_bits(s, 1); } - if ((newpasses = getnpasses(s)) < 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; - av_assert2(newpasses > 0); if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) { avpriv_request_sample(s->avctx, "Too many passes"); return AVERROR_PATCHWELCOME; @@ -1195,65 +1218,244 @@ static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, "Block with length beyond 16 bits"); return AVERROR_PATCHWELCOME; } - - 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)); + 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) { - newpasses1 ++; - if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) { - cblk->nb_terminationsinc ++; + 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); + } - 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]; + 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 { - if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0) - return ret; - cblk->pass_lengths[0] = ret; + 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 (ret > cblk->data_allocated) { - size_t new_size = FFMAX(2*cblk->data_allocated, ret); + // 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 { + 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; + } + } + + 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..d5bebe127b 100644 --- a/libavcodec/jpeg2000htdec.c +++ b/libavcodec/jpeg2000htdec.c @@ -1160,7 +1160,7 @@ int ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, int width, int height, int magp, 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 +1174,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 @@ -1191,7 +1191,7 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c int32_t n, val; // Post-processing - int32_t M_b = magp; + uint8_t num_rempass; const int quad_buf_width = width + 4; const int quad_buf_height = height + 4; @@ -1210,13 +1210,11 @@ ff_jpeg2000_decode_htj2k(const Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c 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