From patchwork Tue Oct 11 17:24:35 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Martijn van Beurden X-Patchwork-Id: 38695 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:4a86:b0:9d:28a3:170e with SMTP id fn6csp981265pzb; Tue, 11 Oct 2022 10:25:17 -0700 (PDT) X-Google-Smtp-Source: AMsMyM4J/TaPFlhy9HmGu93+n8r8uUSJ/HyZlLm3mXGM+mYsGW+DzzEFcCFq2IkBEw1SFlRQFTBr X-Received: by 2002:a17:906:6086:b0:731:3970:48d0 with SMTP id t6-20020a170906608600b00731397048d0mr20075300ejj.16.1665509116829; Tue, 11 Oct 2022 10:25:16 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1665509116; cv=none; d=google.com; s=arc-20160816; b=pdn9p1GHhflb2mxl9PtINkmH/03bWRUVqM29bxt+ixwAxBwRp8lAaheACeBhO99wFx GwwSjFqDz2Xsf7rmxJDl54ghchlQ/7ziJDDy5F5DaOVje0bz4RGEldlNeMRgKTDTaLmO 6RWqspJKiVe4eymE5eONmZzuaxqQCPPqHWNmPN62vUOUYqVdlpYMP8l/1SpNsihCv5D5 2kOKoLVpy63vnncKHZXG+lBGACSquXy839V2gqYS0T4ur1S4Ler/TJvl8U+Wd+KYYXt/ aJQd5pkByKWiiSxR6lLFyCPCJjl1V5qa2KCgPyMqYOJJ6fOcDphIKUkVdkUxiFZ2z7Gi SLcw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding:cc:reply-to :list-subscribe:list-help:list-post:list-archive:list-unsubscribe :list-id:precedence:subject:mime-version:references:in-reply-to :message-id:date:to:from:dkim-signature:delivered-to; bh=yTwCfXytQzzy4/hjfnh95pLbvkP/Ci75FuZ2BQ86zsI=; b=N0fHg6uT6cmb896lqEgS2zg1LOZQ2cQMWevktJ6JPCrGB+ZfNuQCGV3ZRjS21DeXgr UjGxntOyVL0dZngEVKE1B+cQAOT1+rKsLXLjQUXUKZQGWuvOU89TJAjKBK7GkdzNEMKN pzUvhalFwui2mruEmAGy3snFePetAe/Rxt93upvLdstUsyd+gx/7jvDYAM9wF/vALxI3 RKfPtLU6xhA1qZOJlXLdBG/jylqI3HdYk7HIBqOL+1sz0RY1VUjH3DLV+Vj1rRcauOM7 MF99HUG/krrPDma7vwiOmX8RwZhIOEK2JALpBQ6SWDTr3VDP6ZhwAvH7Kq7UcghkEci3 CuqA== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@gmail.com header.s=20210112 header.b=X8UYthAv; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id ht9-20020a170907608900b0078341b2e269si15628397ejc.886.2022.10.11.10.25.16; Tue, 11 Oct 2022 10:25:16 -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=@gmail.com header.s=20210112 header.b=X8UYthAv; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id D7EF868BD08; Tue, 11 Oct 2022 20:25:03 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-ed1-f51.google.com (mail-ed1-f51.google.com [209.85.208.51]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id DA72E68BCB7 for ; Tue, 11 Oct 2022 20:24:57 +0300 (EEST) Received: by mail-ed1-f51.google.com with SMTP id u21so21091057edi.9 for ; Tue, 11 Oct 2022 10:24:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=vJJj8c9y4Eas2D3KAYW004Dqill5XML7AUGAH9RJPYQ=; b=X8UYthAvLgOGjRsKErq3O3eDYbxiWPait2XFVyuy92exqEjNKri4zC86CBLx8ZlCCW o2DNeZgA+uFilkJ5wvNSCSpyjqeTQRTqIjk+7eceG34RbOWuc2cwRuqXJrIgYjyfWFZj Hg2CJlCyu+ybgk0QMrrZDjGOV6Fj83qkIbic0d1Ewq9ai9Emrq3WmjqOfbYzAKEtgFxS WuEBuLlfHSWj4SOMIrLOT2w1VcgfBIsxErZFZEgquzwXbehtwLgvzcGLRnW3aP3QtELK /qz1yolJJtFHoBM660XHMy7/8ZoIWzQnZPDsyWELksxkF9JWNzIndkzj95BiZgJKPzNp T7pg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=vJJj8c9y4Eas2D3KAYW004Dqill5XML7AUGAH9RJPYQ=; b=G0mwcmk1a7Rp+AdO6yQ1sGzLLb79DKd2GJx/LQFg4h+HH0VrcPex1cWXNi+CVeNyPM bPH8t3nZS0AffYelLMyBWCna/WS2wlO5heXiZIVV2mfcYNZ9EmJWKvTQbiyaSNfiFTwJ /cXDqpTw0KPLr0HJgR5wI/bq8tcQ7zmNSyTF7ZhdoSuiSf5OnMVahHK6Ad1POqe6Gy4J K9nnUglBROOHN/shbYvDygODMJApDALy3KcN/0fbEt5opat620GUx6p6IvS+AgV4WrVz 8JliqMwUzzfT9Eq9q/LxIibO1dQqkiqkz+pZJAMC8d+noNPWsg3+d7ByAkGa9Nepxr5h +mcQ== X-Gm-Message-State: ACrzQf28scO+yrGs5YE8InCH/FvsOTPuS/db/pVnXg3CllVgLrz/d+ga zkjXRhIMK2iRB8H4rcJySIt1lQwHbgA= X-Received: by 2002:aa7:db07:0:b0:458:f6e5:ab71 with SMTP id t7-20020aa7db07000000b00458f6e5ab71mr24476557eds.330.1665509096927; Tue, 11 Oct 2022 10:24:56 -0700 (PDT) Received: from localhost.localdomain (92-64-99-37.biz.kpn.net. [92.64.99.37]) by smtp.googlemail.com with ESMTPSA id jt11-20020a170906ca0b00b0078de26f66b9sm8532ejb.114.2022.10.11.10.24.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 11 Oct 2022 10:24:56 -0700 (PDT) From: Martijn van Beurden To: ffmpeg-devel@ffmpeg.org Date: Tue, 11 Oct 2022 19:24:35 +0200 Message-Id: <20221011172437.36211-2-mvanb1@gmail.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20221011172437.36211-1-mvanb1@gmail.com> References: <20221011172437.36211-1-mvanb1@gmail.com> MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH v7 1/3] libavcodec/flacdec: Implement decoding of 32 bit-per-sample PCM 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: Martijn van Beurden Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: 4UKyK93mRejn Add decoding of FLAC files coding for 32 bit-per-sample PCM to libavcodec. --- libavcodec/flac.c | 4 +- libavcodec/flacdec.c | 218 +++++++++++++++++++++++++++++++++++++----- libavcodec/get_bits.h | 12 +++ libavcodec/mathops.h | 9 ++ 4 files changed, 219 insertions(+), 24 deletions(-) diff --git a/libavcodec/flac.c b/libavcodec/flac.c index 352d663c67..174b4801be 100644 --- a/libavcodec/flac.c +++ b/libavcodec/flac.c @@ -28,7 +28,7 @@ #include "flacdata.h" #include "flac_parse.h" -static const int8_t sample_size_table[] = { 0, 8, 12, 0, 16, 20, 24, 0 }; +static const int8_t sample_size_table[] = { 0, 8, 12, 0, 16, 20, 24, 32 }; static const AVChannelLayout flac_channel_layouts[8] = { AV_CHANNEL_LAYOUT_MONO, @@ -82,7 +82,7 @@ int ff_flac_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, /* bits per sample */ bps_code = get_bits(gb, 3); - if (bps_code == 3 || bps_code == 7) { + if (bps_code == 3) { av_log(avctx, AV_LOG_ERROR + log_level_offset, "invalid sample size code (%d)\n", bps_code); diff --git a/libavcodec/flacdec.c b/libavcodec/flacdec.c index 5b8547a98f..56ef033a42 100644 --- a/libavcodec/flacdec.c +++ b/libavcodec/flacdec.c @@ -64,6 +64,9 @@ typedef struct FLACContext { int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples uint8_t *decoded_buffer; unsigned int decoded_buffer_size; + int64_t *decoded_33bps; ///< decoded samples for a 33 bps subframe + uint8_t *decoded_buffer_33bps; + unsigned int decoded_buffer_size_33bps; int buggy_lpc; ///< use workaround for old lavc encoded files FLACDSPContext dsp; @@ -154,6 +157,24 @@ static int allocate_buffers(FLACContext *s) s->stream_info.channels, s->stream_info.max_blocksize, AV_SAMPLE_FMT_S32P, 0); + if (ret >= 0 && s->stream_info.bps == 32 && s->stream_info.channels == 2) { + buf_size = av_samples_get_buffer_size(NULL, 1, + s->stream_info.max_blocksize, + AV_SAMPLE_FMT_S64P, 0); + if (buf_size < 0) + return buf_size; + + av_fast_malloc(&s->decoded_buffer_33bps, &s->decoded_buffer_size_33bps, buf_size); + if (!s->decoded_buffer_33bps) + return AVERROR(ENOMEM); + + ret = av_samples_fill_arrays((uint8_t **)&s->decoded_33bps, NULL, + s->decoded_buffer_33bps, + 1, + s->stream_info.max_blocksize, + AV_SAMPLE_FMT_S64P, 0); + + } return ret < 0 ? ret : 0; } @@ -331,6 +352,62 @@ static int decode_subframe_fixed(FLACContext *s, int32_t *decoded, return 0; } +#define DECODER_SUBFRAME_FIXED_WIDE(residual) { \ + const int blocksize = s->blocksize; \ + int ret; \ + \ + if ((ret = decode_residuals(s, residual, pred_order)) < 0) \ + return ret; \ + \ + switch (pred_order) { \ + case 0: \ + for (int i = pred_order; i < blocksize; i++) \ + decoded[i] = residual[i]; \ + break; \ + case 1: \ + for (int i = pred_order; i < blocksize; i++) \ + decoded[i] = (int64_t)residual[i] + (int64_t)decoded[i-1];\ + break; \ + case 2: \ + for (int i = pred_order; i < blocksize; i++) \ + decoded[i] = (int64_t)residual[i] + 2*(int64_t)decoded[i-1] - (int64_t)decoded[i-2]; \ + break; \ + case 3: \ + for (int i = pred_order; i < blocksize; i++) \ + decoded[i] = (int64_t)residual[i] + 3*(int64_t)decoded[i-1] - 3*(int64_t)decoded[i-2] + (int64_t)decoded[i-3]; \ + break; \ + case 4: \ + for (int i = pred_order; i < blocksize; i++) \ + decoded[i] = (int64_t)residual[i] + 4*(int64_t)decoded[i-1] - 6*(int64_t)decoded[i-2] + 4*(int64_t)decoded[i-3] - (int64_t)decoded[i-4]; \ + break; \ + default: \ + av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order); \ + return AVERROR_INVALIDDATA; \ + } \ + return 0; \ +} + +static int decode_subframe_fixed_wide(FLACContext *s, int32_t *decoded, + int pred_order, int bps) +{ + /* warm up samples */ + for (int i = 0; i < pred_order; i++) { + decoded[i] = get_sbits_long(&s->gb, bps); + } + DECODER_SUBFRAME_FIXED_WIDE(decoded); +} + + +static int decode_subframe_fixed_33bps(FLACContext *s, int64_t *decoded, + int32_t *residual, int pred_order) +{ + /* warm up samples */ \ + for (int i = 0; i < pred_order; i++) { \ + decoded[i] = get_sbits64(&s->gb, 33); \ + } \ + DECODER_SUBFRAME_FIXED_WIDE(residual); +} + static void lpc_analyze_remodulate(SUINT32 *decoded, const int coeffs[32], int order, int qlevel, int len, int bps) { @@ -402,12 +479,53 @@ static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order, return 0; } +static int decode_subframe_lpc_33bps(FLACContext *s, int64_t *decoded, + int32_t *residual, int pred_order) +{ + int i, j, ret; + int coeff_prec, qlevel; + int coeffs[32]; + + /* warm up samples */ + for (i = 0; i < pred_order; i++) { + decoded[i] = get_sbits64(&s->gb, 33); + } + + coeff_prec = get_bits(&s->gb, 4) + 1; + if (coeff_prec == 16) { + av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n"); + return AVERROR_INVALIDDATA; + } + qlevel = get_sbits(&s->gb, 5); + if (qlevel < 0) { + av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n", + qlevel); + return AVERROR_INVALIDDATA; + } + + for (i = 0; i < pred_order; i++) { + coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec); + } + + if ((ret = decode_residuals(s, residual, pred_order)) < 0) + return ret; + + for (i = pred_order; i < s->blocksize; i++, decoded++) { + int64_t sum = 0; + for (j = 0; j < pred_order; j++) + sum += (int64_t)coeffs[j] * decoded[j]; + decoded[j] = residual[i] + (sum >> qlevel); + } + + return 0; +} + static inline int decode_subframe(FLACContext *s, int channel) { int32_t *decoded = s->decoded[channel]; int type, wasted = 0; int bps = s->stream_info.bps; - int i, tmp, ret; + int i, ret; if (channel == 0) { if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE) @@ -427,7 +545,7 @@ static inline int decode_subframe(FLACContext *s, int channel) int left = get_bits_left(&s->gb); if ( left <= 0 || (left < bps && !show_bits_long(&s->gb, left)) || - !show_bits_long(&s->gb, bps)) { + !show_bits_long(&s->gb, bps-1)) { av_log(s->avctx, AV_LOG_ERROR, "Invalid number of wasted bits > available bits (%d) - left=%d\n", bps, left); @@ -436,34 +554,63 @@ static inline int decode_subframe(FLACContext *s, int channel) wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb)); bps -= wasted; } - if (bps > 32) { - avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32"); - return AVERROR_PATCHWELCOME; - } //FIXME use av_log2 for types if (type == 0) { - tmp = get_sbits_long(&s->gb, bps); - for (i = 0; i < s->blocksize; i++) - decoded[i] = tmp; + if (bps < 33) { + int32_t tmp = get_sbits_long(&s->gb, bps); + for (i = 0; i < s->blocksize; i++) + decoded[i] = tmp; + } else { + int64_t tmp = get_sbits64(&s->gb, 33); + for (i = 0; i < s->blocksize; i++) + s->decoded_33bps[i] = tmp; + } } else if (type == 1) { - for (i = 0; i < s->blocksize; i++) - decoded[i] = get_sbits_long(&s->gb, bps); + if (bps < 33) { + for (i = 0; i < s->blocksize; i++) + decoded[i] = get_sbits_long(&s->gb, bps); + } else { + for (i = 0; i < s->blocksize; i++) + s->decoded_33bps[i] = get_sbits64(&s->gb, 33); + } } else if ((type >= 8) && (type <= 12)) { - if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0) - return ret; + int order = type & ~0x8; + if (bps < 33) { + if (bps + order <= 32) { + if ((ret = decode_subframe_fixed(s, decoded, order, bps)) < 0) + return ret; + } else { + if ((ret = decode_subframe_fixed_wide(s, decoded, order, bps)) < 0) + return ret; + } + } else { + if ((ret = decode_subframe_fixed_33bps(s, s->decoded_33bps, decoded, order)) < 0) + return ret; + } } else if (type >= 32) { - if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0) - return ret; + if (bps < 33) { + if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0) + return ret; + } else { + if ((ret = decode_subframe_lpc_33bps(s, s->decoded_33bps, decoded, (type & ~0x20)+1)) < 0) + return ret; + } } else { av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n"); return AVERROR_INVALIDDATA; } - if (wasted && wasted < 32) { - int i; - for (i = 0; i < s->blocksize; i++) - decoded[i] = (unsigned)decoded[i] << wasted; + if (wasted) { + if (wasted+bps == 33) { + int i; + for (i = 0; i < s->blocksize; i++) + s->decoded_33bps[i] = (uint64_t)decoded[i] << wasted; + } else if (wasted < 32) { + int i; + for (i = 0; i < s->blocksize; i++) + decoded[i] = (unsigned)decoded[i] << wasted; + } } return 0; @@ -554,6 +701,26 @@ static int decode_frame(FLACContext *s) return 0; } +static void decorrelate_33bps(int ch_mode, int32_t **decoded, int64_t *decoded_33bps, int len) +{ + int i; + if (ch_mode == FLAC_CHMODE_LEFT_SIDE ) { + for (i = 0; i < len; i++) + decoded[1][i] = decoded[0][i] - decoded_33bps[i]; + } else if (ch_mode == FLAC_CHMODE_RIGHT_SIDE ) { + for (i = 0; i < len; i++) + decoded[0][i] = decoded[1][i] + decoded_33bps[i]; + } else if (ch_mode == FLAC_CHMODE_MID_SIDE ) { + for (i = 0; i < len; i++) { + uint64_t a = decoded[0][i]; + int64_t b = decoded_33bps[i]; + a -= b >> 1; + decoded[0][i] = (a + b); + decoded[1][i] = a; + } + } +} + static int flac_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt) { @@ -612,9 +779,15 @@ static int flac_decode_frame(AVCodecContext *avctx, AVFrame *frame, if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0) return ret; - s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, - s->stream_info.channels, - s->blocksize, s->sample_shift); + if (s->stream_info.bps == 32 && s->ch_mode > 0) { + decorrelate_33bps(s->ch_mode, s->decoded, s->decoded_33bps, s->blocksize); + s->dsp.decorrelate[0](frame->data, s->decoded, s->stream_info.channels, + s->blocksize, s->sample_shift); + } else { + s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, + s->stream_info.channels, + s->blocksize, s->sample_shift); + } if (bytes_read > buf_size) { av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size); @@ -635,6 +808,7 @@ static av_cold int flac_decode_close(AVCodecContext *avctx) FLACContext *s = avctx->priv_data; av_freep(&s->decoded_buffer); + av_freep(&s->decoded_buffer_33bps); return 0; } diff --git a/libavcodec/get_bits.h b/libavcodec/get_bits.h index 992765dc92..52d13b8242 100644 --- a/libavcodec/get_bits.h +++ b/libavcodec/get_bits.h @@ -596,6 +596,18 @@ static inline int get_sbits_long(GetBitContext *s, int n) return sign_extend(get_bits_long(s, n), n); } +/** + * Read 0-64 bits as a signed integer. + */ +static inline int64_t get_sbits64(GetBitContext *s, int n) +{ + // sign_extend(x, 0) is undefined + if (!n) + return 0; + + return sign_extend64(get_bits64(s, n), n); +} + /** * Show 0-32 bits. */ diff --git a/libavcodec/mathops.h b/libavcodec/mathops.h index c89054d6ed..a1dc323304 100644 --- a/libavcodec/mathops.h +++ b/libavcodec/mathops.h @@ -138,6 +138,15 @@ static inline av_const int sign_extend(int val, unsigned bits) } #endif +#ifndef sign_extend64 +static inline av_const int64_t sign_extend64(int64_t val, unsigned bits) +{ + unsigned shift = 8 * sizeof(int64_t) - bits; + union { uint64_t u; int64_t s; } v = { (uint64_t) val << shift }; + return v.s >> shift; +} +#endif + #ifndef zero_extend static inline av_const unsigned zero_extend(unsigned val, unsigned bits) { From patchwork Tue Oct 11 17:24:36 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Martijn van Beurden X-Patchwork-Id: 38696 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:4a86:b0:9d:28a3:170e with SMTP id fn6csp981328pzb; Tue, 11 Oct 2022 10:25:25 -0700 (PDT) X-Google-Smtp-Source: AMsMyM4VOq2Ts5NvJFZiYsRzIMaEv8odGILWT4NgmckWZVuZeObDb4fA2c5Vt83qOShOVGGNuWLg X-Received: by 2002:a17:906:b08d:b0:782:d526:3e36 with SMTP id x13-20020a170906b08d00b00782d5263e36mr19989888ejy.358.1665509125639; Tue, 11 Oct 2022 10:25:25 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1665509125; cv=none; d=google.com; s=arc-20160816; b=TWJf9M/kNpOxi3358GWIpPhL9b5N80deNtM9iwiBDYfO00oW8BTwK6bSW06+SeOtVF Hj7TeFNev/1nP0aaQJ6RSzjzrOPHKiiQx3izb6qjiS/oJfdXDCvTD7uQfRoULrmIFp6t YWBYh07QX55/gfJYOYqItxsvIdPzgMvXr2G0pRTTKfLOpSbziE3fA0wqEBBPvCSPOzP4 pGD1f5VpvNIooXhVVjagzskvFJoaJcPtFkJNjNiVfBdxYsRHfq5IA9lfHKXkJ8lP1Z8L yCMTTHkO0V6eDDJ4COfVi0iMhHmnC22/ivriDwsIz0I6pvAxJgj62vEId89/pDQdtmiY 1RTA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding:cc:reply-to :list-subscribe:list-help:list-post:list-archive:list-unsubscribe :list-id:precedence:subject:mime-version:references:in-reply-to :message-id:date:to:from:dkim-signature:delivered-to; bh=ntrX8ExD0uRYbfxhOoCE89TiQdXxzOcjocVwjbU3Kso=; b=hXY/zXfl+Excsx3SBq16B1unvT3gW7uCInn71kX167aAB5FV6qbCSt/3QLgAU8O0Zn x7RqKtdTak+3sK28mIFxlKtKbpRgMpR3ZKTQs+cm4kRoRTTqOETPK49CJ8yD9/Xlp+l7 Z5rxPuizT3jiE0EmMGx5juxS97CajvleRYrqPCvHcAsAmnAp6M38dl1HayQi79lpofCc 2Y/kHAjkGGn3BjKUOg804Uxp/sa+hplDI3ZdQKTDJzKKa729/gXc7XMgTJQwZnw6JWM2 giRBzuJzAq9wxP8aJqmHsPZ3AiEVftgB/YHqXAF55p2MAWBaG+ue9FRcXe0E2lTiQglT XYiA== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@gmail.com header.s=20210112 header.b=RSHOkZwM; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id h17-20020a50cdd1000000b0045c81b42209si2010500edj.384.2022.10.11.10.25.25; Tue, 11 Oct 2022 10:25:25 -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=@gmail.com header.s=20210112 header.b=RSHOkZwM; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id DC5E568BD11; Tue, 11 Oct 2022 20:25:05 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-ed1-f50.google.com (mail-ed1-f50.google.com [209.85.208.50]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 95B8768BCCD for ; Tue, 11 Oct 2022 20:24:59 +0300 (EEST) Received: by mail-ed1-f50.google.com with SMTP id w10so21143865edd.4 for ; Tue, 11 Oct 2022 10:24:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=JkcnSqZOGvIFZDrWow00JMUMcbg0PwuSV3k7Yr8Rz+k=; b=RSHOkZwMq8zZ5bYaJnhNH5AlJsgQEnvVvQITf/c+UV1Q6dDi1thhH8DCpBpZ2z1jkb Dz1DYHpLRIknhcObXCfGm87ej+GQpfiMgXi3xww7wch5vsEJ+4ZRQ7JLlG76ocnlHTf1 bwkc0q+Bd7FJxwz3qtvxlVwakT+cwVtDZKJi9UmUq+QPLBfS7newzv6Sd1bLFiQFyUGz EcBe0cHsuUHNlEOoPUl/mnlKvEquGXAMg4/3aAwz55kDmB8/jjld5Ip2RR88SiLEbbdy 3qovKbaLycNvFmLdTnG2p5QtWicOxPzEi1AS0A+NyEtMFhQYmSfMvBT6AYnmRHW92m4M oN6A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=JkcnSqZOGvIFZDrWow00JMUMcbg0PwuSV3k7Yr8Rz+k=; b=eqtrYdF49dzy17ZdSxK1+30Lr0Uh25ebUxAjAQuwAcnrskqopiZStnmpVVIARWJvlp C5aPg6+5fleJhITzWhuzfntgfXFW8CW6PF/6liAp8+UZIDBLfyow498eGhj/KL4X3eVQ XfHh8n7EKr1i1bcsKKhg+sJlSXzrhccxr+zI6fKC0CEwnWNoxlICMIu0EqeB0KZwNN+p ekMelpB7wQtbKKiDiWREEj8KtMO5a+55Qo+k1I5VmKcqEInRJINd258MUeCH4rSnk1In Lv39iWwpURf6Kl3igNmO6s3B/jyl5vrPCzZZpguEkEG/lXWGpeF6xUCtveiwmvC81ngh 6NvA== X-Gm-Message-State: ACrzQf2nI/xHucMCNcumRGWhgGjLT+gwfcIZRu08RqvaSLI3y/HnSxbY dZBXVWBzPcIGwbT5UxYOjJvrQWnnC6Y= X-Received: by 2002:a05:6402:176e:b0:45c:9e48:27a5 with SMTP id da14-20020a056402176e00b0045c9e4827a5mr763266edb.53.1665509098220; Tue, 11 Oct 2022 10:24:58 -0700 (PDT) Received: from localhost.localdomain (92-64-99-37.biz.kpn.net. [92.64.99.37]) by smtp.googlemail.com with ESMTPSA id jt11-20020a170906ca0b00b0078de26f66b9sm8532ejb.114.2022.10.11.10.24.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 11 Oct 2022 10:24:57 -0700 (PDT) From: Martijn van Beurden To: ffmpeg-devel@ffmpeg.org Date: Tue, 11 Oct 2022 19:24:36 +0200 Message-Id: <20221011172437.36211-3-mvanb1@gmail.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20221011172437.36211-1-mvanb1@gmail.com> References: <20221011172437.36211-1-mvanb1@gmail.com> MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH v7 2/3] libavcodec/flacenc: Implement encoding of 32 bit-per-sample PCM 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: Martijn van Beurden Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: JSsT/xHQWCtm Add encoding of 32 bit-per-sample PCM to FLAC files to libavcodec. Coding to this format is at this point considered experimental and -strict experimental is needed to get ffmpeg to encode such files. --- libavcodec/flacenc.c | 480 +++++++++++++++++++++++++++++++--------- libavcodec/put_bits.h | 7 + libavcodec/put_golomb.h | 14 -- 3 files changed, 379 insertions(+), 122 deletions(-) diff --git a/libavcodec/flacenc.c b/libavcodec/flacenc.c index 5d8c3f82be..1e4eb0d319 100644 --- a/libavcodec/flacenc.c +++ b/libavcodec/flacenc.c @@ -31,7 +31,6 @@ #include "codec_internal.h" #include "encode.h" #include "put_bits.h" -#include "put_golomb.h" #include "lpc.h" #include "flac.h" #include "flacdata.h" @@ -95,6 +94,7 @@ typedef struct FlacSubframe { typedef struct FlacFrame { FlacSubframe subframes[FLAC_MAX_CHANNELS]; + int64_t samples_33bps[FLAC_MAX_BLOCKSIZE]; int blocksize; int bs_code[2]; uint8_t crc8; @@ -282,10 +282,22 @@ static av_cold int flac_encode_init(AVCodecContext *avctx) s->bps_code = 4; break; case AV_SAMPLE_FMT_S32: - if (avctx->bits_per_raw_sample != 24) - av_log(avctx, AV_LOG_WARNING, "encoding as 24 bits-per-sample\n"); - avctx->bits_per_raw_sample = 24; - s->bps_code = 6; + if (avctx->bits_per_raw_sample <= 24) { + if (avctx->bits_per_raw_sample < 24) + av_log(avctx, AV_LOG_WARNING, "encoding as 24 bits-per-sample\n"); + avctx->bits_per_raw_sample = 24; + s->bps_code = 6; + } else if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) { + av_log(avctx, AV_LOG_WARNING, + "encoding as 24 bits-per-sample, more is considered " + "experimental. Add -strict experimental if you want " + "to encode more than 24 bits-per-sample\n"); + avctx->bits_per_raw_sample = 24; + s->bps_code = 6; + } else { + avctx->bits_per_raw_sample = 32; + s->bps_code = 7; + } break; } @@ -533,8 +545,7 @@ static uint64_t rice_count_exact(const int32_t *res, int n, int k) uint64_t count = 0; for (i = 0; i < n; i++) { - int32_t v = -2 * res[i] - 1; - v ^= v >> 31; + unsigned v = ((unsigned)(res[i]) << 1) ^ (res[i] >> 31); count += (v >> k) + 1 + k; } return count; @@ -713,8 +724,8 @@ static uint64_t calc_rice_params(RiceContext *rc, tmp_rc.coding_mode = rc->coding_mode; - for (i = 0; i < n; i++) - udata[i] = (2 * data[i]) ^ (data[i] >> 31); + for (i = pred_order; i < n; i++) + udata[i] = ((unsigned)(data[i]) << 1) ^ (data[i] >> 31); calc_sum_top(pmax, exact ? kmax : 0, udata, n, pred_order, sums); @@ -812,6 +823,130 @@ static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n, } +/* These four functions check for every residual whether it can be + * contained in INT32_MAX) \ + return 1; \ + res[i] = res64; \ + } \ + } else if (order == 2) { \ + for (int i = order; i < n; i++) { \ + int64_t res64 = (int64_t)smp[i] - 2*(int64_t)smp[i-1] + smp[i-2]; \ + if (res64 <= INT32_MIN || res64 > INT32_MAX) \ + return 1; \ + res[i] = res64; \ + } \ + } else if (order == 3) { \ + for (int i = order; i < n; i++) { \ + int64_t res64 = (int64_t)smp[i] - 3*(int64_t)smp[i-1] + 3*(int64_t)smp[i-2] - smp[i-3]; \ + if (res64 <= INT32_MIN || res64 > INT32_MAX) \ + return 1; \ + res[i] = res64; \ + } \ + } else { \ + for (int i = order; i < n; i++) { \ + int64_t res64 = (int64_t)smp[i] - 4*(int64_t)smp[i-1] + 6*(int64_t)smp[i-2] - 4*(int64_t)smp[i-3] + smp[i-4]; \ + if (res64 <= INT32_MIN || res64 > INT32_MAX) \ + return 1; \ + res[i] = res64; \ + } \ + } \ + return 0; \ +} + +static int encode_residual_fixed_with_residual_limit(int32_t *res, const int32_t *smp, + int n, int order) +{ + ENCODE_RESIDUAL_FIXED_WITH_RESIDUAL_LIMIT(); +} + + +static int encode_residual_fixed_with_residual_limit_33bps(int32_t *res, const int64_t *smp, + int n, int order) +{ + ENCODE_RESIDUAL_FIXED_WITH_RESIDUAL_LIMIT(); +} + +#define LPC_ENCODE_WITH_RESIDUAL_LIMIT() \ +{ \ + for (int i = 0; i < order; i++) \ + res[i] = smp[i]; \ + for (int i = order; i < len; i++) { \ + int64_t p = 0, tmp; \ + for (int j = 0; j < order; j++) \ + p += (int64_t)coefs[j]*smp[(i-1)-j]; \ + p >>= shift; \ + tmp = smp[i] - p; \ + if (tmp <= INT32_MIN || tmp > INT32_MAX) \ + return 1; \ + res[i] = tmp; \ + } \ + return 0; \ +} + +static int lpc_encode_with_residual_limit(int32_t *res, const int32_t *smp, int len, + int order, int32_t *coefs, int shift) +{ + LPC_ENCODE_WITH_RESIDUAL_LIMIT(); +} + +static int lpc_encode_with_residual_limit_33bps(int32_t *res, const int64_t *smp, int len, + int order, int32_t *coefs, int shift) +{ + LPC_ENCODE_WITH_RESIDUAL_LIMIT(); +} + +static int lpc_encode_choose_datapath(FlacEncodeContext *s, int32_t bps, + int32_t *res, const int32_t *smp, + const int64_t *smp_33bps, int len, + int order, int32_t *coefs, int shift) +{ + uint64_t max_residual_value = 0; + int64_t max_sample_value = ((int64_t)(1) << (bps-1)); + /* This calculates the max size of any residual with the current + * predictor, so we know whether we need to check the residual */ + for (int i = 0; i < order; i++) + max_residual_value += FFABS(max_sample_value * coefs[i]); + max_residual_value >>= shift; + max_residual_value += max_sample_value; + if (bps > 32) { + if (lpc_encode_with_residual_limit_33bps(res, smp_33bps, len, order, coefs, shift)) + return 1; + } else if (max_residual_value > INT32_MAX) { + if (lpc_encode_with_residual_limit(res, smp, len, order, coefs, shift)) + return 1; + } else if (bps + s->options.lpc_coeff_precision + av_log2(order) <= 32) { + s->flac_dsp.lpc16_encode(res, smp, len, order, coefs, shift); + } else { + s->flac_dsp.lpc32_encode(res, smp, len, order, coefs, shift); + } + return 0; +} + +#define DEFAULT_TO_VERBATIM() \ +{ \ + sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM; \ + if (sub->obits <= 32) \ + memcpy(res, smp, n * sizeof(int32_t)); \ + return subframe_count_exact(s, sub, 0); \ +} + static int encode_residual_ch(FlacEncodeContext *s, int ch) { int i, n; @@ -821,28 +956,38 @@ static int encode_residual_ch(FlacEncodeContext *s, int ch) int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER]; int shift[MAX_LPC_ORDER]; int32_t *res, *smp; + int64_t *smp_33bps; - frame = &s->frame; - sub = &frame->subframes[ch]; - res = sub->residual; - smp = sub->samples; - n = frame->blocksize; + frame = &s->frame; + sub = &frame->subframes[ch]; + res = sub->residual; + smp = sub->samples; + smp_33bps = frame->samples_33bps; + n = frame->blocksize; /* CONSTANT */ - for (i = 1; i < n; i++) - if(smp[i] != smp[0]) - break; - if (i == n) { - sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT; - res[0] = smp[0]; - return subframe_count_exact(s, sub, 0); + if (sub->obits > 32) { + for (i = 1; i < n; i++) + if(smp_33bps[i] != smp_33bps[0]) + break; + if (i == n) { + sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT; + return subframe_count_exact(s, sub, 0); + } + } else { + for (i = 1; i < n; i++) + if(smp[i] != smp[0]) + break; + if (i == n) { + sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT; + res[0] = smp[0]; + return subframe_count_exact(s, sub, 0); + } } /* VERBATIM */ if (frame->verbatim_only || n < 5) { - sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM; - memcpy(res, smp, n * sizeof(int32_t)); - return subframe_count_exact(s, sub, 0); + DEFAULT_TO_VERBATIM(); } min_order = s->options.min_prediction_order; @@ -859,15 +1004,32 @@ static int encode_residual_ch(FlacEncodeContext *s, int ch) opt_order = 0; bits[0] = UINT32_MAX; for (i = min_order; i <= max_order; i++) { - encode_residual_fixed(res, smp, n, i); + if (sub->obits == 33) { + if (encode_residual_fixed_with_residual_limit_33bps(res, smp_33bps, n, i)) + continue; + } else if (sub->obits + i >= 32) { + if (encode_residual_fixed_with_residual_limit(res, smp, n, i)) + continue; + } else + encode_residual_fixed(res, smp, n, i); bits[i] = find_subframe_rice_params(s, sub, i); if (bits[i] < bits[opt_order]) opt_order = i; } + if (opt_order == 0 && bits[0] == UINT32_MAX) { + /* No predictor found with residuals within order = opt_order; sub->type_code = sub->type | sub->order; if (sub->order != max_order) { - encode_residual_fixed(res, smp, n, sub->order); + if (sub->obits == 33) + encode_residual_fixed_with_residual_limit_33bps(res, smp_33bps, n, sub->order); + else if (sub->obits + i >= 32) + encode_residual_fixed_with_residual_limit(res, smp, n, sub->order); + else + encode_residual_fixed(res, smp, n, sub->order); find_subframe_rice_params(s, sub, sub->order); } return subframe_count_exact(s, sub, sub->order); @@ -875,6 +1037,14 @@ static int encode_residual_ch(FlacEncodeContext *s, int ch) /* LPC */ sub->type = FLAC_SUBFRAME_LPC; + if (sub->obits == 33) + /* As ff_lpc_calc_coefs is shared with other codecs and the LSB + * probably isn't predictable anyway, throw away LSB for analysis + * so it fits 32 bit int and existing function can be used + * unmodified */ + for (i = 0; i < n; i++) + smp[i] = smp_33bps[i] >> 1; + opt_order = ff_lpc_calc_coefs(&s->lpc_ctx, smp, n, min_order, max_order, s->options.lpc_coeff_precision, coefs, shift, s->options.lpc_type, s->options.lpc_passes, omethod, @@ -895,13 +1065,8 @@ static int encode_residual_ch(FlacEncodeContext *s, int ch) order = av_clip(order, min_order - 1, max_order - 1); if (order == last_order) continue; - if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(order) <= 32) { - s->flac_dsp.lpc16_encode(res, smp, n, order+1, coefs[order], - shift[order]); - } else { - s->flac_dsp.lpc32_encode(res, smp, n, order+1, coefs[order], - shift[order]); - } + if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, order+1, coefs[order], shift[order])) + continue; bits[i] = find_subframe_rice_params(s, sub, order+1); if (bits[i] < bits[opt_index]) { opt_index = i; @@ -915,11 +1080,8 @@ static int encode_residual_ch(FlacEncodeContext *s, int ch) opt_order = 0; bits[0] = UINT32_MAX; for (i = min_order-1; i < max_order; i++) { - if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(i) <= 32) { - s->flac_dsp.lpc16_encode(res, smp, n, i+1, coefs[i], shift[i]); - } else { - s->flac_dsp.lpc32_encode(res, smp, n, i+1, coefs[i], shift[i]); - } + if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, i+1, coefs[i], shift[i])) + continue; bits[i] = find_subframe_rice_params(s, sub, i+1); if (bits[i] < bits[opt_order]) opt_order = i; @@ -937,11 +1099,8 @@ static int encode_residual_ch(FlacEncodeContext *s, int ch) for (i = last-step; i <= last+step; i += step) { if (i < min_order-1 || i >= max_order || bits[i] < UINT32_MAX) continue; - if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(i) <= 32) { - s->flac_dsp.lpc32_encode(res, smp, n, i+1, coefs[i], shift[i]); - } else { - s->flac_dsp.lpc16_encode(res, smp, n, i+1, coefs[i], shift[i]); - } + if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, i+1, coefs[i], shift[i])) + continue; bits[i] = find_subframe_rice_params(s, sub, i+1); if (bits[i] < bits[opt_order]) opt_order = i; @@ -978,11 +1137,8 @@ static int encode_residual_ch(FlacEncodeContext *s, int ch) if (diffsum >8) continue; - if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(opt_order - 1) <= 32) { - s->flac_dsp.lpc16_encode(res, smp, n, opt_order, lpc_try, shift[opt_order-1]); - } else { - s->flac_dsp.lpc32_encode(res, smp, n, opt_order, lpc_try, shift[opt_order-1]); - } + if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, opt_order, lpc_try, shift[opt_order-1])) + continue; score = find_subframe_rice_params(s, sub, opt_order); if (score < best_score) { best_score = score; @@ -999,10 +1155,10 @@ static int encode_residual_ch(FlacEncodeContext *s, int ch) for (i = 0; i < sub->order; i++) sub->coefs[i] = coefs[sub->order-1][i]; - if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(opt_order) <= 32) { - s->flac_dsp.lpc16_encode(res, smp, n, sub->order, sub->coefs, sub->shift); - } else { - s->flac_dsp.lpc32_encode(res, smp, n, sub->order, sub->coefs, sub->shift); + if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, sub->order, sub->coefs, sub->shift)) { + /* No predictor found with residuals within order); @@ -1069,57 +1225,91 @@ static int encode_frame(FlacEncodeContext *s) static void remove_wasted_bits(FlacEncodeContext *s) { - int ch, i; + int ch, i, wasted_bits; for (ch = 0; ch < s->channels; ch++) { FlacSubframe *sub = &s->frame.subframes[ch]; - int32_t v = 0; - for (i = 0; i < s->frame.blocksize; i++) { - v |= sub->samples[i]; - if (v & 1) - break; - } + if (sub->obits > 32) { + int64_t v = 0; + for (i = 0; i < s->frame.blocksize; i++) { + v |= s->frame.samples_33bps[i]; + if (v & 1) + break; + } + + if (!v || (v & 1)) + return; + + v = ff_ctzll(v); + + /* If any wasted bits are found, samples are moved + * from frame.samples_33bps to frame.subframes[ch] */ + for (i = 0; i < s->frame.blocksize; i++) + sub->samples[i] = s->frame.samples_33bps[i] >> v; + wasted_bits = v; + } else { + int32_t v = 0; + for (i = 0; i < s->frame.blocksize; i++) { + v |= sub->samples[i]; + if (v & 1) + break; + } + + if (!v || (v & 1)) + return; - if (v && !(v & 1)) { v = ff_ctz(v); for (i = 0; i < s->frame.blocksize; i++) sub->samples[i] >>= v; + wasted_bits = v; + } - sub->wasted = v; - sub->obits -= v; + sub->wasted = wasted_bits; + sub->obits -= wasted_bits; - /* for 24-bit, check if removing wasted bits makes the range better - suited for using RICE instead of RICE2 for entropy coding */ - if (sub->obits <= 17) - sub->rc.coding_mode = CODING_MODE_RICE; - } + /* for 24-bit, check if removing wasted bits makes the range better + * suited for using RICE instead of RICE2 for entropy coding */ + if (sub->obits <= 17) + sub->rc.coding_mode = CODING_MODE_RICE; } } static int estimate_stereo_mode(const int32_t *left_ch, const int32_t *right_ch, int n, - int max_rice_param) + int max_rice_param, int bps) { - int i, best; - int32_t lt, rt; + int best; uint64_t sum[4]; uint64_t score[4]; int k; /* calculate sum of 2nd order residual for each channel */ sum[0] = sum[1] = sum[2] = sum[3] = 0; - for (i = 2; i < n; i++) { - lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2]; - rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2]; - sum[2] += FFABS((lt + rt) >> 1); - sum[3] += FFABS(lt - rt); - sum[0] += FFABS(lt); - sum[1] += FFABS(rt); + if(bps < 30) { + int32_t lt, rt; + for (int i = 2; i < n; i++) { + lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2]; + rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2]; + sum[2] += FFABS((lt + rt) >> 1); + sum[3] += FFABS(lt - rt); + sum[0] += FFABS(lt); + sum[1] += FFABS(rt); + } + } else { + int64_t lt, rt; + for (int i = 2; i < n; i++) { + lt = (int64_t)left_ch[i] - 2*(int64_t)left_ch[i-1] + left_ch[i-2]; + rt = (int64_t)right_ch[i] - 2*(int64_t)right_ch[i-1] + right_ch[i-2]; + sum[2] += FFABS((lt + rt) >> 1); + sum[3] += FFABS(lt - rt); + sum[0] += FFABS(lt); + sum[1] += FFABS(rt); + } } /* estimate bit counts */ - for (i = 0; i < 4; i++) { + for (int i = 0; i < 4; i++) { k = find_optimal_param(2 * sum[i], n, max_rice_param); sum[i] = rice_encode_count( 2 * sum[i], n, k); } @@ -1132,7 +1322,7 @@ static int estimate_stereo_mode(const int32_t *left_ch, const int32_t *right_ch, /* return mode with lowest score */ best = 0; - for (i = 1; i < 4; i++) + for (int i = 1; i < 4; i++) if (score[i] < score[best]) best = i; @@ -1147,12 +1337,14 @@ static void channel_decorrelation(FlacEncodeContext *s) { FlacFrame *frame; int32_t *left, *right; - int i, n; + int64_t *side_33bps; + int n; - frame = &s->frame; - n = frame->blocksize; - left = frame->subframes[0].samples; - right = frame->subframes[1].samples; + frame = &s->frame; + n = frame->blocksize; + left = frame->subframes[0].samples; + right = frame->subframes[1].samples; + side_33bps = frame->samples_33bps; if (s->channels != 2) { frame->ch_mode = FLAC_CHMODE_INDEPENDENT; @@ -1161,29 +1353,49 @@ static void channel_decorrelation(FlacEncodeContext *s) if (s->options.ch_mode < 0) { int max_rice_param = (1 << frame->subframes[0].rc.coding_mode) - 2; - frame->ch_mode = estimate_stereo_mode(left, right, n, max_rice_param); + frame->ch_mode = estimate_stereo_mode(left, right, n, max_rice_param, s->avctx->bits_per_raw_sample); } else frame->ch_mode = s->options.ch_mode; /* perform decorrelation and adjust bits-per-sample */ if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT) return; - if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) { - int32_t tmp; - for (i = 0; i < n; i++) { - tmp = left[i]; - left[i] = (tmp + right[i]) >> 1; - right[i] = tmp - right[i]; + if(s->avctx->bits_per_raw_sample == 32) { + if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) { + int64_t tmp; + for (int i = 0; i < n; i++) { + tmp = left[i]; + left[i] = (tmp + right[i]) >> 1; + side_33bps[i] = tmp - right[i]; + } + frame->subframes[1].obits++; + } else if (frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) { + for (int i = 0; i < n; i++) + side_33bps[i] = (int64_t)left[i] - right[i]; + frame->subframes[1].obits++; + } else { + for (int i = 0; i < n; i++) + side_33bps[i] = (int64_t)left[i] - right[i]; + frame->subframes[0].obits++; } - frame->subframes[1].obits++; - } else if (frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) { - for (i = 0; i < n; i++) - right[i] = left[i] - right[i]; - frame->subframes[1].obits++; } else { - for (i = 0; i < n; i++) - left[i] -= right[i]; - frame->subframes[0].obits++; + if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) { + int32_t tmp; + for (int i = 0; i < n; i++) { + tmp = left[i]; + left[i] = (tmp + right[i]) >> 1; + right[i] = tmp - right[i]; + } + frame->subframes[1].obits++; + } else if (frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) { + for (int i = 0; i < n; i++) + right[i] = left[i] - right[i]; + frame->subframes[1].obits++; + } else { + for (int i = 0; i < n; i++) + left[i] -= right[i]; + frame->subframes[0].obits++; + } } } @@ -1232,13 +1444,32 @@ static void write_frame_header(FlacEncodeContext *s) } +static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k) +{ + unsigned v, e; + + v = ((unsigned)(i) << 1) ^ (i >> 31); + + e = (v >> k) + 1; + while (e > 31) { + put_bits(pb, 31, 0); + e -= 31; + } + put_bits(pb, e, 1); + if (k) { + unsigned mask = UINT32_MAX >> (32-k); + put_bits(pb, k, v & mask); + } +} + + static void write_subframes(FlacEncodeContext *s) { int ch; for (ch = 0; ch < s->channels; ch++) { FlacSubframe *sub = &s->frame.subframes[ch]; - int i, p, porder, psize; + int p, porder, psize; int32_t *part_end; int32_t *res = sub->residual; int32_t *frame_end = &sub->residual[s->frame.blocksize]; @@ -1252,21 +1483,45 @@ static void write_subframes(FlacEncodeContext *s) /* subframe */ if (sub->type == FLAC_SUBFRAME_CONSTANT) { - put_sbits(&s->pb, sub->obits, res[0]); + if(sub->obits == 33) + put_sbits63(&s->pb, 33, s->frame.samples_33bps[0]); + else if(sub->obits == 32) + put_bits32(&s->pb, res[0]); + else + put_sbits(&s->pb, sub->obits, res[0]); } else if (sub->type == FLAC_SUBFRAME_VERBATIM) { - while (res < frame_end) - put_sbits(&s->pb, sub->obits, *res++); + if (sub->obits == 33) { + int64_t *res64 = s->frame.samples_33bps; + int64_t *frame_end64 = &s->frame.samples_33bps[s->frame.blocksize]; + while (res64 < frame_end64) + put_sbits63(&s->pb, 33, (*res64++)); + } else if (sub->obits == 32) { + while (res < frame_end) + put_bits32(&s->pb, *res++); + } else { + while (res < frame_end) + put_sbits(&s->pb, sub->obits, *res++); + } } else { /* warm-up samples */ - for (i = 0; i < sub->order; i++) - put_sbits(&s->pb, sub->obits, *res++); + if (sub->obits == 33) { + for (int i = 0; i < sub->order; i++) + put_sbits63(&s->pb, 33, s->frame.samples_33bps[i]); + res += sub->order; + } else if (sub->obits == 32) { + for (int i = 0; i < sub->order; i++) + put_bits32(&s->pb, *res++); + } else { + for (int i = 0; i < sub->order; i++) + put_sbits(&s->pb, sub->obits, *res++); + } /* LPC coefficients */ if (sub->type == FLAC_SUBFRAME_LPC) { int cbits = s->options.lpc_coeff_precision; put_bits( &s->pb, 4, cbits-1); put_sbits(&s->pb, 5, sub->shift); - for (i = 0; i < sub->order; i++) + for (int i = 0; i < sub->order; i++) put_sbits(&s->pb, cbits, sub->coefs[i]); } @@ -1284,7 +1539,7 @@ static void write_subframes(FlacEncodeContext *s) int k = sub->rc.params[p]; put_bits(&s->pb, sub->rc.coding_mode, k); while (res < part_end) - set_sr_golomb_flac(&s->pb, *res++, k, INT32_MAX, 0); + set_sr_golomb_flac(&s->pb, *res++, k); part_end = FFMIN(frame_end, part_end + psize); } } @@ -1332,7 +1587,7 @@ static int update_md5_sum(FlacEncodeContext *s, const void *samples) (const uint16_t *) samples, buf_size / 2); buf = s->md5_buffer; #endif - } else { + } else if (s->avctx->bits_per_raw_sample <= 24) { int i; const int32_t *samples0 = samples; uint8_t *tmp = s->md5_buffer; @@ -1342,6 +1597,15 @@ static int update_md5_sum(FlacEncodeContext *s, const void *samples) AV_WL24(tmp + 3*i, v); } buf = s->md5_buffer; + } else { + /* s->avctx->bits_per_raw_sample <= 32 */ + int i; + const int32_t *samples0 = samples; + uint8_t *tmp = s->md5_buffer; + + for (i = 0; i < s->frame.blocksize * s->channels; i++) + AV_WL32(tmp + 4*i, samples0[i]); + buf = s->md5_buffer; } av_md5_update(s->md5ctx, buf, buf_size); diff --git a/libavcodec/put_bits.h b/libavcodec/put_bits.h index 4b4f977ad5..4561dc131a 100644 --- a/libavcodec/put_bits.h +++ b/libavcodec/put_bits.h @@ -363,6 +363,13 @@ static inline void put_bits64(PutBitContext *s, int n, uint64_t value) } } +static inline void put_sbits63(PutBitContext *pb, int n, int64_t value) +{ + av_assert2(n >= 0 && n < 64); + + put_bits64(pb, n, (uint64_t)(value) & (~(UINT64_MAX << n))); +} + /** * Return the pointer to the byte where the bitstream writer will put * the next bit. diff --git a/libavcodec/put_golomb.h b/libavcodec/put_golomb.h index 9ca911fc3c..df47fd2c0a 100644 --- a/libavcodec/put_golomb.h +++ b/libavcodec/put_golomb.h @@ -151,18 +151,4 @@ static inline void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, set_ur_golomb(pb, v, k, limit, esc_len); } -/** - * write signed golomb rice code (flac). - */ -static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k, - int limit, int esc_len) -{ - int v; - - v = -2 * i - 1; - v ^= (v >> 31); - - set_ur_golomb_jpegls(pb, v, k, limit, esc_len); -} - #endif /* AVCODEC_PUT_GOLOMB_H */ From patchwork Tue Oct 11 17:24:37 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Martijn van Beurden X-Patchwork-Id: 38697 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:4a86:b0:9d:28a3:170e with SMTP id fn6csp981379pzb; Tue, 11 Oct 2022 10:25:34 -0700 (PDT) X-Google-Smtp-Source: AMsMyM51BApduGtxCbCcCigKmTVnQWnFgqv/Cif6LcV62fY4wm+K5OHdxHxuifiHVRdstOtshHPY X-Received: by 2002:a05:6402:401e:b0:45c:a1ce:94bf with SMTP id d30-20020a056402401e00b0045ca1ce94bfmr361656eda.177.1665509134516; Tue, 11 Oct 2022 10:25:34 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1665509134; cv=none; d=google.com; s=arc-20160816; b=eAPaxHznuMQF77xU9fTvN9/HfVfgEq8vtPj2pNZJRQheNXY5qqwpmCIz5EKguHt2JP 8J5h8ZN2UmAxRDIKI59oULGwNZvFqO9GXg0kToVUiuo5CcwpPSTNXeqdHDBXKwoaa0hH tK4GGzwmLtsJi2nc264YKXJOV2z9pqnhxw6y+Zs1Xc1bMBQs3cNcEb7Nm5+tknLmzxQt bGJi8haq4zW8pVaZ2TzyENOLNuucJOXb8R1mxMMPWhR+5xj5MbrzbEY7JNk0kmigtL9+ L3NszI5QsGwFHejd/cGTjJS9oHtbOewATkkzYFnoJKExoJJN82ydLnEFuauWGq12uu8v uqWQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding:cc:reply-to :list-subscribe:list-help:list-post:list-archive:list-unsubscribe :list-id:precedence:subject:mime-version:references:in-reply-to :message-id:date:to:from:dkim-signature:delivered-to; bh=msKCww62lZ3dQJmxSXI6rxW+qfodxN1IWHAPlsAe8EE=; b=Wdb4HYeYfuBXeM/IjXIvoEGNiRCxOlZ+q9bJj/9aKz6RIeVXEm5i3uiz7G3WVqs8bn hZFp94JxQ9p1yqv7umm1nP1tAuB05U/KldTbErRcwxwcRX5FS1e4Ug/q1LykC7nbXKRN zSIyRMV4picoOxduEVMJpITaTZxjYaub/CX8RqFQKiHjqBazPjtAd0v0mzzdBIP22zRq w3OwNPUHUtgKMMb/xjRZtYGijHZw3ypv+ZnUNqXuWiQK/wV8kVOQtvaWwyuj9gMcVAur hAyjuc/M+sz62Vy6dhPSD8LajoITb6d455mJbyUCkAkdtHzerI5MhBWRjNqRn5hCGgxo xOBQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@gmail.com header.s=20210112 header.b=MkCjO4U4; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id w15-20020a05640234cf00b00458ec94d128si16061665edc.513.2022.10.11.10.25.34; Tue, 11 Oct 2022 10:25:34 -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=@gmail.com header.s=20210112 header.b=MkCjO4U4; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 03D9668BD20; Tue, 11 Oct 2022 20:25:07 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-ej1-f48.google.com (mail-ej1-f48.google.com [209.85.218.48]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id A252368BD11 for ; Tue, 11 Oct 2022 20:25:00 +0300 (EEST) Received: by mail-ej1-f48.google.com with SMTP id 13so32952099ejn.3 for ; Tue, 11 Oct 2022 10:25:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=NNRbks+QKnzDSkeLrfbtYjGrnHB+4v5rMuS6GbBbVYQ=; b=MkCjO4U4d649MTqSuGtDVecoqc4nH7zeyY4W1IcwtXLYNoKlt47SvD2RmpYcwjS+4E 8jSncL2sHxA/m6JTIjKAc945/joJYIPQTG1w6pcnvJKlbRx8K81e33ILsRFShI30+3aD clRY4C/di0YI7QYUwIEfmWWttNUDXheh/BbFj43iXmlJs1M/1+zxZgG2Z7QrSbL5ImGN 2dbuBLiranAv+7/AEwzwH/2135CQweJAaMqDLLzbXvZdVuJ4CL6UqNgOUwm+KWhmmI0O 8ioW44Z0cl4eabMycM+g8qu1wagVWZVuz6PFt2qer26qBAEjUKIazb9m+BzdBZ74L04u gQ1A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=NNRbks+QKnzDSkeLrfbtYjGrnHB+4v5rMuS6GbBbVYQ=; b=oT5WJVImGupaqa3O2k7V8v+1gz4o7jFVxt9Ar/VBHNT/OC0A8fKkE0vCCoffFpVrii F/GIRxI/ZWRpWtE6ZCjWm+NtjrSCst9oHvSztOHga0/Wmb0L6tx7dprKnBTxUEbr39M0 uh/4uBv7aZOaWlvi2IzgOUyDP3PwootNfGXXrIStrTZqVjNqlLjA53xAe3xqe9IGEfzS K5jXJ9prpryl4g37ub4jz1fGynt+hwXLgVW5cwMbKcgyEwJsly1VpcVuU/kto8ExN4o2 AyOlh9tOEQDer3tOr6EjcSyRDBdoD8QOGS5bw4DY4awAeGYUvE6fWofougCNcVyjkpHU UIJQ== X-Gm-Message-State: ACrzQf1wZpyuoK8Cl7gq5E0BsNnej/fhQSNQ9TDf1sCwYAPTl+WSSU80 fHsUofK6a1bjCIDVL/ryRKJCJrl0YuQ= X-Received: by 2002:a17:907:6d29:b0:78d:d12d:15af with SMTP id sa41-20020a1709076d2900b0078dd12d15afmr4673051ejc.53.1665509099862; Tue, 11 Oct 2022 10:24:59 -0700 (PDT) Received: from localhost.localdomain (92-64-99-37.biz.kpn.net. [92.64.99.37]) by smtp.googlemail.com with ESMTPSA id jt11-20020a170906ca0b00b0078de26f66b9sm8532ejb.114.2022.10.11.10.24.58 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 11 Oct 2022 10:24:58 -0700 (PDT) From: Martijn van Beurden To: ffmpeg-devel@ffmpeg.org Date: Tue, 11 Oct 2022 19:24:37 +0200 Message-Id: <20221011172437.36211-4-mvanb1@gmail.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20221011172437.36211-1-mvanb1@gmail.com> References: <20221011172437.36211-1-mvanb1@gmail.com> MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH v7 3/3] fate/flac: Add test of 32 bps encoding/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: Martijn van Beurden Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: 0OcyatH6tjVk --- tests/fate/flac.mak | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/fate/flac.mak b/tests/fate/flac.mak index 115cc965e1..3424b2bf82 100644 --- a/tests/fate/flac.mak +++ b/tests/fate/flac.mak @@ -6,6 +6,7 @@ FATE_FLAC += fate-flac-16-chmode-indep \ fate-flac-16-lpc-cholesky \ fate-flac-16-lpc-levinson \ fate-flac-24-comp-8 \ + fate-flac-32-wasted-bits \ fate-flac-rice-params \ fate-flac-16-chmode-%: OPTS = -ch_mode $(@:fate-flac-16-chmode-%=%) @@ -20,6 +21,9 @@ fate-flac-24-comp-%: OPTS = -compression_level $(@:fate-flac-24-comp-%=%) fate-flac-24-%: REF = $(SAMPLES)/audio-reference/divertimenti_2ch_96kHz_s24.wav fate-flac-24-%: CMD = enc_dec_pcm flac wav s24le $(subst $(SAMPLES),$(TARGET_SAMPLES),$(REF)) -c flac $(OPTS) +fate-flac-32-wasted-bits: REF = $(SAMPLES)/audio-reference/drums_2ch_44kHz_s32_wastedbits.wav +fate-flac-32-wasted-bits: CMD = enc_dec_pcm flac wav s32le $(subst $(SAMPLES),$(TARGET_SAMPLES),$(REF)) -c flac -strict experimental + fate-flac-rice-params: REF = $(SAMPLES)/audio-reference/chorusnoise_2ch_44kHz_s16.wav fate-flac-rice-params: CMD = enc_dec_pcm flac wav s16le $(subst $(SAMPLES),$(TARGET_SAMPLES),$(REF)) -c flac