From patchwork Wed Aug 19 12:20:59 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gautam Ramakrishnan X-Patchwork-Id: 21736 Return-Path: X-Original-To: patchwork@ffaux-bg.ffmpeg.org Delivered-To: patchwork@ffaux-bg.ffmpeg.org Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by ffaux.localdomain (Postfix) with ESMTP id 1248D44B0ED for ; Wed, 19 Aug 2020 15:21:28 +0300 (EEST) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id DC3616881F1; Wed, 19 Aug 2020 15:21:27 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-pj1-f68.google.com (mail-pj1-f68.google.com [209.85.216.68]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 73682687F43 for ; Wed, 19 Aug 2020 15:21:21 +0300 (EEST) Received: by mail-pj1-f68.google.com with SMTP id mw10so1043623pjb.2 for ; Wed, 19 Aug 2020 05:21:21 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id; bh=7SsBHLcUbrsGWagCGMAdHQSuTa81mM/Z4XwCjEwekwg=; b=LRDr/1aXuAhanug/XAbcm59cdbJ1+klLyU9OH1Hub80/6XhXqWSJP/j3JqyVhe4VGy p2lzmzyf35ctyU9bDNj4ZWnN7IZ29pZIdx3r3QKrxsB/bVW03idK9xaAC7DYw5KOBMLV NOL/xyvrEuT/krMK9H9ookNq8ieLD5bShr1HhEtZlNTOYmnJa2d5yqETi0p4QicWv2oA 1EkUpwA3DrJGJPx9Z2el3HROq0R4gtZvV1RgSA8O7IVy1X5vokLcpTcMD3RB+sPKJqa4 jpWxi7ekKb/J2xScN25z21boXr9dvVxbUHBHWMbcGN7YHzhHVFaZhZiwMwHsYdzSiXY2 ROFg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id; bh=7SsBHLcUbrsGWagCGMAdHQSuTa81mM/Z4XwCjEwekwg=; b=bIKZi2XdkbAEGVDrrvSCQmfXRQr6VVA/Xreq/kVzpeEh5J3Awn6nFBv1yMJ8lONuSM p8l5eg09jG2c4VLr5bxQKwa/HQExxOJfUJARsuwiupBxDfCQU1nY7WvCBfbuOeF1WMZi 4BdUJEg8Y5UAF2oPwDfKXXiZM34Cn9j1oJOw5QCR4ESdCS4+LjUDYCcBzVs3NLB+QwFG rAbIcOyzEIaOX9qowvGFWCSB6NUr4fqn6BXpx0qAHM9O9qk5FrUDdn1Mmg5jex5hWc3s dtYyTcvMUcu2tWe/uIFiqoJyC/8bMikAt0LLiM1h96tOwOx9xtRj2ZNqZtx4FHa/6jsG d6Og== X-Gm-Message-State: AOAM532chjSgSjzvP4AungBgrUafI/FAPpTxBqKaIj55hwc8BiwUAD8R t8Exr5QeUfpFb/9lUzo7ifkiYHjhAho= X-Google-Smtp-Source: ABdhPJxZ+dowNq9m1q9fZO1IyfeQTEMFPXMMCwQwnt7NRp6TN+TTXUxZ3tvts+08TKDddyuU8VsmJg== X-Received: by 2002:a17:902:c285:: with SMTP id i5mr11316420pld.288.1597839679362; Wed, 19 Aug 2020 05:21:19 -0700 (PDT) Received: from localhost.localdomain ([122.166.129.193]) by smtp.gmail.com with ESMTPSA id k88sm3039767pjk.19.2020.08.19.05.21.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Aug 2020 05:21:18 -0700 (PDT) From: gautamramk@gmail.com To: ffmpeg-devel@ffmpeg.org Date: Wed, 19 Aug 2020 17:50:59 +0530 Message-Id: <20200819122102.5584-1-gautamramk@gmail.com> X-Mailer: git-send-email 2.17.1 Subject: [FFmpeg-devel] [RFC PATCH 1/4] libavcodec/jpeg2000: Make tag tree functions non static X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 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: Gautam Ramakrishnan MIME-Version: 1.0 Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" From: Gautam Ramakrishnan This patch makes the tag_tree_zero() and tag_tree_size() functions non static and callable from other files. --- libavcodec/jpeg2000.c | 12 ++++++------ libavcodec/jpeg2000.h | 3 +++ 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/libavcodec/jpeg2000.c b/libavcodec/jpeg2000.c index 1aca31ffa4..26e09fbe38 100644 --- a/libavcodec/jpeg2000.c +++ b/libavcodec/jpeg2000.c @@ -39,7 +39,7 @@ /* tag tree routines */ /* allocate the memory for tag tree */ -static int32_t tag_tree_size(int w, int h) +int32_t ff_tag_tree_size(int w, int h) { int64_t res = 0; while (w > 1 || h > 1) { @@ -57,7 +57,7 @@ static Jpeg2000TgtNode *ff_jpeg2000_tag_tree_init(int w, int h) Jpeg2000TgtNode *res, *t, *t2; int32_t tt_size; - tt_size = tag_tree_size(w, h); + tt_size = ff_tag_tree_size(w, h); t = res = av_mallocz_array(tt_size, sizeof(*t)); if (!res) @@ -82,9 +82,9 @@ static Jpeg2000TgtNode *ff_jpeg2000_tag_tree_init(int w, int h) return res; } -static void tag_tree_zero(Jpeg2000TgtNode *t, int w, int h) +void ff_tag_tree_zero(Jpeg2000TgtNode *t, int w, int h) { - int i, siz = tag_tree_size(w, h); + int i, siz = ff_tag_tree_size(w, h); for (i = 0; i < siz; i++) { t[i].val = 0; @@ -567,8 +567,8 @@ void ff_jpeg2000_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty) Jpeg2000Band *band = rlevel->band + bandno; for(precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++) { Jpeg2000Prec *prec = band->prec + precno; - tag_tree_zero(prec->zerobits, prec->nb_codeblocks_width, prec->nb_codeblocks_height); - tag_tree_zero(prec->cblkincl, prec->nb_codeblocks_width, prec->nb_codeblocks_height); + ff_tag_tree_zero(prec->zerobits, prec->nb_codeblocks_width, prec->nb_codeblocks_height); + ff_tag_tree_zero(prec->cblkincl, prec->nb_codeblocks_width, prec->nb_codeblocks_height); for (cblkno = 0; cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height; cblkno++) { Jpeg2000Cblk *cblk = prec->cblk + cblkno; cblk->length = 0; diff --git a/libavcodec/jpeg2000.h b/libavcodec/jpeg2000.h index 5b0627c3dc..c3437b02fe 100644 --- a/libavcodec/jpeg2000.h +++ b/libavcodec/jpeg2000.h @@ -290,4 +290,7 @@ static inline int needs_termination(int style, int passno) { return 0; } +int32_t ff_tag_tree_size(int w, int h); +void ff_tag_tree_zero(Jpeg2000TgtNode *t, int w, int h); + #endif /* AVCODEC_JPEG2000_H */ From patchwork Wed Aug 19 12:21:00 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gautam Ramakrishnan X-Patchwork-Id: 21737 Return-Path: X-Original-To: patchwork@ffaux-bg.ffmpeg.org Delivered-To: patchwork@ffaux-bg.ffmpeg.org Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by ffaux.localdomain (Postfix) with ESMTP id 58C4444B0ED for ; Wed, 19 Aug 2020 15:21:30 +0300 (EEST) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 3298D689C71; Wed, 19 Aug 2020 15:21:30 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-pl1-f174.google.com (mail-pl1-f174.google.com [209.85.214.174]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id BE0D8689AD1 for ; Wed, 19 Aug 2020 15:21:23 +0300 (EEST) Received: by mail-pl1-f174.google.com with SMTP id r4so10742604pls.2 for ; Wed, 19 Aug 2020 05:21:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=r3050TDDiFGByggGay00VvYNulgDDZFevja1BP3fjkI=; b=OybBQAMsf9ffWsHHJxxFexaYuPhjSLfBW42GE8R02MY9L0iWoSOV7OIjNOtTkTpSdm /00ifW7ybGRr8C+8fVbYEynW/qDTPVoQvtOtQbLqBmhSPaSYrVvg0zgBaImMo1D6PB3c edSOXxIllGSkTSyFMylwNQwUOE7qNQU0xK114d6JYhzSXH8ElBD4TEEWOW07aANMU9sU VfG3qxQgp/nNrn8zv8+1Ot1UvTgV6xku64wV1Lj1X7dvyIHmMvHvpvCPI+ijTYUuoqSu QiNC9BeHwf7KpSiPOf6SbkKVaTAjtwXiMWLsGHIzHUEQY2dHmPiqbYbkhTayHtMXJIue nygg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=r3050TDDiFGByggGay00VvYNulgDDZFevja1BP3fjkI=; b=B/IpqMu6KGsnxExmVicD/NlsZx97Oy3/sI0RTAYtJ7V1jsTMI1tnNma0a9k33u7NaX 8E+CQA+I05WkAwYrN9bGh/O/mPDS3P/kLOE2YzEbOpPBT6SG9UcHFgtJ8BnNFyGhM34h CKJ1KHsNrS2E/wgUpzmmp8f9GKmA+Y00rAfajgBEHz6AWRtsrixWMBj9ZohyZtFdT6gu uheZoIDrckPRLkNEDYLIMTo3FeXI6pmVgCQDEnM6M/aw/xFmH3XQD4kx525SCL4qPx/y Sga+MACnP4Xbf/wC3Bw9wDe61LWksB5oHf1z0OzVUzD+opNl/8i4/S79KWEmih4xZ+dx Wbzg== X-Gm-Message-State: AOAM530sR7bf6Px9hvNM6hzk4PzPRXUMPZlxafiycr4HuyedhTTOjqBJ N1aZzXJAzjJ38U4JXl4ofNL8p4wTAPQ= X-Google-Smtp-Source: ABdhPJwUinlU4PcKdwHiLQ57eOodVEreldeNOd23rB4f2rNrvE2X95yg9nqPgSCTFdDtxxFIGuwUgw== X-Received: by 2002:a17:90a:c207:: with SMTP id e7mr4123322pjt.172.1597839681245; Wed, 19 Aug 2020 05:21:21 -0700 (PDT) Received: from localhost.localdomain ([122.166.129.193]) by smtp.gmail.com with ESMTPSA id k88sm3039767pjk.19.2020.08.19.05.21.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Aug 2020 05:21:20 -0700 (PDT) From: gautamramk@gmail.com To: ffmpeg-devel@ffmpeg.org Date: Wed, 19 Aug 2020 17:51:00 +0530 Message-Id: <20200819122102.5584-2-gautamramk@gmail.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200819122102.5584-1-gautamramk@gmail.com> References: <20200819122102.5584-1-gautamramk@gmail.com> Subject: [FFmpeg-devel] [RFC PATCH 2/4] libavcodec/j2kenc: Fix tag tree coding X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 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: Gautam Ramakrishnan MIME-Version: 1.0 Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" From: Gautam Ramakrishnan This patch fixes tag tree coding for JPEG2000 encoder. --- libavcodec/j2kenc.c | 41 ++++++++++++++++++++++++----------------- libavcodec/jpeg2000.c | 1 + libavcodec/jpeg2000.h | 1 + 3 files changed, 26 insertions(+), 17 deletions(-) diff --git a/libavcodec/j2kenc.c b/libavcodec/j2kenc.c index 16863f8e8c..d9777fe07f 100644 --- a/libavcodec/j2kenc.c +++ b/libavcodec/j2kenc.c @@ -242,27 +242,34 @@ static void j2k_flush(Jpeg2000EncoderContext *s) static void tag_tree_code(Jpeg2000EncoderContext *s, Jpeg2000TgtNode *node, int threshold) { Jpeg2000TgtNode *stack[30]; - int sp = 1, curval = 0; - stack[0] = node; + int sp = -1, curval = 0; - node = node->parent; - while(node){ - if (node->vis){ - curval = node->val; - break; - } - node->vis++; - stack[sp++] = node; + while(node->parent){ + stack[++sp] = node; node = node->parent; } - while(--sp >= 0){ - if (stack[sp]->val >= threshold){ - put_bits(s, 0, threshold - curval); - break; + + while (1) { + if (curval > node->temp_val) + node->temp_val = curval; + else { + curval = node->temp_val; } - put_bits(s, 0, stack[sp]->val - curval); - put_bits(s, 1, 1); - curval = stack[sp]->val; + while (curval < threshold) { + if (curval >= node->val) { + if (!node->vis) { + node->vis = 1; + put_bits(s, 1, 1); + } + break; + } + put_bits(s, 0, 1); + curval++; + } + node->temp_val = curval; + if (sp < 0) + break; + node = stack[sp--]; } } diff --git a/libavcodec/jpeg2000.c b/libavcodec/jpeg2000.c index 26e09fbe38..3d3e7ec313 100644 --- a/libavcodec/jpeg2000.c +++ b/libavcodec/jpeg2000.c @@ -88,6 +88,7 @@ void ff_tag_tree_zero(Jpeg2000TgtNode *t, int w, int h) for (i = 0; i < siz; i++) { t[i].val = 0; + t[i].temp_val = 0; t[i].vis = 0; } } diff --git a/libavcodec/jpeg2000.h b/libavcodec/jpeg2000.h index c3437b02fe..ad58b1ae88 100644 --- a/libavcodec/jpeg2000.h +++ b/libavcodec/jpeg2000.h @@ -127,6 +127,7 @@ typedef struct Jpeg2000T1Context { typedef struct Jpeg2000TgtNode { uint8_t val; + uint8_t temp_val; uint8_t vis; struct Jpeg2000TgtNode *parent; } Jpeg2000TgtNode; From patchwork Wed Aug 19 12:21:01 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gautam Ramakrishnan X-Patchwork-Id: 21738 Return-Path: X-Original-To: patchwork@ffaux-bg.ffmpeg.org Delivered-To: patchwork@ffaux-bg.ffmpeg.org Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by ffaux.localdomain (Postfix) with ESMTP id 96A2944B0ED for ; Wed, 19 Aug 2020 15:21:33 +0300 (EEST) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 79D61689CFF; Wed, 19 Aug 2020 15:21:33 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-pj1-f67.google.com (mail-pj1-f67.google.com [209.85.216.67]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 2B36E6899A1 for ; Wed, 19 Aug 2020 15:21:25 +0300 (EEST) Received: by mail-pj1-f67.google.com with SMTP id mw10so1043730pjb.2 for ; Wed, 19 Aug 2020 05:21:25 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=YEGzp5ETiq+KfJTf4eY4GRdflWVj8OQXMtJKRLVq2jY=; b=CuZ/VWVmPWU71Y4zLUlmZoNo9OdtK3OiDM3sTaL6ng3YIs6EaE4T3VIRl77jlCSHih GZqAQP2skIdlfBtzru40BkvBPok+WiolvkLEjOfmckNgDeJOmHwKWPJ2c7ANVSoAX0Tr iXoFyqmrenV9s7kpQi/bY53If8ZeTwX4c8tQNdHh32QUItwy5WGJgpt5yYWAakrpStmR JXde8Tg8kkRc2nquLFdsKl5y2fVu2H0bC7iRzxi45tqkUjNXB0pDh23QaG4jXh2USqH8 lhZQ3qP03uSdYIO6eaDMhoTYZDGSoF09SvZqrmeMRAyOjwe3+hwRqyIPWKB1VflLG6Bf /rew== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=YEGzp5ETiq+KfJTf4eY4GRdflWVj8OQXMtJKRLVq2jY=; b=sU5/t6HPD7crGse/1FBbdtJI+BOQgMnvxJ+hv36rcnkHWIomHmLKpUg0FNSiszEQGT 2R476FRMtfmKjZc0tV7m/aVp/a3XeYDh3a7k9r4Nt9rmDenGq0X8cPa/hlrldkyvL/Th JtY9gfCS8ibkH8GB9C0BNX260sLKxobr9wF+A0EaWqeDO5vCMOMP0h79e4TZ060jEpGz uLy6kSiFCJWlYq9BN4tqKSQMzyiqaUB9RQldPicdYxOUwkhYk0bG8y6YpUtdcca0mtH+ JXE2g2d0PEF2fqK+eCBCG2xwGR70YcTMeOqChn+9RLDkX2h0EMyCmw2NbPezp/gc0O+G PBcA== X-Gm-Message-State: AOAM533vtw02Aff6rPyvexU9lnC7DKP8FOOnCylqYTIRkLh70jBg+Xim KAXORb93tkxPDw74pklYAfN3HMvCJLM= X-Google-Smtp-Source: ABdhPJwGEoDVj2FskRt66rZOoZcDAI5nv7LZFqvr7EzX0Cy2Pw4Ow+JqzJbWg2pU4YebJMG8fAvtRw== X-Received: by 2002:a17:902:bcc5:: with SMTP id o5mr19027593pls.335.1597839683280; Wed, 19 Aug 2020 05:21:23 -0700 (PDT) Received: from localhost.localdomain ([122.166.129.193]) by smtp.gmail.com with ESMTPSA id k88sm3039767pjk.19.2020.08.19.05.21.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Aug 2020 05:21:22 -0700 (PDT) From: gautamramk@gmail.com To: ffmpeg-devel@ffmpeg.org Date: Wed, 19 Aug 2020 17:51:01 +0530 Message-Id: <20200819122102.5584-3-gautamramk@gmail.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200819122102.5584-1-gautamramk@gmail.com> References: <20200819122102.5584-1-gautamramk@gmail.com> Subject: [FFmpeg-devel] [RFC PATCH 3/4] libavcodec/jpeg2000: Modify cleanup X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 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: Gautam Ramakrishnan MIME-Version: 1.0 Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" From: Gautam Ramakrishnan This patch makes the ff_jpeg2000_cleanup function take in an extra parameter which indicates whether it is called from the encoder or decoder. --- libavcodec/j2kenc.c | 2 +- libavcodec/jpeg2000.c | 2 +- libavcodec/jpeg2000.h | 2 +- libavcodec/jpeg2000dec.c | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/libavcodec/j2kenc.c b/libavcodec/j2kenc.c index d9777fe07f..8699296434 100644 --- a/libavcodec/j2kenc.c +++ b/libavcodec/j2kenc.c @@ -1218,7 +1218,7 @@ static void cleanup(Jpeg2000EncoderContext *s) for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){ for (compno = 0; compno < s->ncomponents; compno++){ Jpeg2000Component *comp = s->tile[tileno].comp + compno; - ff_jpeg2000_cleanup(comp, codsty); + ff_jpeg2000_cleanup(comp, codsty, 1); } av_freep(&s->tile[tileno].comp); } diff --git a/libavcodec/jpeg2000.c b/libavcodec/jpeg2000.c index 3d3e7ec313..70c25a0ca2 100644 --- a/libavcodec/jpeg2000.c +++ b/libavcodec/jpeg2000.c @@ -580,7 +580,7 @@ void ff_jpeg2000_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty) } } -void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty) +void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, int isencoder) { int reslevelno, bandno, precno; for (reslevelno = 0; diff --git a/libavcodec/jpeg2000.h b/libavcodec/jpeg2000.h index ad58b1ae88..fee9607e86 100644 --- a/libavcodec/jpeg2000.h +++ b/libavcodec/jpeg2000.h @@ -272,7 +272,7 @@ int ff_jpeg2000_init_component(Jpeg2000Component *comp, void ff_jpeg2000_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty); -void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty); +void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, int isencoder); static inline int needs_termination(int style, int passno) { if (style & JPEG2000_CBLK_BYPASS) { diff --git a/libavcodec/jpeg2000dec.c b/libavcodec/jpeg2000dec.c index 624542c2f8..c5192d007f 100644 --- a/libavcodec/jpeg2000dec.c +++ b/libavcodec/jpeg2000dec.c @@ -2123,7 +2123,7 @@ static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s) Jpeg2000Component *comp = s->tile[tileno].comp + compno; Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno; - ff_jpeg2000_cleanup(comp, codsty); + ff_jpeg2000_cleanup(comp, codsty, 0); } av_freep(&s->tile[tileno].comp); av_freep(&s->tile[tileno].packed_headers); From patchwork Wed Aug 19 12:21:02 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gautam Ramakrishnan X-Patchwork-Id: 21739 Return-Path: X-Original-To: patchwork@ffaux-bg.ffmpeg.org Delivered-To: patchwork@ffaux-bg.ffmpeg.org Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by ffaux.localdomain (Postfix) with ESMTP id 920AB44B0ED for ; Wed, 19 Aug 2020 15:21:35 +0300 (EEST) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 7B934689E2F; Wed, 19 Aug 2020 15:21:35 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-pl1-f194.google.com (mail-pl1-f194.google.com [209.85.214.194]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 06E1C689AE3 for ; Wed, 19 Aug 2020 15:21:28 +0300 (EEST) Received: by mail-pl1-f194.google.com with SMTP id y10so9176945plr.11 for ; Wed, 19 Aug 2020 05:21:27 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=YfObfrbZhgyj1ZmfXURt7ggSo6NysSoGw2R08FTvvwA=; b=jjxBtXwDwkMSMMEDaYMtbegp6v42dI+qvbAnsXaPFWLtRzZdbRH62jMKz2nzIDAT11 35byBeLffMYUX5x/10N2Qk+e9wcyogu3qUUZRcCRwhkEBG1ce6vyriQHehM9ckPjDBs0 T3jIrXyV0zGul/vDuKOUvi3pbwErf1Tqi4ajmpOUTVmB71T4t83zN/PK0qx5UOWywg+j zB72rSaE5FjWIdGfkb/kLQhZvBXpQmZNbycHrxvcoPth9dwKGcM+i4z2Vn3ij0TcenBw pM7O5kL2bdeC3M/zlFhscmHP4WrfGe3l55V9v1F04Q9wmBFDKlf9bxX+wVqwzMxQ+yu1 exhw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=YfObfrbZhgyj1ZmfXURt7ggSo6NysSoGw2R08FTvvwA=; b=OOS1dlEJhr8p330+nsRSZWHR/jtf2KD4biVvm42VkmdmNsuCn0b4n3L+fuPEpurTIh MFfif6uBUsnZFKCGod5d7PFsSnq8bend9tymBFVirIHiL0Kjf0RyzzERcDhi0EL+BrBp gu/JIaTEAcU4Wd2Yzs+Z8xcAjeiGmEnRTlVTwGH+JAG8fE0UEiLgDyNseYEm2FnJ09Sm 5Ob/JzF7kJGmBwSjJCPZYf21L0blymDUfI5yDpu4Qezr24t2N0WKBHcvOYmdjTNgDU4R ybQpsXNNLvnArELy3weHOu7I2NQ9ZAEaoDGPPXdh2j/Qwaw3E9P4CcRpw7j9tUrsMy8G ab9A== X-Gm-Message-State: AOAM531IVQXPhl+GkjKX0YCvChSBDr6l6eOUuOiFWqRkPk6FIuyuElV+ lgP/FP7oTwibhxNeCynP2E2KgHQ+E24= X-Google-Smtp-Source: ABdhPJx9xiiYixupC0UYOF7oBZiNeXP8jE32CHENKqUHC4W5EHMrzI5+jk5tAUDbNjoT024dOdN99A== X-Received: by 2002:a17:902:b111:: with SMTP id q17mr18154048plr.202.1597839685484; Wed, 19 Aug 2020 05:21:25 -0700 (PDT) Received: from localhost.localdomain ([122.166.129.193]) by smtp.gmail.com with ESMTPSA id k88sm3039767pjk.19.2020.08.19.05.21.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 19 Aug 2020 05:21:24 -0700 (PDT) From: gautamramk@gmail.com To: ffmpeg-devel@ffmpeg.org Date: Wed, 19 Aug 2020 17:51:02 +0530 Message-Id: <20200819122102.5584-4-gautamramk@gmail.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200819122102.5584-1-gautamramk@gmail.com> References: <20200819122102.5584-1-gautamramk@gmail.com> Subject: [FFmpeg-devel] [RFC PATCH 4/4] libavcodec/j2kenc: Support for multiple layers X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 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: Gautam Ramakrishnan MIME-Version: 1.0 Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" From: Gautam Ramakrishnan This patch allows setting a compression ratio and to set multiple layers. The user has to input a compression ratio for each layer. The per layer compression ration can be set as follows: -layer_rates "r1,r2,...rn" for to create 'n' layers. --- libavcodec/j2kenc.c | 443 ++++++++++++++++++++++++++++++++++-------- libavcodec/jpeg2000.c | 13 +- libavcodec/jpeg2000.h | 10 + 3 files changed, 384 insertions(+), 82 deletions(-) diff --git a/libavcodec/j2kenc.c b/libavcodec/j2kenc.c index 8699296434..b09db36c14 100644 --- a/libavcodec/j2kenc.c +++ b/libavcodec/j2kenc.c @@ -32,6 +32,7 @@ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe * Copyright (c) 2005, Herve Drolon, FreeImage Team * Copyright (c) 2007, Callum Lerwick + * Copyright (c) 2020, Gautam Ramakrishnan * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -100,6 +101,7 @@ static const int dwt_norms[2][4][10] = { // [dwt_type][band][rlevel] (multiplied typedef struct { Jpeg2000Component *comp; + double *layer_rates; } Jpeg2000Tile; typedef struct { @@ -126,12 +128,15 @@ typedef struct { Jpeg2000QuantStyle qntsty; Jpeg2000Tile *tile; + int layer_rates[100]; int format; int pred; int sop; int eph; int prog; + int nlayers; + char *lr_str; } Jpeg2000EncoderContext; @@ -332,7 +337,7 @@ static int put_cod(Jpeg2000EncoderContext *s) bytestream_put_byte(&s->buf, scod); // Scod // SGcod bytestream_put_byte(&s->buf, s->prog); // progression level - bytestream_put_be16(&s->buf, 1); // num of layers + bytestream_put_be16(&s->buf, s->nlayers); // num of layers if(s->avctx->pix_fmt == AV_PIX_FMT_YUV444P){ bytestream_put_byte(&s->buf, 0); // unspecified }else{ @@ -411,6 +416,31 @@ static uint8_t *put_sot(Jpeg2000EncoderContext *s, int tileno) return psotptr; } +static void compute_rates(Jpeg2000EncoderContext* s) +{ + int i, j; + int layno, compno; + for (i = 0; i < s->numYtiles; i++) { + for (j = 0; j < s->numXtiles; j++) { + Jpeg2000Tile *tile = &s->tile[s->numXtiles * i + j]; + for (compno = 0; compno < s->ncomponents; compno++) { + int tilew = tile->comp[compno].coord[0][1] - tile->comp[compno].coord[0][0]; + int tileh = tile->comp[compno].coord[1][1] - tile->comp[compno].coord[1][0]; + int scale = (compno?1 << s->chroma_shift[0]:1) * (compno?1 << s->chroma_shift[1]:1); + for (layno = 0; layno < s->nlayers; layno++) { + if (s->layer_rates[layno] > 0.0f) { + tile->layer_rates[layno] += (double)(tilew * tileh) * s->ncomponents * s->cbps[compno] / + (double)(s->layer_rates[layno] * 8 * scale); + } else { + tile->layer_rates[layno] = 0.0f; + } + } + } + } + } + +} + /** * compute the sizes of tiles, resolution levels, bands, etc. * allocate memory for them @@ -448,6 +478,10 @@ static int init_tiles(Jpeg2000EncoderContext *s) for (j = 0; j < 2; j++) comp->coord[i][j] = comp->coord_o[i][j] = ff_jpeg2000_ceildivpow2(comp->coord[i][j], s->chroma_shift[i]); + tile->layer_rates = av_mallocz_array(s->ncomponents, sizeof(*tile->layer_rates)); + if (!tile->layer_rates) + return AVERROR(ENOMEM); + if ((ret = ff_jpeg2000_init_component(comp, codsty, qntsty, @@ -459,6 +493,7 @@ static int init_tiles(Jpeg2000EncoderContext *s) return ret; } } + compute_rates(s); return 0; } @@ -701,6 +736,8 @@ static void encode_cblk(Jpeg2000EncoderContext *s, Jpeg2000T1Context *t1, Jpeg20 } cblk->passes[passno].rate = ff_mqc_flush_to(&t1->mqc, cblk->passes[passno].flushed, &cblk->passes[passno].flushed_len); + cblk->passes[passno].rate -= cblk->passes[passno].flushed_len; + wmsedec += (int64_t)nmsedec << (2*bpno); cblk->passes[passno].disto = wmsedec; @@ -733,10 +770,12 @@ static void putnumpasses(Jpeg2000EncoderContext *s, int n) } -static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int precno, - uint8_t *expn, int numgbits, int packetno) +static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int layno, + int precno, uint8_t *expn, int numgbits, int packetno, + int nlayers) { int bandno, empty = 1; + int i; // init bitstream *s->buf = 0; s->bit_index = 0; @@ -748,18 +787,61 @@ static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, in } // header + if (!layno) { + for (bandno = 0; bandno < rlevel->nbands; bandno++){ + Jpeg2000Band *band = rlevel->band + bandno; + if (rlevel->band[bandno].coord[0][0] < rlevel->band[bandno].coord[0][1] + && rlevel->band[bandno].coord[1][0] < rlevel->band[bandno].coord[1][1]){ + Jpeg2000Prec *prec = band->prec + precno; + int nb_cblks = prec->nb_codeblocks_height * prec->nb_codeblocks_width; + int pos; + ff_tag_tree_zero(prec->zerobits, prec->nb_codeblocks_width, prec->nb_codeblocks_height); + ff_tag_tree_zero(prec->cblkincl, prec->nb_codeblocks_width, prec->nb_codeblocks_height); + for (pos = 0; pos < nb_cblks; pos++) { + Jpeg2000Cblk *cblk = &prec->cblk[pos]; + prec->zerobits[pos].val = expn[bandno] + numgbits - 1 - cblk->nonzerobits; + cblk->incl = 0; + cblk->lblock = 3; + tag_tree_update(prec->zerobits + pos); + for (i = 0; i < nlayers; i++) { + if (cblk->layers[i].npasses > 0) { + prec->cblkincl[pos].val = i; + break; + } + } + if (i == nlayers) + prec->cblkincl[pos].val = i; + tag_tree_update(prec->cblkincl + pos); + } + } + } + } + // is the packet empty? for (bandno = 0; bandno < rlevel->nbands; bandno++){ + Jpeg2000Band *band = rlevel->band + bandno; if (rlevel->band[bandno].coord[0][0] < rlevel->band[bandno].coord[0][1] && rlevel->band[bandno].coord[1][0] < rlevel->band[bandno].coord[1][1]){ - empty = 0; - break; + Jpeg2000Prec *prec = band->prec + precno; + int nb_cblks = prec->nb_codeblocks_height * prec->nb_codeblocks_width; + int pos; + for (pos = 0; pos < nb_cblks; pos++) { + Jpeg2000Cblk *cblk = &prec->cblk[pos]; + if (cblk->layers[layno].npasses) { + empty = 0; + break; + } + } + if (!empty) + break; } } put_bits(s, !empty, 1); if (empty){ j2k_flush(s); + if (s->eph) + bytestream_put_be16(&s->buf, JPEG2000_EPH); return 0; } @@ -775,40 +857,44 @@ static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, in for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++){ for (xi = 0; xi < cblknw; xi++, pos++){ - prec->cblkincl[pos].val = prec->cblk[yi * cblknw + xi].ninclpasses == 0; - tag_tree_update(prec->cblkincl + pos); - prec->zerobits[pos].val = expn[bandno] + numgbits - 1 - prec->cblk[yi * cblknw + xi].nonzerobits; - tag_tree_update(prec->zerobits + pos); - } - } - - for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++){ - for (xi = 0; xi < cblknw; xi++, pos++){ - int pad = 0, llen, length; + int llen = 0, length; Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi; if (s->buf_end - s->buf < 20) // approximately return -1; // inclusion information - tag_tree_code(s, prec->cblkincl + pos, 1); - if (!cblk->ninclpasses) + if (!cblk->incl) + tag_tree_code(s, prec->cblkincl + pos, layno + 1); + else { + put_bits(s, cblk->layers[layno].npasses > 0, 1); + } + + if (!cblk->layers[layno].npasses) continue; + // zerobits information - tag_tree_code(s, prec->zerobits + pos, 100); + if (!cblk->incl) { + tag_tree_code(s, prec->zerobits + pos, 100); + cblk->incl = 1; + } + // number of passes - putnumpasses(s, cblk->ninclpasses); + putnumpasses(s, cblk->layers[layno].npasses); - length = cblk->passes[cblk->ninclpasses-1].rate; - llen = av_log2(length) - av_log2(cblk->ninclpasses) - 2; - if (llen < 0){ - pad = -llen; - llen = 0; + length = cblk->layers[layno].data_len; + if (layno == nlayers - 1 && cblk->layers->cum_passes){ + length += cblk->passes[cblk->layers->cum_passes-1].flushed_len; } + if (cblk->lblock + av_log2(cblk->layers[layno].npasses) < av_log2(length) + 1) { + llen = av_log2(length) + 1 - cblk->lblock - av_log2(cblk->layers[layno].npasses); + } + // length of code block + cblk->lblock += llen; put_bits(s, 1, llen); put_bits(s, 0, 1); - put_num(s, length, av_log2(length)+1+pad); + put_num(s, length, cblk->lblock + av_log2(cblk->layers[layno].npasses)); } } } @@ -825,13 +911,14 @@ static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, in int xi; for (xi = 0; xi < cblknw; xi++){ Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi; - if (cblk->ninclpasses){ - if (s->buf_end - s->buf < cblk->passes[cblk->ninclpasses-1].rate) + if (cblk->layers[layno].npasses){ + if (s->buf_end - s->buf < cblk->layers[layno].data_len + 2) return -1; - bytestream_put_buffer(&s->buf, cblk->data + 1, cblk->passes[cblk->ninclpasses-1].rate - - cblk->passes[cblk->ninclpasses-1].flushed_len); - bytestream_put_buffer(&s->buf, cblk->passes[cblk->ninclpasses-1].flushed, - cblk->passes[cblk->ninclpasses-1].flushed_len); + bytestream_put_buffer(&s->buf, cblk->layers[layno].data_start + 1, cblk->layers[layno].data_len); + if (layno == nlayers - 1 && cblk->layers->cum_passes){ + bytestream_put_buffer(&s->buf, cblk->passes[cblk->layers->cum_passes-1].flushed, + cblk->passes[cblk->layers->cum_passes-1].flushed_len); + } } } } @@ -839,9 +926,9 @@ static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, in return 0; } -static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno) +static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno, int nlayers) { - int compno, reslevelno, ret; + int compno, reslevelno, layno, ret; Jpeg2000CodingStyle *codsty = &s->codsty; Jpeg2000QuantStyle *qntsty = &s->qntsty; int packetno = 0; @@ -858,29 +945,33 @@ static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int til av_log(s->avctx, AV_LOG_DEBUG, "tier2\n"); // lay-rlevel-comp-pos progression - switch (s->prog) { + switch (s->prog) { case JPEG2000_PGOD_LRCP: - for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){ - for (compno = 0; compno < s->ncomponents; compno++){ - int precno; - Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno; - for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){ - if ((ret = encode_packet(s, reslevel, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0), - qntsty->nguardbits, packetno++)) < 0) - return ret; + for (layno = 0; layno < nlayers; layno++){ + for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){ + for (compno = 0; compno < s->ncomponents; compno++){ + int precno; + Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno; + for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){ + if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0), + qntsty->nguardbits, packetno++, nlayers)) < 0) + return ret; + } } } } break; case JPEG2000_PGOD_RLCP: for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){ - for (compno = 0; compno < s->ncomponents; compno++){ - int precno; - Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno; - for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){ - if ((ret = encode_packet(s, reslevel, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0), - qntsty->nguardbits, packetno++)) < 0) - return ret; + for (layno = 0; layno < nlayers; layno++){ + for (compno = 0; compno < s->ncomponents; compno++){ + int precno; + Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno; + for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){ + if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0), + qntsty->nguardbits, packetno++, nlayers)) < 0) + return ret; + } } } } @@ -935,10 +1026,11 @@ static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int til prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y); continue; } - - if ((ret = encode_packet(s, reslevel, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0), - qntsty->nguardbits, packetno++)) < 0) - return ret; + for (layno = 0; layno < nlayers; layno++){ + if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0), + qntsty->nguardbits, packetno++, nlayers)) < 0) + return ret; + } } } } @@ -1001,9 +1093,11 @@ static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int til prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y); continue; } - if ((ret = encode_packet(s, reslevel, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0), - qntsty->nguardbits, packetno++)) < 0) - return ret; + for (layno = 0; layno < nlayers; layno++){ + if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0), + qntsty->nguardbits, packetno++, nlayers)) < 0) + return ret; + } } } } @@ -1062,9 +1156,11 @@ static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int til prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y); continue; } - if ((ret = encode_packet(s, reslevel, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0), - qntsty->nguardbits, packetno++)) < 0) - return ret; + for (layno = 0; layno < nlayers; layno++){ + if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0), + qntsty->nguardbits, packetno++, nlayers)) < 0) + return ret; + } } } } @@ -1076,27 +1172,98 @@ static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int til return 0; } -static int getcut(Jpeg2000Cblk *cblk, int64_t lambda, int dwt_norm) +static void makelayer(Jpeg2000EncoderContext *s, int layno, double thresh, Jpeg2000Tile* tile, int final) { - int passno, res = 0; - for (passno = 0; passno < cblk->npasses; passno++){ - int dr; - int64_t dd; - - dr = cblk->passes[passno].rate - - (res ? cblk->passes[res-1].rate:0); - dd = cblk->passes[passno].disto - - (res ? cblk->passes[res-1].disto:0); - - if (((dd * dwt_norm) >> WMSEDEC_SHIFT) * dwt_norm >= dr * lambda) - res = passno+1; + int compno, resno, bandno, precno, cblkno; + int passno; + + for (compno = 0; compno < s->ncomponents; compno++) { + Jpeg2000Component *comp = &tile->comp[compno]; + + for (resno = 0; resno < s->codsty.nreslevels; resno++) { + Jpeg2000ResLevel *reslevel = comp->reslevel + resno; + + for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){ + for (bandno = 0; bandno < reslevel->nbands ; bandno++){ + Jpeg2000Band *band = reslevel->band + bandno; + Jpeg2000Prec *prec = band->prec + precno; + + for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){ + Jpeg2000Cblk *cblk = prec->cblk + cblkno; + Jpeg2000Layer *layer = &cblk->layers[layno]; + int n; + + if (layno == 0) { + cblk->ninclpasses = 0; + } + + n = cblk->ninclpasses; + + if (thresh < 0) { + n = cblk->npasses; + } else { + for (passno = cblk->ninclpasses; passno < cblk->npasses; passno++) { + int32_t dr; + double dd; + Jpeg2000Pass *pass = &cblk->passes[passno]; + + if (n == 0) { + dr = pass->rate; + dd = (double)pass->disto; + } else { + dr = pass->rate - cblk->passes[n - 1].rate; + dd = (double)pass->disto - (double)cblk->passes[n-1].disto; + } + + if (!dr) { + if (dd) { + n = passno + 1; + } + continue; + } + + if (thresh - (dd / dr) < DBL_EPSILON) + n = passno + 1; + } + } + layer->npasses = n - cblk->ninclpasses; + layer->cum_passes = n; + + if (layer->npasses == 0) { + layer->disto = 0; + layer->data_len = 0; + continue; + } + + if (cblk->ninclpasses == 0) { + layer->data_len = cblk->passes[n - 1].rate; + layer->data_start = cblk->data; + layer->disto = cblk->passes[n - 1].disto; + } else { + layer->data_len = cblk->passes[n - 1].rate - cblk->passes[cblk->ninclpasses - 1].rate; + layer->data_start = cblk->data + cblk->passes[cblk->ninclpasses - 1].rate; + layer->disto = cblk->passes[n - 1].disto - + cblk->passes[cblk->ninclpasses - 1].disto; + } + if (final) { + cblk->ninclpasses = n; + } + } + } + } + } } - return res; } -static void truncpasses(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile) +static void makelayers(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile) { - int precno, compno, reslevelno, bandno, cblkno, lev; + int precno, compno, reslevelno, bandno, cblkno, lev, passno, layno; + int i; + double min = DBL_MAX; + double max = 0; + double thresh; + int tile_disto = 0; + Jpeg2000CodingStyle *codsty = &s->codsty; for (compno = 0; compno < s->ncomponents; compno++){ @@ -1107,20 +1274,70 @@ static void truncpasses(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile) for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){ for (bandno = 0; bandno < reslevel->nbands ; bandno++){ - int bandpos = bandno + (reslevelno > 0); Jpeg2000Band *band = reslevel->band + bandno; Jpeg2000Prec *prec = band->prec + precno; for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){ Jpeg2000Cblk *cblk = prec->cblk + cblkno; + for (passno = 0; passno < cblk->npasses; passno++) { + Jpeg2000Pass *pass = &cblk->passes[passno]; + int dr; + double dd, drslope; + + tile_disto += pass->disto; + if (passno == 0) { + dr = (int32_t)pass->rate; + dd = (double)pass->disto; + } else { + dr = (int32_t)(pass->rate) - cblk->passes[passno - 1].rate; + dd = (double)pass->disto - (double)cblk->passes[passno - 1].disto; + } + + if (dr <= 0) + continue; - cblk->ninclpasses = getcut(cblk, s->lambda, - (int64_t)dwt_norms[codsty->transform == FF_DWT53][bandpos][lev] * (int64_t)band->i_stepsize >> 15); + drslope = dd / dr; + if (drslope < min) + min = drslope; + + if (drslope > max) + max = drslope; + } } } } } } + + for (layno = 0; layno < s->nlayers; layno++) { + double lo = min; + double hi = max; + double stable_thresh = 0; + double good_thresh = 0; + if (!s->layer_rates[layno]) { + good_thresh = -1; + } else { + for (i = 0; i < 128; i++) { + uint8_t *stream_pos = s->buf; + int ret; + thresh = (lo + hi) / 2; + makelayer(s, layno, thresh, tile, 0); + ret = encode_packets(s, tile, (int)(tile - s->tile), layno + 1); + memset(stream_pos, 0, s->buf - stream_pos); + if ((s->buf - stream_pos > ceil(tile->layer_rates[layno])) || ret < 0) { + lo = thresh; + s->buf = stream_pos; + continue; + } + hi = thresh; + stable_thresh = thresh; + s->buf = stream_pos; + } + } + if (good_thresh >= 0) + good_thresh = stable_thresh == 0 ? thresh : stable_thresh; + makelayer(s, layno, good_thresh, tile, 1); + } } static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno) @@ -1203,8 +1420,8 @@ static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno } av_log(s->avctx, AV_LOG_DEBUG, "rate control\n"); - truncpasses(s, tile); - if ((ret = encode_packets(s, tile, tileno)) < 0) + makelayers(s, tile); + if ((ret = encode_packets(s, tile, tileno, s->nlayers)) < 0) return ret; av_log(s->avctx, AV_LOG_DEBUG, "after rate control\n"); return 0; @@ -1221,6 +1438,7 @@ static void cleanup(Jpeg2000EncoderContext *s) ff_jpeg2000_cleanup(comp, codsty, 1); } av_freep(&s->tile[tileno].comp); + av_freep(&s->tile[tileno].layer_rates); } av_freep(&s->tile); } @@ -1379,6 +1597,64 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, return 0; } +static int inline check_number(char* st, int* ret) { + int stlen = strlen(st); + int i; + *ret = 0; + if (stlen <= 0) { + return AVERROR_INVALIDDATA; + } + for (i = 0; i < stlen; i++) { + if (st[i] >= '0' && st[i] <= '9') { + *ret = (*ret) * 10 + (st[i] - '0'); + } else { + return AVERROR_INVALIDDATA; + } + } + return 0; +} + +static int parse_layer_rates(Jpeg2000EncoderContext *s) +{ + int i; + char* token; + int rate; + int nlayers = 0; + if (!s->lr_str) { + s->nlayers = 1; + s->layer_rates[0] = 0; + return 0; + } + + token = strtok(s->lr_str, ","); + if (!check_number(token, &rate)) { + s->layer_rates[0] = rate <= 1 ? 0:rate; + nlayers++; + } else { + return AVERROR_INVALIDDATA; + } + + while (1) { + token = strtok(NULL, ","); + if (!token) + break; + if (!check_number(token, &rate)) { + s->layer_rates[nlayers] = rate <= 1 ? 0:rate; + nlayers++; + } else { + return AVERROR_INVALIDDATA; + } + } + + for (i = 1; i < nlayers; i++) { + if (s->layer_rates[i] >= s->layer_rates[i-1]) { + return AVERROR_INVALIDDATA; + } + } + s->nlayers = nlayers; + return 0; +} + static av_cold int j2kenc_init(AVCodecContext *avctx) { int i, ret; @@ -1388,6 +1664,11 @@ static av_cold int j2kenc_init(AVCodecContext *avctx) s->avctx = avctx; av_log(s->avctx, AV_LOG_DEBUG, "init\n"); + if (parse_layer_rates(s)) { + av_log(s, AV_LOG_WARNING, "Layer rates invalid. Shall encode with 1 layer.\n"); + s->nlayers = 1; + s->layer_rates[0] = 0; + } #if FF_API_PRIVATE_OPT FF_DISABLE_DEPRECATION_WARNINGS @@ -1408,6 +1689,7 @@ FF_ENABLE_DEPRECATION_WARNINGS memset(codsty->log2_prec_heights, 15, sizeof(codsty->log2_prec_heights)); codsty->nreslevels2decode= codsty->nreslevels = 7; + codsty->nlayers = s->nlayers; codsty->log2_cblk_width = 4; codsty->log2_cblk_height = 4; codsty->transform = s->pred ? FF_DWT53 : FF_DWT97_INT; @@ -1489,6 +1771,7 @@ static const AVOption options[] = { { "rpcl", NULL, OFFSET(prog), AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_RPCL }, 0, 0, VE, "prog" }, { "pcrl", NULL, OFFSET(prog), AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_PCRL }, 0, 0, VE, "prog" }, { "cprl", NULL, OFFSET(prog), AV_OPT_TYPE_CONST, { .i64 = JPEG2000_PGOD_CPRL }, 0, 0, VE, "prog" }, + { "layer_rates", "Layer Rates", OFFSET(lr_str), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE }, { NULL } }; diff --git a/libavcodec/jpeg2000.c b/libavcodec/jpeg2000.c index 70c25a0ca2..1c294ad9e6 100644 --- a/libavcodec/jpeg2000.c +++ b/libavcodec/jpeg2000.c @@ -261,9 +261,11 @@ static void init_band_stepsize(AVCodecContext *avctx, band->f_stepsize *= 0.5; } -static int init_prec(Jpeg2000Band *band, +static int init_prec(AVCodecContext *avctx, + Jpeg2000Band *band, Jpeg2000ResLevel *reslevel, Jpeg2000Component *comp, + Jpeg2000CodingStyle *codsty, int precno, int bandno, int reslevelno, int log2_band_prec_width, int log2_band_prec_height) @@ -366,6 +368,11 @@ static int init_prec(Jpeg2000Band *band, cblk->lblock = 3; cblk->length = 0; cblk->npasses = 0; + if (av_codec_is_encoder(avctx->codec)) { + cblk->layers = av_mallocz_array(codsty->nlayers, sizeof(*cblk->layers)); + if (!cblk->layers) + return AVERROR(ENOMEM); + } } return 0; @@ -439,7 +446,7 @@ static int init_band(AVCodecContext *avctx, return AVERROR(ENOMEM); for (precno = 0; precno < nb_precincts; precno++) { - ret = init_prec(band, reslevel, comp, + ret = init_prec(avctx, band, reslevel, comp, codsty, precno, bandno, reslevelno, log2_band_prec_width, log2_band_prec_height); if (ret < 0) @@ -614,6 +621,8 @@ void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty, i av_freep(&cblk->passes); av_freep(&cblk->lengthinc); av_freep(&cblk->data_start); + if (isencoder) + av_freep(&cblk->layers); } av_freep(&prec->cblk); } diff --git a/libavcodec/jpeg2000.h b/libavcodec/jpeg2000.h index fee9607e86..3c6e8ede16 100644 --- a/libavcodec/jpeg2000.h +++ b/libavcodec/jpeg2000.h @@ -162,10 +162,19 @@ typedef struct Jpeg2000Pass { int flushed_len; } Jpeg2000Pass; +typedef struct Jpeg2000Layer { + uint8_t *data_start; + int data_len; + int npasses; + double disto; + int cum_passes; +} Jpeg2000Layer; + typedef struct Jpeg2000Cblk { uint8_t npasses; uint8_t ninclpasses; // number coding of passes included in codestream uint8_t nonzerobits; + uint8_t incl; uint16_t length; uint16_t *lengthinc; uint8_t nb_lengthinc; @@ -176,6 +185,7 @@ typedef struct Jpeg2000Cblk { int nb_terminationsinc; int *data_start; Jpeg2000Pass *passes; + Jpeg2000Layer *layers; int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}} } Jpeg2000Cblk; // code block