* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include "libavutil/crc.h"
+#include "libavutil/lls.h"
#include "avcodec.h"
#include "bitstream.h"
-#include "crc.h"
#include "dsputil.h"
#include "golomb.h"
-#include "lls.h"
#define FLAC_MAX_CH 8
#define FLAC_MIN_BLOCKSIZE 16
int ch_code;
int samplerate;
int sr_code[2];
- int blocksize;
int max_framesize;
uint32_t frame_count;
FlacFrame frame;
init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE);
/* streaminfo metadata block */
- put_bits(&pb, 16, s->blocksize);
- put_bits(&pb, 16, s->blocksize);
+ put_bits(&pb, 16, s->avctx->frame_size);
+ put_bits(&pb, 16, s->avctx->frame_size);
put_bits(&pb, 24, 0);
put_bits(&pb, 24, s->max_framesize);
put_bits(&pb, 20, s->samplerate);
return blocksize;
}
-static int flac_encode_init(AVCodecContext *avctx)
+static av_cold int flac_encode_init(AVCodecContext *avctx)
{
int freq = avctx->sample_rate;
int channels = avctx->channels;
avctx->frame_size);
return -1;
}
- s->blocksize = avctx->frame_size;
} else {
- s->blocksize = select_blocksize(s->samplerate, s->options.block_time_ms);
- avctx->frame_size = s->blocksize;
+ s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms);
}
- av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", s->blocksize);
+ av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", s->avctx->frame_size);
/* set LPC precision */
if(avctx->lpc_coeff_precision > 0) {
}
s->options.lpc_coeff_precision = avctx->lpc_coeff_precision;
} else {
- /* select LPC precision based on block size */
- if( s->blocksize <= 192) s->options.lpc_coeff_precision = 7;
- else if(s->blocksize <= 384) s->options.lpc_coeff_precision = 8;
- else if(s->blocksize <= 576) s->options.lpc_coeff_precision = 9;
- else if(s->blocksize <= 1152) s->options.lpc_coeff_precision = 10;
- else if(s->blocksize <= 2304) s->options.lpc_coeff_precision = 11;
- else if(s->blocksize <= 4608) s->options.lpc_coeff_precision = 12;
- else if(s->blocksize <= 8192) s->options.lpc_coeff_precision = 13;
- else if(s->blocksize <= 16384) s->options.lpc_coeff_precision = 14;
- else s->options.lpc_coeff_precision = 15;
+ /* default LPC precision */
+ s->options.lpc_coeff_precision = 15;
}
av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",
s->options.lpc_coeff_precision);
/* set maximum encoded frame size in verbatim mode */
if(s->channels == 2) {
- s->max_framesize = 14 + ((s->blocksize * 33 + 7) >> 3);
+ s->max_framesize = 14 + ((s->avctx->frame_size * 33 + 7) >> 3);
} else {
- s->max_framesize = 14 + (s->blocksize * s->channels * 2);
+ s->max_framesize = 14 + (s->avctx->frame_size * s->channels * 2);
}
streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);
frame = &s->frame;
for(i=0; i<16; i++) {
- if(s->blocksize == flac_blocksizes[i]) {
+ if(s->avctx->frame_size == flac_blocksizes[i]) {
frame->blocksize = flac_blocksizes[i];
frame->bs_code[0] = i;
frame->bs_code[1] = 0;
}
}
if(i == 16) {
- frame->blocksize = s->blocksize;
+ frame->blocksize = s->avctx->frame_size;
if(frame->blocksize <= 256) {
frame->bs_code[0] = 6;
frame->bs_code[1] = frame->blocksize-1;
uint32_t all_bits;
part = (1 << porder);
- all_bits = 0;
+ all_bits = 4 * part;
cnt = (n >> porder) - pred_order;
for(i=0; i<part; i++) {
- if(i == 1) cnt = (n >> porder);
k = find_optimal_param(sums[i], cnt);
rc->params[i] = k;
all_bits += rice_encode_count(sums[i], cnt, k);
+ cnt = n >> porder;
}
- all_bits += (4 * part);
rc->porder = porder;
double w;
double c;
+ assert(!(len&1)); //the optimization in r11881 does not support odd len
+ //if someone wants odd len extend the change in r11881
+
n2 = (len >> 1);
c = 2.0 / (len - 1.0);
+
+ w_data+=n2;
+ data+=n2;
for(i=0; i<n2; i++) {
- w = c - i - 1.0;
+ w = c - n2 + i;
w = 1.0 - (w * w);
- w_data[i] = data[i] * w;
- w_data[len-1-i] = data[len-1-i] * w;
+ w_data[-i-1] = data[-i-1] * w;
+ w_data[+i ] = data[+i ] * w;
}
}
compute_lpc_coefs(autoc, max_order, lpc, ref);
}else{
LLSModel m[2];
- double var[MAX_LPC_ORDER+1], eval, weight;
+ double var[MAX_LPC_ORDER+1], weight;
for(pass=0; pass<use_lpc-1; pass++){
av_init_lls(&m[pass&1], max_order);
var[j]= samples[i-j];
if(pass){
+ double eval, inv, rinv;
eval= av_evaluate_lls(&m[(pass-1)&1], var+1, max_order-1);
eval= (512>>pass) + fabs(eval - var[0]);
+ inv = 1/eval;
+ rinv = sqrt(inv);
for(j=0; j<=max_order; j++)
- var[j]/= sqrt(eval);
- weight += 1/eval;
+ var[j] *= rinv;
+ weight += inv;
}else
weight++;
res[i]= smp[i] - smp[i-1];
}else if(order==2){
int a = smp[order-1] - smp[order-2];
- for(i=order; i<n; i++) {
+ for(i=order; i<n; i+=2) {
int b = smp[i] - smp[i-1];
res[i]= b - a;
- a = b;
+ a = smp[i+1] - smp[i];
+ res[i+1]= a - b;
}
}else if(order==3){
int a = smp[order-1] - smp[order-2];
int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
- for(i=order; i<n; i++) {
+ for(i=order; i<n; i+=2) {
int b = smp[i] - smp[i-1];
int d = b - a;
res[i]= d - c;
- a = b;
- c = d;
+ a = smp[i+1] - smp[i];
+ c = a - b;
+ res[i+1]= c - d;
}
}else{
int a = smp[order-1] - smp[order-2];
int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
- for(i=order; i<n; i++) {
+ for(i=order; i<n; i+=2) {
int b = smp[i] - smp[i-1];
int d = b - a;
int f = d - c;
res[i]= f - e;
- a = b;
- c = d;
- e = f;
+ a = smp[i+1] - smp[i];
+ c = a - b;
+ e = c - d;
+ res[i+1]= e - f;
}
}
}
#define LPC1(x) {\
- int s = smp[i-(x)+1];\
- p1 += c*s;\
- c = coefs[(x)-2];\
+ 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(
{
int i;
for(i=order; i<n; i+=2) {
- int c = coefs[order-1];
- int p0 = c * smp[i-order];
- int p1 = 0;
+ int s = smp[i-order];
+ int p0 = 0, p1 = 0;
if(big) {
switch(order) {
case 32: LPC1(32)
LPC1( 4)
LPC1( 3)
LPC1( 2)
+ LPC1( 1)
}
} else {
switch(order) {
case 4: LPC1( 4)
case 3: LPC1( 3)
case 2: LPC1( 2)
+ case 1: LPC1( 1)
}
}
- p1 += c * smp[i];
res[i ] = smp[i ] - (p0 >> shift);
res[i+1] = smp[i+1] - (p1 >> shift);
}
#ifdef CONFIG_SMALL
for(i=order; i<n; i+=2) {
int j;
- int32_t c = coefs[0];
- int32_t p0 = 0, p1 = c*smp[i];
- for(j=1; j<order; j++) {
- int32_t s = smp[i-j];
- p0 += c*s;
- c = coefs[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;
}
- p0 += c*smp[i-order];
- res[i+0] = smp[i+0] - (p0 >> shift);
+ res[i ] = smp[i ] - (p0 >> shift);
res[i+1] = smp[i+1] - (p1 >> shift);
}
#else
}
}
-static void put_sbits(PutBitContext *pb, int bits, int32_t val)
-{
- assert(bits >= 0 && bits <= 31);
-
- put_bits(pb, bits, val & ((1<<bits)-1));
-}
-
static void write_utf8(PutBitContext *pb, uint32_t val)
{
uint8_t tmp;
put_bits(&s->pb, 16, s->sr_code[1]);
}
flush_put_bits(&s->pb);
- crc = av_crc(av_crc07, 0, s->pb.buf, put_bits_count(&s->pb)>>3);
+ crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
+ s->pb.buf, put_bits_count(&s->pb)>>3);
put_bits(&s->pb, 8, crc);
}
{
int crc;
flush_put_bits(&s->pb);
- crc = bswap_16(av_crc(av_crc8005, 0, s->pb.buf, put_bits_count(&s->pb)>>3));
+ crc = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
+ s->pb.buf, put_bits_count(&s->pb)>>3));
put_bits(&s->pb, 16, crc);
flush_put_bits(&s->pb);
}
s = avctx->priv_data;
- s->blocksize = avctx->frame_size;
init_frame(s);
copy_samples(s, samples);
return out_bytes;
}
-static int flac_encode_close(AVCodecContext *avctx)
+static av_cold int flac_encode_close(AVCodecContext *avctx)
{
av_freep(&avctx->extradata);
avctx->extradata_size = 0;
flac_encode_close,
NULL,
.capabilities = CODEC_CAP_SMALL_LAST_FRAME,
+ .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
+ .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
};
projects / ffmpeg / blobdiff