Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flacenc.c @ 63613fe6

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/md5.h"
24
#include "avcodec.h"
25
#include "get_bits.h"
26
#include "dsputil.h"
27
#include "golomb.h"
28
#include "lpc.h"
29
#include "flac.h"
30
#include "flacdata.h"
31

    
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
#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
typedef struct RiceContext {
57
    int porder;
58
    int params[MAX_PARTITIONS];
59
} RiceContext;
60

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

    
73
typedef struct FlacFrame {
74
    FlacSubframe subframes[FLAC_MAX_CHANNELS];
75
    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
    int channels;
84
    int samplerate;
85
    int sr_code[2];
86
    int max_blocksize;
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->max_blocksize);
112
    put_bits(&pb, 16, s->max_blocksize);
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
    s->max_blocksize = s->avctx->frame_size;
331
    av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", s->avctx->frame_size);
332

    
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
        /* default LPC precision */
343
        s->options.lpc_coeff_precision = 15;
344
    }
345
    av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",
346
           s->options.lpc_coeff_precision);
347

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

    
352
    /* 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
    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
    s->min_framesize = s->max_framesize;
365

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

    
369
    return 0;
370
}
371

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

    
377
    frame = &s->frame;
378

    
379
    for(i=0; i<16; i++) {
380
        if(s->avctx->frame_size == ff_flac_blocksize_table[i]) {
381
            frame->blocksize = ff_flac_blocksize_table[i];
382
            frame->bs_code[0] = i;
383
            frame->bs_code[1] = 0;
384
            break;
385
        }
386
    }
387
    if(i == 16) {
388
        frame->blocksize = s->avctx->frame_size;
389
        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

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

    
422
/**
423
 * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0
424
 */
425
static int find_optimal_param(uint32_t sum, int n)
426
{
427
    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
}
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
    all_bits = 4 * part;
446

    
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
        cnt = n >> porder;
453
    }
454

    
455
    rc->porder = porder;
456

    
457
    return all_bits;
458
}
459

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

    
467
    /* sums for highest level */
468
    parts = (1 << pmax);
469
    res = &data[pred_order];
470
    res_end = &data[n >> pmax];
471
    for(i=0; i<parts; i++) {
472
        uint32_t sum = 0;
473
        while(res < res_end){
474
            sum += *(res++);
475
        }
476
        sums[pmax][i] = sum;
477
        res_end+= n >> pmax;
478
    }
479
    /* sums for lower levels */
480
    for(i=pmax-1; i>=pmin; i--) {
481
        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
static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
489
                                 int32_t *data, int n, int pred_order)
490
{
491
    int i;
492
    uint32_t bits[MAX_PARTITION_ORDER+1];
493
    int opt_porder;
494
    RiceContext tmp_rc;
495
    uint32_t *udata;
496
    uint32_t sums[MAX_PARTITION_ORDER+1][MAX_PARTITIONS];
497

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

    
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
    calc_sums(pmin, pmax, udata, n, pred_order, sums);
508

    
509
    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
            opt_porder = i;
515
            *rc= tmp_rc;
516
        }
517
    }
518

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

    
523
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
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
{
535
    uint32_t bits;
536
    pmin = get_max_p_order(pmin, n, pred_order);
537
    pmax = get_max_p_order(pmax, n, pred_order);
538
    bits = pred_order*bps + 6;
539
    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
    pmin = get_max_p_order(pmin, n, pred_order);
549
    pmax = get_max_p_order(pmax, n, pred_order);
550
    bits = pred_order*bps + 4 + 5 + pred_order*precision + 6;
551
    bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
552
    return bits;
553
}
554

    
555
/**
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
    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
    n2 = (len >> 1);
568
    c = 2.0 / (len - 1.0);
569

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

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

    
591
    apply_welch_window(data, len, data1);
592

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

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

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

    
617

    
618
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
static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
625
                                  int order)
626
{
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
        int a = smp[order-1] - smp[order-2];
641
        for(i=order; i<n; i+=2) {
642
            int b = smp[i] - smp[i-1];
643
            res[i]= b - a;
644
            a = smp[i+1] - smp[i];
645
            res[i+1]= a - b;
646
        }
647
    }else if(order==3){
648
        int a = smp[order-1] - smp[order-2];
649
        int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
650
        for(i=order; i<n; i+=2) {
651
            int b = smp[i] - smp[i-1];
652
            int d = b - a;
653
            res[i]= d - c;
654
            a = smp[i+1] - smp[i];
655
            c = a - b;
656
            res[i+1]= c - d;
657
        }
658
    }else{
659
        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
        for(i=order; i<n; i+=2) {
663
            int b = smp[i] - smp[i-1];
664
            int d = b - a;
665
            int f = d - c;
666
            res[i]= f - e;
667
            a = smp[i+1] - smp[i];
668
            c = a - b;
669
            e = c - d;
670
            res[i+1]= e - f;
671
        }
672
    }
673
}
674

    
675
#define LPC1(x) {\
676
    int c = coefs[(x)-1];\
677
    p0 += c*s;\
678
    s = smp[i-(x)+1];\
679
    p1 += c*s;\
680
}
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
        int s = smp[i-order];
689
        int p0 = 0, p1 = 0;
690
        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
                         LPC1( 1)
724
            }
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
                case  1: LPC1( 1)
735
            }
736
        }
737
        res[i  ] = smp[i  ] - (p0 >> shift);
738
        res[i+1] = smp[i+1] - (p1 >> shift);
739
    }
740
}
741

    
742
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
    int i;
746
    for(i=0; i<order; i++) {
747
        res[i] = smp[i];
748
    }
749
#if CONFIG_SMALL
750
    for(i=order; i<n; i+=2) {
751
        int j;
752
        int s = smp[i];
753
        int p0 = 0, p1 = 0;
754
        for(j=0; j<order; j++) {
755
            int c = coefs[j];
756
            p1 += c*s;
757
            s = smp[i-j-1];
758
            p0 += c*s;
759
        }
760
        res[i  ] = smp[i  ] - (p0 >> shift);
761
        res[i+1] = smp[i+1] - (p1 >> shift);
762
    }
763
#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
}
777

    
778
static int encode_residual(FlacEncodeContext *ctx, int ch)
779
{
780
    int i, n;
781
    int min_order, max_order, opt_order, precision, omethod;
782
    int min_porder, max_porder;
783
    FlacFrame *frame;
784
    FlacSubframe *sub;
785
    int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
786
    int shift[MAX_LPC_ORDER];
787
    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
    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
    omethod = ctx->options.prediction_order_method;
818

    
819
    /* FIXED */
820
    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
            bits[i] = calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res,
828
                                             n, i, sub->obits);
829
            if(bits[i] < bits[opt_order]) {
830
                opt_order = i;
831
            }
832
        }
833
        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
            return calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res, n,
839
                                          sub->order, sub->obits);
840
        }
841
        return bits[sub->order];
842
    }
843

    
844
    /* LPC */
845
    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

    
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
    } 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
    }
905

    
906
    sub->order = opt_order;
907
    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
    }
913
    encode_residual_lpc(res, smp, n, sub->order, sub->coefs, sub->shift);
914
    return calc_rice_params_lpc(&sub->rc, min_porder, max_porder, res, n, sub->order,
915
                                sub->obits, precision);
916
}
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
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
    uint64_t sum[4];
952
    uint64_t score[4];
953
    int k;
954

    
955
    /* calculate sum of 2nd order residual for each channel */
956
    sum[0] = sum[1] = sum[2] = sum[3] = 0;
957
    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
        sum[2] += FFABS((lt + rt) >> 1);
961
        sum[3] += FFABS(lt - rt);
962
        sum[0] += FFABS(lt);
963
        sum[1] += FFABS(rt);
964
    }
965
    /* estimate bit counts */
966
    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
    }
970

    
971
    /* calculate score for each mode */
972
    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

    
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
        return FLAC_CHMODE_INDEPENDENT;
986
    } 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
        frame->ch_mode = FLAC_CHMODE_INDEPENDENT;
1011
        return;
1012
    }
1013

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

    
1016
    /* perform decorrelation and adjust bits-per-sample */
1017
    if(frame->ch_mode == FLAC_CHMODE_INDEPENDENT) {
1018
        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
static void write_utf8(PutBitContext *pb, uint32_t val)
1042
{
1043
    uint8_t tmp;
1044
    PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
1045
}
1046

    
1047
static void output_frame_header(FlacEncodeContext *s)
1048
{
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
    if(frame->ch_mode == FLAC_CHMODE_INDEPENDENT) {
1058
        put_bits(&s->pb, 4, s->channels-1);
1059
    } 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
    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
    }
1070
    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
    }
1075
    flush_put_bits(&s->pb);
1076
    crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
1077
                 s->pb.buf, put_bits_count(&s->pb)>>3);
1078
    put_bits(&s->pb, 8, crc);
1079
}
1080

    
1081
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
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
static void output_residual(FlacEncodeContext *ctx, int ch)
1108
{
1109
    int i, j, p, n, parts;
1110
    int k, porder, psize, res_cnt;
1111
    FlacFrame *frame;
1112
    FlacSubframe *sub;
1113
    int32_t *res;
1114

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

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

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

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

    
1142
static void output_subframe_fixed(FlacEncodeContext *ctx, int ch)
1143
{
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
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
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
        if(sub->type == FLAC_SUBFRAME_CONSTANT) {
1204
            output_subframe_constant(s, ch);
1205
        } else if(sub->type == FLAC_SUBFRAME_VERBATIM) {
1206
            output_subframe_verbatim(s, ch);
1207
        } else if(sub->type == FLAC_SUBFRAME_FIXED) {
1208
            output_subframe_fixed(s, ch);
1209
        } else if(sub->type == FLAC_SUBFRAME_LPC) {
1210
            output_subframe_lpc(s, ch);
1211
        }
1212
    }
1213
}
1214

    
1215
static void output_frame_footer(FlacEncodeContext *s)
1216
{
1217
    int crc;
1218
    flush_put_bits(&s->pb);
1219
    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
    put_bits(&s->pb, 16, crc);
1222
    flush_put_bits(&s->pb);
1223
}
1224

    
1225
static void update_md5_sum(FlacEncodeContext *s, int16_t *samples)
1226
{
1227
#if HAVE_BIGENDIAN
1228
    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
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
    int reencoded=0;
1246

    
1247
    s = avctx->priv_data;
1248

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

    
1262
    init_frame(s);
1263

    
1264
    copy_samples(s, samples);
1265

    
1266
    channel_decorrelation(s);
1267

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

    
1272
write_frame:
1273
    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
    if(out_bytes > s->max_framesize) {
1280
        if(reencoded) {
1281
            /* still too large. must be an error. */
1282
            av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");
1283
            return -1;
1284
        }
1285

    
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
    }
1293

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

    
1302
    return out_bytes;
1303
}
1304

    
1305
static av_cold int flac_encode_close(AVCodecContext *avctx)
1306
{
1307
    if (avctx->priv_data) {
1308
        FlacEncodeContext *s = avctx->priv_data;
1309
        av_freep(&s->md5ctx);
1310
    }
1311
    av_freep(&avctx->extradata);
1312
    avctx->extradata_size = 0;
1313
    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
    .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,
1327
    .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
1328
    .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
1329
};