From patchwork Wed Dec 8 01:06:38 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: James Almer X-Patchwork-Id: 32127 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a6b:cd86:0:0:0:0:0 with SMTP id d128csp7046750iog; Tue, 7 Dec 2021 17:11:39 -0800 (PST) X-Google-Smtp-Source: ABdhPJxDnE/C66cEY9cXflYW0bBYKuzHFBb1Nr67kxndbNZlnNUwX0dRtt5d+g1avurBeIylgOJA X-Received: by 2002:a17:906:229b:: with SMTP id p27mr3527255eja.264.1638925899219; Tue, 07 Dec 2021 17:11:39 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1638925899; cv=none; d=google.com; s=arc-20160816; b=Ij2iYtZtVJ2vVZeK34TheA8vP/hnPQn0TYMHF40aT2Tq7OI+Ar2iBMiE7xnYUgcmR5 xG70k6xGqjXzaRggNPK/zQWbPtp63DKcgKDGnC/JTNsRfasrHgzM0mKZn7AtmDwsUxwa tvY9XIeoWzpT9FNv3I4YJBMi4HhColDJDmNWzJLnRkH66Qj4TdRTcpzQLl6+lAmU4jrQ hpiQZU7XL2Chp0rEf52I09W1Kg69G9zJQ3nF7IfOh+wv2E35FxRYKazzbya6i8fwBrlm bFj/a9exON20/lJgS37W12JO03fzDvxIHnQlTsHQcL5P+f4oamZN7tjDumGfTmTWz1Pl L0Xg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding: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=qEsc+8PgZ5a5RS7cm0YdvZjFobt6Kr/3/5LxFrjyf/E=; b=donj+omTj/HbNfJ2JZAaE9xNehEElc1rNp9kcQXkBZt1/X1cRnf9AuiPHYbG5rPxck aYT9gD/W4WksQCYx73wUstE+8GnXVnZwPJZgwhFMZaOdJbzrE9Io8Tt7cvl2wisPTGPY mxG1OoC+vg7FHpHi5EbfUaUouOw+toclrjbHqKe3EfwkUnYaBN2rnvfDc/ZHy5mNJBty ynA4LvBG1KBxV1pQy1IMEMcCndQaX6h+4d54N94cDxyFIiGRIIYLVQ2+wvnDroVcFRC+ +m8NpR9+mWnxTP0X0a2xhcZUTH30kGOJxy73vrixZg8ZE8AHqVQw+jeoyGp5FgaIqM90 aAEw== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@gmail.com header.s=20210112 header.b=Wiqg3Jot; 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 qk44si2225726ejc.469.2021.12.07.17.11.33; Tue, 07 Dec 2021 17:11:39 -0800 (PST) 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=Wiqg3Jot; 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 0574B68AF49; Wed, 8 Dec 2021 03:08:06 +0200 (EET) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-vk1-f178.google.com (mail-vk1-f178.google.com [209.85.221.178]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 262F368AEDA for ; Wed, 8 Dec 2021 03:07:59 +0200 (EET) Received: by mail-vk1-f178.google.com with SMTP id q21so585195vkn.2 for ; Tue, 07 Dec 2021 17:07:59 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=f6mUH/MCa9LV35UHZKVq72YA+/+X86/D6CT73tPAtaQ=; b=Wiqg3JottP3ABb/v6630J0z9dX3QNLdldNrYQkKx7o8sdpvmch30ImhdZHJnHwKDx3 0gIKlYT0zdxtIEQzCmvJfGsJNgSeWn6TD8lYqWTv/gu2xkGYB0ghDMmfHwb+x/ePwM51 UlKdTeUwyqhUA846OgLuGyt3qEryhRZ/dS/P9oLvyfDfWIii35mpUvzsDhv38BZ64FPm hYnI+QhrxuXEHMuB7LbTjo+NUB275P6NC0ctz7sydtpQBMnTLpbQ64a0uBXJQJ/zFBOF qRYXkudB28rqJiGdSSxt/zWV88mW6J7SUXg/I7eXhvwogwZHjLwlAwr5lZuGtUMjGZeN B3bg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=f6mUH/MCa9LV35UHZKVq72YA+/+X86/D6CT73tPAtaQ=; b=7dmIo5u/MXb155K40bVyXDhtYShDCPlxOtsjVKNOof+80R1bBhOp9QtaDRBoS1w4km iMpm4ciPGO8NSpEbQl85Pnx0/J6+SDGN019rDNsrCoxGrvcQBqiiwoTvdjhkjsKe80ie MHHV5yZpW0F7kN4+TujfNh9BlQeenNubiXjWtOrOI57Ijyp7l0pJSn8FNBfBkZrHItW6 Nzt5CswP4DVh+8L6p9yZegMusd7kbxJZQxIZIEhDaiZVk58YW5U3AYOJTOkCmq4thcUC 4X+dzB2zPEarthjlsRaf+9yE9feTE8Grp4OgEVUARdj28yqmki1lMynEa1fBnevIUQoe Bw4Q== X-Gm-Message-State: AOAM531uG7IipBNebjvAK2R5JaCLpb+Tta3iBD1zyWBmMBrMjps0Mgr/ son4/pGpb9bj/FowDpib8Wj3XtYgWZpR0QpH X-Received: by 2002:ac5:c805:: with SMTP id y5mr57770558vkl.29.1638925675834; Tue, 07 Dec 2021 17:07:55 -0800 (PST) Received: from localhost.localdomain ([181.170.250.138]) by smtp.gmail.com with ESMTPSA id b8sm949898vsl.19.2021.12.07.17.07.54 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 07 Dec 2021 17:07:55 -0800 (PST) From: James Almer To: ffmpeg-devel@ffmpeg.org Date: Tue, 7 Dec 2021 22:06:38 -0300 Message-Id: <20211208010649.381-23-jamrial@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20211208010649.381-1-jamrial@gmail.com> References: <20211208010649.381-1-jamrial@gmail.com> MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH 183/279] adpcm: convert to new channel layout API 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 Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: qYLZc6DH3QiB From: Anton Khirnov Signed-off-by: Vittorio Giovara Signed-off-by: Anton Khirnov Signed-off-by: James Almer --- libavcodec/adpcm.c | 151 ++++++++++++++++++++++-------------------- libavcodec/adpcmenc.c | 122 +++++++++++++++++----------------- 2 files changed, 141 insertions(+), 132 deletions(-) diff --git a/libavcodec/adpcm.c b/libavcodec/adpcm.c index cfde5f58b9..0591314302 100644 --- a/libavcodec/adpcm.c +++ b/libavcodec/adpcm.c @@ -271,14 +271,15 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx) case AV_CODEC_ID_ADPCM_MTAF: min_channels = 2; max_channels = 8; - if (avctx->channels & 1) { - avpriv_request_sample(avctx, "channel count %d", avctx->channels); + if (avctx->ch_layout.nb_channels & 1) { + avpriv_request_sample(avctx, "channel count %d", avctx->ch_layout.nb_channels); return AVERROR_PATCHWELCOME; } break; case AV_CODEC_ID_ADPCM_PSX: max_channels = 8; - if (avctx->channels <= 0 || avctx->block_align % (16 * avctx->channels)) + if (avctx->ch_layout.nb_channels <= 0 || + avctx->block_align % (16 * avctx->ch_layout.nb_channels)) return AVERROR_INVALIDDATA; break; case AV_CODEC_ID_ADPCM_IMA_DAT4: @@ -287,7 +288,8 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx) max_channels = 14; break; } - if (avctx->channels < min_channels || avctx->channels > max_channels) { + if (avctx->ch_layout.nb_channels < min_channels || + avctx->ch_layout.nb_channels > max_channels) { av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n"); return AVERROR(EINVAL); } @@ -298,7 +300,8 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx) return AVERROR_INVALIDDATA; break; case AV_CODEC_ID_ADPCM_ARGO: - if (avctx->bits_per_coded_sample != 4 || avctx->block_align != 17 * avctx->channels) + if (avctx->bits_per_coded_sample != 4 || + avctx->block_align != 17 * avctx->ch_layout.nb_channels) return AVERROR_INVALIDDATA; break; case AV_CODEC_ID_ADPCM_ZORK: @@ -336,7 +339,7 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx) AV_SAMPLE_FMT_S16; break; case AV_CODEC_ID_ADPCM_MS: - avctx->sample_fmt = avctx->channels > 2 ? AV_SAMPLE_FMT_S16P : + avctx->sample_fmt = avctx->ch_layout.nb_channels > 2 ? AV_SAMPLE_FMT_S16P : AV_SAMPLE_FMT_S16; break; default: @@ -755,6 +758,7 @@ static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_ ADPCMDecodeContext *c = avctx->priv_data; GetBitContext gb; const int8_t *table; + int channels = avctx->ch_layout.nb_channels; int k0, signmask, nb_bits, count; int size = buf_size*8; int i; @@ -767,16 +771,16 @@ static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_ k0 = 1 << (nb_bits-2); signmask = 1 << (nb_bits-1); - while (get_bits_count(&gb) <= size - 22*avctx->channels) { - for (i = 0; i < avctx->channels; i++) { + while (get_bits_count(&gb) <= size - 22 * channels) { + for (i = 0; i < channels; i++) { *samples++ = c->status[i].predictor = get_sbits(&gb, 16); c->status[i].step_index = get_bits(&gb, 6); } - for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) { + for (count = 0; get_bits_count(&gb) <= size - nb_bits * channels && count < 4095; count++) { int i; - for (i = 0; i < avctx->channels; i++) { + for (i = 0; i < channels; i++) { // similar to IMA adpcm int delta = get_bits(&gb, nb_bits); int step = ff_adpcm_step_table[c->status[i].step_index]; @@ -840,7 +844,7 @@ static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb, { ADPCMDecodeContext *s = avctx->priv_data; int nb_samples = 0; - int ch = avctx->channels; + int ch = avctx->ch_layout.nb_channels; int has_coded_samples = 0; int header_size; @@ -1061,6 +1065,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; ADPCMDecodeContext *c = avctx->priv_data; + int channels = avctx->ch_layout.nb_channels; int16_t *samples; int16_t **samples_p; int st; /* stereo */ @@ -1089,13 +1094,13 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, frame->nb_samples = nb_samples = coded_samples; } - st = avctx->channels == 2 ? 1 : 0; + st = channels == 2 ? 1 : 0; switch(avctx->codec->id) { CASE(ADPCM_IMA_QT, /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples). Channel data is interleaved per-chunk. */ - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { ADPCMChannelStatus *cs = &c->status[channel]; int predictor; int step_index; @@ -1134,7 +1139,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_IMA_WAV, - for (int i = 0; i < avctx->channels; i++) { + for (int i = 0; i < channels; i++) { ADPCMChannelStatus *cs = &c->status[i]; cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16); @@ -1153,12 +1158,12 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, GetBitContext g; for (int n = 0; n < (nb_samples - 1) / samples_per_block; n++) { - for (int i = 0; i < avctx->channels; i++) { + for (int i = 0; i < channels; i++) { ADPCMChannelStatus *cs = &c->status[i]; samples = &samples_p[i][1 + n * samples_per_block]; for (int j = 0; j < block_size; j++) { - temp[j] = buf[4 * avctx->channels + block_size * n * avctx->channels + - (j % 4) + (j / 4) * (avctx->channels * 4) + i * 4]; + temp[j] = buf[4 * channels + block_size * n * channels + + (j % 4) + (j / 4) * (channels * 4) + i * 4]; } ret = init_get_bits8(&g, (const uint8_t *)&temp, block_size); if (ret < 0) @@ -1169,10 +1174,10 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } } } - bytestream2_skip(&gb, avctx->block_align - avctx->channels * 4); + bytestream2_skip(&gb, avctx->block_align - channels * 4); } else { for (int n = 0; n < (nb_samples - 1) / 8; n++) { - for (int i = 0; i < avctx->channels; i++) { + for (int i = 0; i < channels; i++) { ADPCMChannelStatus *cs = &c->status[i]; samples = &samples_p[i][1 + n * 8]; for (int m = 0; m < 8; m += 2) { @@ -1185,10 +1190,10 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_4XM, - for (int i = 0; i < avctx->channels; i++) + for (int i = 0; i < channels; i++) c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16); - for (int i = 0; i < avctx->channels; i++) { + for (int i = 0; i < channels; i++) { c->status[i].step_index = sign_extend(bytestream2_get_le16u(&gb), 16); if (c->status[i].step_index > 88u) { av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n", @@ -1197,7 +1202,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } } - for (int i = 0; i < avctx->channels; i++) { + for (int i = 0; i < channels; i++) { ADPCMChannelStatus *cs = &c->status[i]; samples = (int16_t *)frame->data[i]; for (int n = nb_samples >> 1; n > 0; n--) { @@ -1208,9 +1213,9 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_AGM, - for (int i = 0; i < avctx->channels; i++) + for (int i = 0; i < channels; i++) c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16); - for (int i = 0; i < avctx->channels; i++) + for (int i = 0; i < channels; i++) c->status[i].step = sign_extend(bytestream2_get_le16u(&gb), 16); for (int n = 0; n < nb_samples >> (1 - st); n++) { @@ -1222,8 +1227,8 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, CASE(ADPCM_MS, int block_predictor; - if (avctx->channels > 2) { - for (int channel = 0; channel < avctx->channels; channel++) { + if (avctx->ch_layout.nb_channels > 2) { + for (int channel = 0; channel < avctx->ch_layout.nb_channels; channel++) { samples = samples_p[channel]; block_predictor = bytestream2_get_byteu(&gb); if (block_predictor > 6) { @@ -1285,7 +1290,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_MTAF, - for (int channel = 0; channel < avctx->channels; channel += 2) { + for (int channel = 0; channel < channels; channel += 2) { bytestream2_skipu(&gb, 4); c->status[channel ].step = bytestream2_get_le16u(&gb) & 0x1f; c->status[channel + 1].step = bytestream2_get_le16u(&gb) & 0x1f; @@ -1306,7 +1311,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_IMA_DK4, - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { ADPCMChannelStatus *cs = &c->status[channel]; cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16); cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16); @@ -1338,7 +1343,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, int nibble; int decode_top_nibble_next = 0; int diff_channel; - const int16_t *samples_end = samples + avctx->channels * nb_samples; + const int16_t *samples_end = samples + channels * nb_samples; bytestream2_skipu(&gb, 10); c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16); @@ -1385,7 +1390,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, bytestream2_skip(&gb, 1); ) /* End of CASE */ CASE(ADPCM_IMA_ISS, - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { ADPCMChannelStatus *cs = &c->status[channel]; cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16); cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16); @@ -1412,7 +1417,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_IMA_MOFLEX, - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { ADPCMChannelStatus *cs = &c->status[channel]; cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16); cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16); @@ -1424,7 +1429,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } for (int subframe = 0; subframe < nb_samples / 256; subframe++) { - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { samples = samples_p[channel] + 256 * subframe; for (int n = 0; n < 256; n += 2) { int v = bytestream2_get_byteu(&gb); @@ -1435,7 +1440,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_IMA_DAT4, - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { ADPCMChannelStatus *cs = &c->status[channel]; samples = samples_p[channel]; bytestream2_skip(&gb, 4); @@ -1462,26 +1467,26 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, ) /* End of CASE */ CASE(ADPCM_IMA_APM, for (int n = nb_samples / 2; n > 0; n--) { - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { int v = bytestream2_get_byteu(&gb); *samples++ = adpcm_ima_qt_expand_nibble(&c->status[channel], v >> 4 ); samples[st] = adpcm_ima_qt_expand_nibble(&c->status[channel], v & 0x0F); } - samples += avctx->channels; + samples += channels; } ) /* End of CASE */ CASE(ADPCM_IMA_ALP, for (int n = nb_samples / 2; n > 0; n--) { - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { int v = bytestream2_get_byteu(&gb); *samples++ = adpcm_ima_alp_expand_nibble(&c->status[channel], v >> 4 , 2); samples[st] = adpcm_ima_alp_expand_nibble(&c->status[channel], v & 0x0F, 2); } - samples += avctx->channels; + samples += channels; } ) /* End of CASE */ CASE(ADPCM_IMA_CUNNING, - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { int16_t *smp = samples_p[channel]; for (int n = 0; n < nb_samples / 2; n++) { int v = bytestream2_get_byteu(&gb); @@ -1498,7 +1503,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_IMA_RAD, - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { ADPCMChannelStatus *cs = &c->status[channel]; cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16); cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16); @@ -1514,17 +1519,17 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, byte[0] = bytestream2_get_byteu(&gb); if (st) byte[1] = bytestream2_get_byteu(&gb); - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] & 0x0F, 3); } - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] >> 4 , 3); } } ) /* End of CASE */ CASE(ADPCM_IMA_WS, if (c->vqa_version == 3) { - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { int16_t *smp = samples_p[channel]; for (int n = nb_samples / 2; n > 0; n--) { @@ -1535,12 +1540,12 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } } else { for (int n = nb_samples / 2; n > 0; n--) { - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { int v = bytestream2_get_byteu(&gb); *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3); samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3); } - samples += avctx->channels; + samples += channels; } } bytestream2_seek(&gb, 0, SEEK_END); @@ -1548,13 +1553,13 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, CASE(ADPCM_XA, int16_t *out0 = samples_p[0]; int16_t *out1 = samples_p[1]; - int samples_per_block = 28 * (3 - avctx->channels) * 4; + int samples_per_block = 28 * (3 - channels) * 4; int sample_offset = 0; int bytes_remaining; while (bytestream2_get_bytes_left(&gb) >= 128) { if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb), &c->status[0], &c->status[1], - avctx->channels, sample_offset)) < 0) + channels, sample_offset)) < 0) return ret; bytestream2_skipu(&gb, 128); sample_offset += samples_per_block; @@ -1604,7 +1609,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces, each coding 28 stereo samples. */ - if(avctx->channels != 2) + if (channels != 2) return AVERROR_INVALIDDATA; current_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16); @@ -1649,7 +1654,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, CASE(ADPCM_EA_MAXIS_XA, int coeff[2][2], shift[2]; - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { int byte = bytestream2_get_byteu(&gb); for (int i = 0; i < 2; i++) coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i]; @@ -1661,7 +1666,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, byte[0] = bytestream2_get_byteu(&gb); if (st) byte[1] = bytestream2_get_byteu(&gb); for (int i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */ - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { int sample = sign_extend(byte[channel] >> i, 4) * (1 << shift[channel]); sample = (sample + c->status[channel].sample1 * coeff[channel][0] + @@ -1690,12 +1695,12 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, int count = 0; int offsets[6]; - for (unsigned channel = 0; channel < avctx->channels; channel++) + for (unsigned channel = 0; channel < channels; channel++) offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) : bytestream2_get_le32(&gb)) + - (avctx->channels + 1) * 4; + (channels + 1) * 4; - for (unsigned channel = 0; channel < avctx->channels; channel++) { + for (unsigned channel = 0; channel < channels; channel++) { int count1; bytestream2_seek(&gb, offsets[channel], SEEK_SET); @@ -1759,7 +1764,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } #endif /* CONFIG_ADPCM_EA_Rx_DECODER */ CASE(ADPCM_EA_XAS, - for (int channel=0; channel < avctx->channels; channel++) { + for (int channel=0; channel < channels; channel++) { int coeff[2][4], shift[4]; int16_t *s = samples_p[channel]; for (int n = 0; n < 4; n++, s += 32) { @@ -1791,7 +1796,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_IMA_ACORN, - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { ADPCMChannelStatus *cs = &c->status[channel]; cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16); cs->step_index = bytestream2_get_le16u(&gb) & 0xFF; @@ -1808,7 +1813,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_IMA_AMV, - av_assert0(avctx->channels == 1); + av_assert0(channels == 1); /* * Header format: @@ -1848,7 +1853,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_IMA_SMJPEG, - for (int i = 0; i < avctx->channels; i++) { + for (int i = 0; i < channels; i++) { c->status[i].predictor = sign_extend(bytestream2_get_be16u(&gb), 16); c->status[i].step_index = bytestream2_get_byteu(&gb); bytestream2_skipu(&gb, 1); @@ -1931,7 +1936,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_AICA, - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { samples = samples_p[channel]; for (int n = nb_samples >> 1; n > 0; n--) { int v = bytestream2_get_byteu(&gb); @@ -1953,7 +1958,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } for (int m = 0; m < blocks; m++) { - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { int prev1 = c->status[channel].sample1; int prev2 = c->status[channel].sample2; @@ -2005,33 +2010,33 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, if (avctx->extradata) { GetByteContext tb; - if (avctx->extradata_size < 32 * avctx->channels) { + if (avctx->extradata_size < 32 * channels) { av_log(avctx, AV_LOG_ERROR, "Missing coeff table\n"); return AVERROR_INVALIDDATA; } bytestream2_init(&tb, avctx->extradata, avctx->extradata_size); - for (int i = 0; i < avctx->channels; i++) + for (int i = 0; i < channels; i++) for (int n = 0; n < 16; n++) table[i][n] = THP_GET16(tb); } else { - for (int i = 0; i < avctx->channels; i++) + for (int i = 0; i < channels; i++) for (int n = 0; n < 16; n++) table[i][n] = THP_GET16(gb); if (!c->has_status) { /* Initialize the previous sample. */ - for (int i = 0; i < avctx->channels; i++) { + for (int i = 0; i < channels; i++) { c->status[i].sample1 = THP_GET16(gb); c->status[i].sample2 = THP_GET16(gb); } c->has_status = 1; } else { - bytestream2_skip(&gb, avctx->channels * 4); + bytestream2_skip(&gb, channels * 4); } } - for (int ch = 0; ch < avctx->channels; ch++) { + for (int ch = 0; ch < channels; ch++) { samples = samples_p[ch]; /* Read in every sample for this channel. */ @@ -2065,7 +2070,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } #endif /* CONFIG_ADPCM_THP(_LE)_DECODER */ CASE(ADPCM_DTK, - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { samples = samples_p[channel]; /* Read in every sample for this channel. */ @@ -2113,9 +2118,9 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_PSX, - for (int block = 0; block < avpkt->size / FFMAX(avctx->block_align, 16 * avctx->channels); block++) { - int nb_samples_per_block = 28 * FFMAX(avctx->block_align, 16 * avctx->channels) / (16 * avctx->channels); - for (int channel = 0; channel < avctx->channels; channel++) { + for (int block = 0; block < avpkt->size / FFMAX(avctx->block_align, 16 * channels); block++) { + int nb_samples_per_block = 28 * FFMAX(avctx->block_align, 16 * channels) / (16 * channels); + for (int channel = 0; channel < channels; channel++) { samples = samples_p[channel] + block * nb_samples_per_block; av_assert0((block + 1) * nb_samples_per_block <= nb_samples); @@ -2172,7 +2177,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, * They should be 0 initially. */ for (int block = 0; block < avpkt->size / avctx->block_align; block++) { - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < avctx->ch_layout.nb_channels; channel++) { ADPCMChannelStatus *cs = c->status + channel; int control, shift; @@ -2191,19 +2196,19 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data, } ) /* End of CASE */ CASE(ADPCM_ZORK, - for (int n = 0; n < nb_samples * avctx->channels; n++) { + for (int n = 0; n < nb_samples * channels; n++) { int v = bytestream2_get_byteu(&gb); - *samples++ = adpcm_zork_expand_nibble(&c->status[n % avctx->channels], v); + *samples++ = adpcm_zork_expand_nibble(&c->status[n % channels], v); } ) /* End of CASE */ CASE(ADPCM_IMA_MTF, for (int n = nb_samples / 2; n > 0; n--) { - for (int channel = 0; channel < avctx->channels; channel++) { + for (int channel = 0; channel < channels; channel++) { int v = bytestream2_get_byteu(&gb); *samples++ = adpcm_ima_mtf_expand_nibble(&c->status[channel], v >> 4); samples[st] = adpcm_ima_mtf_expand_nibble(&c->status[channel], v & 0x0F); } - samples += avctx->channels; + samples += channels; } ) /* End of CASE */ default: diff --git a/libavcodec/adpcmenc.c b/libavcodec/adpcmenc.c index b0f6f209b7..92c31b4841 100644 --- a/libavcodec/adpcmenc.c +++ b/libavcodec/adpcmenc.c @@ -79,11 +79,7 @@ typedef struct ADPCMEncodeContext { static av_cold int adpcm_encode_init(AVCodecContext *avctx) { ADPCMEncodeContext *s = avctx->priv_data; - - if (avctx->channels > 2) { - av_log(avctx, AV_LOG_ERROR, "only stereo or mono is supported\n"); - return AVERROR(EINVAL); - } + int channels = avctx->ch_layout.nb_channels; /* * AMV's block size has to match that of the corresponding video @@ -130,8 +126,8 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) CASE(ADPCM_IMA_WAV, /* each 16 bits sample gives one nibble and we have 4 bytes per channel overhead */ - avctx->frame_size = (s->block_size - 4 * avctx->channels) * 8 / - (4 * avctx->channels) + 1; + avctx->frame_size = (s->block_size - 4 * channels) * 8 / + (4 * channels) + 1; /* seems frame_size isn't taken into account... have to buffer the samples :-( */ avctx->block_align = s->block_size; @@ -139,13 +135,13 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) ) /* End of CASE */ CASE(ADPCM_IMA_QT, avctx->frame_size = 64; - avctx->block_align = 34 * avctx->channels; + avctx->block_align = 34 * channels; ) /* End of CASE */ CASE(ADPCM_MS, uint8_t *extradata; /* each 16 bits sample gives one nibble and we have 7 bytes per channel overhead */ - avctx->frame_size = (s->block_size - 7 * avctx->channels) * 2 / avctx->channels + 2; + avctx->frame_size = (s->block_size - 7 * channels) * 2 / channels + 2; avctx->bits_per_coded_sample = 4; avctx->block_align = s->block_size; if (!(avctx->extradata = av_malloc(32 + AV_INPUT_BUFFER_PADDING_SIZE))) @@ -160,7 +156,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) } ) /* End of CASE */ CASE(ADPCM_YAMAHA, - avctx->frame_size = s->block_size * 2 / avctx->channels; + avctx->frame_size = s->block_size * 2 / channels; avctx->block_align = s->block_size; ) /* End of CASE */ CASE(ADPCM_SWF, @@ -172,11 +168,11 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) return AVERROR(EINVAL); } avctx->frame_size = 4096; /* Hardcoded according to the SWF spec. */ - avctx->block_align = (2 + avctx->channels * (22 + 4 * (avctx->frame_size - 1)) + 7) / 8; + avctx->block_align = (2 + channels * (22 + 4 * (avctx->frame_size - 1)) + 7) / 8; ) /* End of CASE */ case AV_CODEC_ID_ADPCM_IMA_SSI: case AV_CODEC_ID_ADPCM_IMA_ALP: - avctx->frame_size = s->block_size * 2 / avctx->channels; + avctx->frame_size = s->block_size * 2 / channels; avctx->block_align = s->block_size; break; CASE(ADPCM_IMA_AMV, @@ -185,7 +181,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) return AVERROR(EINVAL); } - if (avctx->channels != 1) { + if (channels != 1) { av_log(avctx, AV_LOG_ERROR, "Only mono is supported\n"); return AVERROR(EINVAL); } @@ -194,7 +190,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) avctx->block_align = 8 + (FFALIGN(avctx->frame_size, 2) / 2); ) /* End of CASE */ CASE(ADPCM_IMA_APM, - avctx->frame_size = s->block_size * 2 / avctx->channels; + avctx->frame_size = s->block_size * 2 / channels; avctx->block_align = s->block_size; if (!(avctx->extradata = av_mallocz(28 + AV_INPUT_BUFFER_PADDING_SIZE))) @@ -203,11 +199,11 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx) ) /* End of CASE */ CASE(ADPCM_ARGO, avctx->frame_size = 32; - avctx->block_align = 17 * avctx->channels; + avctx->block_align = 17 * channels; ) /* End of CASE */ CASE(ADPCM_IMA_WS, /* each 16 bits sample gives one nibble */ - avctx->frame_size = s->block_size * 2 / avctx->channels; + avctx->frame_size = s->block_size * 2 / channels; avctx->block_align = s->block_size; ) /* End of CASE */ default: @@ -606,16 +602,17 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, int16_t **samples_p; uint8_t *dst; ADPCMEncodeContext *c = avctx->priv_data; + int channels = avctx->ch_layout.nb_channels; samples = (const int16_t *)frame->data[0]; samples_p = (int16_t **)frame->extended_data; - st = avctx->channels == 2; + st = channels == 2; if (avctx->codec_id == AV_CODEC_ID_ADPCM_IMA_SSI || avctx->codec_id == AV_CODEC_ID_ADPCM_IMA_ALP || avctx->codec_id == AV_CODEC_ID_ADPCM_IMA_APM || avctx->codec_id == AV_CODEC_ID_ADPCM_IMA_WS) - pkt_size = (frame->nb_samples * avctx->channels) / 2; + pkt_size = (frame->nb_samples * channels) / 2; else pkt_size = avctx->block_align; if ((ret = ff_get_encode_buffer(avctx, avpkt, pkt_size, 0)) < 0) @@ -626,7 +623,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, CASE(ADPCM_IMA_WAV, int blocks = (frame->nb_samples - 1) / 8; - for (int ch = 0; ch < avctx->channels; ch++) { + for (int ch = 0; ch < channels; ch++) { ADPCMChannelStatus *status = &c->status[ch]; status->prev_sample = samples_p[ch][0]; /* status->step_index = 0; @@ -639,15 +636,15 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, /* stereo: 4 bytes (8 samples) for left, 4 bytes for right */ if (avctx->trellis > 0) { uint8_t *buf; - if (!FF_ALLOC_TYPED_ARRAY(buf, avctx->channels * blocks * 8)) + if (!FF_ALLOC_TYPED_ARRAY(buf, channels * blocks * 8)) return AVERROR(ENOMEM); - for (int ch = 0; ch < avctx->channels; ch++) { + for (int ch = 0; ch < channels; ch++) { adpcm_compress_trellis(avctx, &samples_p[ch][1], buf + ch * blocks * 8, &c->status[ch], blocks * 8, 1); } for (int i = 0; i < blocks; i++) { - for (int ch = 0; ch < avctx->channels; ch++) { + for (int ch = 0; ch < channels; ch++) { uint8_t *buf1 = buf + ch * blocks * 8 + i * 8; for (int j = 0; j < 8; j += 2) *dst++ = buf1[j] | (buf1[j + 1] << 4); @@ -656,7 +653,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, av_free(buf); } else { for (int i = 0; i < blocks; i++) { - for (int ch = 0; ch < avctx->channels; ch++) { + for (int ch = 0; ch < channels; ch++) { ADPCMChannelStatus *status = &c->status[ch]; const int16_t *smp = &samples_p[ch][1 + i * 8]; for (int j = 0; j < 8; j += 2) { @@ -672,7 +669,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, PutBitContext pb; init_put_bits(&pb, dst, pkt_size); - for (int ch = 0; ch < avctx->channels; ch++) { + for (int ch = 0; ch < channels; ch++) { ADPCMChannelStatus *status = &c->status[ch]; put_bits(&pb, 9, (status->prev_sample & 0xFFFF) >> 7); put_bits(&pb, 7, status->step_index); @@ -703,7 +700,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, av_assert0(avctx->trellis == 0); for (int i = 0; i < frame->nb_samples; i++) { - for (int ch = 0; ch < avctx->channels; ch++) { + for (int ch = 0; ch < channels; ch++) { put_bits(&pb, 4, adpcm_ima_qt_compress_sample(c->status + ch, *samples++)); } } @@ -717,11 +714,11 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, av_assert0(avctx->trellis == 0); for (int n = frame->nb_samples / 2; n > 0; n--) { - for (int ch = 0; ch < avctx->channels; ch++) { + for (int ch = 0; ch < channels; ch++) { put_bits(&pb, 4, adpcm_ima_alp_compress_sample(c->status + ch, *samples++)); put_bits(&pb, 4, adpcm_ima_alp_compress_sample(c->status + ch, samples[st])); } - samples += avctx->channels; + samples += channels; } flush_put_bits(&pb); @@ -738,7 +735,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, put_bits(&pb, 2, 2); // set 4-bit flash adpcm format // init the encoder state - for (int i = 0; i < avctx->channels; i++) { + for (int i = 0; i < channels; i++) { // clip step so it fits 6 bits c->status[i].step_index = av_clip_uintp2(c->status[i].step_index, 6); put_sbits(&pb, 16, samples[i]); @@ -748,22 +745,22 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, if (avctx->trellis > 0) { uint8_t buf[8190 /* = 2 * n */]; - adpcm_compress_trellis(avctx, samples + avctx->channels, buf, - &c->status[0], n, avctx->channels); - if (avctx->channels == 2) - adpcm_compress_trellis(avctx, samples + avctx->channels + 1, + adpcm_compress_trellis(avctx, samples + channels, buf, + &c->status[0], n, channels); + if (channels == 2) + adpcm_compress_trellis(avctx, samples + channels + 1, buf + n, &c->status[1], n, - avctx->channels); + channels); for (int i = 0; i < n; i++) { put_bits(&pb, 4, buf[i]); - if (avctx->channels == 2) + if (channels == 2) put_bits(&pb, 4, buf[n + i]); } } else { for (int i = 1; i < frame->nb_samples; i++) { put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0], - samples[avctx->channels * i])); - if (avctx->channels == 2) + samples[channels * i])); + if (channels == 2) put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1], samples[2 * i + 1])); } @@ -771,47 +768,47 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, flush_put_bits(&pb); ) /* End of CASE */ CASE(ADPCM_MS, - for (int i = 0; i < avctx->channels; i++) { + for (int i = 0; i < channels; i++) { int predictor = 0; *dst++ = predictor; c->status[i].coeff1 = ff_adpcm_AdaptCoeff1[predictor]; c->status[i].coeff2 = ff_adpcm_AdaptCoeff2[predictor]; } - for (int i = 0; i < avctx->channels; i++) { + for (int i = 0; i < channels; i++) { if (c->status[i].idelta < 16) c->status[i].idelta = 16; bytestream_put_le16(&dst, c->status[i].idelta); } - for (int i = 0; i < avctx->channels; i++) + for (int i = 0; i < channels; i++) c->status[i].sample2= *samples++; - for (int i = 0; i < avctx->channels; i++) { + for (int i = 0; i < channels; i++) { c->status[i].sample1 = *samples++; bytestream_put_le16(&dst, c->status[i].sample1); } - for (int i = 0; i < avctx->channels; i++) + for (int i = 0; i < channels; i++) bytestream_put_le16(&dst, c->status[i].sample2); if (avctx->trellis > 0) { - const int n = avctx->block_align - 7 * avctx->channels; + const int n = avctx->block_align - 7 * channels; uint8_t *buf = av_malloc(2 * n); if (!buf) return AVERROR(ENOMEM); - if (avctx->channels == 1) { + if (channels == 1) { adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n, - avctx->channels); + channels); for (int i = 0; i < n; i += 2) *dst++ = (buf[i] << 4) | buf[i + 1]; } else { adpcm_compress_trellis(avctx, samples, buf, - &c->status[0], n, avctx->channels); + &c->status[0], n, channels); adpcm_compress_trellis(avctx, samples + 1, buf + n, - &c->status[1], n, avctx->channels); + &c->status[1], n, channels); for (int i = 0; i < n; i++) *dst++ = (buf[i] << 4) | buf[n + i]; } av_free(buf); } else { - for (int i = 7 * avctx->channels; i < avctx->block_align; i++) { + for (int i = 7 * channels; i < avctx->block_align; i++) { int nibble; nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++) << 4; nibble |= adpcm_ms_compress_sample(&c->status[st], *samples++); @@ -826,22 +823,22 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, if (!buf) return AVERROR(ENOMEM); n *= 2; - if (avctx->channels == 1) { + if (channels == 1) { adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n, - avctx->channels); + channels); for (int i = 0; i < n; i += 2) *dst++ = buf[i] | (buf[i + 1] << 4); } else { adpcm_compress_trellis(avctx, samples, buf, - &c->status[0], n, avctx->channels); + &c->status[0], n, channels); adpcm_compress_trellis(avctx, samples + 1, buf + n, - &c->status[1], n, avctx->channels); + &c->status[1], n, channels); for (int i = 0; i < n; i++) *dst++ = buf[i] | (buf[n + i] << 4); } av_free(buf); } else - for (n *= avctx->channels; n > 0; n--) { + for (n *= channels; n > 0; n--) { int nibble; nibble = adpcm_yamaha_compress_sample(&c->status[ 0], *samples++); nibble |= adpcm_yamaha_compress_sample(&c->status[st], *samples++) << 4; @@ -855,17 +852,17 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, av_assert0(avctx->trellis == 0); for (int n = frame->nb_samples / 2; n > 0; n--) { - for (int ch = 0; ch < avctx->channels; ch++) { + for (int ch = 0; ch < channels; ch++) { put_bits(&pb, 4, adpcm_ima_qt_compress_sample(c->status + ch, *samples++)); put_bits(&pb, 4, adpcm_ima_qt_compress_sample(c->status + ch, samples[st])); } - samples += avctx->channels; + samples += channels; } flush_put_bits(&pb); ) /* End of CASE */ CASE(ADPCM_IMA_AMV, - av_assert0(avctx->channels == 1); + av_assert0(channels == 1); c->status[0].prev_sample = *samples; bytestream_put_le16(&dst, c->status[0].prev_sample); @@ -880,7 +877,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, if (!buf) return AVERROR(ENOMEM); - adpcm_compress_trellis(avctx, samples, buf, &c->status[0], 2 * n, avctx->channels); + adpcm_compress_trellis(avctx, samples, buf, &c->status[0], 2 * n, channels); for (int i = 0; i < n; i++) bytestream_put_byte(&dst, (buf[2 * i] << 4) | buf[2 * i + 1]); @@ -904,7 +901,7 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, av_assert0(frame->nb_samples == 32); - for (int ch = 0; ch < avctx->channels; ch++) { + for (int ch = 0; ch < channels; ch++) { int64_t error = INT64_MAX, tmperr = INT64_MAX; int shift = 2, flag = 0; int saved1 = c->status[ch].sample1; @@ -941,14 +938,14 @@ static int adpcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, av_assert0(avctx->trellis == 0); for (int n = frame->nb_samples / 2; n > 0; n--) { /* stereo: 1 byte (2 samples) for left, 1 byte for right */ - for (int ch = 0; ch < avctx->channels; ch++) { + for (int ch = 0; ch < channels; ch++) { int t1, t2; t1 = adpcm_ima_compress_sample(&c->status[ch], *samples++); t2 = adpcm_ima_compress_sample(&c->status[ch], samples[st]); put_bits(&pb, 4, t2); put_bits(&pb, 4, t1); } - samples += avctx->channels; + samples += channels; } flush_put_bits(&pb); ) /* End of CASE */ @@ -968,6 +965,12 @@ static const enum AVSampleFormat sample_fmts_p[] = { AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_NONE }; +static const AVChannelLayout ch_layouts[] = { + AV_CHANNEL_LAYOUT_MONO, + AV_CHANNEL_LAYOUT_STEREO, + { 0 }, +}; + static const AVOption options[] = { { .name = "block_size", @@ -1001,6 +1004,7 @@ const AVCodec ff_ ## name_ ## _encoder = { \ .encode2 = adpcm_encode_frame, \ .close = adpcm_encode_close, \ .sample_fmts = sample_fmts_, \ + .ch_layouts = ch_layouts, \ .capabilities = capabilities_ | AV_CODEC_CAP_DR1, \ .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE, \ .priv_class = &adpcm_encoder_class, \