Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flacenc.c @ 63613fe6

History | View | Annotate | Download (39.3 KB)

1 9e96ab03 Michael Niedermayer
/**
2
 * FLAC audio encoder
3 38c1a5c4 Justin Ruggles
 * Copyright (c) 2006  Justin Ruggles <justin.ruggles@gmail.com>
4 9e96ab03 Michael Niedermayer
 *
5 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8 9e96ab03 Michael Niedermayer
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
11 9e96ab03 Michael Niedermayer
 *
12 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
13 9e96ab03 Michael Niedermayer
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
19 9e96ab03 Michael Niedermayer
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22 245976da Diego Biurrun
#include "libavutil/crc.h"
23 a9f8587e Justin Ruggles
#include "libavutil/md5.h"
24 9e96ab03 Michael Niedermayer
#include "avcodec.h"
25 9106a698 Stefano Sabatini
#include "get_bits.h"
26 6810b93a Loren Merritt
#include "dsputil.h"
27 9e96ab03 Michael Niedermayer
#include "golomb.h"
28 c50da3ad Ramiro Polla
#include "lpc.h"
29 07d16e2e Justin Ruggles
#include "flac.h"
30 d4df4e50 Justin Ruggles
#include "flacdata.h"
31 9e96ab03 Michael Niedermayer
32
#define FLAC_SUBFRAME_CONSTANT  0
33
#define FLAC_SUBFRAME_VERBATIM  1
34
#define FLAC_SUBFRAME_FIXED     8
35
#define FLAC_SUBFRAME_LPC      32
36
37 a403fc03 Justin Ruggles
#define MAX_FIXED_ORDER     4
38
#define MAX_PARTITION_ORDER 8
39
#define MAX_PARTITIONS     (1 << MAX_PARTITION_ORDER)
40
#define MAX_LPC_PRECISION  15
41
#define MAX_LPC_SHIFT      15
42
#define MAX_RICE_PARAM     14
43
44
typedef struct CompressionOptions {
45
    int compression_level;
46
    int block_time_ms;
47
    int use_lpc;
48
    int lpc_coeff_precision;
49
    int min_prediction_order;
50
    int max_prediction_order;
51
    int prediction_order_method;
52
    int min_partition_order;
53
    int max_partition_order;
54
} CompressionOptions;
55
56 e71bcc37 Justin Ruggles
typedef struct RiceContext {
57
    int porder;
58 a403fc03 Justin Ruggles
    int params[MAX_PARTITIONS];
59 e71bcc37 Justin Ruggles
} RiceContext;
60
61 9e96ab03 Michael Niedermayer
typedef struct FlacSubframe {
62
    int type;
63
    int type_code;
64
    int obits;
65
    int order;
66 a403fc03 Justin Ruggles
    int32_t coefs[MAX_LPC_ORDER];
67
    int shift;
68 e71bcc37 Justin Ruggles
    RiceContext rc;
69 9e96ab03 Michael Niedermayer
    int32_t samples[FLAC_MAX_BLOCKSIZE];
70 0d2caa37 Loren Merritt
    int32_t residual[FLAC_MAX_BLOCKSIZE+1];
71 9e96ab03 Michael Niedermayer
} FlacSubframe;
72
73
typedef struct FlacFrame {
74 07d16e2e Justin Ruggles
    FlacSubframe subframes[FLAC_MAX_CHANNELS];
75 9e96ab03 Michael Niedermayer
    int blocksize;
76
    int bs_code[2];
77
    uint8_t crc8;
78
    int ch_mode;
79
} FlacFrame;
80
81
typedef struct FlacEncodeContext {
82
    PutBitContext pb;
83 f1216221 Justin Ruggles
    int channels;
84
    int samplerate;
85 9e96ab03 Michael Niedermayer
    int sr_code[2];
86 0bc08ed9 Justin Ruggles
    int max_blocksize;
87 6682ae42 Justin Ruggles
    int min_framesize;
88 f1216221 Justin Ruggles
    int max_framesize;
89 6682ae42 Justin Ruggles
    int max_encoded_framesize;
90 9e96ab03 Michael Niedermayer
    uint32_t frame_count;
91 e1a12934 Justin Ruggles
    uint64_t sample_count;
92 a9f8587e Justin Ruggles
    uint8_t md5sum[16];
93 9e96ab03 Michael Niedermayer
    FlacFrame frame;
94 a403fc03 Justin Ruggles
    CompressionOptions options;
95 e71bcc37 Justin Ruggles
    AVCodecContext *avctx;
96 6810b93a Loren Merritt
    DSPContext dsp;
97 a9f8587e Justin Ruggles
    struct AVMD5 *md5ctx;
98 9e96ab03 Michael Niedermayer
} FlacEncodeContext;
99
100
/**
101
 * Writes streaminfo metadata block to byte array
102
 */
103
static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)
104
{
105
    PutBitContext pb;
106
107
    memset(header, 0, FLAC_STREAMINFO_SIZE);
108
    init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE);
109
110
    /* streaminfo metadata block */
111 0bc08ed9 Justin Ruggles
    put_bits(&pb, 16, s->max_blocksize);
112
    put_bits(&pb, 16, s->max_blocksize);
113 6682ae42 Justin Ruggles
    put_bits(&pb, 24, s->min_framesize);
114 9e96ab03 Michael Niedermayer
    put_bits(&pb, 24, s->max_framesize);
115
    put_bits(&pb, 20, s->samplerate);
116
    put_bits(&pb, 3, s->channels-1);
117
    put_bits(&pb, 5, 15);       /* bits per sample - 1 */
118 e1a12934 Justin Ruggles
    /* write 36-bit sample count in 2 put_bits() calls */
119
    put_bits(&pb, 24, (s->sample_count & 0xFFFFFF000LL) >> 12);
120
    put_bits(&pb, 12,  s->sample_count & 0x000000FFFLL);
121 9e96ab03 Michael Niedermayer
    flush_put_bits(&pb);
122 a9f8587e Justin Ruggles
    memcpy(&header[18], s->md5sum, 16);
123 9e96ab03 Michael Niedermayer
}
124
125
/**
126
 * Sets blocksize based on samplerate
127
 * Chooses the closest predefined blocksize >= BLOCK_TIME_MS milliseconds
128
 */
129 a403fc03 Justin Ruggles
static int select_blocksize(int samplerate, int block_time_ms)
130 9e96ab03 Michael Niedermayer
{
131
    int i;
132
    int target;
133
    int blocksize;
134
135
    assert(samplerate > 0);
136 d4df4e50 Justin Ruggles
    blocksize = ff_flac_blocksize_table[1];
137 a403fc03 Justin Ruggles
    target = (samplerate * block_time_ms) / 1000;
138 d1015e88 Michael Niedermayer
    for(i=0; i<16; i++) {
139 d4df4e50 Justin Ruggles
        if(target >= ff_flac_blocksize_table[i] && ff_flac_blocksize_table[i] > blocksize) {
140
            blocksize = ff_flac_blocksize_table[i];
141 9e96ab03 Michael Niedermayer
        }
142
    }
143
    return blocksize;
144
}
145
146 98a6fff9 Zuxy Meng
static av_cold int flac_encode_init(AVCodecContext *avctx)
147 9e96ab03 Michael Niedermayer
{
148
    int freq = avctx->sample_rate;
149
    int channels = avctx->channels;
150
    FlacEncodeContext *s = avctx->priv_data;
151 7c69b830 Michael Niedermayer
    int i, level;
152 9e96ab03 Michael Niedermayer
    uint8_t *streaminfo;
153
154 e71bcc37 Justin Ruggles
    s->avctx = avctx;
155
156 6810b93a Loren Merritt
    dsputil_init(&s->dsp, avctx);
157
158 9e96ab03 Michael Niedermayer
    if(avctx->sample_fmt != SAMPLE_FMT_S16) {
159
        return -1;
160
    }
161
162 07d16e2e Justin Ruggles
    if(channels < 1 || channels > FLAC_MAX_CHANNELS) {
163 9e96ab03 Michael Niedermayer
        return -1;
164
    }
165
    s->channels = channels;
166
167
    /* find samplerate in table */
168
    if(freq < 1)
169
        return -1;
170
    for(i=4; i<12; i++) {
171 d4df4e50 Justin Ruggles
        if(freq == ff_flac_sample_rate_table[i]) {
172
            s->samplerate = ff_flac_sample_rate_table[i];
173 9e96ab03 Michael Niedermayer
            s->sr_code[0] = i;
174
            s->sr_code[1] = 0;
175
            break;
176
        }
177
    }
178
    /* if not in table, samplerate is non-standard */
179
    if(i == 12) {
180
        if(freq % 1000 == 0 && freq < 255000) {
181
            s->sr_code[0] = 12;
182
            s->sr_code[1] = freq / 1000;
183
        } else if(freq % 10 == 0 && freq < 655350) {
184
            s->sr_code[0] = 14;
185
            s->sr_code[1] = freq / 10;
186
        } else if(freq < 65535) {
187
            s->sr_code[0] = 13;
188
            s->sr_code[1] = freq;
189
        } else {
190
            return -1;
191
        }
192
        s->samplerate = freq;
193
    }
194
195 a403fc03 Justin Ruggles
    /* set compression option defaults based on avctx->compression_level */
196
    if(avctx->compression_level < 0) {
197
        s->options.compression_level = 5;
198
    } else {
199
        s->options.compression_level = avctx->compression_level;
200
    }
201
    av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", s->options.compression_level);
202
203 7c69b830 Michael Niedermayer
    level= s->options.compression_level;
204 26053bdc Justin Ruggles
    if(level > 12) {
205 a403fc03 Justin Ruggles
        av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",
206
               s->options.compression_level);
207
        return -1;
208
    }
209
210 26053bdc Justin Ruggles
    s->options.block_time_ms       = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
211
    s->options.use_lpc             = ((int[]){  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1})[level];
212
    s->options.min_prediction_order= ((int[]){  2,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1})[level];
213
    s->options.max_prediction_order= ((int[]){  3,  4,  4,  6,  8,  8,  8,  8, 12, 12, 12, 32, 32})[level];
214
    s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
215
                                                   ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
216 5f3acd9e Justin Ruggles
                                                   ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG,    ORDER_METHOD_4LEVEL,
217
                                                   ORDER_METHOD_LOG,    ORDER_METHOD_SEARCH, ORDER_METHOD_LOG,
218 26053bdc Justin Ruggles
                                                   ORDER_METHOD_SEARCH})[level];
219 e1bbc032 Justin Ruggles
    s->options.min_partition_order = ((int[]){  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0})[level];
220
    s->options.max_partition_order = ((int[]){  2,  2,  3,  3,  3,  8,  8,  8,  8,  8,  8,  8,  8})[level];
221 7c69b830 Michael Niedermayer
222 a403fc03 Justin Ruggles
    /* set compression option overrides from AVCodecContext */
223
    if(avctx->use_lpc >= 0) {
224 f66e4f5f Reimar Döffinger
        s->options.use_lpc = av_clip(avctx->use_lpc, 0, 11);
225 a403fc03 Justin Ruggles
    }
226 ab01b2b8 Michael Niedermayer
    if(s->options.use_lpc == 1)
227
        av_log(avctx, AV_LOG_DEBUG, " use lpc: Levinson-Durbin recursion with Welch window\n");
228
    else if(s->options.use_lpc > 1)
229
        av_log(avctx, AV_LOG_DEBUG, " use lpc: Cholesky factorization\n");
230 a403fc03 Justin Ruggles
231
    if(avctx->min_prediction_order >= 0) {
232
        if(s->options.use_lpc) {
233
            if(avctx->min_prediction_order < MIN_LPC_ORDER ||
234
                    avctx->min_prediction_order > MAX_LPC_ORDER) {
235
                av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
236
                       avctx->min_prediction_order);
237
                return -1;
238
            }
239
        } else {
240
            if(avctx->min_prediction_order > MAX_FIXED_ORDER) {
241
                av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
242
                       avctx->min_prediction_order);
243
                return -1;
244
            }
245
        }
246
        s->options.min_prediction_order = avctx->min_prediction_order;
247
    }
248
    if(avctx->max_prediction_order >= 0) {
249
        if(s->options.use_lpc) {
250
            if(avctx->max_prediction_order < MIN_LPC_ORDER ||
251
                    avctx->max_prediction_order > MAX_LPC_ORDER) {
252
                av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
253
                       avctx->max_prediction_order);
254
                return -1;
255
            }
256
        } else {
257
            if(avctx->max_prediction_order > MAX_FIXED_ORDER) {
258
                av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
259
                       avctx->max_prediction_order);
260
                return -1;
261
            }
262
        }
263
        s->options.max_prediction_order = avctx->max_prediction_order;
264
    }
265
    if(s->options.max_prediction_order < s->options.min_prediction_order) {
266
        av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
267
               s->options.min_prediction_order, s->options.max_prediction_order);
268
        return -1;
269
    }
270
    av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n",
271
           s->options.min_prediction_order, s->options.max_prediction_order);
272
273
    if(avctx->prediction_order_method >= 0) {
274 dbb45a3b Michael Niedermayer
        if(avctx->prediction_order_method > ORDER_METHOD_LOG) {
275 a403fc03 Justin Ruggles
            av_log(avctx, AV_LOG_ERROR, "invalid prediction order method: %d\n",
276
                   avctx->prediction_order_method);
277
            return -1;
278
        }
279
        s->options.prediction_order_method = avctx->prediction_order_method;
280
    }
281 26053bdc Justin Ruggles
    switch(s->options.prediction_order_method) {
282 a403fc03 Justin Ruggles
        case ORDER_METHOD_EST:    av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
283
                                         "estimate"); break;
284
        case ORDER_METHOD_2LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
285
                                         "2-level"); break;
286
        case ORDER_METHOD_4LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
287
                                         "4-level"); break;
288
        case ORDER_METHOD_8LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
289
                                         "8-level"); break;
290
        case ORDER_METHOD_SEARCH: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
291
                                         "full search"); break;
292 dbb45a3b Michael Niedermayer
        case ORDER_METHOD_LOG:    av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
293
                                         "log search"); break;
294 a403fc03 Justin Ruggles
    }
295
296
    if(avctx->min_partition_order >= 0) {
297
        if(avctx->min_partition_order > MAX_PARTITION_ORDER) {
298
            av_log(avctx, AV_LOG_ERROR, "invalid min partition order: %d\n",
299
                   avctx->min_partition_order);
300
            return -1;
301
        }
302
        s->options.min_partition_order = avctx->min_partition_order;
303
    }
304
    if(avctx->max_partition_order >= 0) {
305
        if(avctx->max_partition_order > MAX_PARTITION_ORDER) {
306
            av_log(avctx, AV_LOG_ERROR, "invalid max partition order: %d\n",
307
                   avctx->max_partition_order);
308
            return -1;
309
        }
310
        s->options.max_partition_order = avctx->max_partition_order;
311
    }
312
    if(s->options.max_partition_order < s->options.min_partition_order) {
313
        av_log(avctx, AV_LOG_ERROR, "invalid partition orders: min=%d max=%d\n",
314
               s->options.min_partition_order, s->options.max_partition_order);
315
        return -1;
316
    }
317
    av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n",
318
           s->options.min_partition_order, s->options.max_partition_order);
319
320
    if(avctx->frame_size > 0) {
321
        if(avctx->frame_size < FLAC_MIN_BLOCKSIZE ||
322 c6375bf2 Justin Ruggles
                avctx->frame_size > FLAC_MAX_BLOCKSIZE) {
323 a403fc03 Justin Ruggles
            av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n",
324
                   avctx->frame_size);
325
            return -1;
326
        }
327
    } else {
328 42ceeb5f Justin Ruggles
        s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms);
329 a403fc03 Justin Ruggles
    }
330 0bc08ed9 Justin Ruggles
    s->max_blocksize = s->avctx->frame_size;
331 42ceeb5f Justin Ruggles
    av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", s->avctx->frame_size);
332 a403fc03 Justin Ruggles
333
    /* set LPC precision */
334
    if(avctx->lpc_coeff_precision > 0) {
335
        if(avctx->lpc_coeff_precision > MAX_LPC_PRECISION) {
336
            av_log(avctx, AV_LOG_ERROR, "invalid lpc coeff precision: %d\n",
337
                   avctx->lpc_coeff_precision);
338
            return -1;
339
        }
340
        s->options.lpc_coeff_precision = avctx->lpc_coeff_precision;
341
    } else {
342 fe790f89 Justin Ruggles
        /* default LPC precision */
343
        s->options.lpc_coeff_precision = 15;
344 a403fc03 Justin Ruggles
    }
345
    av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",
346
           s->options.lpc_coeff_precision);
347 9e96ab03 Michael Niedermayer
348 f33aa120 Michael Niedermayer
    /* set maximum encoded frame size in verbatim mode */
349 0fb2182d Justin Ruggles
    s->max_framesize = ff_flac_get_max_frame_size(s->avctx->frame_size,
350
                                                  s->channels, 16);
351 9e96ab03 Michael Niedermayer
352 a9f8587e Justin Ruggles
    /* initialize MD5 context */
353
    s->md5ctx = av_malloc(av_md5_size);
354
    if(!s->md5ctx)
355
        return AVERROR_NOMEM;
356
    av_md5_init(s->md5ctx);
357
358 9e96ab03 Michael Niedermayer
    streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);
359
    write_streaminfo(s, streaminfo);
360
    avctx->extradata = streaminfo;
361
    avctx->extradata_size = FLAC_STREAMINFO_SIZE;
362
363
    s->frame_count = 0;
364 b9b4fc5e Justin Ruggles
    s->min_framesize = s->max_framesize;
365 9e96ab03 Michael Niedermayer
366
    avctx->coded_frame = avcodec_alloc_frame();
367
    avctx->coded_frame->key_frame = 1;
368
369
    return 0;
370
}
371
372 f33aa120 Michael Niedermayer
static void init_frame(FlacEncodeContext *s)
373 9e96ab03 Michael Niedermayer
{
374
    int i, ch;
375
    FlacFrame *frame;
376
377
    frame = &s->frame;
378
379
    for(i=0; i<16; i++) {
380 d4df4e50 Justin Ruggles
        if(s->avctx->frame_size == ff_flac_blocksize_table[i]) {
381
            frame->blocksize = ff_flac_blocksize_table[i];
382 9e96ab03 Michael Niedermayer
            frame->bs_code[0] = i;
383
            frame->bs_code[1] = 0;
384
            break;
385
        }
386
    }
387
    if(i == 16) {
388 42ceeb5f Justin Ruggles
        frame->blocksize = s->avctx->frame_size;
389 9e96ab03 Michael Niedermayer
        if(frame->blocksize <= 256) {
390
            frame->bs_code[0] = 6;
391
            frame->bs_code[1] = frame->blocksize-1;
392
        } else {
393
            frame->bs_code[0] = 7;
394
            frame->bs_code[1] = frame->blocksize-1;
395
        }
396
    }
397
398
    for(ch=0; ch<s->channels; ch++) {
399
        frame->subframes[ch].obits = 16;
400
    }
401
}
402
403
/**
404
 * Copy channel-interleaved input samples into separate subframes
405
 */
406
static void copy_samples(FlacEncodeContext *s, int16_t *samples)
407
{
408
    int i, j, ch;
409
    FlacFrame *frame;
410
411
    frame = &s->frame;
412
    for(i=0,j=0; i<frame->blocksize; i++) {
413
        for(ch=0; ch<s->channels; ch++,j++) {
414
            frame->subframes[ch].samples[i] = samples[j];
415
        }
416
    }
417
}
418
419 e71bcc37 Justin Ruggles
420
#define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
421
422 14bd2a9f Loren Merritt
/**
423
 * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0
424
 */
425 e71bcc37 Justin Ruggles
static int find_optimal_param(uint32_t sum, int n)
426
{
427 14bd2a9f Loren Merritt
    int k;
428
    uint32_t sum2;
429
430
    if(sum <= n>>1)
431
        return 0;
432
    sum2 = sum-(n>>1);
433
    k = av_log2(n<256 ? FASTDIV(sum2,n) : sum2/n);
434
    return FFMIN(k, MAX_RICE_PARAM);
435 e71bcc37 Justin Ruggles
}
436
437
static uint32_t calc_optimal_rice_params(RiceContext *rc, int porder,
438
                                         uint32_t *sums, int n, int pred_order)
439
{
440
    int i;
441
    int k, cnt, part;
442
    uint32_t all_bits;
443
444
    part = (1 << porder);
445 90f03441 Loren Merritt
    all_bits = 4 * part;
446 e71bcc37 Justin Ruggles
447
    cnt = (n >> porder) - pred_order;
448
    for(i=0; i<part; i++) {
449
        k = find_optimal_param(sums[i], cnt);
450
        rc->params[i] = k;
451
        all_bits += rice_encode_count(sums[i], cnt, k);
452 90f03441 Loren Merritt
        cnt = n >> porder;
453 e71bcc37 Justin Ruggles
    }
454
455
    rc->porder = porder;
456
457
    return all_bits;
458
}
459
460 a403fc03 Justin Ruggles
static void calc_sums(int pmin, int pmax, uint32_t *data, int n, int pred_order,
461
                      uint32_t sums[][MAX_PARTITIONS])
462 e71bcc37 Justin Ruggles
{
463
    int i, j;
464 78f67b7a Michael Niedermayer
    int parts;
465
    uint32_t *res, *res_end;
466 e71bcc37 Justin Ruggles
467
    /* sums for highest level */
468
    parts = (1 << pmax);
469
    res = &data[pred_order];
470 78f67b7a Michael Niedermayer
    res_end = &data[n >> pmax];
471 e71bcc37 Justin Ruggles
    for(i=0; i<parts; i++) {
472 f6215b1b Loren Merritt
        uint32_t sum = 0;
473 78f67b7a Michael Niedermayer
        while(res < res_end){
474 f6215b1b Loren Merritt
            sum += *(res++);
475 e71bcc37 Justin Ruggles
        }
476 f6215b1b Loren Merritt
        sums[pmax][i] = sum;
477 78f67b7a Michael Niedermayer
        res_end+= n >> pmax;
478 e71bcc37 Justin Ruggles
    }
479
    /* sums for lower levels */
480 a403fc03 Justin Ruggles
    for(i=pmax-1; i>=pmin; i--) {
481 e71bcc37 Justin Ruggles
        parts = (1 << i);
482
        for(j=0; j<parts; j++) {
483
            sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1];
484
        }
485
    }
486
}
487
488 a403fc03 Justin Ruggles
static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
489
                                 int32_t *data, int n, int pred_order)
490 e71bcc37 Justin Ruggles
{
491
    int i;
492 a403fc03 Justin Ruggles
    uint32_t bits[MAX_PARTITION_ORDER+1];
493 e71bcc37 Justin Ruggles
    int opt_porder;
494 a403fc03 Justin Ruggles
    RiceContext tmp_rc;
495 e71bcc37 Justin Ruggles
    uint32_t *udata;
496 a403fc03 Justin Ruggles
    uint32_t sums[MAX_PARTITION_ORDER+1][MAX_PARTITIONS];
497 e71bcc37 Justin Ruggles
498 a403fc03 Justin Ruggles
    assert(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);
499
    assert(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);
500
    assert(pmin <= pmax);
501 e71bcc37 Justin Ruggles
502
    udata = av_malloc(n * sizeof(uint32_t));
503
    for(i=0; i<n; i++) {
504
        udata[i] = (2*data[i]) ^ (data[i]>>31);
505
    }
506
507 a403fc03 Justin Ruggles
    calc_sums(pmin, pmax, udata, n, pred_order, sums);
508 e71bcc37 Justin Ruggles
509 a403fc03 Justin Ruggles
    opt_porder = pmin;
510
    bits[pmin] = UINT32_MAX;
511
    for(i=pmin; i<=pmax; i++) {
512
        bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums[i], n, pred_order);
513
        if(bits[i] <= bits[opt_porder]) {
514 e71bcc37 Justin Ruggles
            opt_porder = i;
515 41275956 Michael Niedermayer
            *rc= tmp_rc;
516 e71bcc37 Justin Ruggles
        }
517
    }
518
519
    av_freep(&udata);
520 a403fc03 Justin Ruggles
    return bits[opt_porder];
521 e71bcc37 Justin Ruggles
}
522
523 1e5707b7 Justin Ruggles
static int get_max_p_order(int max_porder, int n, int order)
524
{
525
    int porder = FFMIN(max_porder, av_log2(n^(n-1)));
526
    if(order > 0)
527
        porder = FFMIN(porder, av_log2(n/order));
528
    return porder;
529
}
530
531 a403fc03 Justin Ruggles
static uint32_t calc_rice_params_fixed(RiceContext *rc, int pmin, int pmax,
532
                                       int32_t *data, int n, int pred_order,
533
                                       int bps)
534 e71bcc37 Justin Ruggles
{
535
    uint32_t bits;
536 1e5707b7 Justin Ruggles
    pmin = get_max_p_order(pmin, n, pred_order);
537
    pmax = get_max_p_order(pmax, n, pred_order);
538 e71bcc37 Justin Ruggles
    bits = pred_order*bps + 6;
539 a403fc03 Justin Ruggles
    bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
540
    return bits;
541
}
542
543
static uint32_t calc_rice_params_lpc(RiceContext *rc, int pmin, int pmax,
544
                                     int32_t *data, int n, int pred_order,
545
                                     int bps, int precision)
546
{
547
    uint32_t bits;
548 1e5707b7 Justin Ruggles
    pmin = get_max_p_order(pmin, n, pred_order);
549
    pmax = get_max_p_order(pmax, n, pred_order);
550 a403fc03 Justin Ruggles
    bits = pred_order*bps + 4 + 5 + pred_order*precision + 6;
551
    bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
552 e71bcc37 Justin Ruggles
    return bits;
553
}
554
555 a403fc03 Justin Ruggles
/**
556
 * Apply Welch window function to audio block
557
 */
558
static void apply_welch_window(const int32_t *data, int len, double *w_data)
559
{
560
    int i, n2;
561
    double w;
562
    double c;
563
564 a4195e68 Michael Niedermayer
    assert(!(len&1)); //the optimization in r11881 does not support odd len
565
                      //if someone wants odd len extend the change in r11881
566
567 a403fc03 Justin Ruggles
    n2 = (len >> 1);
568
    c = 2.0 / (len - 1.0);
569 fa4ed8c1 Michael Niedermayer
570
    w_data+=n2;
571
      data+=n2;
572 a403fc03 Justin Ruggles
    for(i=0; i<n2; i++) {
573 fa4ed8c1 Michael Niedermayer
        w = c - n2 + i;
574 a403fc03 Justin Ruggles
        w = 1.0 - (w * w);
575 fa4ed8c1 Michael Niedermayer
        w_data[-i-1] = data[-i-1] * w;
576
        w_data[+i  ] = data[+i  ] * w;
577 a403fc03 Justin Ruggles
    }
578
}
579
580
/**
581
 * Calculates autocorrelation data from audio samples
582
 * A Welch window function is applied before calculation.
583
 */
584 6810b93a Loren Merritt
void ff_flac_compute_autocorr(const int32_t *data, int len, int lag,
585
                              double *autoc)
586 a403fc03 Justin Ruggles
{
587 28e968c4 Loren Merritt
    int i, j;
588 19b9c7cc Loren Merritt
    double tmp[len + lag + 1];
589 b2e30cb3 Michael Niedermayer
    double *data1= tmp + lag;
590 a403fc03 Justin Ruggles
591
    apply_welch_window(data, len, data1);
592
593 28e968c4 Loren Merritt
    for(j=0; j<lag; j++)
594
        data1[j-lag]= 0.0;
595 19b9c7cc Loren Merritt
    data1[len] = 0.0;
596 b2e30cb3 Michael Niedermayer
597 28e968c4 Loren Merritt
    for(j=0; j<lag; j+=2){
598
        double sum0 = 1.0, sum1 = 1.0;
599 0aed5e9f Bobby Bingham
        for(i=j; i<len; i++){
600 28e968c4 Loren Merritt
            sum0 += data1[i] * data1[i-j];
601
            sum1 += data1[i] * data1[i-j-1];
602 a403fc03 Justin Ruggles
        }
603 28e968c4 Loren Merritt
        autoc[j  ] = sum0;
604
        autoc[j+1] = sum1;
605
    }
606
607
    if(j==lag){
608
        double sum = 1.0;
609 0aed5e9f Bobby Bingham
        for(i=j-1; i<len; i+=2){
610 19b9c7cc Loren Merritt
            sum += data1[i  ] * data1[i-j  ]
611
                 + data1[i+1] * data1[i-j+1];
612
        }
613 28e968c4 Loren Merritt
        autoc[j] = sum;
614 a403fc03 Justin Ruggles
    }
615
}
616
617
618 e71bcc37 Justin Ruggles
static void encode_residual_verbatim(int32_t *res, int32_t *smp, int n)
619
{
620
    assert(n > 0);
621
    memcpy(res, smp, n * sizeof(int32_t));
622
}
623
624 a403fc03 Justin Ruggles
static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
625
                                  int order)
626 e71bcc37 Justin Ruggles
{
627
    int i;
628
629
    for(i=0; i<order; i++) {
630
        res[i] = smp[i];
631
    }
632
633
    if(order==0){
634
        for(i=order; i<n; i++)
635
            res[i]= smp[i];
636
    }else if(order==1){
637
        for(i=order; i<n; i++)
638
            res[i]= smp[i] - smp[i-1];
639
    }else if(order==2){
640 a309dce7 Loren Merritt
        int a = smp[order-1] - smp[order-2];
641 bfdd5bc1 Loren Merritt
        for(i=order; i<n; i+=2) {
642 a309dce7 Loren Merritt
            int b = smp[i] - smp[i-1];
643
            res[i]= b - a;
644 bfdd5bc1 Loren Merritt
            a = smp[i+1] - smp[i];
645
            res[i+1]= a - b;
646 a309dce7 Loren Merritt
        }
647 e71bcc37 Justin Ruggles
    }else if(order==3){
648 a309dce7 Loren Merritt
        int a = smp[order-1] - smp[order-2];
649
        int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
650 bfdd5bc1 Loren Merritt
        for(i=order; i<n; i+=2) {
651 a309dce7 Loren Merritt
            int b = smp[i] - smp[i-1];
652
            int d = b - a;
653
            res[i]= d - c;
654 bfdd5bc1 Loren Merritt
            a = smp[i+1] - smp[i];
655
            c = a - b;
656
            res[i+1]= c - d;
657 a309dce7 Loren Merritt
        }
658 e71bcc37 Justin Ruggles
    }else{
659 a309dce7 Loren Merritt
        int a = smp[order-1] - smp[order-2];
660
        int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
661
        int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
662 bfdd5bc1 Loren Merritt
        for(i=order; i<n; i+=2) {
663 a309dce7 Loren Merritt
            int b = smp[i] - smp[i-1];
664
            int d = b - a;
665
            int f = d - c;
666
            res[i]= f - e;
667 bfdd5bc1 Loren Merritt
            a = smp[i+1] - smp[i];
668
            c = a - b;
669
            e = c - d;
670
            res[i+1]= e - f;
671 a309dce7 Loren Merritt
        }
672 e71bcc37 Justin Ruggles
    }
673
}
674
675 dc44d4ad Loren Merritt
#define LPC1(x) {\
676 b8de3429 Loren Merritt
    int c = coefs[(x)-1];\
677 dc44d4ad Loren Merritt
    p0 += c*s;\
678 b8de3429 Loren Merritt
    s = smp[i-(x)+1];\
679
    p1 += c*s;\
680 dc44d4ad Loren Merritt
}
681
682
static av_always_inline void encode_residual_lpc_unrolled(
683
    int32_t *res, const int32_t *smp, int n,
684
    int order, const int32_t *coefs, int shift, int big)
685
{
686
    int i;
687
    for(i=order; i<n; i+=2) {
688 b8de3429 Loren Merritt
        int s = smp[i-order];
689
        int p0 = 0, p1 = 0;
690 dc44d4ad Loren Merritt
        if(big) {
691
            switch(order) {
692
                case 32: LPC1(32)
693
                case 31: LPC1(31)
694
                case 30: LPC1(30)
695
                case 29: LPC1(29)
696
                case 28: LPC1(28)
697
                case 27: LPC1(27)
698
                case 26: LPC1(26)
699
                case 25: LPC1(25)
700
                case 24: LPC1(24)
701
                case 23: LPC1(23)
702
                case 22: LPC1(22)
703
                case 21: LPC1(21)
704
                case 20: LPC1(20)
705
                case 19: LPC1(19)
706
                case 18: LPC1(18)
707
                case 17: LPC1(17)
708
                case 16: LPC1(16)
709
                case 15: LPC1(15)
710
                case 14: LPC1(14)
711
                case 13: LPC1(13)
712
                case 12: LPC1(12)
713
                case 11: LPC1(11)
714
                case 10: LPC1(10)
715
                case  9: LPC1( 9)
716
                         LPC1( 8)
717
                         LPC1( 7)
718
                         LPC1( 6)
719
                         LPC1( 5)
720
                         LPC1( 4)
721
                         LPC1( 3)
722
                         LPC1( 2)
723 b8de3429 Loren Merritt
                         LPC1( 1)
724 dc44d4ad Loren Merritt
            }
725
        } else {
726
            switch(order) {
727
                case  8: LPC1( 8)
728
                case  7: LPC1( 7)
729
                case  6: LPC1( 6)
730
                case  5: LPC1( 5)
731
                case  4: LPC1( 4)
732
                case  3: LPC1( 3)
733
                case  2: LPC1( 2)
734 b8de3429 Loren Merritt
                case  1: LPC1( 1)
735 dc44d4ad Loren Merritt
            }
736
        }
737
        res[i  ] = smp[i  ] - (p0 >> shift);
738
        res[i+1] = smp[i+1] - (p1 >> shift);
739
    }
740
}
741
742 a403fc03 Justin Ruggles
static void encode_residual_lpc(int32_t *res, const int32_t *smp, int n,
743
                                int order, const int32_t *coefs, int shift)
744
{
745 dc44d4ad Loren Merritt
    int i;
746 a403fc03 Justin Ruggles
    for(i=0; i<order; i++) {
747
        res[i] = smp[i];
748
    }
749 b250f9c6 Aurelien Jacobs
#if CONFIG_SMALL
750 f74471e0 Loren Merritt
    for(i=order; i<n; i+=2) {
751 dc44d4ad Loren Merritt
        int j;
752 b8de3429 Loren Merritt
        int s = smp[i];
753
        int p0 = 0, p1 = 0;
754
        for(j=0; j<order; j++) {
755
            int c = coefs[j];
756 f74471e0 Loren Merritt
            p1 += c*s;
757 b8de3429 Loren Merritt
            s = smp[i-j-1];
758
            p0 += c*s;
759 a403fc03 Justin Ruggles
        }
760 b8de3429 Loren Merritt
        res[i  ] = smp[i  ] - (p0 >> shift);
761 f74471e0 Loren Merritt
        res[i+1] = smp[i+1] - (p1 >> shift);
762 a403fc03 Justin Ruggles
    }
763 dc44d4ad Loren Merritt
#else
764
    switch(order) {
765
        case  1: encode_residual_lpc_unrolled(res, smp, n, 1, coefs, shift, 0); break;
766
        case  2: encode_residual_lpc_unrolled(res, smp, n, 2, coefs, shift, 0); break;
767
        case  3: encode_residual_lpc_unrolled(res, smp, n, 3, coefs, shift, 0); break;
768
        case  4: encode_residual_lpc_unrolled(res, smp, n, 4, coefs, shift, 0); break;
769
        case  5: encode_residual_lpc_unrolled(res, smp, n, 5, coefs, shift, 0); break;
770
        case  6: encode_residual_lpc_unrolled(res, smp, n, 6, coefs, shift, 0); break;
771
        case  7: encode_residual_lpc_unrolled(res, smp, n, 7, coefs, shift, 0); break;
772
        case  8: encode_residual_lpc_unrolled(res, smp, n, 8, coefs, shift, 0); break;
773
        default: encode_residual_lpc_unrolled(res, smp, n, order, coefs, shift, 1); break;
774
    }
775
#endif
776 a403fc03 Justin Ruggles
}
777
778 e71bcc37 Justin Ruggles
static int encode_residual(FlacEncodeContext *ctx, int ch)
779
{
780 a403fc03 Justin Ruggles
    int i, n;
781 26053bdc Justin Ruggles
    int min_order, max_order, opt_order, precision, omethod;
782 1e5707b7 Justin Ruggles
    int min_porder, max_porder;
783 e71bcc37 Justin Ruggles
    FlacFrame *frame;
784
    FlacSubframe *sub;
785 a403fc03 Justin Ruggles
    int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
786
    int shift[MAX_LPC_ORDER];
787 e71bcc37 Justin Ruggles
    int32_t *res, *smp;
788
789
    frame = &ctx->frame;
790
    sub = &frame->subframes[ch];
791
    res = sub->residual;
792
    smp = sub->samples;
793
    n = frame->blocksize;
794
795
    /* CONSTANT */
796
    for(i=1; i<n; i++) {
797
        if(smp[i] != smp[0]) break;
798
    }
799
    if(i == n) {
800
        sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
801
        res[0] = smp[0];
802
        return sub->obits;
803
    }
804
805
    /* VERBATIM */
806
    if(n < 5) {
807
        sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
808
        encode_residual_verbatim(res, smp, n);
809
        return sub->obits * n;
810
    }
811
812 a403fc03 Justin Ruggles
    min_order = ctx->options.min_prediction_order;
813
    max_order = ctx->options.max_prediction_order;
814
    min_porder = ctx->options.min_partition_order;
815
    max_porder = ctx->options.max_partition_order;
816
    precision = ctx->options.lpc_coeff_precision;
817 26053bdc Justin Ruggles
    omethod = ctx->options.prediction_order_method;
818 e71bcc37 Justin Ruggles
819
    /* FIXED */
820 a403fc03 Justin Ruggles
    if(!ctx->options.use_lpc || max_order == 0 || (n <= max_order)) {
821
        uint32_t bits[MAX_FIXED_ORDER+1];
822
        if(max_order > MAX_FIXED_ORDER) max_order = MAX_FIXED_ORDER;
823
        opt_order = 0;
824
        bits[0] = UINT32_MAX;
825
        for(i=min_order; i<=max_order; i++) {
826
            encode_residual_fixed(res, smp, n, i);
827 1e5707b7 Justin Ruggles
            bits[i] = calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res,
828 a403fc03 Justin Ruggles
                                             n, i, sub->obits);
829
            if(bits[i] < bits[opt_order]) {
830
                opt_order = i;
831
            }
832 e71bcc37 Justin Ruggles
        }
833 a403fc03 Justin Ruggles
        sub->order = opt_order;
834
        sub->type = FLAC_SUBFRAME_FIXED;
835
        sub->type_code = sub->type | sub->order;
836
        if(sub->order != max_order) {
837
            encode_residual_fixed(res, smp, n, sub->order);
838 1e5707b7 Justin Ruggles
            return calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res, n,
839 a403fc03 Justin Ruggles
                                          sub->order, sub->obits);
840
        }
841
        return bits[sub->order];
842 e71bcc37 Justin Ruggles
    }
843 a403fc03 Justin Ruggles
844
    /* LPC */
845 9045f5e7 Justin Ruggles
    opt_order = ff_lpc_calc_coefs(&ctx->dsp, smp, n, min_order, max_order,
846
                                  precision, coefs, shift, ctx->options.use_lpc,
847
                                  omethod, MAX_LPC_SHIFT, 0);
848 26053bdc Justin Ruggles
849
    if(omethod == ORDER_METHOD_2LEVEL ||
850
       omethod == ORDER_METHOD_4LEVEL ||
851
       omethod == ORDER_METHOD_8LEVEL) {
852
        int levels = 1 << omethod;
853
        uint32_t bits[levels];
854
        int order;
855
        int opt_index = levels-1;
856
        opt_order = max_order-1;
857
        bits[opt_index] = UINT32_MAX;
858
        for(i=levels-1; i>=0; i--) {
859
            order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
860
            if(order < 0) order = 0;
861
            encode_residual_lpc(res, smp, n, order+1, coefs[order], shift[order]);
862
            bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
863
                                           res, n, order+1, sub->obits, precision);
864
            if(bits[i] < bits[opt_index]) {
865
                opt_index = i;
866
                opt_order = order;
867
            }
868
        }
869
        opt_order++;
870
    } else if(omethod == ORDER_METHOD_SEARCH) {
871
        // brute-force optimal order search
872
        uint32_t bits[MAX_LPC_ORDER];
873
        opt_order = 0;
874
        bits[0] = UINT32_MAX;
875
        for(i=min_order-1; i<max_order; i++) {
876
            encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
877
            bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
878
                                           res, n, i+1, sub->obits, precision);
879
            if(bits[i] < bits[opt_order]) {
880
                opt_order = i;
881
            }
882
        }
883
        opt_order++;
884 dbb45a3b Michael Niedermayer
    } else if(omethod == ORDER_METHOD_LOG) {
885
        uint32_t bits[MAX_LPC_ORDER];
886
        int step;
887
888
        opt_order= min_order - 1 + (max_order-min_order)/3;
889
        memset(bits, -1, sizeof(bits));
890
891
        for(step=16 ;step; step>>=1){
892
            int last= opt_order;
893
            for(i=last-step; i<=last+step; i+= step){
894
                if(i<min_order-1 || i>=max_order || bits[i] < UINT32_MAX)
895
                    continue;
896
                encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
897
                bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
898
                                            res, n, i+1, sub->obits, precision);
899
                if(bits[i] < bits[opt_order])
900
                    opt_order= i;
901
            }
902
        }
903
        opt_order++;
904 26053bdc Justin Ruggles
    }
905
906
    sub->order = opt_order;
907 a403fc03 Justin Ruggles
    sub->type = FLAC_SUBFRAME_LPC;
908
    sub->type_code = sub->type | (sub->order-1);
909
    sub->shift = shift[sub->order-1];
910
    for(i=0; i<sub->order; i++) {
911
        sub->coefs[i] = coefs[sub->order-1][i];
912 e71bcc37 Justin Ruggles
    }
913 a403fc03 Justin Ruggles
    encode_residual_lpc(res, smp, n, sub->order, sub->coefs, sub->shift);
914 1e5707b7 Justin Ruggles
    return calc_rice_params_lpc(&sub->rc, min_porder, max_porder, res, n, sub->order,
915 a403fc03 Justin Ruggles
                                sub->obits, precision);
916 e71bcc37 Justin Ruggles
}
917
918
static int encode_residual_v(FlacEncodeContext *ctx, int ch)
919
{
920
    int i, n;
921
    FlacFrame *frame;
922
    FlacSubframe *sub;
923
    int32_t *res, *smp;
924
925
    frame = &ctx->frame;
926
    sub = &frame->subframes[ch];
927
    res = sub->residual;
928
    smp = sub->samples;
929
    n = frame->blocksize;
930
931
    /* CONSTANT */
932
    for(i=1; i<n; i++) {
933
        if(smp[i] != smp[0]) break;
934
    }
935
    if(i == n) {
936
        sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
937
        res[0] = smp[0];
938
        return sub->obits;
939
    }
940
941
    /* VERBATIM */
942
    sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
943
    encode_residual_verbatim(res, smp, n);
944
    return sub->obits * n;
945
}
946
947 f33aa120 Michael Niedermayer
static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
948
{
949
    int i, best;
950
    int32_t lt, rt;
951 e71bcc37 Justin Ruggles
    uint64_t sum[4];
952 f33aa120 Michael Niedermayer
    uint64_t score[4];
953 e71bcc37 Justin Ruggles
    int k;
954 f33aa120 Michael Niedermayer
955 a403fc03 Justin Ruggles
    /* calculate sum of 2nd order residual for each channel */
956 e71bcc37 Justin Ruggles
    sum[0] = sum[1] = sum[2] = sum[3] = 0;
957 f33aa120 Michael Niedermayer
    for(i=2; i<n; i++) {
958
        lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
959
        rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
960 c26abfa5 Diego Biurrun
        sum[2] += FFABS((lt + rt) >> 1);
961
        sum[3] += FFABS(lt - rt);
962
        sum[0] += FFABS(lt);
963
        sum[1] += FFABS(rt);
964 e71bcc37 Justin Ruggles
    }
965 a403fc03 Justin Ruggles
    /* estimate bit counts */
966 e71bcc37 Justin Ruggles
    for(i=0; i<4; i++) {
967
        k = find_optimal_param(2*sum[i], n);
968
        sum[i] = rice_encode_count(2*sum[i], n, k);
969 f33aa120 Michael Niedermayer
    }
970
971
    /* calculate score for each mode */
972 e71bcc37 Justin Ruggles
    score[0] = sum[0] + sum[1];
973
    score[1] = sum[0] + sum[3];
974
    score[2] = sum[1] + sum[3];
975
    score[3] = sum[2] + sum[3];
976 f33aa120 Michael Niedermayer
977
    /* return mode with lowest score */
978
    best = 0;
979
    for(i=1; i<4; i++) {
980
        if(score[i] < score[best]) {
981
            best = i;
982
        }
983
    }
984
    if(best == 0) {
985 3159780b Justin Ruggles
        return FLAC_CHMODE_INDEPENDENT;
986 f33aa120 Michael Niedermayer
    } else if(best == 1) {
987
        return FLAC_CHMODE_LEFT_SIDE;
988
    } else if(best == 2) {
989
        return FLAC_CHMODE_RIGHT_SIDE;
990
    } else {
991
        return FLAC_CHMODE_MID_SIDE;
992
    }
993
}
994
995
/**
996
 * Perform stereo channel decorrelation
997
 */
998
static void channel_decorrelation(FlacEncodeContext *ctx)
999
{
1000
    FlacFrame *frame;
1001
    int32_t *left, *right;
1002
    int i, n;
1003
1004
    frame = &ctx->frame;
1005
    n = frame->blocksize;
1006
    left  = frame->subframes[0].samples;
1007
    right = frame->subframes[1].samples;
1008
1009
    if(ctx->channels != 2) {
1010 3159780b Justin Ruggles
        frame->ch_mode = FLAC_CHMODE_INDEPENDENT;
1011 f33aa120 Michael Niedermayer
        return;
1012
    }
1013
1014
    frame->ch_mode = estimate_stereo_mode(left, right, n);
1015
1016
    /* perform decorrelation and adjust bits-per-sample */
1017 3159780b Justin Ruggles
    if(frame->ch_mode == FLAC_CHMODE_INDEPENDENT) {
1018 f33aa120 Michael Niedermayer
        return;
1019
    }
1020
    if(frame->ch_mode == FLAC_CHMODE_MID_SIDE) {
1021
        int32_t tmp;
1022
        for(i=0; i<n; i++) {
1023
            tmp = left[i];
1024
            left[i] = (tmp + right[i]) >> 1;
1025
            right[i] = tmp - right[i];
1026
        }
1027
        frame->subframes[1].obits++;
1028
    } else if(frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {
1029
        for(i=0; i<n; i++) {
1030
            right[i] = left[i] - right[i];
1031
        }
1032
        frame->subframes[1].obits++;
1033
    } else {
1034
        for(i=0; i<n; i++) {
1035
            left[i] -= right[i];
1036
        }
1037
        frame->subframes[0].obits++;
1038
    }
1039
}
1040
1041 e71bcc37 Justin Ruggles
static void write_utf8(PutBitContext *pb, uint32_t val)
1042 9e96ab03 Michael Niedermayer
{
1043 360932f7 Zuxy Meng
    uint8_t tmp;
1044
    PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
1045 9e96ab03 Michael Niedermayer
}
1046
1047 e71bcc37 Justin Ruggles
static void output_frame_header(FlacEncodeContext *s)
1048 9e96ab03 Michael Niedermayer
{
1049
    FlacFrame *frame;
1050
    int crc;
1051
1052
    frame = &s->frame;
1053
1054
    put_bits(&s->pb, 16, 0xFFF8);
1055
    put_bits(&s->pb, 4, frame->bs_code[0]);
1056
    put_bits(&s->pb, 4, s->sr_code[0]);
1057 3159780b Justin Ruggles
    if(frame->ch_mode == FLAC_CHMODE_INDEPENDENT) {
1058 ad52941f Justin Ruggles
        put_bits(&s->pb, 4, s->channels-1);
1059 9e96ab03 Michael Niedermayer
    } else {
1060
        put_bits(&s->pb, 4, frame->ch_mode);
1061
    }
1062
    put_bits(&s->pb, 3, 4); /* bits-per-sample code */
1063
    put_bits(&s->pb, 1, 0);
1064
    write_utf8(&s->pb, s->frame_count);
1065 f33aa120 Michael Niedermayer
    if(frame->bs_code[0] == 6) {
1066
        put_bits(&s->pb, 8, frame->bs_code[1]);
1067
    } else if(frame->bs_code[0] == 7) {
1068
        put_bits(&s->pb, 16, frame->bs_code[1]);
1069 9e96ab03 Michael Niedermayer
    }
1070 f33aa120 Michael Niedermayer
    if(s->sr_code[0] == 12) {
1071
        put_bits(&s->pb, 8, s->sr_code[1]);
1072
    } else if(s->sr_code[0] > 12) {
1073
        put_bits(&s->pb, 16, s->sr_code[1]);
1074 9e96ab03 Michael Niedermayer
    }
1075
    flush_put_bits(&s->pb);
1076 3abe5fbd Aurelien Jacobs
    crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
1077
                 s->pb.buf, put_bits_count(&s->pb)>>3);
1078 9e96ab03 Michael Niedermayer
    put_bits(&s->pb, 8, crc);
1079
}
1080
1081 e71bcc37 Justin Ruggles
static void output_subframe_constant(FlacEncodeContext *s, int ch)
1082
{
1083
    FlacSubframe *sub;
1084
    int32_t res;
1085
1086
    sub = &s->frame.subframes[ch];
1087
    res = sub->residual[0];
1088
    put_sbits(&s->pb, sub->obits, res);
1089
}
1090
1091 9e96ab03 Michael Niedermayer
static void output_subframe_verbatim(FlacEncodeContext *s, int ch)
1092
{
1093
    int i;
1094
    FlacFrame *frame;
1095
    FlacSubframe *sub;
1096
    int32_t res;
1097
1098
    frame = &s->frame;
1099
    sub = &frame->subframes[ch];
1100
1101
    for(i=0; i<frame->blocksize; i++) {
1102
        res = sub->residual[i];
1103
        put_sbits(&s->pb, sub->obits, res);
1104
    }
1105
}
1106
1107 e71bcc37 Justin Ruggles
static void output_residual(FlacEncodeContext *ctx, int ch)
1108 9e96ab03 Michael Niedermayer
{
1109 e71bcc37 Justin Ruggles
    int i, j, p, n, parts;
1110 9e96ab03 Michael Niedermayer
    int k, porder, psize, res_cnt;
1111
    FlacFrame *frame;
1112
    FlacSubframe *sub;
1113 e71bcc37 Justin Ruggles
    int32_t *res;
1114 9e96ab03 Michael Niedermayer
1115
    frame = &ctx->frame;
1116
    sub = &frame->subframes[ch];
1117 e71bcc37 Justin Ruggles
    res = sub->residual;
1118
    n = frame->blocksize;
1119 9e96ab03 Michael Niedermayer
1120
    /* rice-encoded block */
1121
    put_bits(&ctx->pb, 2, 0);
1122
1123
    /* partition order */
1124 e71bcc37 Justin Ruggles
    porder = sub->rc.porder;
1125
    psize = n >> porder;
1126
    parts = (1 << porder);
1127 9e96ab03 Michael Niedermayer
    put_bits(&ctx->pb, 4, porder);
1128
    res_cnt = psize - sub->order;
1129
1130
    /* residual */
1131
    j = sub->order;
1132 e71bcc37 Justin Ruggles
    for(p=0; p<parts; p++) {
1133
        k = sub->rc.params[p];
1134 9e96ab03 Michael Niedermayer
        put_bits(&ctx->pb, 4, k);
1135
        if(p == 1) res_cnt = psize;
1136 e71bcc37 Justin Ruggles
        for(i=0; i<res_cnt && j<n; i++, j++) {
1137
            set_sr_golomb_flac(&ctx->pb, res[j], k, INT32_MAX, 0);
1138 9e96ab03 Michael Niedermayer
        }
1139
    }
1140
}
1141
1142 e71bcc37 Justin Ruggles
static void output_subframe_fixed(FlacEncodeContext *ctx, int ch)
1143 9e96ab03 Michael Niedermayer
{
1144
    int i;
1145
    FlacFrame *frame;
1146
    FlacSubframe *sub;
1147
1148
    frame = &ctx->frame;
1149
    sub = &frame->subframes[ch];
1150
1151
    /* warm-up samples */
1152
    for(i=0; i<sub->order; i++) {
1153
        put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
1154
    }
1155
1156
    /* residual */
1157
    output_residual(ctx, ch);
1158
}
1159
1160 a403fc03 Justin Ruggles
static void output_subframe_lpc(FlacEncodeContext *ctx, int ch)
1161
{
1162
    int i, cbits;
1163
    FlacFrame *frame;
1164
    FlacSubframe *sub;
1165
1166
    frame = &ctx->frame;
1167
    sub = &frame->subframes[ch];
1168
1169
    /* warm-up samples */
1170
    for(i=0; i<sub->order; i++) {
1171
        put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
1172
    }
1173
1174
    /* LPC coefficients */
1175
    cbits = ctx->options.lpc_coeff_precision;
1176
    put_bits(&ctx->pb, 4, cbits-1);
1177
    put_sbits(&ctx->pb, 5, sub->shift);
1178
    for(i=0; i<sub->order; i++) {
1179
        put_sbits(&ctx->pb, cbits, sub->coefs[i]);
1180
    }
1181
1182
    /* residual */
1183
    output_residual(ctx, ch);
1184
}
1185
1186 9e96ab03 Michael Niedermayer
static void output_subframes(FlacEncodeContext *s)
1187
{
1188
    FlacFrame *frame;
1189
    FlacSubframe *sub;
1190
    int ch;
1191
1192
    frame = &s->frame;
1193
1194
    for(ch=0; ch<s->channels; ch++) {
1195
        sub = &frame->subframes[ch];
1196
1197
        /* subframe header */
1198
        put_bits(&s->pb, 1, 0);
1199
        put_bits(&s->pb, 6, sub->type_code);
1200
        put_bits(&s->pb, 1, 0); /* no wasted bits */
1201
1202
        /* subframe */
1203 e71bcc37 Justin Ruggles
        if(sub->type == FLAC_SUBFRAME_CONSTANT) {
1204
            output_subframe_constant(s, ch);
1205
        } else if(sub->type == FLAC_SUBFRAME_VERBATIM) {
1206 9e96ab03 Michael Niedermayer
            output_subframe_verbatim(s, ch);
1207 e71bcc37 Justin Ruggles
        } else if(sub->type == FLAC_SUBFRAME_FIXED) {
1208 9e96ab03 Michael Niedermayer
            output_subframe_fixed(s, ch);
1209 a403fc03 Justin Ruggles
        } else if(sub->type == FLAC_SUBFRAME_LPC) {
1210
            output_subframe_lpc(s, ch);
1211 9e96ab03 Michael Niedermayer
        }
1212
    }
1213
}
1214
1215
static void output_frame_footer(FlacEncodeContext *s)
1216
{
1217
    int crc;
1218
    flush_put_bits(&s->pb);
1219 3abe5fbd Aurelien Jacobs
    crc = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
1220
                          s->pb.buf, put_bits_count(&s->pb)>>3));
1221 9e96ab03 Michael Niedermayer
    put_bits(&s->pb, 16, crc);
1222
    flush_put_bits(&s->pb);
1223
}
1224
1225 a9f8587e Justin Ruggles
static void update_md5_sum(FlacEncodeContext *s, int16_t *samples)
1226
{
1227 63613fe6 Måns Rullgård
#if HAVE_BIGENDIAN
1228 a9f8587e Justin Ruggles
    int i;
1229
    for(i = 0; i < s->frame.blocksize*s->channels; i++) {
1230
        int16_t smp = le2me_16(samples[i]);
1231
        av_md5_update(s->md5ctx, (uint8_t *)&smp, 2);
1232
    }
1233
#else
1234
    av_md5_update(s->md5ctx, (uint8_t *)samples, s->frame.blocksize*s->channels*2);
1235
#endif
1236
}
1237
1238 9e96ab03 Michael Niedermayer
static int flac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
1239
                             int buf_size, void *data)
1240
{
1241
    int ch;
1242
    FlacEncodeContext *s;
1243
    int16_t *samples = data;
1244
    int out_bytes;
1245 f1f373c2 Justin Ruggles
    int reencoded=0;
1246 9e96ab03 Michael Niedermayer
1247
    s = avctx->priv_data;
1248
1249 f1f373c2 Justin Ruggles
    if(buf_size < s->max_framesize*2) {
1250
        av_log(avctx, AV_LOG_ERROR, "output buffer too small\n");
1251
        return 0;
1252
    }
1253
1254 e1a12934 Justin Ruggles
    /* when the last block is reached, update the header in extradata */
1255
    if (!data) {
1256 6682ae42 Justin Ruggles
        s->max_framesize = s->max_encoded_framesize;
1257 a9f8587e Justin Ruggles
        av_md5_final(s->md5ctx, s->md5sum);
1258 e1a12934 Justin Ruggles
        write_streaminfo(s, avctx->extradata);
1259
        return 0;
1260
    }
1261
1262 f33aa120 Michael Niedermayer
    init_frame(s);
1263 9e96ab03 Michael Niedermayer
1264
    copy_samples(s, samples);
1265
1266 f33aa120 Michael Niedermayer
    channel_decorrelation(s);
1267
1268 9e96ab03 Michael Niedermayer
    for(ch=0; ch<s->channels; ch++) {
1269
        encode_residual(s, ch);
1270
    }
1271 f1f373c2 Justin Ruggles
1272
write_frame:
1273 9e96ab03 Michael Niedermayer
    init_put_bits(&s->pb, frame, buf_size);
1274
    output_frame_header(s);
1275
    output_subframes(s);
1276
    output_frame_footer(s);
1277
    out_bytes = put_bits_count(&s->pb) >> 3;
1278
1279 f1f373c2 Justin Ruggles
    if(out_bytes > s->max_framesize) {
1280
        if(reencoded) {
1281 9e96ab03 Michael Niedermayer
            /* still too large. must be an error. */
1282
            av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");
1283
            return -1;
1284
        }
1285 f1f373c2 Justin Ruggles
1286
        /* frame too large. use verbatim mode */
1287
        for(ch=0; ch<s->channels; ch++) {
1288
            encode_residual_v(s, ch);
1289
        }
1290
        reencoded = 1;
1291
        goto write_frame;
1292 9e96ab03 Michael Niedermayer
    }
1293
1294
    s->frame_count++;
1295 e1a12934 Justin Ruggles
    s->sample_count += avctx->frame_size;
1296 a9f8587e Justin Ruggles
    update_md5_sum(s, samples);
1297 6682ae42 Justin Ruggles
    if (out_bytes > s->max_encoded_framesize)
1298
        s->max_encoded_framesize = out_bytes;
1299 b9b4fc5e Justin Ruggles
    if (out_bytes < s->min_framesize)
1300
        s->min_framesize = out_bytes;
1301 e1a12934 Justin Ruggles
1302 9e96ab03 Michael Niedermayer
    return out_bytes;
1303
}
1304
1305 98a6fff9 Zuxy Meng
static av_cold int flac_encode_close(AVCodecContext *avctx)
1306 9e96ab03 Michael Niedermayer
{
1307 a9f8587e Justin Ruggles
    if (avctx->priv_data) {
1308
        FlacEncodeContext *s = avctx->priv_data;
1309
        av_freep(&s->md5ctx);
1310
    }
1311 f33aa120 Michael Niedermayer
    av_freep(&avctx->extradata);
1312
    avctx->extradata_size = 0;
1313 9e96ab03 Michael Niedermayer
    av_freep(&avctx->coded_frame);
1314
    return 0;
1315
}
1316
1317
AVCodec flac_encoder = {
1318
    "flac",
1319
    CODEC_TYPE_AUDIO,
1320
    CODEC_ID_FLAC,
1321
    sizeof(FlacEncodeContext),
1322
    flac_encode_init,
1323
    flac_encode_frame,
1324
    flac_encode_close,
1325
    NULL,
1326 e1a12934 Justin Ruggles
    .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,
1327 fd76c37f Peter Ross
    .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
1328 fe4bf374 Stefano Sabatini
    .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
1329 9e96ab03 Michael Niedermayer
};