mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2024-12-23 12:43:46 +02:00
Merge remote-tracking branch 'qatar/master'
* qatar/master: FATE: add a 24-bit FLAC encoding test FATE: rename FLAC tests from flac-* to flac-16-* flacenc: use RICE2 entropy coding mode for 24-bit flacenc: add 24-bit encoding flacdsp: move lpc encoding from FLAC encoder to FLACDSPContext Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer
commit
6493842900
@ -26,6 +26,7 @@
|
||||
#define SAMPLE_SIZE 16
|
||||
#define PLANAR 0
|
||||
#include "flacdsp_template.c"
|
||||
#include "flacdsp_lpc_template.c"
|
||||
|
||||
#undef PLANAR
|
||||
#define PLANAR 1
|
||||
@ -36,6 +37,7 @@
|
||||
#define SAMPLE_SIZE 32
|
||||
#define PLANAR 0
|
||||
#include "flacdsp_template.c"
|
||||
#include "flacdsp_lpc_template.c"
|
||||
|
||||
#undef PLANAR
|
||||
#define PLANAR 1
|
||||
@ -86,10 +88,13 @@ static void flac_lpc_32_c(int32_t *decoded, const int coeffs[32],
|
||||
av_cold void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt,
|
||||
int bps)
|
||||
{
|
||||
if (bps > 16)
|
||||
if (bps > 16) {
|
||||
c->lpc = flac_lpc_32_c;
|
||||
else
|
||||
c->lpc_encode = flac_lpc_encode_c_32;
|
||||
} else {
|
||||
c->lpc = flac_lpc_16_c;
|
||||
c->lpc_encode = flac_lpc_encode_c_16;
|
||||
}
|
||||
|
||||
switch (fmt) {
|
||||
case AV_SAMPLE_FMT_S32:
|
||||
|
||||
@ -27,6 +27,8 @@ typedef struct FLACDSPContext {
|
||||
int len, int shift);
|
||||
void (*lpc)(int32_t *samples, const int coeffs[32], int order,
|
||||
int qlevel, int len);
|
||||
void (*lpc_encode)(int32_t *res, const int32_t *smp, int len, int order,
|
||||
const int32_t *coefs, int shift);
|
||||
} FLACDSPContext;
|
||||
|
||||
void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt, int bps);
|
||||
|
||||
141
libavcodec/flacdsp_lpc_template.c
Normal file
141
libavcodec/flacdsp_lpc_template.c
Normal file
@ -0,0 +1,141 @@
|
||||
/*
|
||||
* This file is part of FFmpeg.
|
||||
*
|
||||
* FFmpeg is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* FFmpeg is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with FFmpeg; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "libavutil/avutil.h"
|
||||
#include "mathops.h"
|
||||
|
||||
#undef FUNC
|
||||
#undef sum_type
|
||||
#undef MUL
|
||||
#undef CLIP
|
||||
#undef FSUF
|
||||
|
||||
#define FUNC(n) AV_JOIN(n ## _, SAMPLE_SIZE)
|
||||
|
||||
#if SAMPLE_SIZE == 32
|
||||
# define sum_type int64_t
|
||||
# define MUL(a, b) MUL64(a, b)
|
||||
# define CLIP(x) av_clipl_int32(x)
|
||||
#else
|
||||
# define sum_type int32_t
|
||||
# define MUL(a, b) ((a) * (b))
|
||||
# define CLIP(x) (x)
|
||||
#endif
|
||||
|
||||
#define LPC1(x) { \
|
||||
int c = coefs[(x)-1]; \
|
||||
p0 += MUL(c, s); \
|
||||
s = smp[i-(x)+1]; \
|
||||
p1 += MUL(c, s); \
|
||||
}
|
||||
|
||||
static av_always_inline void FUNC(lpc_encode_unrolled)(int32_t *res,
|
||||
const int32_t *smp, int len, int order,
|
||||
const int32_t *coefs, int shift, int big)
|
||||
{
|
||||
int i;
|
||||
for (i = order; i < len; i += 2) {
|
||||
int s = smp[i-order];
|
||||
sum_type p0 = 0, p1 = 0;
|
||||
if (big) {
|
||||
switch (order) {
|
||||
case 32: LPC1(32)
|
||||
case 31: LPC1(31)
|
||||
case 30: LPC1(30)
|
||||
case 29: LPC1(29)
|
||||
case 28: LPC1(28)
|
||||
case 27: LPC1(27)
|
||||
case 26: LPC1(26)
|
||||
case 25: LPC1(25)
|
||||
case 24: LPC1(24)
|
||||
case 23: LPC1(23)
|
||||
case 22: LPC1(22)
|
||||
case 21: LPC1(21)
|
||||
case 20: LPC1(20)
|
||||
case 19: LPC1(19)
|
||||
case 18: LPC1(18)
|
||||
case 17: LPC1(17)
|
||||
case 16: LPC1(16)
|
||||
case 15: LPC1(15)
|
||||
case 14: LPC1(14)
|
||||
case 13: LPC1(13)
|
||||
case 12: LPC1(12)
|
||||
case 11: LPC1(11)
|
||||
case 10: LPC1(10)
|
||||
case 9: LPC1( 9)
|
||||
LPC1( 8)
|
||||
LPC1( 7)
|
||||
LPC1( 6)
|
||||
LPC1( 5)
|
||||
LPC1( 4)
|
||||
LPC1( 3)
|
||||
LPC1( 2)
|
||||
LPC1( 1)
|
||||
}
|
||||
} else {
|
||||
switch (order) {
|
||||
case 8: LPC1( 8)
|
||||
case 7: LPC1( 7)
|
||||
case 6: LPC1( 6)
|
||||
case 5: LPC1( 5)
|
||||
case 4: LPC1( 4)
|
||||
case 3: LPC1( 3)
|
||||
case 2: LPC1( 2)
|
||||
case 1: LPC1( 1)
|
||||
}
|
||||
}
|
||||
res[i ] = smp[i ] - CLIP(p0 >> shift);
|
||||
res[i+1] = smp[i+1] - CLIP(p1 >> shift);
|
||||
}
|
||||
}
|
||||
|
||||
static void FUNC(flac_lpc_encode_c)(int32_t *res, const int32_t *smp, int len,
|
||||
int order, const int32_t *coefs, int shift)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < order; i++)
|
||||
res[i] = smp[i];
|
||||
#if CONFIG_SMALL
|
||||
for (i = order; i < len; i += 2) {
|
||||
int j;
|
||||
int s = smp[i];
|
||||
sum_type p0 = 0, p1 = 0;
|
||||
for (j = 0; j < order; j++) {
|
||||
int c = coefs[j];
|
||||
p1 += MUL(c, s);
|
||||
s = smp[i-j-1];
|
||||
p0 += MUL(c, s);
|
||||
}
|
||||
res[i ] = smp[i ] - CLIP(p0 >> shift);
|
||||
res[i+1] = smp[i+1] - CLIP(p1 >> shift);
|
||||
}
|
||||
#else
|
||||
switch (order) {
|
||||
case 1: FUNC(lpc_encode_unrolled)(res, smp, len, 1, coefs, shift, 0); break;
|
||||
case 2: FUNC(lpc_encode_unrolled)(res, smp, len, 2, coefs, shift, 0); break;
|
||||
case 3: FUNC(lpc_encode_unrolled)(res, smp, len, 3, coefs, shift, 0); break;
|
||||
case 4: FUNC(lpc_encode_unrolled)(res, smp, len, 4, coefs, shift, 0); break;
|
||||
case 5: FUNC(lpc_encode_unrolled)(res, smp, len, 5, coefs, shift, 0); break;
|
||||
case 6: FUNC(lpc_encode_unrolled)(res, smp, len, 6, coefs, shift, 0); break;
|
||||
case 7: FUNC(lpc_encode_unrolled)(res, smp, len, 7, coefs, shift, 0); break;
|
||||
case 8: FUNC(lpc_encode_unrolled)(res, smp, len, 8, coefs, shift, 0); break;
|
||||
default: FUNC(lpc_encode_unrolled)(res, smp, len, order, coefs, shift, 1); break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@ -32,6 +32,7 @@
|
||||
#include "lpc.h"
|
||||
#include "flac.h"
|
||||
#include "flacdata.h"
|
||||
#include "flacdsp.h"
|
||||
|
||||
#define FLAC_SUBFRAME_CONSTANT 0
|
||||
#define FLAC_SUBFRAME_VERBATIM 1
|
||||
@ -43,7 +44,11 @@
|
||||
#define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)
|
||||
#define MAX_LPC_PRECISION 15
|
||||
#define MAX_LPC_SHIFT 15
|
||||
#define MAX_RICE_PARAM 14
|
||||
|
||||
enum CodingMode {
|
||||
CODING_MODE_RICE = 4,
|
||||
CODING_MODE_RICE2 = 5,
|
||||
};
|
||||
|
||||
typedef struct CompressionOptions {
|
||||
int compression_level;
|
||||
@ -60,6 +65,7 @@ typedef struct CompressionOptions {
|
||||
} CompressionOptions;
|
||||
|
||||
typedef struct RiceContext {
|
||||
enum CodingMode coding_mode;
|
||||
int porder;
|
||||
int params[MAX_PARTITIONS];
|
||||
} RiceContext;
|
||||
@ -92,6 +98,7 @@ typedef struct FlacEncodeContext {
|
||||
int channels;
|
||||
int samplerate;
|
||||
int sr_code[2];
|
||||
int bps_code;
|
||||
int max_blocksize;
|
||||
int min_framesize;
|
||||
int max_framesize;
|
||||
@ -107,6 +114,7 @@ typedef struct FlacEncodeContext {
|
||||
uint8_t *md5_buffer;
|
||||
unsigned int md5_buffer_size;
|
||||
DSPContext dsp;
|
||||
FLACDSPContext flac_dsp;
|
||||
} FlacEncodeContext;
|
||||
|
||||
|
||||
@ -127,7 +135,7 @@ static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)
|
||||
put_bits(&pb, 24, s->max_framesize);
|
||||
put_bits(&pb, 20, s->samplerate);
|
||||
put_bits(&pb, 3, s->channels-1);
|
||||
put_bits(&pb, 5, 15); /* bits per sample - 1 */
|
||||
put_bits(&pb, 5, s->avctx->bits_per_raw_sample - 1);
|
||||
/* write 36-bit sample count in 2 put_bits() calls */
|
||||
put_bits(&pb, 24, (s->sample_count & 0xFFFFFF000LL) >> 12);
|
||||
put_bits(&pb, 12, s->sample_count & 0x000000FFFLL);
|
||||
@ -227,8 +235,18 @@ static av_cold int flac_encode_init(AVCodecContext *avctx)
|
||||
|
||||
s->avctx = avctx;
|
||||
|
||||
if (avctx->sample_fmt != AV_SAMPLE_FMT_S16)
|
||||
return -1;
|
||||
switch (avctx->sample_fmt) {
|
||||
case AV_SAMPLE_FMT_S16:
|
||||
avctx->bits_per_raw_sample = 16;
|
||||
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;
|
||||
break;
|
||||
}
|
||||
|
||||
if (channels < 1 || channels > FLAC_MAX_CHANNELS)
|
||||
return -1;
|
||||
@ -358,7 +376,8 @@ static av_cold int flac_encode_init(AVCodecContext *avctx)
|
||||
|
||||
/* set maximum encoded frame size in verbatim mode */
|
||||
s->max_framesize = ff_flac_get_max_frame_size(s->avctx->frame_size,
|
||||
s->channels, 16);
|
||||
s->channels,
|
||||
s->avctx->bits_per_raw_sample);
|
||||
|
||||
/* initialize MD5 context */
|
||||
s->md5ctx = av_md5_alloc();
|
||||
@ -408,6 +427,8 @@ static av_cold int flac_encode_init(AVCodecContext *avctx)
|
||||
s->options.max_prediction_order, FF_LPC_TYPE_LEVINSON);
|
||||
|
||||
ff_dsputil_init(&s->dsp, avctx);
|
||||
ff_flacdsp_init(&s->flac_dsp, avctx->sample_fmt,
|
||||
avctx->bits_per_raw_sample);
|
||||
|
||||
dprint_compression_options(s);
|
||||
|
||||
@ -442,8 +463,15 @@ static void init_frame(FlacEncodeContext *s, int nb_samples)
|
||||
}
|
||||
|
||||
for (ch = 0; ch < s->channels; ch++) {
|
||||
frame->subframes[ch].wasted = 0;
|
||||
frame->subframes[ch].obits = 16;
|
||||
FlacSubframe *sub = &frame->subframes[ch];
|
||||
|
||||
sub->wasted = 0;
|
||||
sub->obits = s->avctx->bits_per_raw_sample;
|
||||
|
||||
if (sub->obits > 16)
|
||||
sub->rc.coding_mode = CODING_MODE_RICE2;
|
||||
else
|
||||
sub->rc.coding_mode = CODING_MODE_RICE;
|
||||
}
|
||||
|
||||
frame->verbatim_only = 0;
|
||||
@ -453,15 +481,25 @@ static void init_frame(FlacEncodeContext *s, int nb_samples)
|
||||
/**
|
||||
* Copy channel-interleaved input samples into separate subframes.
|
||||
*/
|
||||
static void copy_samples(FlacEncodeContext *s, const int16_t *samples)
|
||||
static void copy_samples(FlacEncodeContext *s, const void *samples)
|
||||
{
|
||||
int i, j, ch;
|
||||
FlacFrame *frame;
|
||||
int shift = av_get_bytes_per_sample(s->avctx->sample_fmt) * 8 -
|
||||
s->avctx->bits_per_raw_sample;
|
||||
|
||||
frame = &s->frame;
|
||||
for (i = 0, j = 0; i < frame->blocksize; i++)
|
||||
for (ch = 0; ch < s->channels; ch++, j++)
|
||||
frame->subframes[ch].samples[i] = samples[j];
|
||||
#define COPY_SAMPLES(bits) do { \
|
||||
const int ## bits ## _t *samples0 = samples; \
|
||||
frame = &s->frame; \
|
||||
for (i = 0, j = 0; i < frame->blocksize; i++) \
|
||||
for (ch = 0; ch < s->channels; ch++, j++) \
|
||||
frame->subframes[ch].samples[i] = samples0[j] >> shift; \
|
||||
} while (0)
|
||||
|
||||
if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S16)
|
||||
COPY_SAMPLES(16);
|
||||
else
|
||||
COPY_SAMPLES(32);
|
||||
}
|
||||
|
||||
|
||||
@ -515,7 +553,7 @@ static uint64_t subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub,
|
||||
part_end = psize;
|
||||
for (p = 0; p < 1 << porder; p++) {
|
||||
int k = sub->rc.params[p];
|
||||
count += 4;
|
||||
count += sub->rc.coding_mode;
|
||||
count += rice_count_exact(&sub->residual[i], part_end - i, k);
|
||||
i = part_end;
|
||||
part_end = FFMIN(s->frame.blocksize, part_end + psize);
|
||||
@ -531,7 +569,7 @@ static uint64_t subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub,
|
||||
/**
|
||||
* Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0.
|
||||
*/
|
||||
static int find_optimal_param(uint64_t sum, int n)
|
||||
static int find_optimal_param(uint64_t sum, int n, int max_param)
|
||||
{
|
||||
int k;
|
||||
uint64_t sum2;
|
||||
@ -540,7 +578,7 @@ static int find_optimal_param(uint64_t sum, int n)
|
||||
return 0;
|
||||
sum2 = sum - (n >> 1);
|
||||
k = av_log2(av_clipl_int32(sum2 / n));
|
||||
return FFMIN(k, MAX_RICE_PARAM);
|
||||
return FFMIN(k, max_param);
|
||||
}
|
||||
|
||||
|
||||
@ -548,15 +586,17 @@ static uint64_t calc_optimal_rice_params(RiceContext *rc, int porder,
|
||||
uint64_t *sums, int n, int pred_order)
|
||||
{
|
||||
int i;
|
||||
int k, cnt, part;
|
||||
int k, cnt, part, max_param;
|
||||
uint64_t all_bits;
|
||||
|
||||
max_param = (1 << rc->coding_mode) - 2;
|
||||
|
||||
part = (1 << porder);
|
||||
all_bits = 4 * part;
|
||||
|
||||
cnt = (n >> porder) - pred_order;
|
||||
for (i = 0; i < part; i++) {
|
||||
k = find_optimal_param(sums[i], cnt);
|
||||
k = find_optimal_param(sums[i], cnt, max_param);
|
||||
rc->params[i] = k;
|
||||
all_bits += rice_encode_count(sums[i], cnt, k);
|
||||
cnt = n >> porder;
|
||||
@ -609,6 +649,8 @@ static uint64_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
|
||||
av_assert1(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);
|
||||
av_assert1(pmin <= pmax);
|
||||
|
||||
tmp_rc.coding_mode = rc->coding_mode;
|
||||
|
||||
udata = av_malloc(n * sizeof(uint32_t));
|
||||
for (i = 0; i < n; i++)
|
||||
udata[i] = (2*data[i]) ^ (data[i]>>31);
|
||||
@ -647,7 +689,7 @@ static uint64_t find_subframe_rice_params(FlacEncodeContext *s,
|
||||
int pmax = get_max_p_order(s->options.max_partition_order,
|
||||
s->frame.blocksize, pred_order);
|
||||
|
||||
uint64_t bits = 8 + pred_order * sub->obits + 2 + 4;
|
||||
uint64_t bits = 8 + pred_order * sub->obits + 2 + sub->rc.coding_mode;
|
||||
if (sub->type == FLAC_SUBFRAME_LPC)
|
||||
bits += 4 + 5 + pred_order * s->options.lpc_coeff_precision;
|
||||
bits += calc_rice_params(&sub->rc, pmin, pmax, sub->residual,
|
||||
@ -707,110 +749,6 @@ static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
|
||||
}
|
||||
|
||||
|
||||
#define LPC1(x) {\
|
||||
int c = coefs[(x)-1];\
|
||||
p0 += c * s;\
|
||||
s = smp[i-(x)+1];\
|
||||
p1 += c * s;\
|
||||
}
|
||||
|
||||
static av_always_inline void encode_residual_lpc_unrolled(int32_t *res,
|
||||
const int32_t *smp, int n, int order,
|
||||
const int32_t *coefs, int shift, int big)
|
||||
{
|
||||
int i;
|
||||
for (i = order; i < n; i += 2) {
|
||||
int s = smp[i-order];
|
||||
int p0 = 0, p1 = 0;
|
||||
if (big) {
|
||||
switch (order) {
|
||||
case 32: LPC1(32)
|
||||
case 31: LPC1(31)
|
||||
case 30: LPC1(30)
|
||||
case 29: LPC1(29)
|
||||
case 28: LPC1(28)
|
||||
case 27: LPC1(27)
|
||||
case 26: LPC1(26)
|
||||
case 25: LPC1(25)
|
||||
case 24: LPC1(24)
|
||||
case 23: LPC1(23)
|
||||
case 22: LPC1(22)
|
||||
case 21: LPC1(21)
|
||||
case 20: LPC1(20)
|
||||
case 19: LPC1(19)
|
||||
case 18: LPC1(18)
|
||||
case 17: LPC1(17)
|
||||
case 16: LPC1(16)
|
||||
case 15: LPC1(15)
|
||||
case 14: LPC1(14)
|
||||
case 13: LPC1(13)
|
||||
case 12: LPC1(12)
|
||||
case 11: LPC1(11)
|
||||
case 10: LPC1(10)
|
||||
case 9: LPC1( 9)
|
||||
LPC1( 8)
|
||||
LPC1( 7)
|
||||
LPC1( 6)
|
||||
LPC1( 5)
|
||||
LPC1( 4)
|
||||
LPC1( 3)
|
||||
LPC1( 2)
|
||||
LPC1( 1)
|
||||
}
|
||||
} else {
|
||||
switch (order) {
|
||||
case 8: LPC1( 8)
|
||||
case 7: LPC1( 7)
|
||||
case 6: LPC1( 6)
|
||||
case 5: LPC1( 5)
|
||||
case 4: LPC1( 4)
|
||||
case 3: LPC1( 3)
|
||||
case 2: LPC1( 2)
|
||||
case 1: LPC1( 1)
|
||||
}
|
||||
}
|
||||
res[i ] = smp[i ] - (p0 >> shift);
|
||||
res[i+1] = smp[i+1] - (p1 >> shift);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void encode_residual_lpc(int32_t *res, const int32_t *smp, int n,
|
||||
int order, const int32_t *coefs, int shift)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < order; i++)
|
||||
res[i] = smp[i];
|
||||
#if CONFIG_SMALL
|
||||
for (i = order; i < n; i += 2) {
|
||||
int j;
|
||||
int s = smp[i];
|
||||
int p0 = 0, p1 = 0;
|
||||
for (j = 0; j < order; j++) {
|
||||
int c = coefs[j];
|
||||
p1 += c * s;
|
||||
s = smp[i-j-1];
|
||||
p0 += c * s;
|
||||
}
|
||||
res[i ] = smp[i ] - (p0 >> shift);
|
||||
res[i+1] = smp[i+1] - (p1 >> shift);
|
||||
}
|
||||
#else
|
||||
switch (order) {
|
||||
case 1: encode_residual_lpc_unrolled(res, smp, n, 1, coefs, shift, 0); break;
|
||||
case 2: encode_residual_lpc_unrolled(res, smp, n, 2, coefs, shift, 0); break;
|
||||
case 3: encode_residual_lpc_unrolled(res, smp, n, 3, coefs, shift, 0); break;
|
||||
case 4: encode_residual_lpc_unrolled(res, smp, n, 4, coefs, shift, 0); break;
|
||||
case 5: encode_residual_lpc_unrolled(res, smp, n, 5, coefs, shift, 0); break;
|
||||
case 6: encode_residual_lpc_unrolled(res, smp, n, 6, coefs, shift, 0); break;
|
||||
case 7: encode_residual_lpc_unrolled(res, smp, n, 7, coefs, shift, 0); break;
|
||||
case 8: encode_residual_lpc_unrolled(res, smp, n, 8, coefs, shift, 0); break;
|
||||
default: encode_residual_lpc_unrolled(res, smp, n, order, coefs, shift, 1); break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
static int encode_residual_ch(FlacEncodeContext *s, int ch)
|
||||
{
|
||||
int i, n;
|
||||
@ -892,7 +830,8 @@ static int encode_residual_ch(FlacEncodeContext *s, int ch)
|
||||
order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
|
||||
if (order < 0)
|
||||
order = 0;
|
||||
encode_residual_lpc(res, smp, n, order+1, coefs[order], shift[order]);
|
||||
s->flac_dsp.lpc_encode(res, smp, n, order+1, coefs[order],
|
||||
shift[order]);
|
||||
bits[i] = find_subframe_rice_params(s, sub, order+1);
|
||||
if (bits[i] < bits[opt_index]) {
|
||||
opt_index = i;
|
||||
@ -906,7 +845,7 @@ 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++) {
|
||||
encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
|
||||
s->flac_dsp.lpc_encode(res, smp, n, i+1, coefs[i], shift[i]);
|
||||
bits[i] = find_subframe_rice_params(s, sub, i+1);
|
||||
if (bits[i] < bits[opt_order])
|
||||
opt_order = i;
|
||||
@ -924,7 +863,7 @@ 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;
|
||||
encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
|
||||
s->flac_dsp.lpc_encode(res, smp, n, i+1, coefs[i], shift[i]);
|
||||
bits[i] = find_subframe_rice_params(s, sub, i+1);
|
||||
if (bits[i] < bits[opt_order])
|
||||
opt_order = i;
|
||||
@ -939,7 +878,7 @@ static int encode_residual_ch(FlacEncodeContext *s, int ch)
|
||||
for (i = 0; i < sub->order; i++)
|
||||
sub->coefs[i] = coefs[sub->order-1][i];
|
||||
|
||||
encode_residual_lpc(res, smp, n, sub->order, sub->coefs, sub->shift);
|
||||
s->flac_dsp.lpc_encode(res, smp, n, sub->order, sub->coefs, sub->shift);
|
||||
|
||||
find_subframe_rice_params(s, sub, sub->order);
|
||||
|
||||
@ -1025,12 +964,18 @@ static void remove_wasted_bits(FlacEncodeContext *s)
|
||||
|
||||
sub->wasted = v;
|
||||
sub->obits -= v;
|
||||
|
||||
/* 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(int32_t *left_ch, int32_t *right_ch, int n)
|
||||
static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n,
|
||||
int max_rice_param)
|
||||
{
|
||||
int i, best;
|
||||
int32_t lt, rt;
|
||||
@ -1050,7 +995,7 @@ static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
|
||||
}
|
||||
/* estimate bit counts */
|
||||
for (i = 0; i < 4; i++) {
|
||||
k = find_optimal_param(2 * sum[i], n);
|
||||
k = find_optimal_param(2 * sum[i], n, max_rice_param);
|
||||
sum[i] = rice_encode_count( 2 * sum[i], n, k);
|
||||
}
|
||||
|
||||
@ -1089,9 +1034,10 @@ static void channel_decorrelation(FlacEncodeContext *s)
|
||||
return;
|
||||
}
|
||||
|
||||
if (s->options.ch_mode < 0)
|
||||
frame->ch_mode = estimate_stereo_mode(left, right, n);
|
||||
else
|
||||
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);
|
||||
} else
|
||||
frame->ch_mode = s->options.ch_mode;
|
||||
|
||||
/* perform decorrelation and adjust bits-per-sample */
|
||||
@ -1140,7 +1086,7 @@ static void write_frame_header(FlacEncodeContext *s)
|
||||
else
|
||||
put_bits(&s->pb, 4, frame->ch_mode + FLAC_MAX_CHANNELS - 1);
|
||||
|
||||
put_bits(&s->pb, 3, 4); /* bits-per-sample code */
|
||||
put_bits(&s->pb, 3, s->bps_code);
|
||||
put_bits(&s->pb, 1, 0);
|
||||
write_utf8(&s->pb, s->frame_count);
|
||||
|
||||
@ -1200,7 +1146,7 @@ static void write_subframes(FlacEncodeContext *s)
|
||||
}
|
||||
|
||||
/* rice-encoded block */
|
||||
put_bits(&s->pb, 2, 0);
|
||||
put_bits(&s->pb, 2, sub->rc.coding_mode - 4);
|
||||
|
||||
/* partition order */
|
||||
porder = sub->rc.porder;
|
||||
@ -1211,7 +1157,7 @@ static void write_subframes(FlacEncodeContext *s)
|
||||
part_end = &sub->residual[psize];
|
||||
for (p = 0; p < 1 << porder; p++) {
|
||||
int k = sub->rc.params[p];
|
||||
put_bits(&s->pb, 4, k);
|
||||
put_bits(&s->pb, sub->rc.coding_mode, k);
|
||||
while (res < part_end)
|
||||
set_sr_golomb_flac(&s->pb, *res++, k, INT32_MAX, 0);
|
||||
part_end = FFMIN(frame_end, part_end + psize);
|
||||
@ -1242,23 +1188,38 @@ static int write_frame(FlacEncodeContext *s, AVPacket *avpkt)
|
||||
}
|
||||
|
||||
|
||||
static int update_md5_sum(FlacEncodeContext *s, const int16_t *samples)
|
||||
static int update_md5_sum(FlacEncodeContext *s, const void *samples)
|
||||
{
|
||||
const uint8_t *buf;
|
||||
int buf_size = s->frame.blocksize * s->channels * 2;
|
||||
int buf_size = s->frame.blocksize * s->channels *
|
||||
((s->avctx->bits_per_raw_sample + 7) / 8);
|
||||
|
||||
if (HAVE_BIGENDIAN) {
|
||||
if (s->avctx->bits_per_raw_sample > 16 || HAVE_BIGENDIAN) {
|
||||
av_fast_malloc(&s->md5_buffer, &s->md5_buffer_size, buf_size);
|
||||
if (!s->md5_buffer)
|
||||
return AVERROR(ENOMEM);
|
||||
}
|
||||
|
||||
buf = (const uint8_t *)samples;
|
||||
if (s->avctx->bits_per_raw_sample <= 16) {
|
||||
buf = (const uint8_t *)samples;
|
||||
#if HAVE_BIGENDIAN
|
||||
s->dsp.bswap16_buf((uint16_t *)s->md5_buffer,
|
||||
(const uint16_t *)samples, buf_size / 2);
|
||||
buf = s->md5_buffer;
|
||||
s->dsp.bswap16_buf((uint16_t *)s->md5_buffer,
|
||||
(const uint16_t *)samples, buf_size / 2);
|
||||
buf = s->md5_buffer;
|
||||
#endif
|
||||
} else {
|
||||
int i;
|
||||
const int32_t *samples0 = samples;
|
||||
uint8_t *tmp = s->md5_buffer;
|
||||
|
||||
for (i = 0; i < s->frame.blocksize * s->channels; i++) {
|
||||
int32_t v = samples0[i] >> 8;
|
||||
*tmp++ = (v ) & 0xFF;
|
||||
*tmp++ = (v >> 8) & 0xFF;
|
||||
*tmp++ = (v >> 16) & 0xFF;
|
||||
}
|
||||
buf = s->md5_buffer;
|
||||
}
|
||||
av_md5_update(s->md5ctx, buf, buf_size);
|
||||
|
||||
return 0;
|
||||
@ -1269,7 +1230,6 @@ static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
|
||||
const AVFrame *frame, int *got_packet_ptr)
|
||||
{
|
||||
FlacEncodeContext *s;
|
||||
const int16_t *samples;
|
||||
int frame_bytes, out_bytes, ret;
|
||||
|
||||
s = avctx->priv_data;
|
||||
@ -1281,17 +1241,17 @@ static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
|
||||
write_streaminfo(s, avctx->extradata);
|
||||
return 0;
|
||||
}
|
||||
samples = (const int16_t *)frame->data[0];
|
||||
|
||||
/* change max_framesize for small final frame */
|
||||
if (frame->nb_samples < s->frame.blocksize) {
|
||||
s->max_framesize = ff_flac_get_max_frame_size(frame->nb_samples,
|
||||
s->channels, 16);
|
||||
s->channels,
|
||||
avctx->bits_per_raw_sample);
|
||||
}
|
||||
|
||||
init_frame(s, frame->nb_samples);
|
||||
|
||||
copy_samples(s, samples);
|
||||
copy_samples(s, frame->data[0]);
|
||||
|
||||
channel_decorrelation(s);
|
||||
|
||||
@ -1317,7 +1277,7 @@ static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
|
||||
|
||||
s->frame_count++;
|
||||
s->sample_count += frame->nb_samples;
|
||||
if ((ret = update_md5_sum(s, samples)) < 0) {
|
||||
if ((ret = update_md5_sum(s, frame->data[0])) < 0) {
|
||||
av_log(avctx, AV_LOG_ERROR, "Error updating MD5 checksum\n");
|
||||
return ret;
|
||||
}
|
||||
@ -1394,6 +1354,7 @@ AVCodec ff_flac_encoder = {
|
||||
.close = flac_encode_close,
|
||||
.capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY | CODEC_CAP_LOSSLESS,
|
||||
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
|
||||
AV_SAMPLE_FMT_S32,
|
||||
AV_SAMPLE_FMT_NONE },
|
||||
.long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
|
||||
.priv_class = &flac_encoder_class,
|
||||
|
||||
@ -1,17 +1,24 @@
|
||||
FATE_FLAC += fate-flac-chmode-indep \
|
||||
fate-flac-chmode-left_side \
|
||||
fate-flac-chmode-mid_side \
|
||||
fate-flac-chmode-right_side \
|
||||
fate-flac-fixed \
|
||||
fate-flac-lpc-cholesky \
|
||||
fate-flac-lpc-levinson \
|
||||
FATE_FLAC += fate-flac-16-chmode-indep \
|
||||
fate-flac-16-chmode-left_side \
|
||||
fate-flac-16-chmode-mid_side \
|
||||
fate-flac-16-chmode-right_side \
|
||||
fate-flac-16-fixed \
|
||||
fate-flac-16-lpc-cholesky \
|
||||
fate-flac-16-lpc-levinson \
|
||||
fate-flac-24-comp-8 \
|
||||
|
||||
fate-flac-chmode-%: OPTS = -ch_mode $(@:fate-flac-chmode-%=%)
|
||||
fate-flac-fixed: OPTS = -lpc_type fixed
|
||||
fate-flac-lpc-%: OPTS = -lpc_type $(@:fate-flac-lpc-%=%)
|
||||
fate-flac-16-chmode-%: OPTS = -ch_mode $(@:fate-flac-16-chmode-%=%)
|
||||
fate-flac-16-fixed: OPTS = -lpc_type fixed
|
||||
fate-flac-16-lpc-%: OPTS = -lpc_type $(@:fate-flac-16-lpc-%=%)
|
||||
|
||||
fate-flac-16-%: REF = $(SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav
|
||||
fate-flac-16-%: CMD = enc_dec_pcm flac wav s16le $(REF) -c flac $(OPTS)
|
||||
|
||||
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 $(REF) -c flac $(OPTS)
|
||||
|
||||
fate-flac-%: REF = $(SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav
|
||||
fate-flac-%: CMD = enc_dec_pcm flac wav s16le $(REF) -c flac $(OPTS)
|
||||
fate-flac-%: CMP = oneoff
|
||||
fate-flac-%: FUZZ = 0
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user