Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flacenc.c @ 9106a698

History | View | Annotate | Download (39.3 KB)

1
/**
2
 * FLAC audio encoder
3
 * Copyright (c) 2006  Justin Ruggles <justin.ruggles@gmail.com>
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * 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
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
#include "libavutil/crc.h"
23
#include "libavutil/lls.h"
24
#include "libavutil/md5.h"
25
#include "avcodec.h"
26
#include "get_bits.h"
27
#include "dsputil.h"
28
#include "golomb.h"
29
#include "lpc.h"
30
#include "flac.h"
31
#include "flacdata.h"
32

    
33
#define FLAC_SUBFRAME_CONSTANT  0
34
#define FLAC_SUBFRAME_VERBATIM  1
35
#define FLAC_SUBFRAME_FIXED     8
36
#define FLAC_SUBFRAME_LPC      32
37

    
38
#define MAX_FIXED_ORDER     4
39
#define MAX_PARTITION_ORDER 8
40
#define MAX_PARTITIONS     (1 << MAX_PARTITION_ORDER)
41
#define MAX_LPC_PRECISION  15
42
#define MAX_LPC_SHIFT      15
43
#define MAX_RICE_PARAM     14
44

    
45
typedef struct CompressionOptions {
46
    int compression_level;
47
    int block_time_ms;
48
    int use_lpc;
49
    int lpc_coeff_precision;
50
    int min_prediction_order;
51
    int max_prediction_order;
52
    int prediction_order_method;
53
    int min_partition_order;
54
    int max_partition_order;
55
} CompressionOptions;
56

    
57
typedef struct RiceContext {
58
    int porder;
59
    int params[MAX_PARTITIONS];
60
} RiceContext;
61

    
62
typedef struct FlacSubframe {
63
    int type;
64
    int type_code;
65
    int obits;
66
    int order;
67
    int32_t coefs[MAX_LPC_ORDER];
68
    int shift;
69
    RiceContext rc;
70
    int32_t samples[FLAC_MAX_BLOCKSIZE];
71
    int32_t residual[FLAC_MAX_BLOCKSIZE+1];
72
} FlacSubframe;
73

    
74
typedef struct FlacFrame {
75
    FlacSubframe subframes[FLAC_MAX_CHANNELS];
76
    int blocksize;
77
    int bs_code[2];
78
    uint8_t crc8;
79
    int ch_mode;
80
} FlacFrame;
81

    
82
typedef struct FlacEncodeContext {
83
    PutBitContext pb;
84
    int channels;
85
    int samplerate;
86
    int sr_code[2];
87
    int min_framesize;
88
    int max_framesize;
89
    int max_encoded_framesize;
90
    uint32_t frame_count;
91
    uint64_t sample_count;
92
    uint8_t md5sum[16];
93
    FlacFrame frame;
94
    CompressionOptions options;
95
    AVCodecContext *avctx;
96
    DSPContext dsp;
97
    struct AVMD5 *md5ctx;
98
} 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
    put_bits(&pb, 16, s->avctx->frame_size);
112
    put_bits(&pb, 16, s->avctx->frame_size);
113
    put_bits(&pb, 24, s->min_framesize);
114
    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
    /* 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
    flush_put_bits(&pb);
122
    memcpy(&header[18], s->md5sum, 16);
123
}
124

    
125
/**
126
 * Sets blocksize based on samplerate
127
 * Chooses the closest predefined blocksize >= BLOCK_TIME_MS milliseconds
128
 */
129
static int select_blocksize(int samplerate, int block_time_ms)
130
{
131
    int i;
132
    int target;
133
    int blocksize;
134

    
135
    assert(samplerate > 0);
136
    blocksize = ff_flac_blocksize_table[1];
137
    target = (samplerate * block_time_ms) / 1000;
138
    for(i=0; i<16; i++) {
139
        if(target >= ff_flac_blocksize_table[i] && ff_flac_blocksize_table[i] > blocksize) {
140
            blocksize = ff_flac_blocksize_table[i];
141
        }
142
    }
143
    return blocksize;
144
}
145

    
146
static av_cold int flac_encode_init(AVCodecContext *avctx)
147
{
148
    int freq = avctx->sample_rate;
149
    int channels = avctx->channels;
150
    FlacEncodeContext *s = avctx->priv_data;
151
    int i, level;
152
    uint8_t *streaminfo;
153

    
154
    s->avctx = avctx;
155

    
156
    dsputil_init(&s->dsp, avctx);
157

    
158
    if(avctx->sample_fmt != SAMPLE_FMT_S16) {
159
        return -1;
160
    }
161

    
162
    if(channels < 1 || channels > FLAC_MAX_CHANNELS) {
163
        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
        if(freq == ff_flac_sample_rate_table[i]) {
172
            s->samplerate = ff_flac_sample_rate_table[i];
173
            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
    /* 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
    level= s->options.compression_level;
204
    if(level > 12) {
205
        av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",
206
               s->options.compression_level);
207
        return -1;
208
    }
209

    
210
    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
                                                   ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG,    ORDER_METHOD_4LEVEL,
217
                                                   ORDER_METHOD_LOG,    ORDER_METHOD_SEARCH, ORDER_METHOD_LOG,
218
                                                   ORDER_METHOD_SEARCH})[level];
219
    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

    
222
    /* set compression option overrides from AVCodecContext */
223
    if(avctx->use_lpc >= 0) {
224
        s->options.use_lpc = av_clip(avctx->use_lpc, 0, 11);
225
    }
226
    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

    
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
        if(avctx->prediction_order_method > ORDER_METHOD_LOG) {
275
            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
    switch(s->options.prediction_order_method) {
282
        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
        case ORDER_METHOD_LOG:    av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
293
                                         "log search"); break;
294
    }
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
                avctx->frame_size > FLAC_MAX_BLOCKSIZE) {
323
            av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n",
324
                   avctx->frame_size);
325
            return -1;
326
        }
327
    } else {
328
        s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms);
329
    }
330
    av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", s->avctx->frame_size);
331

    
332
    /* set LPC precision */
333
    if(avctx->lpc_coeff_precision > 0) {
334
        if(avctx->lpc_coeff_precision > MAX_LPC_PRECISION) {
335
            av_log(avctx, AV_LOG_ERROR, "invalid lpc coeff precision: %d\n",
336
                   avctx->lpc_coeff_precision);
337
            return -1;
338
        }
339
        s->options.lpc_coeff_precision = avctx->lpc_coeff_precision;
340
    } else {
341
        /* default LPC precision */
342
        s->options.lpc_coeff_precision = 15;
343
    }
344
    av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",
345
           s->options.lpc_coeff_precision);
346

    
347
    /* set maximum encoded frame size in verbatim mode */
348
    s->max_framesize = ff_flac_get_max_frame_size(s->avctx->frame_size,
349
                                                  s->channels, 16);
350

    
351
    /* initialize MD5 context */
352
    s->md5ctx = av_malloc(av_md5_size);
353
    if(!s->md5ctx)
354
        return AVERROR_NOMEM;
355
    av_md5_init(s->md5ctx);
356

    
357
    streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);
358
    write_streaminfo(s, streaminfo);
359
    avctx->extradata = streaminfo;
360
    avctx->extradata_size = FLAC_STREAMINFO_SIZE;
361

    
362
    s->frame_count = 0;
363
    s->min_framesize = s->max_framesize;
364

    
365
    avctx->coded_frame = avcodec_alloc_frame();
366
    avctx->coded_frame->key_frame = 1;
367

    
368
    return 0;
369
}
370

    
371
static void init_frame(FlacEncodeContext *s)
372
{
373
    int i, ch;
374
    FlacFrame *frame;
375

    
376
    frame = &s->frame;
377

    
378
    for(i=0; i<16; i++) {
379
        if(s->avctx->frame_size == ff_flac_blocksize_table[i]) {
380
            frame->blocksize = ff_flac_blocksize_table[i];
381
            frame->bs_code[0] = i;
382
            frame->bs_code[1] = 0;
383
            break;
384
        }
385
    }
386
    if(i == 16) {
387
        frame->blocksize = s->avctx->frame_size;
388
        if(frame->blocksize <= 256) {
389
            frame->bs_code[0] = 6;
390
            frame->bs_code[1] = frame->blocksize-1;
391
        } else {
392
            frame->bs_code[0] = 7;
393
            frame->bs_code[1] = frame->blocksize-1;
394
        }
395
    }
396

    
397
    for(ch=0; ch<s->channels; ch++) {
398
        frame->subframes[ch].obits = 16;
399
    }
400
}
401

    
402
/**
403
 * Copy channel-interleaved input samples into separate subframes
404
 */
405
static void copy_samples(FlacEncodeContext *s, int16_t *samples)
406
{
407
    int i, j, ch;
408
    FlacFrame *frame;
409

    
410
    frame = &s->frame;
411
    for(i=0,j=0; i<frame->blocksize; i++) {
412
        for(ch=0; ch<s->channels; ch++,j++) {
413
            frame->subframes[ch].samples[i] = samples[j];
414
        }
415
    }
416
}
417

    
418

    
419
#define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
420

    
421
/**
422
 * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0
423
 */
424
static int find_optimal_param(uint32_t sum, int n)
425
{
426
    int k;
427
    uint32_t sum2;
428

    
429
    if(sum <= n>>1)
430
        return 0;
431
    sum2 = sum-(n>>1);
432
    k = av_log2(n<256 ? FASTDIV(sum2,n) : sum2/n);
433
    return FFMIN(k, MAX_RICE_PARAM);
434
}
435

    
436
static uint32_t calc_optimal_rice_params(RiceContext *rc, int porder,
437
                                         uint32_t *sums, int n, int pred_order)
438
{
439
    int i;
440
    int k, cnt, part;
441
    uint32_t all_bits;
442

    
443
    part = (1 << porder);
444
    all_bits = 4 * part;
445

    
446
    cnt = (n >> porder) - pred_order;
447
    for(i=0; i<part; i++) {
448
        k = find_optimal_param(sums[i], cnt);
449
        rc->params[i] = k;
450
        all_bits += rice_encode_count(sums[i], cnt, k);
451
        cnt = n >> porder;
452
    }
453

    
454
    rc->porder = porder;
455

    
456
    return all_bits;
457
}
458

    
459
static void calc_sums(int pmin, int pmax, uint32_t *data, int n, int pred_order,
460
                      uint32_t sums[][MAX_PARTITIONS])
461
{
462
    int i, j;
463
    int parts;
464
    uint32_t *res, *res_end;
465

    
466
    /* sums for highest level */
467
    parts = (1 << pmax);
468
    res = &data[pred_order];
469
    res_end = &data[n >> pmax];
470
    for(i=0; i<parts; i++) {
471
        uint32_t sum = 0;
472
        while(res < res_end){
473
            sum += *(res++);
474
        }
475
        sums[pmax][i] = sum;
476
        res_end+= n >> pmax;
477
    }
478
    /* sums for lower levels */
479
    for(i=pmax-1; i>=pmin; i--) {
480
        parts = (1 << i);
481
        for(j=0; j<parts; j++) {
482
            sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1];
483
        }
484
    }
485
}
486

    
487
static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
488
                                 int32_t *data, int n, int pred_order)
489
{
490
    int i;
491
    uint32_t bits[MAX_PARTITION_ORDER+1];
492
    int opt_porder;
493
    RiceContext tmp_rc;
494
    uint32_t *udata;
495
    uint32_t sums[MAX_PARTITION_ORDER+1][MAX_PARTITIONS];
496

    
497
    assert(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);
498
    assert(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);
499
    assert(pmin <= pmax);
500

    
501
    udata = av_malloc(n * sizeof(uint32_t));
502
    for(i=0; i<n; i++) {
503
        udata[i] = (2*data[i]) ^ (data[i]>>31);
504
    }
505

    
506
    calc_sums(pmin, pmax, udata, n, pred_order, sums);
507

    
508
    opt_porder = pmin;
509
    bits[pmin] = UINT32_MAX;
510
    for(i=pmin; i<=pmax; i++) {
511
        bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums[i], n, pred_order);
512
        if(bits[i] <= bits[opt_porder]) {
513
            opt_porder = i;
514
            *rc= tmp_rc;
515
        }
516
    }
517

    
518
    av_freep(&udata);
519
    return bits[opt_porder];
520
}
521

    
522
static int get_max_p_order(int max_porder, int n, int order)
523
{
524
    int porder = FFMIN(max_porder, av_log2(n^(n-1)));
525
    if(order > 0)
526
        porder = FFMIN(porder, av_log2(n/order));
527
    return porder;
528
}
529

    
530
static uint32_t calc_rice_params_fixed(RiceContext *rc, int pmin, int pmax,
531
                                       int32_t *data, int n, int pred_order,
532
                                       int bps)
533
{
534
    uint32_t bits;
535
    pmin = get_max_p_order(pmin, n, pred_order);
536
    pmax = get_max_p_order(pmax, n, pred_order);
537
    bits = pred_order*bps + 6;
538
    bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
539
    return bits;
540
}
541

    
542
static uint32_t calc_rice_params_lpc(RiceContext *rc, int pmin, int pmax,
543
                                     int32_t *data, int n, int pred_order,
544
                                     int bps, int precision)
545
{
546
    uint32_t bits;
547
    pmin = get_max_p_order(pmin, n, pred_order);
548
    pmax = get_max_p_order(pmax, n, pred_order);
549
    bits = pred_order*bps + 4 + 5 + pred_order*precision + 6;
550
    bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
551
    return bits;
552
}
553

    
554
/**
555
 * Apply Welch window function to audio block
556
 */
557
static void apply_welch_window(const int32_t *data, int len, double *w_data)
558
{
559
    int i, n2;
560
    double w;
561
    double c;
562

    
563
    assert(!(len&1)); //the optimization in r11881 does not support odd len
564
                      //if someone wants odd len extend the change in r11881
565

    
566
    n2 = (len >> 1);
567
    c = 2.0 / (len - 1.0);
568

    
569
    w_data+=n2;
570
      data+=n2;
571
    for(i=0; i<n2; i++) {
572
        w = c - n2 + i;
573
        w = 1.0 - (w * w);
574
        w_data[-i-1] = data[-i-1] * w;
575
        w_data[+i  ] = data[+i  ] * w;
576
    }
577
}
578

    
579
/**
580
 * Calculates autocorrelation data from audio samples
581
 * A Welch window function is applied before calculation.
582
 */
583
void ff_flac_compute_autocorr(const int32_t *data, int len, int lag,
584
                              double *autoc)
585
{
586
    int i, j;
587
    double tmp[len + lag + 1];
588
    double *data1= tmp + lag;
589

    
590
    apply_welch_window(data, len, data1);
591

    
592
    for(j=0; j<lag; j++)
593
        data1[j-lag]= 0.0;
594
    data1[len] = 0.0;
595

    
596
    for(j=0; j<lag; j+=2){
597
        double sum0 = 1.0, sum1 = 1.0;
598
        for(i=0; i<len; i++){
599
            sum0 += data1[i] * data1[i-j];
600
            sum1 += data1[i] * data1[i-j-1];
601
        }
602
        autoc[j  ] = sum0;
603
        autoc[j+1] = sum1;
604
    }
605

    
606
    if(j==lag){
607
        double sum = 1.0;
608
        for(i=0; i<len; i+=2){
609
            sum += data1[i  ] * data1[i-j  ]
610
                 + data1[i+1] * data1[i-j+1];
611
        }
612
        autoc[j] = sum;
613
    }
614
}
615

    
616

    
617
static void encode_residual_verbatim(int32_t *res, int32_t *smp, int n)
618
{
619
    assert(n > 0);
620
    memcpy(res, smp, n * sizeof(int32_t));
621
}
622

    
623
static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
624
                                  int order)
625
{
626
    int i;
627

    
628
    for(i=0; i<order; i++) {
629
        res[i] = smp[i];
630
    }
631

    
632
    if(order==0){
633
        for(i=order; i<n; i++)
634
            res[i]= smp[i];
635
    }else if(order==1){
636
        for(i=order; i<n; i++)
637
            res[i]= smp[i] - smp[i-1];
638
    }else if(order==2){
639
        int a = smp[order-1] - smp[order-2];
640
        for(i=order; i<n; i+=2) {
641
            int b = smp[i] - smp[i-1];
642
            res[i]= b - a;
643
            a = smp[i+1] - smp[i];
644
            res[i+1]= a - b;
645
        }
646
    }else if(order==3){
647
        int a = smp[order-1] - smp[order-2];
648
        int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
649
        for(i=order; i<n; i+=2) {
650
            int b = smp[i] - smp[i-1];
651
            int d = b - a;
652
            res[i]= d - c;
653
            a = smp[i+1] - smp[i];
654
            c = a - b;
655
            res[i+1]= c - d;
656
        }
657
    }else{
658
        int a = smp[order-1] - smp[order-2];
659
        int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
660
        int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
661
        for(i=order; i<n; i+=2) {
662
            int b = smp[i] - smp[i-1];
663
            int d = b - a;
664
            int f = d - c;
665
            res[i]= f - e;
666
            a = smp[i+1] - smp[i];
667
            c = a - b;
668
            e = c - d;
669
            res[i+1]= e - f;
670
        }
671
    }
672
}
673

    
674
#define LPC1(x) {\
675
    int c = coefs[(x)-1];\
676
    p0 += c*s;\
677
    s = smp[i-(x)+1];\
678
    p1 += c*s;\
679
}
680

    
681
static av_always_inline void encode_residual_lpc_unrolled(
682
    int32_t *res, const int32_t *smp, int n,
683
    int order, const int32_t *coefs, int shift, int big)
684
{
685
    int i;
686
    for(i=order; i<n; i+=2) {
687
        int s = smp[i-order];
688
        int p0 = 0, p1 = 0;
689
        if(big) {
690
            switch(order) {
691
                case 32: LPC1(32)
692
                case 31: LPC1(31)
693
                case 30: LPC1(30)
694
                case 29: LPC1(29)
695
                case 28: LPC1(28)
696
                case 27: LPC1(27)
697
                case 26: LPC1(26)
698
                case 25: LPC1(25)
699
                case 24: LPC1(24)
700
                case 23: LPC1(23)
701
                case 22: LPC1(22)
702
                case 21: LPC1(21)
703
                case 20: LPC1(20)
704
                case 19: LPC1(19)
705
                case 18: LPC1(18)
706
                case 17: LPC1(17)
707
                case 16: LPC1(16)
708
                case 15: LPC1(15)
709
                case 14: LPC1(14)
710
                case 13: LPC1(13)
711
                case 12: LPC1(12)
712
                case 11: LPC1(11)
713
                case 10: LPC1(10)
714
                case  9: LPC1( 9)
715
                         LPC1( 8)
716
                         LPC1( 7)
717
                         LPC1( 6)
718
                         LPC1( 5)
719
                         LPC1( 4)
720
                         LPC1( 3)
721
                         LPC1( 2)
722
                         LPC1( 1)
723
            }
724
        } else {
725
            switch(order) {
726
                case  8: LPC1( 8)
727
                case  7: LPC1( 7)
728
                case  6: LPC1( 6)
729
                case  5: LPC1( 5)
730
                case  4: LPC1( 4)
731
                case  3: LPC1( 3)
732
                case  2: LPC1( 2)
733
                case  1: LPC1( 1)
734
            }
735
        }
736
        res[i  ] = smp[i  ] - (p0 >> shift);
737
        res[i+1] = smp[i+1] - (p1 >> shift);
738
    }
739
}
740

    
741
static void encode_residual_lpc(int32_t *res, const int32_t *smp, int n,
742
                                int order, const int32_t *coefs, int shift)
743
{
744
    int i;
745
    for(i=0; i<order; i++) {
746
        res[i] = smp[i];
747
    }
748
#if CONFIG_SMALL
749
    for(i=order; i<n; i+=2) {
750
        int j;
751
        int s = smp[i];
752
        int p0 = 0, p1 = 0;
753
        for(j=0; j<order; j++) {
754
            int c = coefs[j];
755
            p1 += c*s;
756
            s = smp[i-j-1];
757
            p0 += c*s;
758
        }
759
        res[i  ] = smp[i  ] - (p0 >> shift);
760
        res[i+1] = smp[i+1] - (p1 >> shift);
761
    }
762
#else
763
    switch(order) {
764
        case  1: encode_residual_lpc_unrolled(res, smp, n, 1, coefs, shift, 0); break;
765
        case  2: encode_residual_lpc_unrolled(res, smp, n, 2, coefs, shift, 0); break;
766
        case  3: encode_residual_lpc_unrolled(res, smp, n, 3, coefs, shift, 0); break;
767
        case  4: encode_residual_lpc_unrolled(res, smp, n, 4, coefs, shift, 0); break;
768
        case  5: encode_residual_lpc_unrolled(res, smp, n, 5, coefs, shift, 0); break;
769
        case  6: encode_residual_lpc_unrolled(res, smp, n, 6, coefs, shift, 0); break;
770
        case  7: encode_residual_lpc_unrolled(res, smp, n, 7, coefs, shift, 0); break;
771
        case  8: encode_residual_lpc_unrolled(res, smp, n, 8, coefs, shift, 0); break;
772
        default: encode_residual_lpc_unrolled(res, smp, n, order, coefs, shift, 1); break;
773
    }
774
#endif
775
}
776

    
777
static int encode_residual(FlacEncodeContext *ctx, int ch)
778
{
779
    int i, n;
780
    int min_order, max_order, opt_order, precision, omethod;
781
    int min_porder, max_porder;
782
    FlacFrame *frame;
783
    FlacSubframe *sub;
784
    int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
785
    int shift[MAX_LPC_ORDER];
786
    int32_t *res, *smp;
787

    
788
    frame = &ctx->frame;
789
    sub = &frame->subframes[ch];
790
    res = sub->residual;
791
    smp = sub->samples;
792
    n = frame->blocksize;
793

    
794
    /* CONSTANT */
795
    for(i=1; i<n; i++) {
796
        if(smp[i] != smp[0]) break;
797
    }
798
    if(i == n) {
799
        sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
800
        res[0] = smp[0];
801
        return sub->obits;
802
    }
803

    
804
    /* VERBATIM */
805
    if(n < 5) {
806
        sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
807
        encode_residual_verbatim(res, smp, n);
808
        return sub->obits * n;
809
    }
810

    
811
    min_order = ctx->options.min_prediction_order;
812
    max_order = ctx->options.max_prediction_order;
813
    min_porder = ctx->options.min_partition_order;
814
    max_porder = ctx->options.max_partition_order;
815
    precision = ctx->options.lpc_coeff_precision;
816
    omethod = ctx->options.prediction_order_method;
817

    
818
    /* FIXED */
819
    if(!ctx->options.use_lpc || max_order == 0 || (n <= max_order)) {
820
        uint32_t bits[MAX_FIXED_ORDER+1];
821
        if(max_order > MAX_FIXED_ORDER) max_order = MAX_FIXED_ORDER;
822
        opt_order = 0;
823
        bits[0] = UINT32_MAX;
824
        for(i=min_order; i<=max_order; i++) {
825
            encode_residual_fixed(res, smp, n, i);
826
            bits[i] = calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res,
827
                                             n, i, sub->obits);
828
            if(bits[i] < bits[opt_order]) {
829
                opt_order = i;
830
            }
831
        }
832
        sub->order = opt_order;
833
        sub->type = FLAC_SUBFRAME_FIXED;
834
        sub->type_code = sub->type | sub->order;
835
        if(sub->order != max_order) {
836
            encode_residual_fixed(res, smp, n, sub->order);
837
            return calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res, n,
838
                                          sub->order, sub->obits);
839
        }
840
        return bits[sub->order];
841
    }
842

    
843
    /* LPC */
844
    opt_order = ff_lpc_calc_coefs(&ctx->dsp, smp, n, min_order, max_order,
845
                                  precision, coefs, shift, ctx->options.use_lpc,
846
                                  omethod, MAX_LPC_SHIFT, 0);
847

    
848
    if(omethod == ORDER_METHOD_2LEVEL ||
849
       omethod == ORDER_METHOD_4LEVEL ||
850
       omethod == ORDER_METHOD_8LEVEL) {
851
        int levels = 1 << omethod;
852
        uint32_t bits[levels];
853
        int order;
854
        int opt_index = levels-1;
855
        opt_order = max_order-1;
856
        bits[opt_index] = UINT32_MAX;
857
        for(i=levels-1; i>=0; i--) {
858
            order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
859
            if(order < 0) order = 0;
860
            encode_residual_lpc(res, smp, n, order+1, coefs[order], shift[order]);
861
            bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
862
                                           res, n, order+1, sub->obits, precision);
863
            if(bits[i] < bits[opt_index]) {
864
                opt_index = i;
865
                opt_order = order;
866
            }
867
        }
868
        opt_order++;
869
    } else if(omethod == ORDER_METHOD_SEARCH) {
870
        // brute-force optimal order search
871
        uint32_t bits[MAX_LPC_ORDER];
872
        opt_order = 0;
873
        bits[0] = UINT32_MAX;
874
        for(i=min_order-1; i<max_order; i++) {
875
            encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
876
            bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
877
                                           res, n, i+1, sub->obits, precision);
878
            if(bits[i] < bits[opt_order]) {
879
                opt_order = i;
880
            }
881
        }
882
        opt_order++;
883
    } else if(omethod == ORDER_METHOD_LOG) {
884
        uint32_t bits[MAX_LPC_ORDER];
885
        int step;
886

    
887
        opt_order= min_order - 1 + (max_order-min_order)/3;
888
        memset(bits, -1, sizeof(bits));
889

    
890
        for(step=16 ;step; step>>=1){
891
            int last= opt_order;
892
            for(i=last-step; i<=last+step; i+= step){
893
                if(i<min_order-1 || i>=max_order || bits[i] < UINT32_MAX)
894
                    continue;
895
                encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
896
                bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
897
                                            res, n, i+1, sub->obits, precision);
898
                if(bits[i] < bits[opt_order])
899
                    opt_order= i;
900
            }
901
        }
902
        opt_order++;
903
    }
904

    
905
    sub->order = opt_order;
906
    sub->type = FLAC_SUBFRAME_LPC;
907
    sub->type_code = sub->type | (sub->order-1);
908
    sub->shift = shift[sub->order-1];
909
    for(i=0; i<sub->order; i++) {
910
        sub->coefs[i] = coefs[sub->order-1][i];
911
    }
912
    encode_residual_lpc(res, smp, n, sub->order, sub->coefs, sub->shift);
913
    return calc_rice_params_lpc(&sub->rc, min_porder, max_porder, res, n, sub->order,
914
                                sub->obits, precision);
915
}
916

    
917
static int encode_residual_v(FlacEncodeContext *ctx, int ch)
918
{
919
    int i, n;
920
    FlacFrame *frame;
921
    FlacSubframe *sub;
922
    int32_t *res, *smp;
923

    
924
    frame = &ctx->frame;
925
    sub = &frame->subframes[ch];
926
    res = sub->residual;
927
    smp = sub->samples;
928
    n = frame->blocksize;
929

    
930
    /* CONSTANT */
931
    for(i=1; i<n; i++) {
932
        if(smp[i] != smp[0]) break;
933
    }
934
    if(i == n) {
935
        sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
936
        res[0] = smp[0];
937
        return sub->obits;
938
    }
939

    
940
    /* VERBATIM */
941
    sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
942
    encode_residual_verbatim(res, smp, n);
943
    return sub->obits * n;
944
}
945

    
946
static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
947
{
948
    int i, best;
949
    int32_t lt, rt;
950
    uint64_t sum[4];
951
    uint64_t score[4];
952
    int k;
953

    
954
    /* calculate sum of 2nd order residual for each channel */
955
    sum[0] = sum[1] = sum[2] = sum[3] = 0;
956
    for(i=2; i<n; i++) {
957
        lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
958
        rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
959
        sum[2] += FFABS((lt + rt) >> 1);
960
        sum[3] += FFABS(lt - rt);
961
        sum[0] += FFABS(lt);
962
        sum[1] += FFABS(rt);
963
    }
964
    /* estimate bit counts */
965
    for(i=0; i<4; i++) {
966
        k = find_optimal_param(2*sum[i], n);
967
        sum[i] = rice_encode_count(2*sum[i], n, k);
968
    }
969

    
970
    /* calculate score for each mode */
971
    score[0] = sum[0] + sum[1];
972
    score[1] = sum[0] + sum[3];
973
    score[2] = sum[1] + sum[3];
974
    score[3] = sum[2] + sum[3];
975

    
976
    /* return mode with lowest score */
977
    best = 0;
978
    for(i=1; i<4; i++) {
979
        if(score[i] < score[best]) {
980
            best = i;
981
        }
982
    }
983
    if(best == 0) {
984
        return FLAC_CHMODE_INDEPENDENT;
985
    } else if(best == 1) {
986
        return FLAC_CHMODE_LEFT_SIDE;
987
    } else if(best == 2) {
988
        return FLAC_CHMODE_RIGHT_SIDE;
989
    } else {
990
        return FLAC_CHMODE_MID_SIDE;
991
    }
992
}
993

    
994
/**
995
 * Perform stereo channel decorrelation
996
 */
997
static void channel_decorrelation(FlacEncodeContext *ctx)
998
{
999
    FlacFrame *frame;
1000
    int32_t *left, *right;
1001
    int i, n;
1002

    
1003
    frame = &ctx->frame;
1004
    n = frame->blocksize;
1005
    left  = frame->subframes[0].samples;
1006
    right = frame->subframes[1].samples;
1007

    
1008
    if(ctx->channels != 2) {
1009
        frame->ch_mode = FLAC_CHMODE_INDEPENDENT;
1010
        return;
1011
    }
1012

    
1013
    frame->ch_mode = estimate_stereo_mode(left, right, n);
1014

    
1015
    /* perform decorrelation and adjust bits-per-sample */
1016
    if(frame->ch_mode == FLAC_CHMODE_INDEPENDENT) {
1017
        return;
1018
    }
1019
    if(frame->ch_mode == FLAC_CHMODE_MID_SIDE) {
1020
        int32_t tmp;
1021
        for(i=0; i<n; i++) {
1022
            tmp = left[i];
1023
            left[i] = (tmp + right[i]) >> 1;
1024
            right[i] = tmp - right[i];
1025
        }
1026
        frame->subframes[1].obits++;
1027
    } else if(frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {
1028
        for(i=0; i<n; i++) {
1029
            right[i] = left[i] - right[i];
1030
        }
1031
        frame->subframes[1].obits++;
1032
    } else {
1033
        for(i=0; i<n; i++) {
1034
            left[i] -= right[i];
1035
        }
1036
        frame->subframes[0].obits++;
1037
    }
1038
}
1039

    
1040
static void write_utf8(PutBitContext *pb, uint32_t val)
1041
{
1042
    uint8_t tmp;
1043
    PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
1044
}
1045

    
1046
static void output_frame_header(FlacEncodeContext *s)
1047
{
1048
    FlacFrame *frame;
1049
    int crc;
1050

    
1051
    frame = &s->frame;
1052

    
1053
    put_bits(&s->pb, 16, 0xFFF8);
1054
    put_bits(&s->pb, 4, frame->bs_code[0]);
1055
    put_bits(&s->pb, 4, s->sr_code[0]);
1056
    if(frame->ch_mode == FLAC_CHMODE_INDEPENDENT) {
1057
        put_bits(&s->pb, 4, s->channels-1);
1058
    } else {
1059
        put_bits(&s->pb, 4, frame->ch_mode);
1060
    }
1061
    put_bits(&s->pb, 3, 4); /* bits-per-sample code */
1062
    put_bits(&s->pb, 1, 0);
1063
    write_utf8(&s->pb, s->frame_count);
1064
    if(frame->bs_code[0] == 6) {
1065
        put_bits(&s->pb, 8, frame->bs_code[1]);
1066
    } else if(frame->bs_code[0] == 7) {
1067
        put_bits(&s->pb, 16, frame->bs_code[1]);
1068
    }
1069
    if(s->sr_code[0] == 12) {
1070
        put_bits(&s->pb, 8, s->sr_code[1]);
1071
    } else if(s->sr_code[0] > 12) {
1072
        put_bits(&s->pb, 16, s->sr_code[1]);
1073
    }
1074
    flush_put_bits(&s->pb);
1075
    crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
1076
                 s->pb.buf, put_bits_count(&s->pb)>>3);
1077
    put_bits(&s->pb, 8, crc);
1078
}
1079

    
1080
static void output_subframe_constant(FlacEncodeContext *s, int ch)
1081
{
1082
    FlacSubframe *sub;
1083
    int32_t res;
1084

    
1085
    sub = &s->frame.subframes[ch];
1086
    res = sub->residual[0];
1087
    put_sbits(&s->pb, sub->obits, res);
1088
}
1089

    
1090
static void output_subframe_verbatim(FlacEncodeContext *s, int ch)
1091
{
1092
    int i;
1093
    FlacFrame *frame;
1094
    FlacSubframe *sub;
1095
    int32_t res;
1096

    
1097
    frame = &s->frame;
1098
    sub = &frame->subframes[ch];
1099

    
1100
    for(i=0; i<frame->blocksize; i++) {
1101
        res = sub->residual[i];
1102
        put_sbits(&s->pb, sub->obits, res);
1103
    }
1104
}
1105

    
1106
static void output_residual(FlacEncodeContext *ctx, int ch)
1107
{
1108
    int i, j, p, n, parts;
1109
    int k, porder, psize, res_cnt;
1110
    FlacFrame *frame;
1111
    FlacSubframe *sub;
1112
    int32_t *res;
1113

    
1114
    frame = &ctx->frame;
1115
    sub = &frame->subframes[ch];
1116
    res = sub->residual;
1117
    n = frame->blocksize;
1118

    
1119
    /* rice-encoded block */
1120
    put_bits(&ctx->pb, 2, 0);
1121

    
1122
    /* partition order */
1123
    porder = sub->rc.porder;
1124
    psize = n >> porder;
1125
    parts = (1 << porder);
1126
    put_bits(&ctx->pb, 4, porder);
1127
    res_cnt = psize - sub->order;
1128

    
1129
    /* residual */
1130
    j = sub->order;
1131
    for(p=0; p<parts; p++) {
1132
        k = sub->rc.params[p];
1133
        put_bits(&ctx->pb, 4, k);
1134
        if(p == 1) res_cnt = psize;
1135
        for(i=0; i<res_cnt && j<n; i++, j++) {
1136
            set_sr_golomb_flac(&ctx->pb, res[j], k, INT32_MAX, 0);
1137
        }
1138
    }
1139
}
1140

    
1141
static void output_subframe_fixed(FlacEncodeContext *ctx, int ch)
1142
{
1143
    int i;
1144
    FlacFrame *frame;
1145
    FlacSubframe *sub;
1146

    
1147
    frame = &ctx->frame;
1148
    sub = &frame->subframes[ch];
1149

    
1150
    /* warm-up samples */
1151
    for(i=0; i<sub->order; i++) {
1152
        put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
1153
    }
1154

    
1155
    /* residual */
1156
    output_residual(ctx, ch);
1157
}
1158

    
1159
static void output_subframe_lpc(FlacEncodeContext *ctx, int ch)
1160
{
1161
    int i, cbits;
1162
    FlacFrame *frame;
1163
    FlacSubframe *sub;
1164

    
1165
    frame = &ctx->frame;
1166
    sub = &frame->subframes[ch];
1167

    
1168
    /* warm-up samples */
1169
    for(i=0; i<sub->order; i++) {
1170
        put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
1171
    }
1172

    
1173
    /* LPC coefficients */
1174
    cbits = ctx->options.lpc_coeff_precision;
1175
    put_bits(&ctx->pb, 4, cbits-1);
1176
    put_sbits(&ctx->pb, 5, sub->shift);
1177
    for(i=0; i<sub->order; i++) {
1178
        put_sbits(&ctx->pb, cbits, sub->coefs[i]);
1179
    }
1180

    
1181
    /* residual */
1182
    output_residual(ctx, ch);
1183
}
1184

    
1185
static void output_subframes(FlacEncodeContext *s)
1186
{
1187
    FlacFrame *frame;
1188
    FlacSubframe *sub;
1189
    int ch;
1190

    
1191
    frame = &s->frame;
1192

    
1193
    for(ch=0; ch<s->channels; ch++) {
1194
        sub = &frame->subframes[ch];
1195

    
1196
        /* subframe header */
1197
        put_bits(&s->pb, 1, 0);
1198
        put_bits(&s->pb, 6, sub->type_code);
1199
        put_bits(&s->pb, 1, 0); /* no wasted bits */
1200

    
1201
        /* subframe */
1202
        if(sub->type == FLAC_SUBFRAME_CONSTANT) {
1203
            output_subframe_constant(s, ch);
1204
        } else if(sub->type == FLAC_SUBFRAME_VERBATIM) {
1205
            output_subframe_verbatim(s, ch);
1206
        } else if(sub->type == FLAC_SUBFRAME_FIXED) {
1207
            output_subframe_fixed(s, ch);
1208
        } else if(sub->type == FLAC_SUBFRAME_LPC) {
1209
            output_subframe_lpc(s, ch);
1210
        }
1211
    }
1212
}
1213

    
1214
static void output_frame_footer(FlacEncodeContext *s)
1215
{
1216
    int crc;
1217
    flush_put_bits(&s->pb);
1218
    crc = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
1219
                          s->pb.buf, put_bits_count(&s->pb)>>3));
1220
    put_bits(&s->pb, 16, crc);
1221
    flush_put_bits(&s->pb);
1222
}
1223

    
1224
static void update_md5_sum(FlacEncodeContext *s, int16_t *samples)
1225
{
1226
#ifdef WORDS_BIGENDIAN
1227
    int i;
1228
    for(i = 0; i < s->frame.blocksize*s->channels; i++) {
1229
        int16_t smp = le2me_16(samples[i]);
1230
        av_md5_update(s->md5ctx, (uint8_t *)&smp, 2);
1231
    }
1232
#else
1233
    av_md5_update(s->md5ctx, (uint8_t *)samples, s->frame.blocksize*s->channels*2);
1234
#endif
1235
}
1236

    
1237
static int flac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
1238
                             int buf_size, void *data)
1239
{
1240
    int ch;
1241
    FlacEncodeContext *s;
1242
    int16_t *samples = data;
1243
    int out_bytes;
1244
    int reencoded=0;
1245

    
1246
    s = avctx->priv_data;
1247

    
1248
    if(buf_size < s->max_framesize*2) {
1249
        av_log(avctx, AV_LOG_ERROR, "output buffer too small\n");
1250
        return 0;
1251
    }
1252

    
1253
    /* when the last block is reached, update the header in extradata */
1254
    if (!data) {
1255
        s->max_framesize = s->max_encoded_framesize;
1256
        av_md5_final(s->md5ctx, s->md5sum);
1257
        write_streaminfo(s, avctx->extradata);
1258
        return 0;
1259
    }
1260

    
1261
    init_frame(s);
1262

    
1263
    copy_samples(s, samples);
1264

    
1265
    channel_decorrelation(s);
1266

    
1267
    for(ch=0; ch<s->channels; ch++) {
1268
        encode_residual(s, ch);
1269
    }
1270

    
1271
write_frame:
1272
    init_put_bits(&s->pb, frame, buf_size);
1273
    output_frame_header(s);
1274
    output_subframes(s);
1275
    output_frame_footer(s);
1276
    out_bytes = put_bits_count(&s->pb) >> 3;
1277

    
1278
    if(out_bytes > s->max_framesize) {
1279
        if(reencoded) {
1280
            /* still too large. must be an error. */
1281
            av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");
1282
            return -1;
1283
        }
1284

    
1285
        /* frame too large. use verbatim mode */
1286
        for(ch=0; ch<s->channels; ch++) {
1287
            encode_residual_v(s, ch);
1288
        }
1289
        reencoded = 1;
1290
        goto write_frame;
1291
    }
1292

    
1293
    s->frame_count++;
1294
    s->sample_count += avctx->frame_size;
1295
    update_md5_sum(s, samples);
1296
    if (out_bytes > s->max_encoded_framesize)
1297
        s->max_encoded_framesize = out_bytes;
1298
    if (out_bytes < s->min_framesize)
1299
        s->min_framesize = out_bytes;
1300

    
1301
    return out_bytes;
1302
}
1303

    
1304
static av_cold int flac_encode_close(AVCodecContext *avctx)
1305
{
1306
    if (avctx->priv_data) {
1307
        FlacEncodeContext *s = avctx->priv_data;
1308
        av_freep(&s->md5ctx);
1309
    }
1310
    av_freep(&avctx->extradata);
1311
    avctx->extradata_size = 0;
1312
    av_freep(&avctx->coded_frame);
1313
    return 0;
1314
}
1315

    
1316
AVCodec flac_encoder = {
1317
    "flac",
1318
    CODEC_TYPE_AUDIO,
1319
    CODEC_ID_FLAC,
1320
    sizeof(FlacEncodeContext),
1321
    flac_encode_init,
1322
    flac_encode_frame,
1323
    flac_encode_close,
1324
    NULL,
1325
    .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,
1326
    .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
1327
    .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
1328
};